0555 - Overflow: Difference between revisions

From Bitnami MediaWiki
Paul Ungur (talk | contribs)
Pagină nouă: ==Cerința== Lui Gigel i s-a cerut să scrie un program care realizează înmulțirea dintre două numere naturale. Pentru a-i da o provocare lui Gigel, profesorul îi dă ca date de intrare un set de perechi de numere naturale pentru care produsul poate depăși <span style=“color: red”> 2 64</span>. Gigel trebuie acum să-și modifice programul pentru ca să poată detecta cazurile speciale. ==Date de intrare== Programul citește de la tastatură numărul <span style=...
 
Paul Ungur (talk | contribs)
No edit summary
 
(2 intermediate revisions by the same user not shown)
Line 6: Line 6:


==Date de ieșire==
==Date de ieșire==
Programul va afișa pe ecran rezultatele pentru cele <span style=“color: red”> n</span> operații, fiecare pe câte o linie. Rezultatul operației este produsul celor două numere, dacă acesta se poate reprezenta pe <span style=“color: red”> 8</span> octeți fără semn, sau mesajul <span style=“color: red”> Overflow!</span>, în caz contrar.
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran rezultatele pentru cele <span style=“color: red”> n</span> operații, fiecare pe câte o linie. Rezultatul operației este produsul celor două numere, dacă acesta se poate reprezenta pe <span style=“color: red”> 8</span> octeți fără semn, sau mesajul <span style=“color: red”> Overflow!</span>, în caz contrar. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''


==Restricții și precizări==
==Restricții și precizări==
Line 15: Line 15:
==Exemplu:==
==Exemplu:==
Intrare
Intrare
3
: 3
2147483647 2147483647
: 2147483647 2147483647
18446744073709551615 2
: 18446744073709551615 2
666013 1
: 666013 1


Ieșire
Ieșire
4611686014132420609
: Date de intrare valide
Overflow!
: 4611686014132420609
666013
: Overflow!
: 666013


==Rezolvare==
==Rezolvare==
<syntaxhighlight lang="python" line>
<syntaxhighlight lang="python" line>
def validate_input(n, a, b):
def validare(n):
    """
     if not (1 <= n <= 100_000):
    Verifică dacă numerele date sunt numere naturale și dacă se pot reprezenta pe 8 octeți.
         return False
    """
     return True
     if not isinstance(n, int) or not isinstance(a, int) or not isinstance(b, int):
         raise ValueError("Numerele trebuie să fie numere naturale.")
     if a > 18446744073709551615 or b > 18446744073709551615:
        raise ValueError("Valorile celor două numere trebuie să fie cuprinse între 0 și 18.446.744.073.709.551.615.")




def read_input():
def overflow(nr1, nr2):
    """
     return nr2 and nr1 > 18446744073709551615 // nr2
    Citește numărul n și cele n perechi de numere de la tastatură și verifică dacă datele sunt corecte.
    """
    n = int(input())
    result = []
    for i in range(n):
        a, b = map(int, input().split())
        validate_input(n, a, b)
        result.append((a, b))
     return result




def multiply(a, b):
def produs(nr1, nr2):
     """
     return nr1 * nr2
    Înmulțește cele două numere primite ca parametri și returnează rezultatul.
    """
    result = a * b
    if result > 18446744073709551615:
        return "Overflow!"
    return str(result)




def main():
def verificare(n):
     pairs = read_input()
     nr = []
     for a, b in pairs:
    for i in range(n):
         print(multiply(a, b))
        nr1, nr2 = map(int, input().split())
        nr.append((nr1, nr2))
     for i in range(n):
        if overflow(nr[i][0], nr[i][1]):
            print("Overflow!")
         else:
            print(produs(nr[i][0], nr[i][1]))




if __name__ == "__main__":
if __name__ == '__main__':
    main()
    n = int(input())
    if validare(n):
        print("Date de intrare valide")
        verificare(n)
    else:
        print("Date de intrare invalide")
</syntaxhighlight>
</syntaxhighlight>
==Explicatie cod:==
Acest cod Python realizează următoarele acțiuni:


==Explicatie==
Funcția validare(n) primește un parametru n de tip întreg și verifică dacă acesta se află în intervalul [1, 100_000]. Dacă condiția este îndeplinită, funcția returnează True, altfel returnează False.
Programul are trei funcții:
Funcția overflow(nr1, nr2) primește două parametri nr1 și nr2 de tip întreg și verifică dacă există un overflow în timpul efectuării operației de înmulțire nr1 * nr2. Dacă nr2 este diferit de zero și rezultatul înmulțirii depășește valoarea maximă acceptată de un număr întreg în Python (18446744073709551615), funcția returnează True, altfel returnează False.
 
