Editing 3465 - jocprim

Sursa: [https://www.pbinfo.ro/probleme/3465/jocprim - jocprim]
----
== Cerinţa ==
Aky și Alex joacă un joc interesant. Acesta se desfășoară în felul următor: aceștia au cartonașe cu numere naturale până la '''10.000.000''' (se consideră că au un număr infinit de cartonașe pentru fiecare număr natural mai mic sau egal cu '''10.000.000'''). Ei aleg la întâmplare '''n''' cartonașe din cele date, iar pentru fiecare număr '''x''' de pe un cartonaș ales caută cartonașul pe care se află scris cel mai mare divizor prim al numărului '''x'''.

Astfel observă că pentru multe din numerele alese cel mai mare divizor prim coincide, deci se hotărăsc să creeze mai multe perechi de cartonașe astfel: primul cartonaș al perechii va fi un număr prim, '''P''', care este cel mai mare divizor prim al cel puțin unuia dintre numerele alese, iar numărul '''C''' de pe al doilea cartonaș reprezintă pentru câte din numerele din șirul numerelor alese numărul de pe primul cartonaș este cel mai mare divizor prim. De asemenea, perechile sunt ordonate crescător după '''P''''.

Cei doi băieți nu se descurcă singuri când numerele de pe cartonașe sunt foarte mari, deci vă roagă pe voi să realizați un program care să realizeze afișarea numarului de perechi formate precum și a acestora pentru un șir de '''n''' cartonașe alese.
== Date de intrare ==
Fișierul de intrare '''jocprim.in''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieșire == 
Dacă datele sunt introduse corect, pe ecran se va afișa: 
"Datele sunt corecte.", iar apoi in fișierul de ieșire '''jocprim.out''' va conține pe prima linie numărul de perechi formate, iar pe următoarele linii, câte o pereche de numere '''P''' și '''C''', separate printr-un spațiu, cu semnificațiile din enunț. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''n''' ≤ 20.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât'''10.000.000'''
== Exemple ==
===Exemplul 1===
; jocprim.in
: 12
: 6 8 3 4 24 20 25 26 30 15 18 22
; Ieșire
: Datele sunt corecte.
; jocprim.out
: 5
: 2 2
: 3 4
: 5 4
: 11 1
: 13 1
===Exemplul 2===
; jocprim.in
: 5
: 1 45 37 10 29
; Ieșire
: Datele sunt corecte.
; jocprim.out
: 4
: 1 1
: 5 2
: 29 1
: 37 1
 
===Exemplul 3===
; jocprim.in
: 2 
: 314441 41241241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
<br>
== Rezolvare == 
<syntaxhighlight lang="python" line>
#3465 jocprim

import math
def e_prim(n):
    if n < 2:
        return False
    for i in range(2, int(math.sqrt(n))+1):
        if n % i == 0:
            return False
    return True


def cel_mai_mare_divizor_prim(n):
    cel_mai_mare_divizor = 1
    for i in range(2, int(math.sqrt(n))+1):
        if n % i == 0 and e_prim(i):
            cel_mai_mare_divizor = i
        while n % i == 0:
            n //= i
    if n > 1 and e_prim(n):
        cel_mai_mare_divizor = n
    return cel_mai_mare_divizor
    

def numarare_perechi(n, vector):
    pairs = {}
    for cartonas in vector:
        divizor = cel_mai_mare_divizor_prim(cartonas)
        if divizor not in pairs:
            pairs[divizor]=0
        pairs[divizor] += 1
    result = sorted(pairs.items(), key=lambda x: x[0])
    return len(result), result
    
    
def joc_prim(vector,n):
    numar_perechi, perechi = numarare_perechi(n,vector)
    f = open("jocprim.out", "w")
    f.write(str(numar_perechi) + "\n")
    for p, c in perechi:
        f.write(str(p) + " " + str(c) + "\n")
    
    
def conform_restrictiilor():
    with open("jocprim.in", "r") as f:
        n = int(f.readline().strip())
        vector = list(map(int, f.readline().strip().split()))
        if n < 1 or n > 20000 or any(numere > 10000000 for numere in vector):
            print("Datele nu sunt conform restricțiilor impuse.")
            exit()
        print("Datele sunt corecte.")
        return vector, n
        

if __name__ == '__main__':
    vector , n = conform_restrictiilor()
    joc_prim(vector , n)

</syntaxhighlight>

==Explicaţie cod==
În funcția '''e_prim(n)''', se verifică dacă un număr dat '''n''' este prim. În cazul în care numărul este mai mic decât 2, se returnează False, altfel se verifică dacă '''n''' este divizibil cu orice număr între 2 și radicalul pătrat din '''n'''. Dacă da, atunci n nu este prim și se returnează False, altfel se returnează True.
În funcția '''cel_mai_mare_divizor_prim(n)''', se găsește cel mai mare divizor prim al unui număr dat '''n'''. Pentru fiecare număr între 2 și radicalul pătrat din '''n''', se verifică dacă acesta este divizor al lui '''n''' și, dacă este, se verifică dacă este prim. Dacă este, atunci acesta este cel mai mare divizor prim până în acel moment. Se continuă până când nu mai există divizori primi și se returnează cel mai mare divizor prim găsit.

În funcția '''numarare_perechi(n, vector)''', se calculează numărul și frecvența divizorilor primi ai fiecărui element dintr-un vector dat. Pentru fiecare element din vector, se găsește cel mai mare divizor prim utilizând funcția '''cel_mai_mare_divizor_prim(n)'''. Se construiește un dicționar în care se stochează fiecare divizor prim găsit și frecvența acestuia. Se sortează dicționarul în funcție de chei și se returnează numărul de perechi și dicționarul de perechi.
În funcția '''joc_prim(vector,n)''', se apelează funcția '''numarare_perechi(n, vector)''' pentru a obține numărul și frecvența divizorilor primi ai vectorului dat. Acestea sunt scrise într-un fișier '''jocprim.out'''.
În funcția '''conform_restrictiilor()''', se verifică dacă datele de intrare sunt conforme cu restricțiile impuse. Dacă sunt, se returnează vectorul și numărul dat.

În secțiunea '''if name == 'main':''', se apelează funcția '''conform_restrictiilor()''' pentru a obține datele de intrare, apoi se apelează funcția '''joc_prim(vector,n)''' pentru a scrie datele de ieșire în fișierul '''jocprim.out'''. În plus, se afișează un mesaj de confirmare dacă datele de intrare sunt corecte.