Bitnami MediaWiki - User contributions [en]

15678

2024-01-16T08:42:38Z

Paul Matei:

'''15678 (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)'''

''Aflați toate numerele de forma ''<math>\overline{abcd}</math>''pentru care<math display="block">\overline{abcd} = 2021+5(a-c+b-d+1).</math>''

'''Soluție:'''

''Ultima cifră numărului 5(a-c+b-d+1) poate fi 0 sau 5.Atunci ultima cifră a numărului 2021+5(a-c+b-d+1) poate fi 1 sau 6,de unde deducem că d=1 sau d=6.Pentru d=1 relația devine ''<math>\overline{abcd}</math>''= 2021+5(a-c+b).Deoarece a-c+b≤18 avem 2021+5(a-c+b)≤2111 și, cum ''<math>\overline{abcd}</math>''= 2021+5(a-c+b), obținem a≤2.Pentru a=2 relația dată devine ''<math>\overline{2bc1}</math>''= 2021+5(2-c+b)sau 2001+100b+10c=2031-5c+5b,de unde 95b+15c=30.De aici b=0 și c=2.Numărul căutat este 2021.Pentru a=1 nu obținem nicio soluție.Pentru d=6 relația dată devine ''<math>\overline{abc6}</math>''= 2021+5(a-c+b-5).Deoarece a-c+b-5≤13 avem 2021+5(a-c+b)≤2086 și cum ''<math>\overline{abc6}</math>''= 2021+5(a-c+b-5),obținem a≤2.Pentru a=2 relația dată devine ''<math>\overline{2bc6}</math>''= 2021+5(2-c+b-5) sau 2006+100b+10c=2006-5c+5b,de unde 95b+15c=0.De aici b=0 și c=0.Numărul căutat este 2006.Pentru a=1 nu obținem nicio soluție.''

15678

2024-01-16T07:47:49Z

Paul Matei:

14441

2024-01-16T07:39:25Z

Paul Matei: Paul Matei a redenumit pagina 14441 în 15678

#REDIRECTEAZA [[15678]]

15678

2024-01-16T07:39:24Z

Paul Matei: Paul Matei a redenumit pagina 14441 în 15678

'''14441 (Constantin Apostol, Rm. Sărat)'''

''Arătați că oricare ar fi cifrele '' <math>a</math> '' și <math>b</math>, numărul <math>\overline{ab15}</math> are un număr par de divizori naturali.''

'''Soluție:'''

''Se știe că un număr natural cu un număr impar de divizori este pătrat perfect.De asemenea, un pătrat perfect care are cifra unităților 5 are cifra zecilor 2.Cu acestea, dacă presupunem că numărul <math>\overline{ab15}</math> are un număr impar de divizori, atunci el este pătrat perfect-fals.''

User:Paul Matei

2024-01-13T16:52:05Z

Paul Matei: Paul Matei a redenumit pagina Utilizator:Paul Matei în 14441

#REDIRECTEAZA [[14441]]

15678

2024-01-13T16:52:05Z

Paul Matei: Paul Matei a redenumit pagina Utilizator:Paul Matei în 14441

15678

2024-01-13T16:33:46Z

Paul Matei: Pagină nouă: '''14441 (Constantin Apostol, Rm. Sărat)''' ''Arătați că oricare ar fi cifrele '' <math>a</math> '' și <math>b</math>, numărul <math>\overline{ab15}</math> are un număr par de divizori naturali.'' '''Soluție:''' ''Se știe că un număr natural cu un număr impar de divizori este pătrat perfect.De asemenea, un pătrat perfect care are cifra unităților 5 are cifra zecilor 2.Cu acestea, dacă presupunem că numărul <math>\overline{ab15}</math> are un număr i...

0440 - Fact Zero 1

2023-04-29T12:43:02Z

Paul Matei: Pagină nouă: == Cerinţa == Se citește un număr natural '''n'''. Să se determine ultima cifră nenulă din scrierea zecimală a numărului '''n!'''. == Date de intrare == Programul citește de la tastatură numărul '''n'''. == Date de ieşire == Programul afișează pe ecran numărul '''C''', reprezentând ultima cifră nenulă din scrierea zecimală a numărului '''n!'''. == Restricții și precizări == *'''1 ≤ n ≤ 1000''' *'''n! = 1 * 2 * ... * n''' == Exemplu == ; Intrare :13...

== Cerinţa ==
Se citește un număr natural '''n'''. Să se determine ultima cifră nenulă din scrierea zecimală a numărului '''n!'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''C''', reprezentând ultima cifră nenulă din scrierea zecimală a numărului '''n!'''.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*'''n! = 1 * 2 * ... * n'''
== Exemplu ==
; Intrare
:13
; Ieșire
:8
== Explicație ==
'''13! = 6227020800''', iar ultima cifră nenulă este '''8'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
if n < 1 or n > 1000:
return False
return True

if __name__ == '__main__':
n = int(input("Introduceți numărul n: "))

if validare_date(n):
# Inițializăm contoarele pentru factorii 2 și 5
nr_factori_2 = 0
nr_factori_5 = 0

# Calculăm numărul de factori ai lui 2 și 5 din descompunerea factorialului
for i in range(2, n+1):
x = i
while x % 2 == 0:
nr_factori_2 += 1
x //= 2
while x % 5 == 0:
nr_factori_5 += 1
x //= 5

# Determinăm ultima cifră nenulă
if nr_factori_2 > nr_factori_5:
ultima_cifra_nenula = 8
elif nr_factori_5 > nr_factori_2:
ultima_cifra_nenula = 5
else:
ultima_cifra_nenula = 6

print("Ultima cifră nenulă a lui", n, "! este", ultima_cifra_nenula)
print("\nDatele de intrare corespund restricțiilor impuse.\n")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Pentru a determina ultima cifră nenulă din descompunerea factorialului numărului '''n''', trebuie să determinăm câți factori primi '''2''' și câți factori primi '''5''' sunt în descompunerea factorialului și să comparăm aceste valori. Pentru a implementa această soluție în Python, putem citi numărul '''n''' de la tastatură și apoi putem calcula numărul de factori primi '''2''' și '''5''' din descompunerea factorialului folosind o buclă for și două bucle '''while'''. După ce am calculat numărul de factori primi '''2''' și '''5''', putem compara aceste valori și să determinăm ultima cifră nenulă. Pentru a ne asigura că datele de intrare respectă restricțiile impuse, putem defini o funcție separată de validare a datelor și să apelăm această funcție înainte de a efectua calculul și afișarea rezultatului.

0439 - Fact Zero

2023-04-29T12:27:17Z

Paul Matei: Pagină nouă: == Cerinţa == Se citește un număr natural '''n'''. Să se determine numărul de zerouri de la sfârșitul scrierii zecimale a numărului '''n!'''. == Date de intrare == Programul citește de la tastatură numărul '''n'''. == Date de ieşire == Programul afișează pe ecran numărul '''Z''', reprezentând numărul de zerouri de la sfârșitul scrierii zecimale a numărului '''n!'''. == Restricții și precizări == *'''1 ≤ n ≤ 1000''' *'''n! = 1 * 2 * ... * n''' == Exe...

== Cerinţa ==
Se citește un număr natural '''n'''. Să se determine numărul de zerouri de la sfârșitul scrierii zecimale a numărului '''n!'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''Z''', reprezentând numărul de zerouri de la sfârșitul scrierii zecimale a numărului '''n!'''.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*'''n! = 1 * 2 * ... * n'''
== Exemplu ==
; Intrare
:13
; Ieșire
:2
== Explicație ==
'''13! = 6227020800''', deci se termină cu '''2''' zerouri.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
if n < 1 or n > 10**5:
return False
return True

def calculeaza_puteri(n):
nr5 = 0
nr2 = 0

i = 5
while i <= n:
nr5 += n // i
i *= 5

i = 2
while i <= n:
nr2 += n // i
i *= 2

if nr5 <= nr2:
return nr5
else:
return nr2

if __name__ == '__main__':
n = int(input("Introduceti n: "))
if validare_date(n):
putere = calculeaza_puteri(n)
print(f"Puterea minima de 2 sau 5 care divide n! fara rest este: {putere}")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Acest cod calculează puterea minimă de '''2''' sau '''5''' care divide '''n!''' fără rest, unde '''n''' este un număr dat de la tastatură. Codul verifică mai întâi dacă intrarea este validă, apoi folosește două bucle '''while''' pentru a calcula numărul de factori de '''5''' și '''2''' care împart '''n!''' fără rest. La final, codul compară cele două numere de factori și afișează cel mai mic dintre ele ca putere minimă de '''2''' sau '''5''' care divide '''n!''' fără rest.

2769 - Trei Prime

2023-04-29T12:09:26Z

Paul Matei: Pagină nouă: == Cerinţa == Se dă un număr natural '''n''' care este produs de trei numere prime distincte. Ştiind că există '''m''' numere naturale prime cu '''n''' şi mai mici decât acesta, să se afişeze în ordine crescătoare cele trei numere prime din descompunerea lui '''n'''. == Date de intrare == Programul citește de la tastatură numerele '''n''' şi '''m'''. == Date de ieşire == Programul va afișa pe ecran numerele prime din descompunerea lui '''n'''. == Restricții...

== Cerinţa ==
Se dă un număr natural '''n''' care este produs de trei numere prime distincte. Ştiind că există '''m''' numere naturale prime cu '''n''' şi mai mici decât acesta, să se afişeze în ordine crescătoare cele trei numere prime din descompunerea lui '''n'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m'''.
== Date de ieşire ==
Programul va afișa pe ecran numerele prime din descompunerea lui '''n'''.
== Restricții și precizări ==
*1 ≤ m ≤ n ≤ 10*18
== Exemplu ==
; Intrare
:66 20
; Ieșire
:2 3 11
== Explicație ==
Avem '''66=2•3•11''' şi există '''20''' de numere prime cu '''66''', mai mici decât acesta.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date(n, m):
if not (1 <= m <= n <= 10**18):
return False
return True

if __name__ == '__main__':
# Citim valorile de la tastatură
n = int(input("Introduceti numarul n: "))
m = int(input("Introduceti numarul m: "))

# Validăm datele de intrare
if not validare_date(n, m):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
# Initializam variabilele
factori = []
numar_prim = 0

# Factorizam numarul n
while n > 1:
for i in range(2, int(math.sqrt(n))+1):
if n % i == 0:
factori.append(i)
n //= i
break
else:
factori.append(n)
n //= n

# Numaram factorii primi care sunt mai mici decat n si sunt, de asemenea, primi
for factor in factori:
if factor < n and all(factor % i != 0 for i in range(2, int(math.sqrt(factor))+1)):
numar_prim += 1

# Afisam cei trei factori primi distincti ai lui n in ordine crescatoare
print(sorted(set(factori))[:3])
print("\nDatele de intrare corespund restricțiilor impuse.\n")

</syntaxhighlight>

==Explicație rezolvare==
Acest program calculează factorii primi ai unui număr natural dat și afișează cele trei numere prime distincte care alcătuiesc acel număr, precum și numărul de numere prime mai mici decât numărul dat și le afișează pe ecran. Programul verifică mai întâi dacă datele de intrare sunt valide și apoi factorizează numărul dat pentru a găsi factorii primi. În cele din urmă, programul afișează cele trei numere prime distincte din lista factorilor primi și confirmă că datele de intrare sunt valide.

3308 - N Div Tri

2023-04-29T11:55:19Z

Paul Matei: Pagină nouă: == Cerinţa == Șirul numerelor triunghiulare e obținut prin adunarea numerelor naturale. Deci al șaptelea număr triunghiular e '''1 + 2 + 3 + 4 + 5 + 6 + 7 = 28'''. Primii '''10''' termeni din șir sunt: '''1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...''' Să listăm toți divizorii primelor '''7''' numere triunghiulare: '''1: 1 3: 1,3 6: 1,2,3,6 10: 1,2,5,10 15: 1,3,5,15 21: 1,3,7,21 28: 1,2,4,7,14,28''' Se poate observa că '''28''' e primul număr triunghiular care are...

== Cerinţa ==
Șirul numerelor triunghiulare e obținut prin adunarea numerelor naturale. Deci al șaptelea număr triunghiular e '''1 + 2 + 3 + 4 + 5 + 6 + 7 = 28'''. Primii '''10''' termeni din șir sunt: '''1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...'''
Să listăm toți divizorii primelor '''7''' numere triunghiulare:
'''1: 1
3: 1,3
6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28'''

Se poate observa că '''28''' e primul număr triunghiular care are mai mult de '''5''' divizori.
Se dă un număr natural '''n'''. Să se scrie un program care determină '''primul număr triunghiular''' cu mai mult de '''n''' divizori.
== Date de intrare ==
Programul citește de la tastatură numărul natural '''n'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''x''', reprezentând primul număr triunghiular care are mai mult de '''n''' divizori.
== Restricții și precizări ==
*1 ≤ n ≤ 1000
== Exemplu ==
; Intrare
:3
; Ieșire
:6
== Explicație ==
Primul număr trunghiular care are mai mult de '''3''' divizori este '''6'''.
== Exemplu 2 ==
; Intrare
:1
; Ieșire
:3
== Explicație ==
Primul număr trunghiular care are mai mult de un divizor este '''3'''.
== Exemplu 3 ==
; Intrare
:133
; Ieșire
:437580
== Explicație ==
Primul număr trunghiular care are mai mult de '''133''' de divizori este '''437580'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_divizori(n):
numar = 0
for i in range(1, int(n**0.5)+1):
if n % i == 0:
if n/i == i:
numar += 1
else:
numar += 2
return numar

def validare_date(n):
if n.isdigit() and 1 <= int(n) <= 1000:
print("\nDatele de intrare corespund restricțiilor impuse.\n")
return True
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
return False

if __name__ == '__main__':
n = input("Introduceti n: ")

if validare_date(n):
numar = 1
index = 2

while numar_divizori(numar) <= int(n):
numar += index
index += 1

print("Primul număr triunghiular cu mai mult de", n, "divizori este:", numar)

</syntaxhighlight>

==Explicație rezolvare==
Acest program găsește primul număr triunghiular care are mai mult de '''n''' divizori. Folosind o buclă '''while''', programul calculează numerele triunghiulare și numără divizorii acestora până când se găsește primul număr triunghiular care are mai mult de '''n''' divizori. Pentru a se asigura că datele de intrare sunt valide, programul include o funcție care verifică dacă '''n''' se află în intervalul specificat.

2608 - Bi Prime

2023-04-29T11:33:46Z

Paul Matei: Pagină nouă: == Cerinţa == Se dă '''n''' un număr natural care este produsul a două numere prime distincte, şi '''m''' reprezentând numărul numerelor mai mici sau egale cu '''n''', prime cu '''n'''. Aflaţi cele două numere prime din descompunerea lui '''n'''. == Date de intrare == Programul citește de la tastatură numerele '''n''' şi '''m'''. == Date de ieşire == Programul va afișa pe ecran numerele prime din descompunerea lui '''n''', în ordine crescătoare, separate prin...

== Cerinţa ==
Se dă '''n''' un număr natural care este produsul a două numere prime distincte, şi '''m''' reprezentând numărul numerelor mai mici sau egale cu '''n''', prime cu '''n'''. Aflaţi cele două numere prime din descompunerea lui '''n'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m'''.
== Date de ieşire ==
Programul va afișa pe ecran numerele prime din descompunerea lui '''n''', în ordine crescătoare, separate prin spaţiu.
== Restricții și precizări ==
*'''1 ≤ m ≤ n ≤ 10*25'''
== Exemplu ==
; Intrare
:8777 8580
; Ieșire
:67 131
== Explicație ==
Avem '''8777=67•131'''
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

