एक अंश कैलक्यूलेटर कोड बनाने के लिए टिप्स अधिक अनुकूलित (तेज और कम मेमोरी का उपयोग करके)

Question

मूल रूप से, मुझे प्रोग्राम के लिए जो कुछ चाहिए, वह सरल अंश कैलकुलेटर (अतिरिक्त, घटाव, गुणा और विभाजन) के लिए कार्य करना है। इनपुट के एकल लाइन, उदाहरण के लिए:
-Input: 1/7 + 3/5
आउटपुट: 26/35

मेरे प्रारंभिक कोड:

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) 

कौन सा मैं करने के लिए कम:

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))])) 

इस भविष्य में सुधार करने के तरीके पर कोई सलाह स्वागत है।

संपादित करें: एक और चीज जिसे मैं उल्लेख करना भूल गया - कोड sys के अलावा किसी भी पुस्तकालय का उपयोग नहीं कर सकता है।

Answer 1

मैं एक वर्ग numerator और denominator क्षेत्रों (दोनों पूर्णांक) और __add__, __sub__, __mul__, और __div__ तरीकों को लागू करने वाले बनाएंगे। फिर आप उदाहरणों को गठबंधन करने के लिए साधारण गणित कार्यों का उपयोग कर सकते हैं।

यह आपके उद्देश्यों के लिए अधिक हो सकता है, लेकिन कोड बहुत साफ होगा।

वास्तव में, कक्षा-आधारित दृष्टिकोण बिल्कुल fractions मॉड्यूल लागू किया गया है। आम तौर पर मैं यह देखने के लिए कि यह कैसे लिखा गया है, फ्रैक्शंस मॉड्यूल के स्रोत कोड की जांच करने का सुझाव देगा, लेकिन चूंकि यह होमवर्क के लिए है, मुझे यकीन नहीं है कि इसकी अनुमति होगी। असाइनमेंट खत्म हो जाने के बाद जांच करना उचित हो सकता है, यह देखने के लिए कि एक पूर्ण-उड़ा हुआ अंश-संख्या प्रकार कैसे कार्यान्वित किया जाता है।

Answer 2

शायद सबसे बड़ी सुधार आप कर सकते अजगर का उपयोग किया जाएगा (2.6) के fractions पुस्तकालय:

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

Answer 3

आप कोड है कि व्यक्ति से न्यूनतम शर्तों के अंश कम कर देता है को अलग कर सकता है '+' , '-', आदि। कोड को थोड़ा क्लीनर और अधिक कॉम्पैक्ट और पठनीय बनाना चाहिए।

Answer 4

आप memoization पर euclid फ़ंक्शन पर उपयोग कर सकते हैं जो इनपुट डेटा के आधार पर तेज़ी से मदद कर सकता है। हालांकि इस अधिक स्मृति का उपयोग करेगा

तुम भी में euclid

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

नक्शा एक टपल काम का उपयोग कर सकते तेजी से यहां

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

Answer 5

फैक्टरिंग बाहर euclid एक सहायक समारोह में है एक अच्छा विचार है। मैं सुझाव देता हूं कि आपके कोड को और अधिक सहायक कार्यों में आगे बढ़ाने की कोशिश करें।

एक विचार इस तरह चार कार्य (जोड़, घटाना, गुणा, विभाजित) बनाने के लिए है:

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 

सहायक कार्यों का उपयोग करने के लिए अपने कोड refactor और मुझे लगता है कि अपने मुख्य कोड क्लीनर हो जाएगा।

Answer 6

आप यूक्लिड फ़ंक्शन को भी अनुकूलित कर सकते हैं। यूक्लिड के एल्गोरिदम का उपयोग करने के बजाय आप Binary GCD का उपयोग कर सकते हैं।

एल्गोरिदम लागू करने के दो तरीके here पाया जा सकता है, दुर्भाग्य से कोड सी में है। फिर भी मुझे नहीं लगता कि अगर आप इसे पायथन में अनुवाद करते हैं तो यह मुश्किल है।