cpp_yandex/01_White_belt/04 Streams, overloads, exceptions, classes/09_5_Rational_map.cpp at master · romanwrites/cpp_yandex · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#include <iostream>
#include <map>
#include <set>
#include <vector>
#include <numeric>
using namespace std;

class Rational {
public:
	Rational() {
		num = 0;
		denum = 1;
	}

	Rational(int numerator, int denominator) {
		RationalSetValue(numerator, denominator);
	}

	int Numerator() const {
		return num;
	}

	int Denominator() const {
		return denum;
	}

	void RationalSetValue(int numerator, int denominator) {
		if (numerator == 0) {
			num = 0;
			denum = 1;
			return ;
		}
		int div = gcd(numerator, denominator);

		if (numerator < 0 && denominator < 0) {
			denum = abs(denominator) / div;
			num = abs(numerator) / div;
		} else if (denominator < 0) {
			denum = abs(denominator) / div;
			num = numerator / div;
			num = -num;
		} else {
			denum = denominator / div;
			num = numerator / div;
		}
	}

	bool	operator==(Rational const &rhs) const {
		return num == rhs.num && denum == rhs.denum;
	}

	Rational	operator+(Rational const &rhs) const {
		int denominator = denum * rhs.denum;
		int numerator = ((num * (denominator / denum)) + (rhs.num * (denominator / rhs.denum)));
		return Rational(numerator, denominator);
	}

	Rational	operator-(Rational const &rhs) const {
		int denominator = denum * rhs.denum;
		int numerator = ((num * (denominator / denum)) - (rhs.num * (denominator / rhs.denum)));
		return Rational(numerator, denominator);
	}

	Rational	operator*(Rational const &rhs) const {
		return Rational(num * rhs.num, denum * rhs.denum);
	}

	Rational	operator/(Rational const &rhs) const {
		return Rational(num * rhs.denum, denum * rhs.num);
	}

private:
	int num;
	int denum;
};

ostream &operator<<(ostream &out, Rational const &obj) {
	out << obj.Numerator() << "/" << obj.Denominator();
	return out;
}

istream &operator>>(istream &in, Rational &obj) {
	if (in) {
		int numerator;
		int	denominator;
		in >> numerator;
		if (!in.fail() && !in.eof()) {
			char c;
			in >> c;
			if (!in.fail() && !in.eof() && c == '/') {
				in >> denominator;
				if (!in.fail())
					obj.RationalSetValue(numerator, denominator);
			}
		}
	}
	return in;
}

bool operator>(Rational const &lhs, Rational const &rhs) {
	int denominator = lhs.Denominator() * rhs.Denominator();
	return (lhs.Numerator() * (denominator / lhs.Denominator())) > (rhs.Numerator() * (denominator / rhs.Denominator()));
}

bool operator<(Rational const &lhs, Rational const &rhs) {
	int denominator = lhs.Denominator() * rhs.Denominator();
	return (lhs.Numerator() * (denominator / lhs.Denominator())) < (rhs.Numerator() * (denominator / rhs.Denominator()));
}

int main() {
    {
        const set<Rational> rs = {{1, 2}, {1, 25}, {3, 4}, {3, 4}, {1, 2}};
        if (rs.size() != 3) {
            cout << "Wrong amount of items in the set" << endl;
            return 1;
        }

        vector<Rational> v;
        for (auto x : rs) {
            v.push_back(x);
        }
        if (v != vector<Rational>{{1, 25}, {1, 2}, {3, 4}}) {
            cout << "Rationals comparison works incorrectly" << endl;
            return 2;
        }
    }

    {
        map<Rational, int> count;
        ++count[{1, 2}];
        ++count[{1, 2}];

        ++count[{2, 3}];

        if (count.size() != 2) {
            cout << "Wrong amount of items in the map" << endl;
            return 3;
        }
    }

    cout << "OK" << endl;
    return 0;
}