# functie pentru a calcula cel mai mare divizor comun
def cmmdc(a, b):
if b == 0:
return a
return cmmdc(b, a % b)

# functie pentru a determina un factor al lui n folosind metoda lui Pollard-Rho
def pollard_rho(n):
x = 2
y = 2
d = 1
while d == 1:
x = (x * x + 1) % n
y = (y * y + 1) % n
y = (y * y + 1) % n
d = cmmdc(abs(x - y), n)
return d

# functie pentru a valida datele de intrare
def validare_date(n, m):
if n < 1 or m < 1 or n > 10**25 or m > n:
return False
return True

if __name__ == '__main__':
# citim numerele n si m de la tastatura
n, m = map(int, input().split())

# validam datele de intrare
if validare_date(n, m):
# factorizam n folosind metoda lui Pollard-Rho
factor1 = pollard_rho(n)
factor2 = n // factor1

# calculam numarul de numere prime mai mici sau egale cu n, prime cu n
phi = (factor1 - 1) * (factor2 - 1)

# afisam cei doi factori primi ai lui n in ordine crescatoare
print(min(factor1, factor2), max(factor1, factor2))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

4305 - Chimie 1

2023-04-29T11:19:00Z

Paul Matei: Pagină nouă: == Cerinţa == Mateo este elev în clasa a 9-a și este pasionat atât de chimie cât și de informatică. El folosește de obicei două substanțe standard în cantități ce reprezintă două numere prime distincte, și a descoperit că anumite substanțe au în compoziție una sau chiar cele două substanțe standard în cantități ce reprezintă produsul cantităților celor două substanțe standard sau puteri ale acestora. El are în laborator un set de recipiente cu s...

== Cerinţa ==
Mateo este elev în clasa a 9-a și este pasionat atât de chimie cât și de informatică. El folosește de obicei două substanțe standard în cantități ce reprezintă două numere prime distincte, și a descoperit că anumite substanțe au în compoziție una sau chiar cele două substanțe standard în cantități ce reprezintă produsul cantităților celor două substanțe standard sau puteri ale acestora. El are în laborator un set de recipiente cu substanțe diferite și dorește să afle care este substanța de cantitate maximă care să aibă în componență una sau chiar cele două substanțe standard și de câte ori se regăsește această substanță de cantitate maximă.
Pentru a-l ajuta pe Mateo căutați într-un sir de '''n''' numere cel mai mare element care are maximum doi divizori factori primi '''d1 si d2''', reprezentând cele două substanțe standard și afișați de câte ori apare.
== Date de intrare ==
Fișierul de intrare '''chimie1.in''' conține pe prima linie trei parametrii '''n''', '''d1 și d2''' cu semnificația din enunț, iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieşire ==
Fișierul de ieșire '''chimie1.out''' va conține pe prima linie numărul '''m''', reprezentând cel mai mare număr care respectă cerința și o variabilă '''ap''' care reprezintă numărul său de apariții. Dacă nu există niciun număr care respectă cerința se afișează mesajul '''NU EXISTA'''.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1.000.000'''
*'''1 < d1 < d2 < 33.000'''
*numerele de pe a doua linie a fișierului de intrare sunt naturale și vor fi mai mici decât '''33000'''
== Exemplu ==
; '''chimie1.in'''
:6 5 7
4 35 5 175 23 175
; '''chimie1.out'''
:175 2
== Explicație ==
'''175''' este format din '''5''' la puterea '''2''' si '''7''' la puterea '''1'''. Mai apar în șir numere care respectă cerința, dar '''175''' este cel mai mare.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n, d1, d2, numere):
return 1 <= n <= 1000000 and 1 < d1 < d2 < 33000 and all(numar < 33000 for numar in numere)

if __name__ == '__main__':
# citire date din fisier
with open('chimie1.in', 'r') as f:
n, d1, d2 = map(int, f.readline().split())
numere = list(map(int, f.readline().split()))

# validare date
if not validare_date(n, d1, d2, numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
exit()

# calculare rezultat
numere_aparitii = {}
for numar in numere:
if numar % d1 == 0 or numar % d2 == 0:
# numarul are unul dintre divizorii cautati
factori = set()
if numar % d1 == 0:
factori.add(d1)
numar //= d1
if numar % d2 == 0:
factori.add(d2)
numar //= d2
if numar == 1 and len(factori) <= 2:
# numarul are maxim 2 factori primi si are cel putin unul dintre divizorii cautati
numere_aparitii[numar] = numere_aparitii.get(numar, 0) + 1

# afisare rezultat
if not numere_aparitii:
print("NU EXISTA")
else:
max_numar = max(numere_aparitii.keys())
ap_max = numere_aparitii[max_numar]
print(max_numar, ap_max)

</syntaxhighlight>

==Explicație rezolvare==
În acest cod se caută cel mai mare număr dintr-o listă care are cel puțin unul dintre doi divizori specificați, iar acest număr trebuie să aibă cel mult doi factori primi. Se verifică în prealabil dacă datele de intrare corespund restricțiilor impuse, se trece prin toate numerele din listă și se verifică condiția impusă, iar la final se afișează rezultatul.

0258 - Det Prim

2023-04-29T11:04:07Z

Paul Matei: Pagină nouă: == Cerinţa == Se dau două numere naturale '''a''' şi '''b''', '''a≤b'''. Să se determine, dacă există, un număr prim '''x''' care aparţine intervalului închis '''[a,b]''' pentru care valoarea expresiei '''|b+a-2*x|''' este minimă, unde '''|m|''' este valoarea absolută a numărului întreg '''m'''. Dacă nu există nici un astfel de număr, se va afişa mesajul '''NU EXISTA''', iar dacă există mai multe se va afişa cel mai mic. == Date de intrare == Programul c...

== Cerinţa ==
Se dau două numere naturale '''a''' şi '''b''', '''a≤b'''. Să se determine, dacă există, un număr prim '''x''' care aparţine intervalului închis '''[a,b]''' pentru care valoarea expresiei '''|b+a-2*x|''' este minimă, unde '''|m|''' este valoarea absolută a numărului întreg '''m'''. Dacă nu există nici un astfel de număr, se va afişa mesajul '''NU EXISTA''', iar dacă există mai multe se va afişa cel mai mic.
== Date de intrare ==
Programul citește de la tastatură numerele '''a''' şi '''b'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''x''' determinat, sau mesajul '''NU EXISTA'''.
== Restricții și precizări ==
*'''1 ≤ a ≤ b ≤ 1.000.000.000'''
== Exemplu ==
; Intrare
:7 18
; Ieșire
:13
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def este_prim(x):
"""
Verifică dacă un număr x este prim.
"""
return x > 1 and all(x % i != 0 for i in range(2, int(math.sqrt(x))+1))

def validare_date(a, b):
"""
Verifică dacă datele de intrare sunt valide.
"""
if not isinstance(a, int) or not isinstance(b, int):
return False
if not (1 < a <= b <= 1000000000):
return False
return True

if __name__ == '__main__':
print("Introduceti intervalul [a, b]:")
a = int(input("a = "))
b = int(input("b = "))

# validam datele de intrare
if validare_date(a, b):
min_val = float('inf') # initializam minimul cu o valoare foarte mare
min_prim = None # initializam numarul prim cu None

# cautam numarul prim x din intervalul [a,b] pentru care expresia este minima
for x in range(a, b+1):
if este_prim(x):
# calculam valoarea expresiei |b+a-2*x|
val = abs(b+a-2*x)
# actualizam minimul si numarul prim daca este cazul
if val < min_val:
min_val = val
min_prim = x

# afisam rezultatul
if min_prim is None:
print("NU EXISTA")
else:
print(f"Numarul prim din intervalul [{a}, {b}] pentru care expresia este minima este {min_prim}.")
else:
print("Datele de intrare nu corespund restricților impuse.")
# afisam un mesaj care sa confirme faptul ca datele de intrare sunt valide
print(f"\nDatele de intrare ({a}, {b}) corespund restricțiilor impuse.\n")

</syntaxhighlight>

==Explicație rezolvare==
Acesta este un cod Python care găsește un număr prim într-un interval specificat [a, b], care minimizează o anumită expresie. Se verifică dacă numerele de intrare sunt valide, se caută numărul prim care minimizează expresia și se afișează rezultatul. La final se afișează un mesaj de confirmare a validității datelor de intrare.

3302 - Sum Inv Div

2023-04-29T10:50:44Z

Paul Matei: Pagină nouă: == Cerinţa == Pe prima linie a fișierului '''suminvdiv.in''' se găsesc cel mult '''1000''' de numere naturale distincte mai mici decât '''10.000.000.000'''. Scrieți un program care determină pentru fiecare număr citit '''x''' suma '''s=1/d1+1/d2+..+1/di , unde d1,d2,….,di''' sunt divizorii numărului '''x'''. Valorile determinate se vor afișa separate printr-un spațiu. == Date de intrare == Fișierul de intrare '''suminvdiv.in''' conține pe prima linie cel mult '...

== Cerinţa ==
Pe prima linie a fișierului '''suminvdiv.in''' se găsesc cel mult '''1000''' de numere naturale distincte mai mici decât '''10.000.000.000'''. Scrieți un program care determină pentru fiecare număr citit '''x''' suma '''s=1/d1+1/d2+..+1/di
, unde d1,d2,….,di''' sunt divizorii numărului '''x'''. Valorile determinate se vor afișa separate printr-un spațiu.

== Date de intrare ==
Fișierul de intrare '''suminvdiv.in''' conține pe prima linie cel mult '''1000''' de numere naturale distincte mai mici decât '''10.000.000.000''' separate prin spații.
== Date de ieşire ==
Fișierul de ieșire '''suminvdiv.out''' va conține pe prima linie valorile determinate cu exact '''2''' zecimale pentru fiecare număr '''x''' din fișierul de intrare, valori separate printr-un spațiu.
== Restricții și precizări ==
*pe prima linie a fișierului sunt cel mult '''1000''' de numere
*numerele de pe prima linie a fișierului de intrare sunt mai mici decât '''10.000.000.000'''
*rezultatul este considerat corect dacă diferența dintre fiecare valoare afișată și cea corectă este mai mică decât '''0'''.
== Exemplu ==
; '''suminvdiv.in'''
:12 9 123 78 34 278313 349012 6 24242 900000
; '''suminvdiv.out'''
:2.33 1.44 1.37 2.15 1.59 1.58 1.75 2.00 1.71 3.55
== Explicație ==
*Divizorii lui '''12''' sunt: '''1, 2, 3, 4, 6 și 12……s=(11+12+13+14+16+112)=2.33'''
*Divizorii lui '''9''' sunt: '''1, 3 și 9……s=(11+13+19)=1.44, etc.'''

== Rezolvare ==
<syntaxhighlight lang="python" line>
import math
import os

def validare_date(nums):
# Verifică dacă numerele sunt mai mici de 10 miliarde
for num in nums:
if num >= 10000000000:
return False
return True

if __name__ == '__main__':
# Verifică dacă fișierul de intrare există
if not os.path.isfile('suminvdiv.in'):
print("Fișierul de intrare nu există")
exit()

# Citeste numerele din fișier
with open('suminvdiv.in', 'r') as f:
nums = [int(x) for x in f.readline().split()]

