ułamki zwykłe

0

Co zrobić żeby program skracał ułamki? np. po wykonaniu działania 2/10 + 4/10 = 6/10 program skróci ten ułamek do jak najprostszej formy, czyli 3/5

#include <iostream>
using namespace std;

int nwd_odejmowanie (int a, int b)
{
	while (a!=b)
		if (a>b) a-=b;
			else b-=a;
		return a;
}

void dodawanie (int l1, int m1, int l2, int m2)
{
	int nww;

		nww=m1*m2/nwd_odejmowanie(m1, m2);
	cout<<endl;
	cout<<l1<<"/"<<m1<<" + "<<l2<<"/"<<m2<<" = "<<nww/m1*l1<<"/"<<nww<<" + "<<nww/m2*l2<<"/"<<nww<<" = "<<(nww/m1*l1)
	+(nww/m2*l2)<<"/"<<nww;
	cout<<endl;
	return;
}

void odejmowanie (int l1, int m1, int l2, int m2)
{
	int nww;
		nww=m1*m2/nwd_odejmowanie(m1, m2);
	cout<<endl;
	cout<<l1<<"/"<<m1<<" - "<<l2<<"/"<<m2<<" = "<<nww/m1*l1<<"/"<<nww<<" - "<<nww/m2*l2<<"/"<<nww<<" = "<<(nww/m1*l1)
	-(nww/m2*l2)<<"/"<<nww;
	cout<<endl;
	return;
}

void mnozenie (int l1, int m1, int l2, int m2)
{
	cout<<l1<<"/"<<m1<<" x "<<l2<<"/"<<m2<<" = "<<(l1*l2)<<"/"<<(m1*m2);
	cout<<endl;
	return;
}

void dzielenie (int l1, int m1, int l2, int m2)
{
	cout<<l1<<"/"<<m1<<" : "<<l2<<"/"<<m2<<" = "<<(l1*m2)<<"/"<<(m1*l2);
	cout<<endl;
	return;
}


int main()
{
	int l1; int l2; int m1; int m2;
	int dzialanie;
	int kontynuacja;
		
		do
		{
			cout<<"Podaj licznik ";
			cin>>l1;
			cout<<"Podaj mianownik ";
			cin>>m1;
			cout<<"Podaj liczik ";
			cin>>l2;
			cout<<"Podaj mianownik ";
			cin>>m2;
			
			cout<<"Wybierz jakie dzialanie chcesz wykonac: 1-dodawanie, 2-odejmowanie, 3-mnozenie, 4-dzielenie"<<endl;
			cin>>dzialanie;
			
				if (dzialanie==1)
				{
					dodawanie(l1,m1,l2,m2);
					cout<<"Czy chcesz kontunuowac? 1-tak 2-nie";
					cin>>kontynuacja;
					cout<<endl;
				}
			else
				if (dzialanie==2)
				{
					odejmowanie(l1,m1,l2,m2);
					cout<<"Czy chcesz kontunuowac? 1-tak 2-nie";
					cin>>kontynuacja;
					cout<<endl;
				}
			else
				if (dzialanie==3)
				{
					mnozenie(l1,m1,l2,m2);
					cout<<"Czy chcesz kontunuowac? 1-tak 2-nie";
					cin>>kontynuacja;
					cout<<endl;
				}
			else
				if (dzialanie==4)
				{
					dzielenie(l1,m1,l2,m2);
					cout<<"Czy chcesz kontunuowac? 1-tak 2-nie";
					cin>>kontynuacja;
					cout<<endl;
				}
			else
				{
					cout<<endl<<"Wprowadziles zle dzialanie"<<endl;
					cout<<"Czy chcesz kontynuowac? 1-tak 2-nie";
					cin>>kontynuacja;
					cout<<endl;
				}
			
		}
		while (kontynuacja==1);
		
		
}
2

Co rozumiesz przez "wyciąganie całości z ułamków"? Co się dzieje i co ma się dziać? https://dsp.krzaq.cc/post/445/jak-zadawac-pytania-na-forum/

