1608 - Sortare Divizori: Difference between revisions

From Bitnami MediaWiki
No edit summary
 
(One intermediate revision by the same user not shown)
Line 11: Line 11:




== Exemplu 1 ==
== Exemplul 1 ==
; sortare_divizoriin.txt
; sortare_divizoriin.txt
: 5
5
: 12 20 4 100 13
12 20 4 100 13
;sortare_divizoriout.txt
;sortare_divizoriout.txt
: 100 12 20 4 13
Datele de intrare respectă cerințele impuse.
100 12 20 4 13
 
==Explicație==
12 are 6 divizori, 20 are 6 divizori, 4 are 3 divizori, 100 are 9 divizori, 13 are 2 divizori, 12 și 20 au același număr de divizori. Așadar ordinea va fi 100 12 20 4 13.
==Exemplul2==
; sortare_divizoriin.txt
5
12 20 4 100 1000000001
; sortare_divizoriout.txt
Datele de intrare nu respectă cerințele impuse.
<br>
<br>
== Rezolvare ==  
== Rezolvare ==  
Line 27: Line 37:
     return divizori
     return divizori


if __name__ == "__main__":
def sortare_divizori(n, numere):
     # Citim numărul n și lista de numere din fișierul de intrare
     # Calculează numărul de divizori pentru fiecare număr și creează o listă de tupluri (număr, număr_divizori)
     with open("sortare_divizoriin.txt", "r") as f:
    numere_divizori = [(nr, numar_divizori(nr)) for nr in numere]
        n = int(f.readline().strip())
 
        numere = list(map(int, f.readline().strip().split()))
    # Sortează lista de tupluri în funcție de numărul de divizori descrescător și apoi după valoarea numărului crescător
    numere_divizori.sort(key=lambda x: (-x[1], x[0]))
 
    return [nr for nr, _ in numere_divizori]
 
def main():
     try:
        with open("sortare_divizoriin.txt", "r", encoding="utf-8") as f:
            n = int(f.readline())
            if not 1 <= n <= 1000:
                raise ValueError
            numere = list(map(int, f.readline().split()))
            if not all(1 <= nr < 1000000000 for nr in numere):
                raise ValueError
 
        with open("sortare_divizoriout.txt", "w", encoding="utf-8") as f_out:
            f_out.write("Datele de intrare respectă cerințele impuse.\n")


    # Verificăm restricțiile impuse pentru numere
            rezultat = sortare_divizori(n, numere)
     numere = [numar for numar in numere if numar < 1000000000]
            f_out.write(" ".join(map(str, rezultat)))
     except Exception as e:
        with open("sortare_divizoriout.txt", "w", encoding="utf-8") as f_out:
            f_out.write(f"Datele de intrare nu respectă cerințele impuse.")


    # Calculăm numărul de divizori pentru fiecare număr și sortăm numerele în ordine descrescătoare după numărul de divizori,
if __name__ == "__main__":
     # iar în caz de egalitate, sortăm crescător
     main()
    numere.sort(key=lambda x: (numar_divizori(x), -x), reverse=True)


    # Scriem rezultatul în fișierul de ieșire
    with open("sortare_divizoriout.txt", "w") as f:
        for numar in numere:
            f.write(str(numar) + " ")
</syntaxhighlight>
</syntaxhighlight>
==Explicație==
12 are 6 divizori, 20 are 6 divizori, 4 are 3 divizori, 100 are 9 divizori, 13 are 2 divizori, 12 și 20 au același număr de divizori. Așadar ordinea va fi 100 12 20 4 13.

Latest revision as of 19:31, 10 January 2024

Cerinţa[edit | edit source]

Se dau n numere naturale nenule. Ordonați descrescător cele n numere după numărul lor de divizori.

Date de intrare[edit | edit source]

Fișierul de intrare sortare_divizoriin.txt conține pe prima linie numărul n, iar pe a doua linie n numere naturale nenule separate prin câte un spațiu.

Date de ieșire[edit | edit source]

Fișierul de ieșire sortare_divizoriout.txt va conține cele n numere aflate pe a doua linie a fișierului de intrare ordonate descrescător după numărul de divizori.

Restricţii şi precizări[edit | edit source]

  • 1 ≤ n ⩽ 1.000
  • numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât 1.000.000.000
  • dacă există mai multe numere care au același număr de divizori, acestea vor fi ordonate crescător


Exemplul 1[edit | edit source]

sortare_divizoriin.txt
5
12 20 4 100 13
sortare_divizoriout.txt
Datele de intrare respectă cerințele impuse.
100 12 20 4 13

Explicație[edit | edit source]

12 are 6 divizori, 20 are 6 divizori, 4 are 3 divizori, 100 are 9 divizori, 13 are 2 divizori, 12 și 20 au același număr de divizori. Așadar ordinea va fi 100 12 20 4 13.

Exemplul2[edit | edit source]

sortare_divizoriin.txt
5
12 20 4 100 1000000001
sortare_divizoriout.txt
Datele de intrare nu respectă cerințele impuse.


Rezolvare[edit | edit source]

<syntaxhighlight lang="python" line>

def numar_divizori(numar):
   divizori = 0
   for i in range(1, numar + 1):
       if numar % i == 0:
           divizori += 1
   return divizori

def sortare_divizori(n, numere):

   # Calculează numărul de divizori pentru fiecare număr și creează o listă de tupluri (număr, număr_divizori)
   numere_divizori = [(nr, numar_divizori(nr)) for nr in numere]
   # Sortează lista de tupluri în funcție de numărul de divizori descrescător și apoi după valoarea numărului crescător
   numere_divizori.sort(key=lambda x: (-x[1], x[0]))
   return [nr for nr, _ in numere_divizori]

def main():

   try:
       with open("sortare_divizoriin.txt", "r", encoding="utf-8") as f:
           n = int(f.readline())
           if not 1 <= n <= 1000:
               raise ValueError
           numere = list(map(int, f.readline().split()))
           if not all(1 <= nr < 1000000000 for nr in numere):
               raise ValueError
       with open("sortare_divizoriout.txt", "w", encoding="utf-8") as f_out:
           f_out.write("Datele de intrare respectă cerințele impuse.\n")
           rezultat = sortare_divizori(n, numere)
           f_out.write(" ".join(map(str, rezultat)))
   except Exception as e:
       with open("sortare_divizoriout.txt", "w", encoding="utf-8") as f_out:
           f_out.write(f"Datele de intrare nu respectă cerințele impuse.")

if __name__ == "__main__":

   main()

</syntaxhighlight>