# Validează datele de intrare
if validare_date(nums):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
# Parcurge fiecare număr și calculează suma inverselor divizorilor
results = []
for num in nums:
divisors_sum = 0
limit = int(math.sqrt(num))
for i in range(1, limit+1):
if num % i == 0:
divisors_sum += 1/i
if i != num // i:
divisors_sum += 1/(num//i)
results.append(divisors_sum)

# Afișează rezultatele în fișier
with open('suminvdiv.out', 'w') as f:
f.write(' '.join(f'{result:.2f}' for result in results))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Acest cod rezolvă o problemă care implică citirea unui set de numere dintr-un fișier de intrare, validarea acestora și calcularea sumei inverselor divizorilor pentru fiecare număr. Rezultatele sunt afișate cu două zecimale și scrise într-un fișier de ieșire.

1409 - Numere 11

2023-04-29T08:48:16Z

Paul Matei: Pagină nouă: == Cerinţa == Se dau '''n''' numere naturale. Calculați suma obținută prin adunarea celui mai mare divizor prim al fiecărui număr dat. == Date de intrare == Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale. == Date de ieşire == Programul va afișa pe ecran numărul '''S''', reprezentând suma ceruta. == Restricții și precizări == *'''1 ≤ n ≤ 10000''' *cele '''n''' numere citite vor fi mai mari decât '''1''' și mai mici dec...

== Cerinţa ==
Se dau '''n''' numere naturale. Calculați suma obținută prin adunarea celui mai mare divizor prim al fiecărui număr dat.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale.
== Date de ieşire ==
Programul va afișa pe ecran numărul '''S''', reprezentând suma ceruta.
== Restricții și precizări ==
*'''1 ≤ n ≤ 10000'''
*cele '''n''' numere citite vor fi mai mari decât '''1''' și mai mici decât '''1.000.000.000'''
== Exemplu ==
; Intrare
:9
7 30 2 17 14 10 9 3 13
; Ieșire
:62
== Explicație ==
'''7 + 5 + 2 + 17 + 7 + 5 + 3 + 3 + 13 = 62'''
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def factor_prim_maxim(n):
d = 2
var = 0
while n > 1:
p = 0
while n % d == 0:
p += 1
n //= d
if p != 0:
var = d
d += 1
if d * d > n:
if n > 1:
var = n
break
return var

def validare_date(n):
if n < 1:
print("Intrare nevalidă! Numărul de numere întregi trebuie să fie pozitiv.")
return False
return True

if __name__ == '__main__':
n = int(input("Introduceți numărul de numere întregi: "))
if validare_date(n):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
s = 0
for i in range(n):
tmp = int(input(f"Introduceți numărul întreg {i+1}: "))
s += factor_prim_maxim(tmp)
print(s)

</syntaxhighlight>

==Explicație rezolvare==
Acest program primește de la utilizator un număr '''n''' și '''n''' numere întregi și calculează suma factorilor primi maximi ai acestor numere. Programul verifică mai întâi dacă '''n''' este pozitiv și apoi calculează factorii primi maximi pentru fiecare număr întreg dat prin intermediul unei funcții numite '''factor_prim_maxim'''. Rezultatul final este suma totală a factorilor primi maximi.

0443 - Divizori Primi

2023-04-29T08:36:01Z

Paul Matei: Pagină nouă: == Cerinţa == Se dau '''n''' numere naturale. Calculaţi suma obținută prin adunarea primului divizor prim al fiecărui număr citit. == Date de intrare == Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii. == Date de ieşire == Programul afișează pe ecran numărul '''S''', reprezentând suma cerută. == Restricții și precizări == *'''1 ≤ n ≤ 1000''' *cele '''n''' numere citite vor fi mai mari decât '''1...

== Cerinţa ==
Se dau '''n''' numere naturale. Calculaţi suma obținută prin adunarea primului divizor prim al fiecărui număr citit.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii.
== Date de ieşire ==
Programul afișează pe ecran numărul '''S''', reprezentând suma cerută.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*cele '''n''' numere citite vor fi mai mari decât '''1''' și mai mici decât '''1.000.000.000'''
== Exemplu ==
; Intrare
:5
15 13 39 49 25
; Ieșire
:31
== Explicație ==
Pentru numerele date, primul divizor prim este, respectiv: '''3 13 3 7 5''', cu suma '''31'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def prim(n):
d = 2
p = 0
while n > 1:
p = 0
while n % d == 0:
p += 1
n //= d
if p > 0:
return d
d += 1
if d * d > n:
d = n
return n

def validare_date():
n = 0
while n <= 0:
try:
n = int(input("Introduceti n: "))
if n <= 0:
print("n trebuie sa fie un numar intreg pozitiv.")
except ValueError:
print("n trebuie sa fie un numar intreg pozitiv.")
return n

if __name__ == '__main__':
if validare_date():
print("\nDatele de intrare corespund restricțiilor impuse.\n")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

n = validare_date()
s = 0
for i in range(n):
x = 0
while x <= 0:
try:
x = int(input(f"Introduceti x[{i+1}]: "))
if x <= 0:
print("x trebuie sa fie un numar intreg pozitiv.")
except ValueError:
print("x trebuie sa fie un numar intreg pozitiv.")
s += prim(x)
print(f"Suma divizorilor primi este: {s}")

</syntaxhighlight>

==Explicație rezolvare==
Acest program calculează suma divizorilor primi ai unui set de numere introduse de utilizator. Folosește o funcție pentru a verifica dacă intrarea este validă și o altă funcție pentru a găsi cel mai mic divizor prim al unui număr. Programul calculează suma divizorilor primi pentru fiecare număr introdus de utilizator și le adună pentru a obține o valoare totală, pe care o afișează la final.

0462 - Div Prim Max

2023-04-26T12:05:13Z

Paul Matei: Pagină nouă: == Cerinţa == Se citesc numere de la tastatură până când se introduc două numere egale. Să se determine numărul citit cu număr maxim de divizori primi. == Date de intrare == Programul citește de la tastatură numere întregi. Citirea se încheie când se introduc două numere egale. == Date de ieşire == Programul afișează pe ecran numerele '''M NRDIV''', separate printr-un spațiu, reprezentând numărul citit cu număr maxim de divizori primi și numărul de div...

== Cerinţa ==
Se citesc numere de la tastatură până când se introduc două numere egale. Să se determine numărul citit cu număr maxim de divizori primi.
== Date de intrare ==
Programul citește de la tastatură numere întregi. Citirea se încheie când se introduc două numere egale.
== Date de ieşire ==
Programul afișează pe ecran numerele '''M NRDIV''', separate printr-un spațiu, reprezentând numărul citit cu număr maxim de divizori primi și numărul de divizori primi ai săi.
== Restricții și precizări ==
*numerele citite sunt numere naturale mai mici decât '''1.000.000.000'''
*'''dacă există mai multe numere cu număr maxim de divizori primi, se va afişa cel mai mare dintre ele'''
== Exemplu ==
; Intrare
:15 30 24 17 84 42 108 20 20
; Ieșire
:84 3
==Explicație==
Numerele '''30 84 42''' au câte '''3''' divizori primi, și nu există printre numerele date numere cu mai mulți divizori primi. Dintre acestea, cel mai mare este '''84'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def nrdiv(x):
d = 2
cnt = 0
while x > 1:
p = 0
while x % d == 0:
p += 1
x //= d
if p > 0:
cnt += 1
d += 1
if d * d > x:
d = x
return cnt

def validare_date(numar):
while True:
try:
n = int(input(f"Introduceți {numar} număr: "))
if n <= 0:
raise ValueError("Numărul trebuie să fie pozitiv.")
return n
except ValueError as e:
print(f"Input invalid: {e}")

if __name__ == '__main__':
a = validare_date("primul")
nmax = a
max_div = nrdiv(a)
while True:
b = validare_date("următorul")
if a == b:
break
div_b = nrdiv(b)
if div_b > max_div:
max_div = div_b
nmax = b
elif div_b == max_div and b > nmax:
nmax = b
a = b
print(f"Numărul cu cele mai multe divizori este: {nmax} cu {max_div} divizori.")
print("Datele de intrare corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Pentru a rezolva problema, trebuie să parcurgem secvența dată și să numărăm divizorii fiecărui element. Dacă numărul de divizori al unui element este mai mare decât cel al celorlalte elemente întâlnite până în acel moment, actualizăm numărul maxim de divizori și numărul corespunzător. Dacă numărul de divizori al elementului curent este egal cu numărul maxim de divizori întâlnit până acum, comparam elementul curent cu cel mai mare număr găsit până acum și actualizăm numărul corespunzător dacă este cazul. Pentru a număra divizorii unui număr, parcurgem toate numerele mai mici sau egale cu rădăcina pătrată a numărului respectiv și verificăm dacă sunt divizori sau nu. Pentru a gestiona citirea datelor de intrare, folosim o funcție de validare a datelor care verifică dacă valorile introduse sunt numere întregi pozitive.

3289 - Max Prime Intre Ele

2023-04-25T22:07:34Z

Paul Matei: Pagină nouă: == Cerinţa == Indicatorul lui Euler, '''φ(n)''' – uneori numită funcția phi, este folosit pentru a determina câte numere mai mici decât '''n''' sunt relativ prime cu '''n'''. De exemplu, cum '''1, 2, 4, 5, 7 și 8''' sunt toate mai mici decât '''9''' și relativ prime la '''9, φ(9)=6'''. n Relativ prime φ(n) n/φ(n) 2 1 1 2 3 1,2 2 1.5 4 1,3 2 2 5 1,2,3,4 4 1.25 6 1,5 2 3 7 1,2,3,4,5,6 6 1.1666…. 8 1,3,5,7 4 2 9 1,2,4,5,7,8 6 1.5 10 1,3,7,9 4 2.5 Se poate vedea...

== Cerinţa ==
Indicatorul lui Euler, '''φ(n)''' – uneori numită funcția phi, este folosit pentru a determina câte numere mai mici decât '''n''' sunt relativ prime cu '''n'''. De exemplu, cum '''1, 2, 4, 5, 7 și 8''' sunt toate mai mici decât '''9''' și relativ prime la '''9, φ(9)=6'''.

n Relativ prime φ(n) n/φ(n)
2 1 1 2
3 1,2 2 1.5
4 1,3 2 2
5 1,2,3,4 4 1.25
6 1,5 2 3
7 1,2,3,4,5,6 6 1.1666….
8 1,3,5,7 4 2
9 1,2,4,5,7,8 6 1.5
10 1,3,7,9 4 2.5
Se poate vedea că '''n=6''' produce valoarea maximă '''n/φ(n)''' pentru '''n ≤ 10'''.

Se consideră un șir de numere naturale mai mari decât '''1''', numere formate din cel mult '''9''' cifre. Să se scrie un program care determină dintre acestea numărul '''n''' pentru care raportul '''n/φ(n)''' are valoare maximă. În cazul în care sunt mai multe valori pentru care raportul '''n/φ(n)''' este maxim se va afișa prima dintre ele.
== Date de intrare ==
Fișierul de intrare '''maxprimeintreele.in''' conține pe prima linie cel mult '''10000''' numere naturale din intervalul '''[2,999999999]''' separate prin spații.
== Date de ieşire ==
Fișierul de ieșire '''maxprimeintreele.out''' va conține pe prima linie numărul '''k''', reprezentând numărul '''n''' pentru care raportul '''n/φ(n)''' are valoare maximă.
== Restricții și precizări ==
*numerele din fișierul de intrare sunt din intervalul '''[2, 999999999]'''
== Exemplu ==
; '''maxprimeintreele.in'''
:2 3 4 5 6 7 8 9 10
; '''maxprimeintreele.out'''
:6
==Explicație==
Dintre numerele aflate în fișierul de intrare, numărul '''6''' are raportul '''n/φ(n)''' cu valoare maximă și anume '''3'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def totient(nr):
rank = nr
if nr == 1:
return 0
if nr % 2 == 0:
rank -= rank // 2
while nr % 2 == 0:
nr //= 2
i = 3
while i * i <= nr:
if nr % i == 0:
rank -= rank // i
while nr % i == 0:
nr //= i
i += 2
if nr > 1:
rank -= rank // nr
return rank

def validare_date(valoare):
try:
valoare_int = int(valoare)
if valoare_int > 0:
return valoare_int
else:
print("Numărul trebuie să fie pozitiv.")
except ValueError:
print("Intrare invalidă. Vă rugăm să introduceți un număr întreg.")

if __name__ == '__main__':
print("Introduceți numere întregi pozitive. Pentru a opri introducerea de numere, introduceți orice altă valoare.")
valoare_max = 0
nr_max = 6
while True:
valoare = input()
if valoare_max and not valoare:
break
valoare_int = validare_date(valoare)
if not valoare_int:
continue
if valoare_int / totient(valoare_int) > valoare_max:
valoare_max = valoare_int / totient(valoare_int)
nr_max = valoare_int

if nr_max:
print(f"Numărul cu valoarea maximă a x/totient(x) este {nr_max}.")
print("\nDatele de intrare corespund restricțiilor impuse.\n")
else:
print("Nu ați introdus niciun număr valid.")
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Programul este o implementare a funcției '''Euler Totient''', care calculează numărul de numere întregi pozitive mai mici decât un anumit număr și care sunt prime relativ cu acel număr. Programul primește date de intrare de la utilizator, validează datele și calculează valoarea '''x/totient(x)''' pentru fiecare valoare introdusă. Programul afișează valoarea maximă a '''x/totient(x)''' și indică dacă datele de intrare introduse de utilizator au fost valide sau nu.

1780 - Fractie

2023-04-25T21:22:07Z

Paul Matei: Pagină nouă: == Cerinţa == Se dau două numere naturale '''n''' și '''m''', '''m''' fiind prim. Să se afle cel mai mare număr natural '''x''', astfel încât numărul '''n!/mx'''să fie natural. == Date de intrare == Programul citește de la tastatură numerele '''n''' si '''m'''. == Date de ieşire == Programul va afișa pe ecran numarul '''x'''. == Restricții și precizări == *'''2 ≤ m ≤ n ≤ 10000''' *'''m''' este prim. == Exemplu == ; Intrare :5 5 ; Ieșire :1 ==Explicație...

== Cerinţa ==
Se dau două numere naturale '''n''' și '''m''', '''m''' fiind prim. Să se afle cel mai mare număr natural '''x''', astfel încât numărul '''n!/mx'''să fie natural.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' si '''m'''.
== Date de ieşire ==
Programul va afișa pe ecran numarul '''x'''.
== Restricții și precizări ==
*'''2 ≤ m ≤ n ≤ 10000'''
*'''m''' este prim.
== Exemplu ==
; Intrare
:5 5
; Ieșire
:1
==Explicație==
'''5! = 120. 60 = 5 * 2 * 2 * 2 * 3'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n, m):
# Verifică dacă n și m sunt numere întregi pozitive
if isinstance(n, int) and isinstance(m, int) and n > 0 and m > 0:
return True
else:
return False

if __name__ == '__main__':
# Citește datele de intrare de la utilizator
n, m = map(int, input().split())

# Validează datele de intrare
if validare_date(n, m):
# Efectuează aceeași calculație ca în codul original
p = 0
for i in range(1, n+1):
aux = i
if aux % m == 0:
while aux % m == 0:
p += 1
aux = aux // m
print(p)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

2306 - Numere 22

2023-04-25T21:09:29Z

Paul Matei: Pagină nouă: == Cerinţa == Se dau două numere prime '''p''', '''q''' și '''n''' numere naturale nenule. Determinați exponentul maxim '''E''' pentru care numărul '''pE⋅qE''' divide produsul celor '''n''' numere date. == Date de intrare == Programul citește de la tastatură numere '''p q n''', iar apoi '''n''' numere naturale, separate prin spaţii. == Date de ieşire == Programul afișează pe ecran numărul '''E''', reprezentând numărul cerut. == Restricții și precizări == *'...

== Cerinţa ==
Se dau două numere prime '''p''', '''q''' și '''n''' numere naturale nenule. Determinați exponentul maxim '''E''' pentru care numărul '''pE⋅qE''' divide produsul celor '''n''' numere date.
== Date de intrare ==
Programul citește de la tastatură numere '''p q n''', iar apoi '''n''' numere naturale, separate prin spaţii.
== Date de ieşire ==
Programul afișează pe ecran numărul '''E''', reprezentând numărul cerut.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*cele '''n''' numere citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu ==
; Intrare
:7 2 5
72 56 70 9 700
; Ieșire
:3
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date(p, q, n):
"""
Verifică dacă valorile de intrare sunt valide, bazate pe anumite restricții.
Returnează True dacă sunt valide, False altfel.
"""
if not (2 <= p <= 10**9):
return False
if not (2 <= q <= 10**9):
return False
if not (1 <= n <= 10**5):
return False
return True

def calculeaza_puteri(p, q, n, nums):
p1 = p2 = 0
for tmp in nums:
d = 2
while d * d <= tmp:
p = 0
while tmp % d == 0:
tmp //= d
p += 1
if d == p:
p1 += p
if d == q:
p2 += p
d += 1
if tmp > 1:
if tmp == p:
p1 += 1
elif tmp == q:
p2 += 1
return min(p1, p2)

if __name__ == '__main__':
# citeste valorile de intrare
p, q, n = map(int, input().split())
nums = list(map(int, input().split()))

# valideaza valorile de intrare
if validare_date(p, q, n):
# calculeaza puterile si afiseaza rezultatul
result = calculeaza_puteri(p, q, n, nums)
print(result)
print("\nDatele de intrare corespund restricțiilor impuse.\n")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Soluția calculează numărul minim de numere dintr-o listă care au ca factori primi doar numerele a și b date. Algoritmul descompune fiecare număr în factori primi, numără factorii primi egali cu '''p și q''' și returnează minimul dintre cele două valori. În plus, soluția include o funcție de validare a datelor de intrare.

3360 - Pereche 2

2023-04-25T12:05:34Z

Paul Matei: Pagină nouă: == Cerinţa == Se dă un șir de '''n''' numere naturale. Determinați o pereche de numere consecutive în șir, cu proprietatea că au același număr de factori primi. Dacă sunt mai multe asemenea perechi se va determina aceea cu suma numerelor mai mică. Dacă în continuare sunt mai multe perechi, se va determina prima din șir. == Date de intrare == Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale == Date de ieşire == Programul va...

== Cerinţa ==
Se dă un șir de '''n''' numere naturale. Determinați o pereche de numere consecutive în șir, cu proprietatea că au același număr de factori primi. Dacă sunt mai multe asemenea perechi se va determina aceea cu suma numerelor mai mică. Dacă în continuare sunt mai multe perechi, se va determina prima din șir.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale
== Date de ieşire ==
Programul va afișa pe ecran două numere '''a b''', separate prin câte un spațiu, reprezentând perechea determinată. Ordinea numerelor '''a b''' este cea din șir.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*numerele din șir vor fi mai mici decât '''1.000.000.000'''
*dacă nu există nicio pereche care respectă cerința se va afișa '''NU EXISTA'''
== Exemplu ==
; Intrare
:5
40 63 64 27 100
; Ieșire
:64 27
==Explicație==
Perechea '''40 63''' respectă regula, dar are suma mai mare ('''40+63 > 64 + 27''').

== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def desc(n):
cnt = 0
d = 2
while n > 1:
p = 0
while n % d == 0:
p += 1
n //= d
if p:
cnt += 1
d += 1
if d * d > n:
d = n
return cnt

def ok(a, b):
return desc(a) == desc(b)

def validare_date():
while True:
try:
n = int(input("Introduceti numarul de elemente din sir: "))
if n < 2:
print("Sirul trebuie sa aiba cel putin 2 elemente.")
else:
break
except ValueError:
print("Numarul de elemente trebuie sa fie un numar intreg.")
a = None
while a is None:
try:
a = int(input("Introduceti primul element: "))
except ValueError:
print("Elementul trebuie sa fie un numar intreg.")
return n, a

if __name__ == '__main__':
n, a = validare_date()
rez1 = 1000000000
rez2 = 1000000000

for i in range(2, n+1):
b = None
while b is None:
try:
b = int(input(f"Introduceti al {i}-lea element: "))
except ValueError:
print("Elementul trebuie sa fie un numar intreg.")

if ok(a, b) and a + b < rez1 + rez2:
rez1 = a
rez2 = b
a = b

if rez1 != 1000000000:
print(f"Numerele cautate sunt {rez1} si {rez2}.")
else:
print("NU EXISTA")

</syntaxhighlight>
==Explicație rezolvare==
Scopul programului este să găsească două numere consecutive dintr-un șir dat, astfel încât cele două numere să aibă același număr de factori primi, iar suma lor să fie cea mai mică posibilă.

Programul începe prin citirea numărului de elemente din șir și a primului element din șir. Datele de intrare sunt verificate și validate pentru a se asigura că sunt corecte.

Următorul pas este să căutăm perechile de numere consecutive cu același număr de factori primi. Pentru aceasta, vom itera prin șir, începând cu al doilea element, și vom verifica fiecare pereche de numere consecutive. Pentru a verifica dacă două numere au același număr de factori primi, putem folosi funcția '''desc()''', care primește un număr și returnează numărul de factori primi ai săi. Apoi, vom compara suma celor două numere cu cele mai mici sume găsite până acum și vom actualiza cele două numere de rezultat, '''rez1 și rez2''', dacă găsim o pereche cu o sumă mai mică.

La sfârșitul programului, dacă am găsit o pereche validă de numere, vom afișa cele două numere. În caz contrar, vom afișa "NU EXISTA".

În plus față de acest proces de găsire a perechilor, programul a fost modificat și pentru a include o funcție de validare a datelor de intrare pentru a verifica dacă numărul de elemente din șir și primul element din șir sunt introduse corect. Astfel, se evită erorile de execuție cauzate de datele de intrare incorecte.

3359 - Pereche 1

2023-04-25T11:28:05Z

Paul Matei: Pagină nouă: == Cerinţa == Se dă un șir de '''n''' numere naturale. Determinați o pereche de numere consecutive în șir, cu proprietatea că au exact aceiași factori primi, indiferent de exponent. Dacă sunt mai multe asemenea perechi se va determina aceea cu suma numerelor mai mare. Dacă în continuare sunt mai multe perechi, se va determina prima din șir. == Date de intrare == Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale. == Date de ieş...

== Cerinţa ==
Se dă un șir de '''n''' numere naturale. Determinați o pereche de numere consecutive în șir, cu proprietatea că au exact aceiași factori primi, indiferent de exponent. Dacă sunt mai multe asemenea perechi se va determina aceea cu suma numerelor mai mare. Dacă în continuare sunt mai multe perechi, se va determina prima din șir.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale.
== Date de ieşire ==
Programul va afișa pe ecran două numere '''a b''', separate prin câte un spațiu, reprezentând perechea determinată. Numerele '''a b''' vor fi afișate în ordinea din șir.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*numerele din șir vor fi mai mici decât '''1.000.000.000'''
*dacă nu există nicio pereche care respectă cerința se va afișa '''NU EXISTA'''

== Exemplu ==
; Intrare
:5
45 75 80 100 45
; Ieșire
:80 100
==Explicație==
Perechea '''45 75''' respectă și ea regula, dar are suma mai mică '''(45 + 75 < 80 + 100)'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def ok(a, b):
d = 2
while a > 1:
if a % d == 0:
if b % d != 0:
return False
else:
while a % d == 0:
a //= d
while b % d == 0:
b //= d
d += 1
if d * d > a:
d = a
return a == b

if __name__ == '__main__':
n = input("Introduceti n: ")
try:
n = int(n)
if n < 2 or n > 1000:
raise ValueError
except ValueError:
print("Datele de intrare nu respecta restrictiile impuse.")
else:
a = input("Introduceti elementele array-ului: ")
try:
a = list(map(int, a.split()))
if len(a) != n:
raise ValueError
for x in a:
if x < 1 or x > 10**6:
raise ValueError
except ValueError:
print("Datele de intrare nu respecta restrictiile impuse.")
else:
rez1 = -1
rez2 = -1
for i in range(1, n):
if ok(a[i-1], a[i]) and rez1 + rez2 < a[i-1] + a[i]:
rez1 = a[i-1]
rez2 = a[i]
if rez1 != -1:
print(rez1, rez2)
else:
print("NU EXISTA")
print("\nDatele de intrare respecta restrictiile impuse.\n")

</syntaxhighlight>
==Explicație rezolvare==
Acest program caută o pereche de numere prime între ele dintr-un array dat și afișează cele două numere cu suma lor maximă. Programul folosește o metodă de factorizare pentru a verifica dacă două numere sunt prime între ele sau nu. Dacă nu există o astfel de pereche de numere în array, se afișează '''NU EXISTA'''. Programul include și o funcție de validare a datelor de intrare și afișează un mesaj corespunzător în funcție de rezultatul verificării.

3355 - Factori 4

2023-04-25T11:07:10Z

Paul Matei: Pagină nouă: == Cerinţa == Se dau '''n''' numere naturale. Determinați cel mai mic număr care are un singur factor prim. Dacă nu există niciun număr cu un singur factor prim se va afișa mesajul '''NU EXISTA'''. == Date de intrare == Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale. == Date de ieşire == Programul va afișa pe ecran numărul cerut. == Restricții și precizări == *'''1 ≤ n ≤ 1000''' *cele '''n''' numere citite vor fi mai mi...

== Cerinţa ==
Se dau '''n''' numere naturale. Determinați cel mai mic număr care are un singur factor prim. Dacă nu există niciun număr cu un singur factor prim se va afișa mesajul '''NU EXISTA'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale.
== Date de ieşire ==
Programul va afișa pe ecran numărul cerut.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*cele '''n''' numere citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu ==
; Intrare
:5
12 9 16 4 20
; Ieșire
:4
==Explicație==
Dintre numere citite au un factor prim numerele '''9 16 4'''. Dintre acestea cel mai mic este '''4'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date(n, arr):
if not isinstance(n, int) or n <= 0:
return False
if not isinstance(arr, list) or len(arr) != n or not all(isinstance(x, int) for x in arr):
return False
return True

def ok(n):
d, cnt = 2, 0
while n > 1:
p = 0
while n % d == 0:
n //= d
p += 1
if p:
cnt += 1
d += 1
if d * d > n:
d = n
return cnt == 1

if __name__ == '__main__':
n = int(input("Introduceti numarul de elemente din lista: "))
arr = list(map(int, input("Introduceti lista de numere: ").split()))

if validare_date(n, arr):
mini = math.inf
for x in arr:
if ok(x) and x < mini:
mini = x
if mini < math.inf:
print("Cel mai mic număr prim putere din listă este:", mini)
else:
print("Nu există niciun număr prim putere în listă.")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest cod primește o listă de numere întregi și găsește cel mai mic număr din listă care este un număr prim putere.

Pentru a verifica dacă un număr este un număr prim putere, se calculează factorii primi ai numărului și se numără câți factori primi diferiți are. Dacă numărul de factori primi diferiți este 1, atunci numărul este o putere a unui număr prim.

Codul începe prin a citi numărul de elemente din listă și lista însăși, utilizând funcția '''input() și list()'''. Apoi, se validează datele de intrare cu funcția '''validare_date()''', care verifică că n este un număr întreg pozitiv și că lista conține n numere întregi.

După validarea datelor de intrare, se inițializează variabila '''mini''' cu o valoare foarte mare. Se parcurge lista cu un '''for loop''', și pentru fiecare element se verifică dacă este un număr prim putere cu ajutorul funcției '''ok()'''. Dacă numărul este un număr prim putere și este mai mic decât valoarea actuală a lui '''mini''', atunci acesta devine noul mini.

La final, se verifică dacă '''mini''' a fost actualizat. Dacă da, atunci se afișează cel mai mic număr prim putere din listă, altfel se afișează un mesaj de eroare.

3354 - Factori 3

2023-04-25T10:47:06Z

Paul Matei: Pagină nouă: == Cerinţa == Se dau '''n''' numere naturale. Determinați cel mai mare număr care are un singur factor prim. Dacă nu există niciun număr cu un singur factor prim se va afișa mesajul '''NU EXISTA'''. == Date de intrare == Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale. == Date de ieşire == Programul va afișa pe ecran numărul cerut. == Restricții și precizări == *'''1 ≤ n ≤ 1000''' *cele n numere citite vor fi mai mici de...

== Cerinţa ==
Se dau '''n''' numere naturale. Determinați cel mai mare număr care are un singur factor prim. Dacă nu există niciun număr cu un singur factor prim se va afișa mesajul '''NU EXISTA'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale.
== Date de ieşire ==
Programul va afișa pe ecran numărul cerut.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*cele n numere citite vor fi mai mici decât '''1.000.000.000'''

== Exemplu ==
; Intrare
:5
12 9 16 4 20
; Ieșire
:16
==Explicație==
Dintre numere citite au un factor prim numerele '''9 16 4'''. Dintre acestea cel mai mare este '''16'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def prm(n):
d = 2
cnt = 0
while n > 1:
if n % d == 0:
cnt += 1
while n % d == 0:
n //= d
d += 1
if d * d > n:
d = n
return cnt

def validare_date(input_str):
try:
n = int(input_str)
if n <= 0:
raise ValueError
return n
except ValueError:
print("Datele de intrare nu corespund restricțiilor impuse.")
exit(1)

if __name__ == '__main__':
input_str = input("Introduceti numarul de date de intrare: ")
n = validare_date(input_str)

nums = []
for i in range(n):
x = input("Introduceti numarul {}: ".format(i + 1))
nums.append(int(x))

maxi = 0
for x in nums:
if prm(x) == 1 and x > maxi:
maxi = x

if maxi != 0:
print("Numarul maxim care indeplineste conditia este:", maxi)
else:
print("NU EXISTA")
</syntaxhighlight>
==Explicație rezolvare==
Acest program are ca scop găsirea celui mai mare număr dintr-un set de numere introduse de utilizator care are exact doi divizori (numere prime).

Pentru a face acest lucru, programul folosește două funcții. Funcția '''prm(n)''' calculează numărul de divizori ai unui număr întreg pozitiv n. Funcția '''validare_date(input_str)''' verifică dacă datele de intrare introduse de utilizator sunt corecte.

În funcția principală a programului, întâi se solicită numărul de date de intrare și se verifică utilizând funcția '''validare_date(input_str)'''. Apoi se solicită introducerea fiecărui număr în parte și se stochează într-o listă.

În final, programul iterează prin lista de numere, determină numărul de divizori ai fiecărui număr și dacă acesta are exact doi divizori și este mai mare decât numerele anterioare verificate, îl atribuie variabilei maxi. Dacă niciun număr din listă nu îndeplinește condiția, se afișează '''NU EXISTA'''.

0435 - Factori Primi

2023-04-25T10:11:38Z

Paul Matei:

== Cerinţa ==
Se dau două numere naturale nenule. Să se verifice dacă cele două numere au exact aceiași factor primi, indiferent de puterea acestora.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' și '''m'''.
== Date de ieşire ==
Programul afișează pe ecran mesajul '''DA''', dacă cele două numere au exact aceiași factori primi, respectiv '''NU''' în caz contrar.
== Restricții și precizări ==
*cele două numere citite vor fi mai mici decât 2*30
== Exemplu ==
; Intrare
:72 48
; Ieșire
:DA
==Explicație==
'''72''' și '''48''' au exact aceiași factori primi: '''2 3'''.
==Exemplu 2==
; Intrare
:72 30
; Ieșire
:NU
==Explicație==
Factorii primi ai lui '''72''' sunt '''2 3''', iar factorii primi ai lui '''30''' sunt '''2 3 5'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n, m):
if n <= 0 or m <= 0:
print("Datele de intrare nu corespund restricțiilor impuse.")
return False
else:
print("Datele de intrare corespund restricțiilor impuse.")
return True

if __name__ == '__main__':
n = int(input("Introduceți primul număr: "))
m = int(input("Introduceți al doilea număr: "))

if validare_date(n, m):
aceiasi_factori = True
d = 2
while n > 1:
if n % d == 0:
if m % d != 0:
aceiasi_factori = False
while n % d == 0:
n /= d
while m % d == 0:
m /= d
d += 1
if d * d > n:
d = n
if aceiasi_factori and m == 1:
print("DA")
else:
print("NU")

</syntaxhighlight>
==Explicație rezolvare==
În această problemă se cere verificarea dacă două numere naturale au aceiași factori primi. Codul primește cele două numere de la tastatură, apoi verifică dacă datele de intrare sunt valide (ambele numere trebuie să fie pozitive). Dacă datele sunt valide, codul caută factorii primi ai primului număr și verifică dacă aceiași factori apar și în al doilea număr. Dacă toți factorii primi ai primului număr apar și în al doilea număr, iar al doilea număr nu are alți factori primi, atunci cele două numere au aceiași factori primi. La sfârșit, codul afișează dacă cele două numere au aceiași factori primi sau nu.

0463 - Factor

2023-04-25T10:08:39Z

Paul Matei: Pagină nouă: == Cerinţa == Se dau '''n''' numere naturale nenule. Determinați cel mai mare număr prim care apare în descompunerea în factori a produsului celor '''n''' numere, precum și exponentul său în descompunere. == Date de intrare == Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii. == Date de ieşire == Programul afișează pe ecran numerele '''P E''', separate printr-un spațiu, reprezentând numărul prim căuta...

== Cerinţa ==
Se dau '''n''' numere naturale nenule. Determinați cel mai mare număr prim care apare în descompunerea în factori a produsului celor '''n''' numere, precum și exponentul său în descompunere.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii.
== Date de ieşire ==
Programul afișează pe ecran numerele '''P E''', separate printr-un spațiu, reprezentând numărul prim căutat și exponentul său.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*cele '''n''' numere citite vor fi mai mici decât '''1.000.000.000'''
*pentru toate datele de test va exista cel puțin un număr dintre cele '''n''' care are factori primi
== Exemplu ==
; Intrare
:5
72 56 70 9 100
; Ieșire
:7 2

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n, arr):
if not isinstance(n, int) or n <= 0:
return False
if len(arr) != n:
return False
for x in arr:
if not isinstance(x, int) or x <= 0:
return False
return True

