Introducere

În acest articol, vă voi prezenta cum să rezolvați o întrebare tipică de interviu pentru dezvoltarea software-ului: Repetarea zecimalelor.

Pentru a rezolva acest exemplu, am decis să folosesc Python (tot codul este disponibil aici). Dacă doriți, nu ezitați să încercați să rezolvați același exercițiu folosind orice alt limbaj de programare la alegere.

Problema

Creați o funcție capabilă să ia două numere (numărătorul și numitorul unei fracții) care returnează rezultatele fracției în formă zecimală, încadrând între paranteze orice zecimal care se repetă.

Examples:
1) 1/3 = 0.(3)
2) 1/4 = 0.25
3) 1/5 = 0.2
4) 1/6 = 0.1(6)
5) 1/7 = 0.(142857)
6) 1/8 = 0.125

Vă voi prezenta acum printr-o implementare simplă pentru a rezolva această problemă. Dacă sunteți capabil să creați o soluție mai eficientă în timp și memorie, nu ezitați să o împărtășiți în secțiunea de comentarii de mai jos.

Soluția

Să începem prin a crea o funcție (repetarea_dec_sol) și gestionarea unor excepții simple:

  1. Dacă numeratorul este zero, întoarceți zero.
  2. Dacă numitorul este zero, întoarceți Nedefinit (la fel dacă atât numărătorul, cât și numitorul sunt egale cu zero).
  3. Dacă restul este zero, (numărătorul este divizibil cu numitorul) returnează direct rezultatul împărțirii.
  4. Dacă numeratorul sau numitorul returnează un număr negativ atunci când este împărțit, adăugați un semn minus la începutul rezultatului returnat (acest lucru se va face la sfârșitul codului).
def repeating_dec_sol(numerator, denominator):
    negative = False
    if denominator == 0:
        return 'Undefined'
    if numerator == 0:
        return '0'
    if numerator*denominator < 0:
        negative = True
    if numerator % denominator == 0:
        return str(numerator/denominator)
    
    num = abs(numerator)
    den = abs(denominator)

Acum, putem stoca pur și simplu ieșirea noastră pentru toate cifrele dinaintea punctului zecimal concatenând coeficientul numărătorului și numitorului într-un șir numit rezultat (care va fi folosit ulterior pentru a stoca întregul rezultat al operației).

    result = ""
    result += str(num // den)
    result += "."

Pentru a gestiona partea după punctul zecimal, vom începe acum să ținem evidența fiecărui numărător și coeficient nou (cantitatea produsă prin împărțirea celor două numere) după punctul zecimal.

După cum putem vedea din imaginea de mai jos (Figura 1), de fiecare dată când se repetă o zecimală, aceleași valori ale noilor numeratori și coeficienții vor fi repetați de mai multe ori.

Cum se rezolva o intrebare tipica de interviu privind repetarea
Figura 1: Zecimale repetate [1]

Pentru a modela acest comportament în Python, putem începe prin crearea unei liste goale (coeficient _num) pe care urmează să îl actualizăm cu toți numeratorii și coeficienții noi înregistrați după punctul zecimal (folosind o listă din listă).

De fiecare dată când vom adăuga o listă care conține un numărător și un coeficient nou, vom verifica dacă sunt prezente în orice altă listă aceeași combinație de numărător și coeficient nou și dacă acesta este cazul, atunci vom rupe execuția (acest steaguri) noi că am ajuns la o zecimală repetată).

    quotient_num = []
    while num:
    	# In case the remainder is equal to zero, there are no repeating
        # decimals. Therefore, we don't need to add any parenthesis and we can
        # break the while loop and return the result.
        remainder = num % den
        if remainder == 0:
            for i in quotient_num:
                result += str(i[-1])
            break
        num = remainder*10
        quotient = num // den

		# If the new numerator and quotient are not already in the list, we
        # append them to the list.
        if [num, quotient] not in quotient_num:
            quotient_num.append([num, quotient])
        # If the new numerator and quotient are instead already in the list, we 
        # break the execution and we prepare to return the final result.
        # We take track of the index position, in order to add the parenthesis 
        # at the output in the right place.
        elif [num, quotient] in quotient_num:
            index = quotient_num.index([num, quotient])
            for i in quotient_num[:index]:
                result += str(i[-1])
            result += "("
            for i in quotient_num[index:]:
                result += str(i[-1])
            result += ")"
            break

În cele din urmă, putem adăuga următorul cod pentru a gestiona excepția în cazul în care numeratorul sau numitorul de intrare sunt numere negative.

        if negative:
            result = "-" + result

    return result

Dacă acum ne testăm funcția, vom obține următorul rezultat:

NUM, DEN = 1, 6
print("The result of the fraction", NUM, "/", DEN, "is equal to: ",
       repeating_dec_sol(NUM, DEN))

# Output 
# The result of the fraction 1 / 6 is equal to:  0.1(6)

Concluzie

Sper că v-a plăcut acest articol. Dacă aveți întrebări, nu ezitați să lăsați un comentariu mai jos. Dacă căutați și o explicație video despre cum să rezolvați acest tip de problemă, aceasta video de PyLenin este un loc minunat pentru a începe.

Informatii de contact

Dacă doriți să fiți la curent cu ultimele mele articole și proiecte, urmați-mă și abonați-vă la listă de email-uri. Acestea sunt câteva dintre detaliile mele de contact:

Bibliografie

[1] 33 1 3 Procente ca o fracțiune Imagine matematică intitulată Schimbați o fracție comună într-o etapă zecimală 8 Panta Mathpapa – lugezi.com Accesat la: http://novine.club/wp-content/uploads//2018/09/33-1-3-percent-as-a-fraction-math-image-titled-change-a-common-fraction-into-a -decimal-step-8-mathpapa-pantă.jpg