Funcția produs(nr1, nr2) primește două parametri nr1 și nr2 de tip întreg și returnează rezultatul înmulțirii lor.
validate_input: verifică dacă cele trei numere date sunt numere naturale și dacă cele două numere din pereche pot fi reprezentate pe 8 octeți fără semn. Dacă una din condiții nu este îndeplinită, se aruncă o excepție cu mesajul corespunzător.
Funcția verificare(n) primește un parametru n de tip întreg și efectuează verificarea și afișarea produselor pentru perechile de numere citite de la intrare. În cadrul unei bucle, se citește fiecare pereche de numere și se apelează funcția overflow(nr1, nr2) pentru a verifica dacă există un overflow. Dacă există un overflow, se afișează mesajul "Overflow!", altfel se calculează produsul folosind funcția produs(nr1, nr2) și se afișează rezultatul.
read_input: citește numărul n și cele n perechi de numere de la tastatură, apoi validează datele și le adaugă într-o listă. Funcția returnează lista cu perechile de numere.
În blocul if __name__ == '__main__':, se citește n de la intrare folosind funcția input(). Se validează datele de intrare utilizând funcția validare(n). Dacă datele de intrare sunt valide, se afișează un mesaj de confirmare, se apelează funcția verificare(n) și se afișează rezultatele pe ecran. Altfel, se afișează un mesaj de eroare.
multiply: primește două numere ca parametri, le înmulțește și verifică dacă rezultatul se poate reprezenta pe 8 octeți fără semn. Dacă rezultatul este mai mare, returnează mesajul "Overflow!", altfel returnează rezultatul ca șir de caractere.
Codul primește un număr de la intrare, validează datele și verifică dacă există un overflow în timpul înmulțirii perechilor de numere citite. Produsele sau mesajele de overflow sunt afișate pe ecran.
Funcția main apelează read_input pentru a citi datele de intrare și multiply pentru a înmulți fiecare pereche de numere. Rezultatele sunt afișate pe ecran, fiecare pe câte o linie.

Latest revision as of 19:08, 29 June 2023

Cerința[edit | edit source]

Lui Gigel i s-a cerut să scrie un program care realizează înmulțirea dintre două numere naturale. Pentru a-i da o provocare lui Gigel, profesorul îi dă ca date de intrare un set de perechi de numere naturale pentru care produsul poate depăși 2 64. Gigel trebuie acum să-și modifice programul pentru ca să poată detecta cazurile speciale.

Date de intrare[edit | edit source]

Programul citește de la tastatură numărul n, iar apoi n perechi de numere naturale, care trebuie înmulțite.

Date de ieșire[edit | edit source]

Dacă datele sunt introduse corect, pe ecran se va afișa: "Date de intrare valide.", apoi programul va afișa pe ecran rezultatele pentru cele n operații, fiecare pe câte o linie. Rezultatul operației este produsul celor două numere, dacă acesta se poate reprezenta pe 8 octeți fără semn, sau mesajul Overflow!, în caz contrar. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Date de intrare invalide".

Restricții și precizări[edit | edit source]

1 ≤ n ≤ 100.000 pentru fiecare pereche, cele două numere se pot reprezenta pe 8 octeți, fără semn valorile care se pot reprezenta pe 8 octeți fără semn sunt cuprinse între 0 și 18.446.744.073.709.551.615

Exemplu:[edit | edit source]

Intrare

3
2147483647 2147483647
18446744073709551615 2
666013 1

Ieșire

Date de intrare valide
4611686014132420609
Overflow!
666013

Rezolvare[edit | edit source]

<syntaxhighlight lang="python" line> def validare(n):

   if not (1 <= n <= 100_000):
       return False
   return True


def overflow(nr1, nr2):

   return nr2 and nr1 > 18446744073709551615 // nr2


def produs(nr1, nr2):

   return nr1 * nr2


def verificare(n):

   nr = []
   for i in range(n):
       nr1, nr2 = map(int, input().split())
       nr.append((nr1, nr2))
   for i in range(n):
       if overflow(nr[i][0], nr[i][1]):
           print("Overflow!")
       else:
           print(produs(nr[i][0], nr[i][1]))


if __name__ == '__main__':

   n = int(input())
   if validare(n):
       print("Date de intrare valide")
       verificare(n)
   else:
       print("Date de intrare invalide")

</syntaxhighlight>

Explicatie cod:[edit | edit source]

Acest cod Python realizează următoarele acțiuni:

Funcția validare(n) primește un parametru n de tip întreg și verifică dacă acesta se află în intervalul [1, 100_000]. Dacă condiția este îndeplinită, funcția returnează True, altfel returnează False. Funcția overflow(nr1, nr2) primește două parametri nr1 și nr2 de tip întreg și verifică dacă există un overflow în timpul efectuării operației de înmulțire nr1 * nr2. Dacă nr2 este diferit de zero și rezultatul înmulțirii depășește valoarea maximă acceptată de un număr întreg în Python (18446744073709551615), funcția returnează True, altfel returnează False. Funcția produs(nr1, nr2) primește două parametri nr1 și nr2 de tip întreg și returnează rezultatul înmulțirii lor. Funcția verificare(n) primește un parametru n de tip întreg și efectuează verificarea și afișarea produselor pentru perechile de numere citite de la intrare. În cadrul unei bucle, se citește fiecare pereche de numere și se apelează funcția overflow(nr1, nr2) pentru a verifica dacă există un overflow. Dacă există un overflow, se afișează mesajul "Overflow!", altfel se calculează produsul folosind funcția produs(nr1, nr2) și se afișează rezultatul. În blocul if __name__ == '__main__':, se citește n de la intrare folosind funcția input(). Se validează datele de intrare utilizând funcția validare(n). Dacă datele de intrare sunt valide, se afișează un mesaj de confirmare, se apelează funcția verificare(n) și se afișează rezultatele pe ecran. Altfel, se afișează un mesaj de eroare. Codul primește un număr de la intrare, validează datele și verifică dacă există un overflow în timpul înmulțirii perechilor de numere citite. Produsele sau mesajele de overflow sunt afișate pe ecran.