if __name__ == '__main__':
n = int(input("Introduceți numărul de elemente: "))
arr = [int(x) for x in input("Introduceți elementele separate prin spațiu: ").split()]

if validare_date(n, arr):
dmax, pmax = 0, 0
for i in range(n):
x = arr[i]
d, p = 2, 0
while x > 1:
p = 0
while x % d == 0:
x //= d
p += 1
if p:
if d > dmax:
dmax, pmax = d, p
elif d == dmax:
pmax += p
d += 1
if d * d > x:
d = x
print("Numărul prim căutat și exponentul său sunt: ", dmax, pmax)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explcație rezolvare==
Acest program primește o listă de numere și găsește cel mai mare factor prim al fiecărui număr și exponentul său. Înainte de procesul de descompunere, programul verifică dacă datele de intrare corespund restricțiilor impuse. Dacă datele de intrare nu corespund, programul va afișa un mesaj corespunzător.

0435 - Factori Primi

2023-04-25T09:52:17Z

Paul Matei: Pagină nouă: == Cerinţa == Se dau două numere naturale nenule. Să se verifice dacă cele două numere au exact aceiași factor primi, indiferent de puterea acestora. == Date de intrare == Programul citește de la tastatură numerele '''n''' și '''m'''. == Date de ieşire == Programul afișează pe ecran mesajul '''DA''', dacă cele două numere au exact aceiași factori primi, respectiv '''NU''' în caz contrar. == Restricții și precizări == *cele două numere citite vor fi mai mic...

