Mam problem z pewnym zadaniem.
Rozwiązanie ma być napisane w języku C++, bez użycia jakichkolwiek zewnętrznych bibliotek, z wyjątkiem <iostream>. W dużym uproszczeniu, na wejściu dostajemy współrzędne (liczby całkowite) kilku punktów, a na wyjściu program powinien podać współrzędne szukanego punktu B, w postaci ułamków zwykłych (np. x = 8/3, y = -3/1).
W moim rozwiązaniu doszedłem do momentu, w którym mam:
- Znane współrzędne (liczby całkowite, podane na wejściu) punktów A, C oraz D.
- Znane pole trójkąta ABC (w postaci ułamka prostego)
- Nieznane współrzędne punktu B
- Wiadomo, że punkty B, C i D leżą na jednej prostej oraz, że suma długości odcinków BC i BD jest równa długości odcinka CD (B znajduje się pomiędzy C i D)
W jaki sposób, mając powyższe dane, znaleźć dokładne współrzędne punktu B? Mój początkowy zamysł polegał na dzieleniu odcinka CD rekurencyjnie, na połowy, tak długo, aż kolejny wyznaczony środek (nazwijmy go E) okaże się być szukanym punktem B (pole trójkąta AEC bedzie się równało znanemu polu ABC). W praktyce okazało się, że podczas dzielenia odcinka licznik/mianownik ułamka rosną do rozmiarów przekraczających zakres typu long long int i program się wysypuje. Wynik musi być w stu procentach precyzycyjny, dlatego odpada wszelkie liczenie pierwiastków czy działania na liczbach zmiennoprzecinkowych. Utknąłem w tym miejscu i proszę o pomoc.
Na potrzeby rozwiązania stworzyłem klasy:
Ułamek:
class Fraction
{
private:
long long n;
long long d;
public:
Fraction(long long a, long long b);
Fraction() {}
void Reduce();
void Print();
long long GetN();
long long GetD();
Fraction operator*(const Fraction& f);
Fraction operator/(const Fraction& f);
Fraction operator+(const Fraction& f);
Fraction operator-(const Fraction& f);
bool operator>(const Fraction& f);
bool operator!=(const Fraction& f);
};
Punkt:
class Point
{
private:
Fraction x;
Fraction y;
public:
Point(int xn, int yn, int xd = 1, int yd = 1);
Point() {}
void Print();
Fraction GetX();
Fraction GetY();
};
Definicje metod i konstruktorów:
//Konstruktory Fraction
Fraction::Fraction(long long a, long long b) {
if (a == 0) {
this->n = 0;
this->d = 1;
}
else {
this->n = a;
this->d = b;
}
Reduce();
}
//Przeciazone operatory Fraction
//Przeciazony operator *
Fraction Fraction::operator*(const Fraction& f) {
long long a = this->n * f.n;
long long b = this->d * f.d;
return Fraction(a, b);
}
//Przeciazony operator /
Fraction Fraction::operator/(const Fraction& f) {
long long a = this->n * f.d;
long long b = this->d * f.n;
if (f.n < 0) {
b = -b;
a = -a;
}
return Fraction(a, b);
}
//Przeciazony operator +
Fraction Fraction::operator+(const Fraction& f) {
long long a = this->n * f.d + f.n * this->d;
long long b = this->d * f.d;
return Fraction(a, b);
}
//Przeciazony operator -
Fraction Fraction::operator-(const Fraction& f) {
long long a = this->n * f.d - f.n * this->d;
long long b = this->d * f.d;
return Fraction(a, b);
}
//Przeciazony operator >
bool Fraction::operator>(const Fraction& f) {
long long a, b;
a = this->n * f.d;
b = f.n * this->d;
if (a > b) {
return true;
}
else {
return false;
}
}
//Przeciazony operator !=
bool Fraction::operator!=(const Fraction& f) {
if (this->n == f.n && this->d == f.d) {
return false;
}
else {
return true;
}
}
//Metody Fraction
//Metoda skracajaca ulamek
void Fraction::Reduce() {
long long a, aa;
long long b, bb;
this->n < 0 ? aa = -(this->n) : aa = this->n;
bb = this->d;
while (bb != 0) {
a = aa;
b = bb;
aa = bb;
bb = a % b;
}
this->n = this->n / b;
this->d = this->d / b;
}
//Metoda wypisujaca ulamek
void Fraction::Print() {
cout << this->n << "/" << this->d << endl;
}
//getter n
long long Fraction::GetN() {
return this->n;
}
//getter d
long long Fraction::GetD() {
return this->d;
}
//Konstruktory Point
Point::Point(int xn, int yn, int xd, int yd) {
this->x = Fraction(xn, xd);
this->y = Fraction(yn, yd);
}
//Metody Point
//Metoda wypisująca punkt
void Point::Print() {
cout << "X: ";
this->x.Print();
cout << "\nY: ";
this->y.Print();
}
Fraction Point::GetX() {
return this->x;
}
Fraction Point::GetY() {
return this->y;
}
![]
![]