Co do samego kodu, od razu kilka uwag:

  • bardzo dużo się powtarzasz, co zrobisz jak będziesz chciał zmienić komunikat w switchu drzewku ifów (tfu)?
  • funkcje nazwane operacjami matematycznymi nic nie zwracają. No i są w formie niedokonanej, co mi osobiście bardzo nie pasuje.
1

Jeśli chodzi o skracanie ułamków to poczytaj o NWD.Chociaż widzę ,że w kodzie masz już NWD. Teraz wystarczy podzielić licznik i mianownik przez NWD A co do kodu to do tego co już napisał @kq dodam jeszcze ,że w każdym ife masz taki sam kod. Więc po co on jest w ifie?

cout<<"Czy chcesz kontynuowac? 1-tak 2-nie";
cin>>kontynuacja;
cout<<endl;

return Pusty return przy void ma jedynie sens gdy chcesz przerwać funkcję przed jej zakończeniem. Więc dawanie pustego returna na końcu funkcji nie ma, żadnego sensu.

3

Jeśli Chcesz zaimplementowac ułamki, to jedyną sensowną drogą w C++ jest klasa; w std jest już gcd, można skorzystać. Oczywiście Zrobisz sobie to porządnie, z przeładowaniem operatorów arytmetycznych, strumienia, konstruktorów, etc... Co do normalizacji, można ją też dać opcjonalnie, będzie trochę szybciej.

#include <iostream>
#include <algorithm>

class Fraction {
	long nom;
	long den;
	Fraction normalize(Fraction f) {
		long _gcd = std::__gcd(f.nom, f.den);
		return Fraction(f.nom / _gcd, f.den / _gcd);
	}
	public: Fraction(long _nom, long _den){
		this->nom = _nom;
		this->den = _den;
	}
	Fraction add(Fraction r) {
			return normalize(Fraction(this->nom * r.den + r.nom * this->den, r.den * this->den));
	}
	void toString() {
		std::cout << "("<<this->nom<<","<<this->den<<")\n";
	}
};

int main() {
	Fraction f1{1, 2};
	Fraction f2{2, 3};
	f1.add(f2).toString(); // ->(7, 6)
	return 0;
}

https://www.geeksforgeeks.org/stdgcd-c-inbuilt-function-finding-gcd/

1

@lion137 ten normalize jest troszkę niedopieszczony.
Powinno być:

class Fraction {
     ....
    void normalize();
    // albo
    Fraction normalized() const;
    // albo
    static Fraction normalized(Fraction f); // jako niewielki obiekt nie widzę problemu w przekazywaniu przez wartość
0

Troszkę inna wersja implementacji dodawania ułamków. Jednak nie polecam jej wykorzystywać bez zrozumienia kodu.

#include <iostream>
#include <algorithm>
#include <cassert>

using namespace std;

class Fraction
{
    size_t nom {1};
    size_t den {1};

    Fraction&& normalize() &&
    {
        auto _gcd = __gcd(nom,den);
        nom/=_gcd; den/=_gcd ;
        return move(*this);
    }

public:

    Fraction( size_t _nom , size_t _den ): nom {_nom} , den {_den} { assert( den!=0 ); }

    friend Fraction operator+( const Fraction& f1 , const Fraction& f2 )
    {
        return (Fraction{ f1.nom*f2.den + f2.nom*f1.den , f2.den*f1.den }).normalize();
    }

    friend ostream& operator<<( ostream& os , const Fraction& fraction )
    {
        os << "(" << fraction.nom << "|" << fraction.den << ")" << endl;
        return os;
    }

    friend Fraction operator|( const Fraction& nom , const Fraction& den )
    {
        return { nom.nom , den.den };
    }
};

Fraction operator""_n( size_t n ){ return {n,1}; }
Fraction operator""_d( size_t d ){ return {1,d}; }

int main()
{
    cout <<  (1_n|2_d) + (2_n|3_d);
    return 0;
}

1 użytkowników online, w tym zalogowanych: 0, gości: 1