== Cerinţa ==
Se dau două numere naturale nenule. Să se verifice dacă cele două numere au exact aceiași factor primi, indiferent de puterea acestora.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' și '''m'''.
== Date de ieşire ==
Programul afișează pe ecran mesajul '''DA''', dacă cele două numere au exact aceiași factori primi, respectiv '''NU''' în caz contrar.
== Restricții și precizări ==
*cele două numere citite vor fi mai mici decât 2*30
== Exemplu ==
; Intrare
:72 48
; Ieșire
:DA
==Explicație==
'''72''' și '''48''' au exact aceiași factori primi: '''2 3'''.
==Exemplu 2==
; Intrare
:72 30
; Ieșire
:NU
==Explicație==
Factorii primi ai lui '''72''' sunt '''2 3''', iar factorii primi ai lui '''30''' sunt '''2 3 5'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n, m):
if n <= 0 or m <= 0:
return False
return True

if __name__ == '__main__':
n, m = map(int, input().split())
if validare_date(n, m):
aceiasi_factori = True
d = 2
while n > 1:
p = 0
if n % d == 0:
if m % d != 0:
aceiasi_factori = False
while n % d == 0:
n //= d
while m % d == 0:
m //= d
d += 1
if d * d > n:
d = n
if aceiasi_factori and m == 1:
print("DA")
else:
print("NU")
print("\nDatele de intrare corespund restricțiilor impuse.\n")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
În această problemă se cere verificarea dacă două numere naturale au aceiași factori primi. Codul primește cele două numere de la tastatură, apoi verifică dacă datele de intrare sunt valide (ambele numere trebuie să fie pozitive). Dacă datele sunt valide, codul caută factorii primi ai primului număr și verifică dacă aceiași factori apar și în al doilea număr. Dacă toți factorii primi ai primului număr apar și în al doilea număr, iar al doilea număr nu are alți factori primi, atunci cele două numere au aceiași factori primi. La sfârșit, codul afișează dacă cele două numere au aceiași factori primi sau nu.

2821 - Factori Primi 1

2023-04-11T12:04:41Z

Paul Matei:

== Cerinţa ==
Se citește un număr natural, '''n (n≥2)''' și se cere să se scrie cel mai mic număr natural care are aceiași divizori primi ca '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran cel mai mic număr natural care are aceiași divizori primi ca '''n'''.
== Restricții și precizări ==
*2 ≤ n ≤ 2^30
== Exemplu 1 ==
; Intrare
:75
; Ieșire
:15
== Exemplu 2 ==
; Intrare
:7
; Ieșire
:7
== Rezolvare ==
<syntaxhighlight lang="python" line>

def prime_factorization(n):
"""Calculează factorizarea în factori primi ai numărului n"""
nr = 1
d = 2
while n > 1:
p = 0
while n % d == 0:
n //= d
p += 1
if p:
nr *= d
d += 1
if d * d > n:
d = n
return nr

def validare_date(n):
"""Verifică dacă intrarea este un număr întreg pozitiv mai mic sau egal cu 10^9."""
if isinstance(n, int) and n > 0 and n <= 10**9:
return True
else:
return False

if __name__ == '__main__':
n = int(input("Introduceți n: "))
if validare_date(n):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
nr = prime_factorization(n)
print(f"Factorizarea în factori primi a numărului {n} este: {nr}")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acesta este un program Python care calculează factorizarea în factori primi ai unui număr întreg pozitiv dat. Programul verifică dacă numărul este valid (întreg pozitiv mai mic sau egal cu 10^9) și apoi calculează factorizarea în factori primi folosind o metodă iterativă.

0111 - Nr Fact

2023-04-11T11:55:26Z

Paul Matei:

== Cerinţa ==
Să se scrie un program care citește un șir de '''n''' numere naturale şi determină numărul din şir care are număr maxim de factori primi.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale nenule, separate prin spaţii.
== Date de ieşire ==
Programul afișează pe ecran numărul '''x''', numărul din şir cu număr maxim de factori primi.
== Restricții și precizări ==
*'''0 < n < 1001'''
*cele '''n''' numere citite vor fi mai mici decât '''2.000.000.000'''
*dacă în şir există mai multe numere cu număr maxim de factori primi, se va afişa cel mai mic dintre acestea
== Exemplu ==
; Intrare
:5
:72 30 12 75 17
; Ieșire
:30

== Explicație ==
'''30''' are trei factori primi. Celelalte numere au mai puţini factori primi.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_factori_primi(n):
factori_primi = 0
divizor = 2
while divizor <= n:
if n % divizor == 0:
factori_primi += 1
while n % divizor == 0:
n //= divizor
divizor += 1
return factori_primi

def validare_date(n, sir_numere):
if n < 1 or n > 1000:
return False
for numar in sir_numere:
if numar <= 0 or numar >= 2000000000:
return False
return True

if __name__ == '__main__':
n = int(input("Introduceti numarul de numere din sir: "))
sir_numere = list(map(int, input("Introduceti numerele separate prin spatii: ").split()))
if validare_date(n, sir_numere):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
max_factori_primi = 0
numar_max_factori_primi = sir_numere[0]

for numar in sir_numere:
factori_primi = numar_factori_primi(numar)
if factori_primi > max_factori_primi:
max_factori_primi = factori_primi
numar_max_factori_primi = numar
elif factori_primi == max_factori_primi and numar < numar_max_factori_primi:
numar_max_factori_primi = numar

print(f"Numarul cu cel mai mare numar de factori primi este: {numar_max_factori_primi}")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest cod verifică validitatea datelor de intrare și apoi găsește numărul dintr-un șir de numere care are cel mai mare număr de factori primi. Funcția '''numar_factori_primi(n)''' calculează numărul de factori primi ai unui număr, iar funcția '''validare_date(n, sir_numere)''' verifică dacă datele introduse sunt valide. Dacă datele sunt valide, programul găsește numărul din șir care are cel mai mare număr de factori primi și îl afișează.

2323 - Prim 001

2023-04-11T11:50:03Z

Paul Matei:

== Cerinţa ==
Se dă un număr natural '''n'''. Să se afle numărul divizorilor naturali ai lui '''n^n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul va afișa pe ecran numărul divizorilor lui '''n^n''', modulo '''59999'''.
== Restricții și precizări ==
*'''1 ≤ n ≤ 10^13'''
== Exemplu ==
; Intrare
:4
; Ieșire
:9
== Explicație ==
Numărul '''4^4=256''' are '''9''' divizori: '''1,2,4,8,16,32,64,128,256'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
if not n.isdigit() or int(n) <= 0:
return False
return True

if __name__ == '__main__':
n = input("Introduceți un număr întreg pozitiv: ")
if validare_date(n):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
n = int(n)
cnt, d = 1, 2
cn = n
while n > 1:
p = 0
while n % d == 0:
n //= d
p += 1
cnt *= (p * cn + 1)
d += 1
if d * d > n:
d = n
while cnt >= 59999:
cnt %= 59999
print(cnt % 59999)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Acest cod verifică dacă datele de intrare sunt corecte și apoi calculează numărul de divizori proprii ai unui număr întreg dat prin parcurgerea tuturor divizorilor primi ai numărului și calcularea puterilor lor. În cele din urmă, se afișează numărul de divizori proprii '''modulo 59999'''.

0063 - Factorizare 1

2023-04-11T11:46:14Z

Paul Matei:

== Cerinţa ==
Să se scrie un program care citeşte un număr natural '''n''' şi determină factorul care apare în descompunerea în factori primi a lui '''n''' la puterea cea mai mare.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran numărul prim '''p''', cu semnificaţia precizată.
== Restricții și precizări ==
*1 < n < 1.000.000.000
*dacă în descompunerea în factori primi a lui n apar mai mulţi factori la puterea maximă, se va afişa cel mai mare dintre ei

== Exemplu ==
; Intrare
:405
; Ieșire
: 3
== Explicație ==
'''405 = 34 * 51'''. Astfel, factorul care apare la puterea cea mai mare este '''3'''.

== Rezolvare ==
<syntaxhighlight lang="python" line>

def validare_date(n):
if n <= 1 or n >= 1000000000:
return False
return True

if __name__ == '__main__':
n = int(input("Introduceți numărul n: "))

if validare_date(n):

factors = {}
d = 2
while d*d <= n:
while (n % d) == 0:
if d in factors:
factors[d] += 1
else:
factors[d] = 1
n //= d
d += 1
if n > 1:
if n in factors:
factors[n] += 1
else:
factors[n] = 1

max_factor = 0
max_power = 0
for factor, power in factors.items():
if power > max_power:
max_factor = factor
max_power = power

print(f"Factorul cu puterea cea mai mare în descompunerea lui n este {max_factor}")
print("\nDatele de intrare corespund restricțiilor impuse.\n")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Problema cere să scriem un program în Python care primește un număr natural '''n''' și determină factorul care apare în descompunerea în factori primi a lui '''n''' la puterea cea mai mare. Algoritmul constă în factorizarea în factori primi a lui '''n''' și stocarea acestora într-un dicționar, apoi determinarea factorului cu puterea cea mai mare prin parcurgerea dicționarului. Pentru a valida datele de intrare, am scris o funcție '''validare_date''' care verifică dacă numărul '''n''' se află în intervalul impus de restricții. Programul afișează mesaje corespunzătoare în funcție de validitatea datelor de intrare prin utilizarea instrucțiunii '''if __name__ == '__main__'''':

0971 - Max

2023-04-11T11:44:08Z

Paul Matei:

== Cerinţa ==
În zorii zilei, harnicele albinuţe se pregătesc să zboare la cules de nectar. În apropierea stupului, se află o grădină fermecată cu '''N''' flori, numerotate '''1, 2,… N'''. Pentru fiecare floare se cunoaște numărul de petale.

Anumite flori din grădină pot fi flori capcană. O astfel de floare are un număr prim de petale. Dacă o albină s-ar aşeza pe corola florii capcană, atunci floarea i-ar fura o cantitate de nectar egală cu numărul ei de petale.

Alte flori pot fi florile abundenţei. Numărul de petale ale florii abundenţei are un număr impar de divizori. Dacă o albină s-ar aşeza pe corola unei astfel de flori, atunci ea i-ar dărui albinuţei o cantitate de nectar egală cu triplul numărului ei de petale.

Celelalte flori pot fi flori obişnuite. Dacă o albină s-ar aşeza pe corola unei flori obişnuite, atunci floarea i-ar dărui albinuţei o cantitate de nectar egală cu numărul ei de petale.

Regina stupului, le-a poruncit albinuţelor să adune cea mai mare cantitate de nectar care se poate culege din grădină, altfel … vor fi alungate din stup.Scrieţi un program care să citească numerele naturale '''N''' și numărul de petale ale fiecărei flori şi care să determine cantitatea maximă '''C''' de nectar pe care albinuţele o pot aduna din grădina fermecată.

== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, reprezentând numărul de petale ale fiecărei flori.
== Date de ieşire ==
Programul va afișa pe ecran numărul '''C'''.
== Restricții și precizări ==
*'''1 ≤ n ≤ 100 000'''
*fiecare floare are cel mult '''10 000''' petale
*nectarul unei flori poate fi cules de o singură albină
*cantitatea maximă '''C''' de nectar culeasă este un număr natural, '''C ≤ 2 000 000 000'''

== Exemplu ==
; Intrare
:8
:25 13 10 7 1 12 31 102
; Ieșire
:202

== Explicație ==
Cantitatea maximă de nectar se obţine din florile '''1, 3, 5, 6 şi 8'''. '''C=3x25+10+3x1+12+102=202'''
== Rezolvare ==
<syntaxhighlight lang="python" line>
def is_prime(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 num_divisors(n):
count = 0
for i in range(1, int(math.sqrt(n))+1):
if n % i == 0:
count += 2
if i * i == n:
count -= 1
return count

def get_nectar(flower):
if is_prime(flower):
return -flower
elif num_divisors(flower) % 2 == 1:
return 3 * flower
else:
return flower

def validare_date(n, flowers):
if not (1 <= n <= 100000):
return False
if any(not (1 <= f <= 10000) for f in flowers):
return False
return True

if __name__ == '__main__':
n = int(input())
flowers = [int(x) for x in input().split()]

if validare_date(n, flowers):
C = sum(get_nectar(f) for f in flowers)
print(C)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest program calculează suma unor numere, în funcție de proprietățile numerelor respective.

Mai întâi, sunt definite trei funcții:

*'''is_prime(n)''': returnează '''True''' dacă numărul '''n''' este prim și '''False''' în caz contrar.
*'''num_divisors(n)''': returnează numărul de divizori ai numărului '''n'''.
*'''get_nectar(flower)''': returnează un număr în funcție de proprietățile florii. Dacă floarea are un număr prim de petale, se returnează negativul numărului de petale. Dacă floarea are un număr impar de divizori, se returnează triplul numărului de petale. În celelalte cazuri, se returnează numărul de petale.
Apoi, este definită funcția '''validare_date(n, flowers)''', care primește ca parametri numărul '''n''' de flori și '''lista flowers''' cu numărul de petale al fiecărei flori. Această funcție verifică dacă valorile introduse respectă restricțiile impuse în enunțul problemei.

În funcția principală '''(__main__)''', se citesc valorile de intrare și se verifică dacă acestea sunt valide folosind funcția '''validare_date()'''. Dacă datele sunt valide, se calculează suma numerelor obținute prin aplicarea funcției '''get_nectar()''' pe fiecare element din '''lista flowers''', și se afișează valoarea calculată. În caz contrar, se afișează un mesaj de eroare.

1908 - Fractii Ired

2023-04-11T11:27:37Z

Paul Matei:

== Cerinţa ==
Dându-se şirul de fracţii '''1/N, 2/N, 3/N, ...,N/N''', să se afle câte fracţii sunt ireductibile.
== Date de intrare ==
Programul citește de la tastatură numărul '''N'''.
== Date de ieşire ==
Programul va afișa pe ecran numărul de fracţii ireductibile.
== Restricții și precizări ==
*'''1 ≤ n ≤ 2.000.000.022'''
== Exemplu ==
; Intrare
:4
; Ieșire
: 2
== Explicație ==
Fracţiile sunt '''1/4, 3/4'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
if not isinstance(n, int) or n < 1:
return False
return True

