Porady dotyczące tworzenia kodu kalkulatora frakcji bardziej zoptymalizowanego (szybszego i mniejszego wykorzystania pamięci)

Question

Zasadniczo potrzebuję, aby program działał jak prosty kalkulator frakcji (dodawanie, odejmowanie, mnożenie i dzielenie) dla pojedyncza linia wejścia, na przykład:
-input: 1/7 + 3/5
-Output: 26/35

Mój początkowy kod:

import sys 

def euclid(numA, numB): 
    while numB != 0: 
     numRem = numA % numB 
     numA = numB 
     numB = numRem 
    return numA 

for wejscie in sys.stdin: 
    wyjscie = wejscie.split(' ') 
    a, b = [int(x) for x in wyjscie[0].split("/")] 
    c, d = [int(x) for x in wyjscie[2].split("/")] 
    if wyjscie[1] == '+': 
     licz = a * d + b * c 
     mian= b * d 
     nwd = euclid(licz, mian) 
     konA = licz/nwd 
     konB = mian/nwd 
     wynik = str(konA) + '/' + str(konB) 
     print(wynik) 
    elif wyjscie[1] == '-': 
     licz= a * d - b * c 
     mian= b * d 
     nwd = euclid(licz, mian) 
     konA = licz/nwd 
     konB = mian/nwd 
     wynik = str(konA) + '/' + str(konB) 
     print(wynik) 
    elif wyjscie[1] == '*': 
     licz= a * c 
     mian= b * d 
     nwd = euclid(licz, mian) 
     konA = licz/nwd 
     konB = mian/nwd 
     wynik = str(konA) + '/' + str(konB) 
     print(wynik) 
    else: 
     licz= a * d 
     mian= b * c 
     nwd = euclid(licz, mian) 
     konA = licz/nwd 
     konB = mian/nwd 
     wynik = str(konA) + '/' + str(konB) 
     print(wynik) 

Który ja zmniejszona do:

import sys 

def euclid(numA, numB): 
    while numB != 0: 
     numRem = numA % numB 
     numA = numB 
     numB = numRem 
    return numA 

for wejscie in sys.stdin: 
    wyjscie = wejscie.split(' ') 
    a, b = [int(x) for x in wyjscie[0].split("/")] 
    c, d = [int(x) for x in wyjscie[2].split("/")] 
    if wyjscie[1] == '+': 
     print("/".join([str((a * d + b * c)/euclid(a * d + b * c, b * d)),str((b * d)/euclid(a * d + b * c, b * d))])) 
    elif wyjscie[1] == '-': 
     print("/".join([str((a * d - b * c)/euclid(a * d - b * c, b * d)),str((b * d)/euclid(a * d - b * c, b * d))])) 
    elif wyjscie[1] == '*': 
     print("/".join([str((a * c)/euclid(a * c, b * d)),str((b * d)/euclid(a * c, b * d))])) 
    else: 
     print("/".join([str((a * d)/euclid(a * d, b * c)),str((b * c)/euclid(a * d, b * c))])) 

Każda rada na temat tego, jak poprawić to dalej, jest mile widziana.

Edycja: jeszcze jedna rzecz, o której zapomniałem wspomnieć - kod nie może korzystać z żadnych bibliotek poza sys.

Answer 1

bym utworzyć klasę zawierającą numerator i denominator pola (obie liczby) oraz wdrożenie __add__, __sub__, __mul__ i __div__ metod. Następnie możesz po prostu użyć zwykłych funkcji matematycznych, aby połączyć instancje.

Może to być przesada do twoich celów, ale kod będzie dużo czystszy.

W rzeczywistości podejście klasowe jest dokładnie tym, w jaki sposób wdrażany jest moduł fractions. Normalnie sugerowałbym zbadanie kodu źródłowego modułu frakcji, aby zobaczyć, jak jest napisany, ale ponieważ jest to praca domowa, nie jestem pewien, czy byłoby to dozwolone. Może warto sprawdzić po zakończeniu zadania, aby zobaczyć, jak implementowany jest pełnowymiarowy typ ułamkowego numeru.

Answer 2

Prawdopodobnie największą poprawę można zrobić byłoby użyć Python (2.6) 's fractions biblioteka:

>>> import fractions 
>>> fractions.Fraction(1,7) + fractions.Fraction("3/5") 
Fraction(26, 35) 

Answer 3

Można czynnik poza kodu, który redukuje część do najniższych kategoriach od osobnika «+» , '-', itp. To powinno uczynić kod nieco czystszym i bardziej zwartym i czytelnym.

Answer 4

Możesz użyć memoization na funkcji euclid, która może przyspieszyć działanie w zależności od danych wejściowych. Jednak będzie to więcej pamięci

Można również użyć zadanie krotka w euclid

def euclid(numA, numB): 
    while numB != 0: 
     numA, numB = numB, numA % numB 
    return numA 

mapie jest szybsze tutaj

a, b, c, d = map(int, wyjscie[0].split("/")+wyjscie[2].split("/")) 

Answer 5

Faktoring się euclid do funkcji pomocnika jest dobrym pomysłem. Sugerowałbym próbę dalszego podzielenia kodu na dodatkowe funkcje pomocnicze.

Jednym z pomysłów jest stworzenie czterech funkcji (dodawanie, odejmowanie, mnożenie, dzielenie), jak ten:

def multiply(val1, val2): 
    # Unpack the tuples. 
    numerator1, denominator1 = val1 
    numerator2, denoninator2 = val2 

    # Figure out the resulting numerator and denominator here. 

    # Return the result as a tuple. 
    return numerator, denominator 

byłaby kodu do korzystania z funkcji pomocniczych i myślę, że głównym kod będzie czystsze.

Answer 6

Można również zoptymalizować funkcję euklidesową. Zamiast używać algorytmu Euclida, możesz użyć Binary GCD.

Dwa sposoby wdrożenia algorytmu można znaleźć here, niestety kod jest w C. Wciąż nie sądzę, że jest to trudne, jeśli przetłumaczyć go na python.