if __name__ == '__main__':
n = int(input("Introduceti numarul: "))
if validare_date(n):
nr = n

d = 2
while n > 1:
if n % d == 0:
nr //= d
nr *= d - 1
while n % d == 0:
n //= d
if d == 2:
d = 3
else:
d += 2
if d * d > n:
d = n

print(nr)
print("\nDatele de intrare corespund restricțiilor impuse.\n")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Codul Python calculează funcția Euler Totient pentru un număr natural introdus de utilizator. În timpul procesului de calcul, se parcurg divizorii primi distincti ai numărului și se aplică o formulă specifică pentru a obține valoarea funcției. Codul include, de asemenea, o verificare a datelor de intrare pentru a asigura validitatea acestora.

3353 - Factori 2

2023-04-11T11:06:40Z

Paul Matei:

== Cerinţa ==
Se dau două numere naturale. Afișați numărul pentru care produsul factorilor primi este mai mare. Dacă cele două numere au același produs al factorilor primi, afișați-l pe cel mai mic.
== Date de intrare ==
Programul citește de la tastatură două numere naturale.
== Date de ieşire ==
Programul va afișa pe ecran numărul cerut.
== Restricții și precizări ==
*cele două numere citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu ==
; Intrare
:36 26
; Ieșire
: 26
== Explicație ==
Factorii primi ai lui '''36''' sunt '''2''' și '''3''', cu produsul '''6'''. Factorii primi ai lui '''26''' sunt '''2''' și '''13''', cu produsul '''26'''. Rezultatul este '''26''', pentru că are produsul factorilor primi mai mare.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def desc(n):
prod = 1
d = 2
while n > 1:
p = 0
while n % d == 0:
n //= d
p += 1
if p:
prod *= d
d += 1
if d * d > n:
d = n
return prod

def validare_date(a, b):
if a < 1 or a > 10**18 or b < 1 or b > 10**18:
return False
return True

if __name__ == '__main__':
a, b = map(int, input().split())
if validare_date(a, b):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
prod1 = desc(a)
prod2 = desc(b)
if prod1 > prod2:
print(a)
elif prod1 == prod2:
print(min(a, b))
else:
print(b)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Codul verifică dacă două numere date sunt în intervalul [1, 10^18] și calculează divizorul cel mai mic comun între ele. Pentru a face acest lucru, se utilizează o funcție care găsește factorii primi ai fiecărui număr și apoi calculează produsul lor. Dacă datele de intrare nu corespund restricțiilor impuse, programul afișează un mesaj de eroare. Altfel, programul afișează divizorul cel mai mic comun și numărul corespunzător cu cel mai mic divizor.

3352 - Factori 1

2023-04-11T11:00:06Z

Paul Matei:

== Cerinţa ==
Se dau două numere naturale. Afișați numărul pentru care suma factorilor primi distincți este mai mare. Dacă cele două numere au aceași sumă a factorilor primi, afișați-l pe cel mai mic.
== Date de intrare ==
Programul citește de la tastatură două numere naturale.
== Date de ieşire ==
Programul va afișa pe ecran numărul cerut.
== Restricții și precizări ==
*cele două numere citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu ==
; Intrare
:36 26
; Ieșire
: 26
== Explicație ==
Factorii primi ai lui '''36''' sunt '''2''' și '''3''', cu suma '''5'''. Factorii primi ai lui '''26''' sunt '''2''' și '''13''', cu suma '''15'''. Rezultatul este '''26''', pentru că are suma factorilor primi mai mare.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def prim(x):
d = 2
cnt = 0
while x > 1:
p = 0
while x % d == 0:
p += 1
x //= d
if p:
cnt += d
d += 1
if d * d > x:
d = x
return cnt

def validate_input(x, y):
if x < 0 or y < 0:
return False
if x == 0 and y == 0:
return False
return True

if __name__ == '__main__':
x, y = map(int, input().split())
if validate_input(x, y):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
if prim(x) > prim(y):
print(x)
elif prim(x) < prim(y):
print(y)
else:
print(min(x, y))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește de la utilizator două numere întregi și verifică dacă acestea îndeplinesc anumite condiții. Dacă numerele sunt valabile, programul afișează numărul dintre cele două care are suma cifrelor factorilor primi mai mare. Dacă suma este aceeași pentru ambele numere, programul va afișa cel mai mic dintre cele două numere. Dacă cele două numere nu sunt valabile, programul afișează un mesaj de eroare.

2312 - GuIT

2023-04-11T10:57:43Z

Paul Matei:

== Cerinţa ==
Ghiţă s-a hotărât să plece de-acasă de Ignat, având nişte previziuni sumbre. Neavând bani, s-a gândit să-şi scoată un single de sezon, “guIT”. Din vânzarea lui a obţinut frumoasa sumă de '''n''' dolari.Pentru a câştiga un meniu vegetarian de Crăciun, trebuie să aflaţi suma numerelor prime din descompunerea lui '''n''', ştiind că '''n''' este produs de trei numere prime distincte.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul va afișa pe ecran numărul '''S''', reprezentând suma celor trei numere prime din descompunerea lui '''n'''.
== Restricții și precizări ==
*'''1 ≤ n ≤ 10^12'''
== Exemplu ==
; Intrare
:105
; Ieșire
: 15
== Explicație ==
'''105 = 3•5•7''', deci suma este '''3+5+7=15'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date_numar(n):
if 1 <= int(n) <= 1000000:
return True
else:
return False

def validare_date(k):
if 1 <= int(k) <= 1000:
return True
else:
return False

def print_num(n, k):
s = 0
d = 2

while n > 1:
p = 0
while n % d == 0:
n //= d
p += 1
if p > 0:
s += d
d += 1
if d * d > n:
d = n

return s

if __name__ == '__main__':
n = input()
k = input()
if validare_date_numar(n) and validare_date(k):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
numar = print_num(int(n), int(k))
print(numar)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acesta este un cod Python care primește două numere, verifică dacă acestea sunt valide și apoi calculează suma factorilor primi ai primului număr care apar de cel puțin a doua valoare dată. Dacă numerele introduse sunt valide, codul va afișa suma factorilor primi, altfel va afișa un mesaj de eroare.

2913 - Proth Number

2023-04-11T10:54:10Z

Paul Matei:

== Cerinţa ==
Un număr natural n se numește număr Proth dacă este de forma '''n=k*2p+1''', unde '''k''' și '''p''' sunt numere naturale, '''k''' este impar și '''k < 2p'''.
Să se scrie un program care citește un număr natural și verifică dacă este număr Proth.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul va afișa pe ecran mesajul '''DA''' dacă '''n''' este număr Proth, respectiv '''NU''' în caz contrar.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1.000.000.000'''
== Exemplu ==
; Intrare
: 25
; Ieșire
:DA
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
if not 1 <= n <= 1000000000:
print("Numarul trebuie sa fie intre 1 si 1000000000.")
return False
return True

def este_numar_proth(n):
if not validare_date(n):
return False

k = 1
while k < n:
p = (n - 1) // (2**k)
if 2**k * p + 1 == n and p % 2 == 1:
return True
k += 1

return False

if __name__ == '__main__':
n = int(input("Introduceti numarul n: "))
if validare_date(n):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
if este_numar_proth(n):
print(f"{n} este numar Proth.")
else:
print(f"{n} nu este numar Proth.")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest cod este un program scris în Python care verifică dacă un număr dat este un număr Proth. Programul definește două funcții, una care validează numărul dat și alta care verifică dacă numărul este un număr Proth. Programul verifică dacă numărul dat este valid, iar dacă este, afișează un mesaj de confirmare și verifică dacă numărul este un număr Proth. Dacă numărul este un număr Proth, programul afișează un mesaj care confirmă acest lucru, altfel afișează un mesaj care indică faptul că numărul nu este un număr Proth. Dacă numărul dat nu este valid, programul afișează un mesaj care indică acest lucru.

2324 - Prim 002

2023-04-11T10:44:50Z

Paul Matei:

== Cerinţa ==
Anul '''2017''' tocmai s-a încheiat, iar nostalgicii suferă în tăcere deoarece acesta era număr prim. Dorel, un personaj întreprinzător, s-a gândit să afle pentru un număr natural n dat, care este cel mai mare divizor prim al acestuia.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul va afișa pe ecran cel mai mare divizor prim al lui '''n'''.
== Restricții și precizări ==
*'''1 ≤ n ≤ 10^14'''
== Exemplu ==
; Intrare
: 2018
; Ieșire
:1009
== Explicație ==
Divizorii lui '''2018''' sunt '''1, 2, 1009, 2018,''' iar cel mai mare divizor prim este '''1009'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
"""Verifică dacă n se încadrează în intervalul [1, 10^14]."""
return 1 <= n <= 10**14

def este_prim(n):
"""Verifică dacă n este un număr prim."""
if n < 2:
return False
for i in range(2, int(n**0.5)+1):
if n % i == 0:
return False
return True

if __name__ == '__main__':
n = int(input("Introduceți numărul n: "))
if not validare_date(n):
print("Numărul introdus nu se încadrează în intervalul [1, 10^14].")
exit()

if este_prim(n):
print(n, "este un număr prim.")
else:
d = 2
max_div_prim = 1
while n > 1:
if n % d == 0:
n //= d
if este_prim(d):
max_div_prim = d
else:
d += 1
print("Cel mai mare divizor prim al lui", n, "este", max_div_prim)

</syntaxhighlight>
==Explicație rezolvare==
Înainte de a începe căutarea divizorului prim, se verifică dacă numărul dat se încadrează în intervalul [1, 10^14], utilizând funcția '''validare_date'''. Dacă numărul introdus nu se încadrează în acest interval, programul afișează un mesaj de eroare și se oprește cu ajutorul funcției '''exit()'''.

În caz contrar, se verifică dacă numărul este prim utilizând funcția '''este_prim'''. Dacă numărul este prim, se afișează un mesaj corespunzător.

Dacă numărul nu este prim, se caută cel mai mare divizor prim al numărului prin intermediul unui buclă while. Începând cu divizorul 2, se verifică dacă numărul dat se divide cu acesta. Dacă da, se împarte numărul la acest divizor și se verifică dacă divizorul este prim. Dacă da, divizorul este reținut ca și cel mai mare divizor prim găsit până în acel moment.

În caz contrar, se trece la următorul divizor. Procesul se repetă până când numărul dat ajunge la 1. La final, programul afișează cel mai mare divizor prim găsit, sau 1 dacă nu a fost găsit niciun divizor prim.

În general, codul are o structură clară și folosește funcții separate pentru a îmbunătăți legibilitatea și modularitatea programului.

4295 - Factor Exp Max

2023-04-11T10:34:50Z

Paul Matei:

== Cerinţa ==
Se dă un număr natural '''n'''. Să se determine factorul prim din descompunerea lui '''n''' care apare la puterea cea mai mare. Dacă există mai mulți factori care apar la putere maximă, se va afișa cel mai mare dintre ei.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul va afișa pe ecran factorul prim cerut.
== Restricții și precizări ==
*'''n''' este un număr natural strict mai mare decât '''1''' și are cel mult '''12''' cifre (este de tip '''long long''')
== Exemplu ==
; Intrare
: 7623
; Ieșire
: 11
== Explicație ==
Descompunerea lui '''n=7623''' în factori este '''32 * 71 * 112'''. Sunt doi factori de exponent maxim '''2''', din care cel mai mare este '''11'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date(n):
try:
n = int(n)
if n > 1 and n < 10**12:
return n
else:
print("Numarul trebuie sa fie un numar natural mai mare decat 1 si mai mic decat 10^12.")
return None
except ValueError:
print("Nu ati introdus un numar natural valid.")
return None

if __name__ == '__main__':
n = input("Introduceti numarul n: ")
n = validare_date(n)

if n:
i = 2
factori = {}
while i <= math.sqrt(n):
p = 0
while n % i == 0:
p += 1
n //= i
if p > 0:
factori[i] = p
i += 1
if n > 1:
factori[n] = 1

max_putere = max(factori.values())
factor_max_putere = max([f for f in factori.keys() if factori[f] == max_putere])
print(factor_max_putere)

else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Am implementat o soluție în Python pentru a găsi cel mai mare factor prim al unui număr natural dat. Am folosit o funcție de validare a datelor de intrare pentru a verifica dacă numărul dat este un număr natural între 2 și 10^12. Am apoi parcurge factorii primi ai numărului dat și am folosit un dicționar pentru a stoca puterile fiecărui factor prim. Am aflat factorul prim cu cea mai mare putere și l-am afișat. Dacă numărul de intrare nu a trecut validarea, am afișat un mesaj corespunzător.

0062 - Factorizare

2023-04-11T10:23:26Z

Paul Matei:

== Cerinţa ==
Se citeşte un număr natural '''n'''. Să se afişeze descompunerea în factori primi a lui '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran perechile '''b p''', reprezentând factorii primi şi puterile corespunzătoare.
Perechile se afişează câte una pe o linie a ecranului, în ordinea crescătoare a bazelor. Cele două valori din pereche sunt separate printr-un spaţiu.
== Restricții și precizări ==
*1 < n < 2.100.000.000
== Exemplu ==
; Intrare
: 135
; Ieșire
: 3 3
: 5 1

== Explicație ==
*'''135 = 33 * 51'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
try:
n = int(n)
if n > 1 and n < 2100000000:
return n
else:
print("Numarul trebuie sa fie un numar natural mai mare decat 1 si mai mic decat 2100000000.")
return None
except ValueError:
print("Nu ati introdus un numar natural valid.")
return None

if __name__ == '__main__':
n = input("Introduceti numarul n: ")
n = validare_date(n)
if n:
i = 2
while i <= n:
p = 0
while n % i == 0:
p += 1
n //= i
if p > 0:
print(i, p)
i += 1
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest cod primește un număr întreg pozitiv '''n''' de la utilizator și verifică dacă este un număr natural valid (adică un număr întreg pozitiv mai mare decât 1 și mai mic decât 2.100.000.000).

Dacă numărul este valid, programul afișează factorii primi ai numărului. Factorii primi sunt numerele prime care pot fi înmulțite pentru a obține numărul inițial. De exemplu, factorii primi ai numărului 12 sunt 2 și 3, deoarece 12 = 2 * 2 * 3.

Pentru a afla factorii primi ai numărului, programul împarte succesiv numărul la numerele prime începând cu 2, până când rămâne doar 1. Dacă numărul este divizibil cu un anumit număr prim, programul afișează numărul prim și de câte ori apare acesta în descompunerea factorială a numărului.

Dacă numărul nu este valid, programul afișează un mesaj corespunzător.

1319 - Descompunere factori

2023-04-11T10:14:30Z

Paul Matei:

== Cerinţa ==
Se citeşte un număr natural '''n'''. Să se determine descompunerea în factori primi a lui '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul va afișa pe ecran factorii primi ai lui '''n''' în ordine crescătoare, separați prin câte un spațiu.
== Restricții și precizări ==
*'''2 ≤ n ≤ 2.000.000.000'''
== Exemplu ==
; Intrare
: 1100
; Ieșire
: 2 2 5 5 11
== Explicație ==
Numărul '''n=1100=2*2*5*5*11'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date(date):
try:
n = int(date)
if n >= 2 and n <= 2000000000:
return n
else:
print("Numarul introdus trebuie sa fie un numar natural intre 2 si 2.000.000.000")
return None
except ValueError:
print("Nu ati introdus un numar natural valid")
return None

if __name__ == '__main__':
n = input("Introduceti numarul n: ")
n = validare_date(n)

if n:
i = 2
while i <= math.sqrt(n):
if n % i == 0:
print(i, end=' ')
n //= i
else:
i += 1

if n > 1:
print(n, end=' ')

print("\nDatele de intrare corespund restricțiilor impuse.\n")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest cod realizează factorizarea în factori primi a unui număr natural dat de utilizator. Factorizarea în factori primi reprezintă descompunerea unui număr natural în produsul de numere prime.

Codul începe prin definirea funcției '''validare_date''', care primește un argument '''date''' și încearcă să convertască acest argument la un număr întreg folosind funcția '''int()'''. Dacă conversia este posibilă și numărul este mai mare sau egal cu 2 și mai mic sau egal cu 2.000.000.000, atunci funcția returnează acest număr. În caz contrar, funcția afișează un mesaj corespunzător și returnează valoarea None.

După definirea funcției '''validare_date''', codul verifică dacă acesta este rulat ca program principal folosind instrucțiunea '''if name == 'main':'''. În caz afirmativ, utilizatorului i se cere să introducă numărul n prin intermediul funcției '''input()'''. Apoi, valoarea introdusă este validată prin apelarea funcției '''validare_date'''.

Dacă valoarea introdusă este validă, codul continuă să factorizeze numărul în factori primi. În acest scop, este folosită o buclă '''while''' care parcurge valorile între 2 și radicalul numărului dat (inclusiv). Dacă numărul dat este divizibil cu valoarea curentă a buclei, atunci această valoare reprezintă un factor prim și este afișată. De asemenea, numărul dat este împărțit la acest factor. Dacă numărul dat nu este divizibil cu valoarea curentă a buclei, atunci valoarea curentă este incrementată cu 1.

După ce bucla se termină, numărul dat trebuie să fie un număr prim sau să fie egal cu 1 (deoarece toți ceilalți factori primi au fost deja afișați). Dacă numărul dat este mai mare decât 1, atunci acesta este afișat.

În cele din urmă, este afișat un mesaj corespunzător care indică dacă datele introduse de utilizator corespund restricțiilor impuse de funcția '''validare_date'''.

0967 - Cifre 8

2023-04-09T21:06:53Z

Paul Matei:

== Cerinţa ==
Scrieţi un program care să citească numerele '''c''', '''n''' şi şirul '''s''', şi să determine:
a) suma tuturor numerelor din şirul '''s''' care au proprietatea că sunt numere prime
b) numărul de apariţii ale cifrei '''c''' în scrierea zecimală a tuturor numerelor din şirul '''s'''
c) numărul minim de numere din şirul '''v'''
== Date de intrare ==
Programul citește de la tastatură numerele '''n c''', iar apoi cele '''n''' elemente ale șirului '''s'''.
== Date de ieşire ==
Programul va afișa pe ecran trei numere, câte unul pe o linie, reprezentând în ordine:
*suma tuturor numerelor din şirul '''s''' care au proprietatea că sunt numere prime
*numărul de apariţii ale cifrei '''c''' în scrierea zecimală a tuturor numerelor din şirul '''s'''
*numărul minim de valori din şirul '''v'''
== Restricții și precizări ==
*Numerele '''n''' şi '''c''' sunt naturale
*'''2 ≤ n ≤ 10000'''
*'''0 ≤ c ≤ 9'''
*toate cele '''n''' numere naturale din şirul '''s''' sunt mai mici sau egale cu '''30000'''
*pentru rezolvarea cerinţei a) se acordă '''40%''' din punctaj, pentru cerinţa b) '''20%''' din punctaj şi pentru cerinţa c) '''40%''' din punctaj.
== Exemplu ==
; Intrare
: 10 9
: 1943 31 19 1199 34 941 7971 131 223 6
; Ieșire
: 1345
: 6
: 4

== Explicație ==
a) numerele prime din şirul '''s''' sunt: '''31, 19, 941, 131 şi 223'''. Suma acestora este '''1345'''.
b) cifra '''c=9''' apare de '''6''' ori în scrierea numerelor din '''s'''.
c) cifrele impare ale unităţilor numerelor din '''s''' sunt, în ordine crescătoare: '''1, 1, 1, 1, 3, 3, 9, 9'''. Se pot forma minimum '''4''' numere cu toate cifrele identice: '''11, 11, 33, 99''', fiecare număr din noul şir având numărul maxim posibil de cifre, adică '''2'''. Numărul minim de termeni ai şirului este egal cu '''4'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def este_prim(numar):
if numar < 2:
return False
for i in range(2, int(numar ** 0.5) + 1):
if numar % i == 0:
return False
return True

def aparitii_cifra(numar, cifra):
aparitii = 0
while numar > 0:
if numar % 10 == cifra:
aparitii += 1
numar //= 10
return aparitii

def minim_numere(sir):
frecventa = {}
for numar in sir:
if numar not in frecventa:
frecventa[numar] = 4
else:
frecventa[numar] += 1
return min(frecventa.values())

def validare_date(n, c, s):
if not (2 <= n <= 10000):
return False
if not (0 <= c <= 9):
return False
if not all(1 <= x <= 30000 for x in s):
return False
return True

n, c = map(int, input().split())
s = list(map(int, input().split()))

if not validare_date(n, c, s):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
suma_prime = 0
aparitii_cifra_c = 0

for numar in s:
if este_prim(numar):
suma_prime += numar
aparitii_cifra_c += aparitii_cifra(numar, c)

nr_minim_numere = minim_numere(s)

print(suma_prime)
print(aparitii_cifra_c)
print(nr_minim_numere)

print("Datele de intrare corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acesta este un program care primește o listă de numere și o cifră, efectuează anumite calcule pe baza acestor date și afișează rezultatele. Programul verifică dacă datele de intrare sunt valide și afișează un mesaj corespunzător.

2305 - Numere 21

2023-04-09T20:13:46Z

Paul Matei:

== Cerinţa ==
Se citesc perechi de numere naturale până la citirea a două valori nule. Să se calculeze suma numerelor din perechile pentru care atât valorile inițiale cât și oglinditele lor sunt prime între ele.
== Date de intrare ==
Programul citește de la tastatură perechi de numere naturale. Citirea se încheie la introducerea a două valori nule.
== Date de ieşire ==
Programul va afișa pe ecran numărul '''C''', reprezentând valoarea cerută.
== Restricții și precizări ==
*se vor citi cel mult '''40''' de perechi de numere;
*toate numerele citite vor fi mai mici decât '''1.000.000''';
*toate numerele citite sunt nenule, cu excepția ultimelor două;
== Exemplu ==
; Intrare
: 14 516
: 14 416
: 13 13
: 123 321
: 156 2651
: 456 674
: 0 0
; Ieșire
: 2807

== Explicație ==
Singura pereche care respectă regula este '''156 2651'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(a, b):
if a < 1 or a > 10**6:
return False
if b < 1 or b > 10**6:
return False
return True

def ogl(n):
ogl = 0
while n > 0:
ogl = ogl * 10 + n % 10
n //= 10
return ogl

def pie(a, b):
while b > 0:
r = a % b
a = b
b = r
if a == 1:
return 1
else:
return 0

if __name__ == '__main__':
a, b = map(int, input().split())
if not validare_date(a, b):
print("Datele de intrare nu corespund restrictiilor impuse.")
else:
s = 0
while a != 0 or b != 0:
if pie(a, b) and pie(ogl(a), ogl(b)):
s += a + b
a, b = map(int, input().split())
print(s)

</syntaxhighlight>
==Explicație rezolvare==
Acest cod verifică dacă două numere întregi sunt prime între ele și dacă oglinditele lor sunt, de asemenea, prime între ele. Se primesc două astfel de numere de la utilizator și se efectuează verificările respective. Dacă cele două numere respectă ambele condiții, ele sunt adunate la o variabilă '''s'''. Procesul se repetă până când utilizatorul introduce alte valori sau se atinge o limită. La final, se afișează valoarea acumulată în variabila '''s'''.

0407 - Oglindit Prim

2023-04-09T19:44:10Z

Paul Matei:

== Cerinţa ==
Se dă un șir cu '''n''' numere naturale. Determinați suma celor care au oglinditul număr prim.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale.
== Date de ieşire ==
Programul afișează pe ecran numărul '''S''', reprezentând rezultatul cerut.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*cele '''n''' numere citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu ==
; Intrare
:6
133 35 41 31 90 7
; Ieșire
: 206
== Explicație ==
Dintre cele '''6''' numere citite au oglinditul număr prim: '''133 35 31 7'''. Suma lor este '''206'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def prim(n):
if n == 0 or n == 1:
return 0
if n == 2:
return 1
if n % 2 == 0:
return 0
for i in range(3, int(n**0.5) + 1, 2):
if n % i == 0:
return 0
return 1

def validare_date(n):
if n <= 0:
return False
return True

if __name__ == '__main__':
n = int(input("Introduceti numarul de valori: "))
if validare_date(n):
s = 0
for i in range(n):
x = int(input(f"Introduceti valoarea {i+1}: "))
if validare_date(x):
ogl = 0
aux = x
while x != 0:
ogl = ogl*10 + x%10
x //= 10
if prim(ogl):
s += aux
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
break
else:
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print(f"Suma numerelor care au oglinda prima este: {s}")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește un număr '''n''' de valori de la tastatură și calculează suma tuturor numerelor care au oglinda primă.

Oglinda unui număr este reprezentată de cifrele numărului în ordine inversă. De exemplu, oglinda numărului 1234 este 4321.

Pentru a determina dacă un număr este prim, se verifică dacă acesta este divizibil cu numerele între 2 și rădăcina pătrată a numărului (exclusiv). Dacă numărul este divizibil cu oricare dintre aceste numere, nu este prim.

Funcția '''validare_date''' verifică dacă un număr este pozitiv.

Programul afișează mesaje de eroare în cazul în care datele introduse nu corespund restricțiilor impuse și afișează suma numerelor care au oglinda primă în caz contrar.

0406 - Sum Cif Prim

2023-04-09T19:35:57Z

Paul Matei:

== Cerinţa ==
Se dă un șir cu '''n''' numere naturale. Determinați câte dintre ele sunt prime și au suma cifrelor un număr prim.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale.
== Date de ieşire ==
Programul afișează pe ecran numărul '''C''', reprezentând rezultatul cerut.
== Restricții și precizări ==
* '''1 ≤ n ≤ 1000'''
*cele '''n''' numere citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu ==
; Intrare
: 6
83 36 53 401 90 7
; Ieșire
: 3
== Explicație ==
Dintre cele '''6''' numere citite sunt prime : '''83 53 401 7'''. Dintre ele '''83 401 7''' suma cifrelor număr prim, respectiv '''11 5 7'''. În consecință, sunt '''3''' numere care respectă regula.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True

def sum_digits(n):
return sum(int(d) for d in str(n))

def validare_date(n, nums):
if n < 1 or n > 1000:
return False
for num in nums:
if num < 1 or num > 1000000000:
return False
return True

if __name__ == '__main__':
n = int(input("Introduceți numărul de numere: "))
nums = []
for i in range(n):
num = int(input(f"Introduceți numărul {i+1}: "))
nums.append(num)

if validare_date(n, nums):
count = 0
for num in nums:
if is_prime(num) and is_prime(sum_digits(num)):
count += 1
print(f"Numărul de numere prime cu suma cifrelor primă este: {count}")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest cod primește un număr '''n''' și o listă de '''n''' numere și numără câte dintre aceste numere sunt prime și au suma cifrelor, de asemenea, un număr prim. Pentru a face acest lucru, codul utilizează funcțiile '''is_prime''' și '''sum_digits''' pentru a verifica dacă un număr este prim și dacă suma cifrelor sale este, de asemenea, un număr prim. De asemenea, codul include o funcție '''validare_date''' care verifică dacă datele introduse de utilizator respectă restricțiile impuse. Dacă datele sunt valide, programul numără numerele prime din listă care au suma cifrelor, de asemenea, un număr prim și afișează rezultatul. În caz contrar, programul afișează un mesaj corespunzător.

1345 - K Prim

2023-04-09T19:16:10Z

Paul Matei:

== Cerinţa ==
Să se scrie un program care citește un număr natural '''k''' și afișează cel mai mic număr natural '''n''' mai mare decât '''1''', care nu este divizibil cu primele '''k''' numere prime și nu este prim.
Fișierul de intrare '''kprim.in''' conține pe prima linie numărul '''k'''.
== Date de ieşire ==
Fișierul de ieșire '''kprim.out''' va conține pe prima linie numărul '''n''', reprezentând cel mai mic număr natural '''n''',care nu este divizibil cu primele '''k''' numere prime și nu este prim.
== Restricții și precizări ==
* '''1 ≤ k ≤ 10000'''
== Exemplu ==
; '''kprim.in'''
: 3
; '''kprim.out'''
: 49
== Explicație ==
Primele '''3''' numere prime sunt '''2''', '''3''',''' 5'''.
Numerele care nu sunt divizibile cu '''2''', '''3''' sau '''5''' sunt : '''7''', '''11''', '''13''', '''17''', '''19''', '''23''', '''31''', '''37''', '''41''', '''47''', '''49''', …
'''49''' este cel mai mic număr care nu este prim
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date(n):
if isinstance(n, int) and n > 0:
return True
return False

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

if __name__ == '__main__':
n = int(input("Introduceti un numar natural: "))
if validare_date(n):
if n == 1:
print(9)
else:
x = 3
while n > 0:
if prim(x):
r = x
n -= 1
x += 1
p = r * r
print(p)
else:
print("\nDatele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest program calculează pătratul celui de-al n-lea număr prim, unde '''n''' este un număr natural citit de la tastatură. Înainte de a începe calculele, programul verifică dacă datele de intrare sunt valide, adică dacă '''n''' este un număr natural pozitiv. Dacă datele sunt invalide, programul va afișa un mesaj corespunzător. Dacă datele sunt valide și '''n''' este egal cu 1, programul va afișa numărul 9. În caz contrar, programul va căuta cel de-al n-lea număr prim și va calcula pătratul acestuia, folosind o funcție care verifică dacă un număr dat este prim. Rezultatul este apoi afișat la ecran.

0405 - Suma Cifre Nr Prime

2023-04-09T19:08:59Z

Paul Matei:

== Cerinţa ==
Se dă un șir cu '''n''' numere naturale. Determinați suma tuturor cifrelor numerelor prime din șir.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale.
== Date de ieşire ==
Programul afișează pe ecran numărul '''S''', reprezentând suma tuturor cifrelor numerelor prime din șir.
== Restricții și precizări ==
* '''1 ≤ n ≤ 1000'''
*cele '''n''' numere citite vor fi mai mici decât '''1.000.000.000'''.
== Exemplu ==
; Intrare
: 6
83 36 53 401 90 7
; Ieșire
: 31
== Explicație ==
Dintre cele '''6''' numere citite sunt prime : '''83''' '''53''' '''401''' '''7'''. Suma cifrelor acestor numere este '''31'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n: int, a: list) -> bool:
if not 1 <= n <= 1000:
return False
for x in a:
if not 1 <= x <= 10**6:
return False
return True

def prim(n: int) -> int:
cnt = 0
for i in range(1, int(n**0.5)+1):
if n % i == 0:
cnt += 2
if i*i == n:
cnt -= 1
if cnt == 2:
return 1
else:
return 0

def sum(n: int) -> int:
s = 0
while n > 0:
s += n % 10
n //= 10
return s

if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))
if validare_date(n, a):
s = 0
for x in a:
if prim(x):
s += sum(x)
print(s)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest cod conține trei funcții și un bloc de cod principal care folosește aceste funcții pentru a efectua o sarcină specifică:

1.Funcția '''validare_date''' primește un număr întreg '''n''' și o listă de numere întregi '''a''' și returnează '''True''' dacă valorile sunt conforme cu anumite restricții și '''False''' în caz contrar. În acest caz, valorile valide pentru '''n''' sunt între 1 și 1000, iar valorile valide pentru fiecare element din lista '''a''' sunt între 1 și 10^6.

2.Funcția '''prim''' primește un număr întreg '''n''' și returnează 1 dacă numărul este prim și 0 în caz contrar. În această funcție, se folosește o metodă de determinare a numărului de divizori ai lui '''n''', și anume, se numără câți divizori există în intervalul [1, sqrt(n)]. Dacă numărul total de divizori este 2, atunci numărul este prim.

3.Funcția '''sum''' primește un număr întreg '''n''' și returnează suma cifrelor acestuia. Această funcție extrage cifrele din numărul dat prin împărțirea repetată la 10 și adună cifra obținută la suma totală.

4.Blocul de cod principal solicită introducerea numărului '''n''' și a listei '''a''', validează datele introduse utilizând funcția '''validare_date''', calculează suma cifrelor tuturor numerelor prime din lista '''a''' și o afișează. În cazul în care datele introduse nu sunt valide, se afișează un mesaj de eroare.

0404 - Cifre Nr Prime

2023-04-09T18:40:35Z

Paul Matei:

== Cerinţa ==
Se dă un șir cu '''n''' numere naturale. Determinați numărul total de cifre al tuturor numerelor prime din șir.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale.
== Date de ieşire ==
Programul afișează pe ecran numărul '''C''', reprezentând numărul total de cifre al tuturor numerelor prime din șir.
== Restricții și precizări ==
*'''1 ≤ n ≤ 1000'''
*cele '''n''' numere citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu ==
; Intrare
: 6
83 36 53 401 90 7
; Ieșire
: 8
== Explicație ==
Dintre cele '''6''' numere citite sunt prime : '''83''' '''53''' '''401''' '''7'''. În total, ele au '''8''' cifre.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def prim(n):
if n == 0 or n == 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
for i in range(3, int(n**0.5) + 1, 2):
if n % i == 0:
return False
return True

def validare_date(n, a):
if n < 1 or n > 10**5:
return False
if len(a) != n:
return False
for x in a:
if x < 1 or x > 10**9:
return False
return True

if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))

if not validare_date(n, a):
print("Datele de intrare nu corespund restrictiilor impuse.")
else:
nrcif = 0
for x in a:
if prim(x):
while x != 0:
nrcif += 1
x //= 10
print(nrcif)

</syntaxhighlight>
==Explicație rezolvare==
Acest cod verifică dacă un șir de numere îndeplinește anumite condiții și apoi calculează numărul de cifre prime din acele numere.

Funcția '''prim''' primește un număr întreg și returnează adevărat dacă acesta este prim și fals în caz contrar. Algoritmul folosit parcurge toate numerele impare mai mici sau egale cu rădăcina pătrată a numărului dat și verifică dacă acestea sunt divizibile cu numărul dat.

Funcția '''validare_date''' primește un număr întreg '''n''' și o listă '''a''' de '''n''' numere întregi și verifică dacă acestea corespund cu anumite condiții: '''n''' trebuie să fie între 1 și 10^5, iar fiecare element din lista '''a''' trebuie să fie între 1 și 10^9.

În blocul principal, programul citește un număr '''n''' și o listă de '''n''' numere întregi '''a'''. Dacă datele de intrare nu respectă restricțiile impuse, programul afișează un mesaj de eroare. În caz contrar, programul calculează numărul de cifre prime din fiecare număr din lista '''a'''. Pentru fiecare număr, programul îl împarte la 10 până când ajunge la zero și numără cifrele prime găsite în procesul acesta. La final, programul afișează numărul total de cifre prime găsite în toate numerele din lista '''a'''.

0381 - A Prim 2

2023-04-09T06:06:53Z

Paul Matei:

== Cerinţa ==
Se citește un număr natural '''n''' și apoi '''n''' numere naturale. Să se determine cel mai mare număr aproape prim dintre cele date, și de câte ori apare.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', și apoi '''n''' numere naturale.
== Date de ieşire ==
Programul afișează pe ecran numere '''M''' și '''C''', separate prin exact un spațiu, reprezentând cel mai mare număr aproape prim dintre cele date și numărul său de apariții.
== Restricții și precizări ==
*'''1 ≤ n ≤ 100'''
*cele '''n''' numere citite sunt cuprinse între '''1 '''și '''1.000.000.000'''
== Exemplu ==
; Intrare
: 6
35 55 12 6 25 50
; Ieșire
: 55 1

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar1, numar2):
flag = False

def is_prime(n):
if n < 2:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True

def is_almost_prime(n):
prime_factors = []
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
if is_prime(i):
prime_factors.append(i)
if is_prime(n//i):
prime_factors.append(n//i)
if len(prime_factors) == 2 or (len(prime_factors) == 1 and prime_factors[0]**2 == n):
return True
if len(prime_factors) == 0:
return False
if len(prime_factors) > 2:
return False
if abs(prime_factors[0]*prime_factors[1] - n) <= 1:
return True
return False

n = int(input("Introduceti numarul de numere: "))

validare_date(n, 1_000_000_000) # Validare date

max_almost_prime = -1
count = 0

for i in range(n):
num = int(input("Introduceti numarul: "))
if is_almost_prime(num) and num > max_almost_prime:
max_almost_prime = num
count = 1
elif num == max_almost_prime:
count += 1

print("Cel mai mare numar aproape prim este", max_almost_prime, "si apare de", count, "ori.")

</syntaxhighlight>
==Explicație rezolvare==
Acesta este un program Python care determină cel mai mare număr '''aproape prim''' introdus de utilizator și numărul de apariții ale acestuia. Funcția '''is_almost_prime(n)''' determină dacă un număr este '''aproape prim''', adică are exact doi factori primi sau un singur factor prim dublu și niciun alt factor prim. Programul utilizează o '''funcție is_prime(n)''' care verifică dacă un număr este prim.