Bitnami MediaWiki - User contributions [en]

Gazeta Matematică nr 9 2012

2023-12-04T14:07:26Z

Diana Butuza: Pagină nouă: '''14380 (Vasile Ienuțaș)''' ''Determinați cifrele a și b știind că <math>\overline{\rm ab}=(a+b)(a+b-1)</math>.'' '''14383 (Gheorghe Gherasim)''' ''Numerele naturale distincte a, b verifică <math>9 \cdot [\,a, b]\,=a \cdot b \cdot (\,a \cdot b)\,</math>.'' i) ''Arătați că a și b nu sunt prime între ele.'' ii) ''Arătați că diferența numerelor este cel puțin 3.'' ''([a, b] reprezintă cel mai mic multiplu comun al numerelor a și b, iar (a, b) este cel m...

'''14380 (Vasile Ienuțaș)'''

''Determinați cifrele a și b știind că <math>\overline{\rm ab}=(a+b)(a+b-1)</math>.''

'''14383 (Gheorghe Gherasim)'''

''Numerele naturale distincte a, b verifică <math>9 \cdot [\,a, b]\,=a \cdot b \cdot (\,a \cdot b)\,</math>.''

i) ''Arătați că a și b nu sunt prime între ele.''

ii) ''Arătați că diferența numerelor este cel puțin 3.''

''([a, b] reprezintă cel mai mic multiplu comun al numerelor a și b, iar (a, b) este cel mai mare divizor comun al numerelor a și b).''

Gazeta Matematică

2023-12-04T14:00:49Z

Diana Butuza:

Această pagină conține o listă cu numerele revistei ''[https://gmb.ssmr.ro/ Gazeta Matematică]'' care conțin articole/probleme cu autori membri ai [https://ssmr.cunbm.utcluj.ro/ Filialei Maramureș] a [https://ssmr.ro/ Societății de Științe Matematice din România].
{| class="wikitable mw-collapsible"
|+
!Anul
!Numărul
!Numărul problemei
!Clasa
!Domeniu
|-
|rowspan="8" |2022
|rowspan="2"|1
| [[28247]]
|11
|Matrice
|-
| [[28250]]
|12
|integrala Riemann
limită
|-
|4 - [[Gazeta Matematică nr 4 2022|link]]
| [[28315]]
|10
|numere complexe
|-
|5
| [[28338]]
|10
|numere complexe
afixe
|-
|6-7-8
| [[28354]]
|9
|vectori
|-
|10
| [[28437]]
|11
|șir recurent
|-
|rowspan="2"|11
| [[E:16407]]
|5
|cub perfect
|-
| [[28450]]
|9
|progresii aritmetice
|-
|rowspan = "4" |2021
|rowspan= "1" | 12
|[[28208]]
|9
|vectori
|-
|rowspan = "3" |678 - [[Gazeta Matematică nr 678 2021|link]]
|[[E:15990]]
|5
|numere naturale
|-
| [[E:15991]]
|5
|numere naturale
|-
| [[E:15992]]
|5
|numere naturale
|-
|rowspan="3" |2018
|rowspan="3" |4 - [[Gazeta Matematică nr 4 2018|link]]
| [[S:E18.128]]
|
|
|-
|[[S:E18.131]]
|
|
|-
| [[S:E18.131]]
|
|
|-
|rowspan="2" |2015
|1 - [[Gazeta Matematică nr 1 2015|link]]
|[[27020]]
|10
|coeficienți binomiali
|-
|2 - [[Gazeta Matematică nr 2 2015|link]]
|[[27036]]
|11
|ecuații funcționale
|-
|rowspan="2"| 2012
|rowspan="2"|9 - [[Gazeta Matematică nr 9 2012|link]]
|[[14380]]
|5
|
|-
|[[14383]]
|6
|
|-
|rowspan="2"| 2011
|rowspan="2"|7-8-9 - [[Gazeta Matematică nr 789 2011|link]]
|[[E:14223]]
|7
|rezolvarea triunghiului
|-
|[[E:14228]]
|7
|radicali
|}

14383

2023-12-04T13:46:50Z

Diana Butuza: Pagină nouă: '''14383 (Gheorghe Gherasim)''' ''Numerele naturale distincte a, b verifică <math>9 \cdot [\,a, b]\,=a \cdot b \cdot (\,a \cdot b)\,</math>.'' i) ''Arătați că a și b nu sunt prime între ele.'' ii) ''Arătați că diferența numerelor este cel puțin 3.'' ''([a, b] reprezintă cel mai mic multiplu comun al numerelor a și b, iar (a, b) este cel mai mare divizor comun al numerelor a și b).'' '''Soluție.''' i) Se știe că <math>a \cdot b= [\,a, b]\, \cdot (\,a, b)...

'''14383 (Gheorghe Gherasim)'''

''Numerele naturale distincte a, b verifică <math>9 \cdot [\,a, b]\,=a \cdot b \cdot (\,a \cdot b)\,</math>.''

i) ''Arătați că a și b nu sunt prime între ele.''

ii) ''Arătați că diferența numerelor este cel puțin 3.''

''([a, b] reprezintă cel mai mic multiplu comun al numerelor a și b, iar (a, b) este cel mai mare divizor comun al numerelor a și b).''

'''Soluție.'''

i) Se știe că <math>a \cdot b= [\,a, b]\, \cdot (\,a, b)\,</math> și relația devine <math>9 \cdot [\,a, b]\,=[\,a, b]\, \cdot {\{(\,a, b)\,\}}^2</math>. De aici obținem <math>{\{(\,a, b)\,\}}^2=9</math>, de unde <math>(\,a, b)\,=3</math>, ceea ce arată că a și b nu sunt prime între ele.

ii) Din <math>(\,a, b)\,=3</math> rezultă <math>a=3x</math> și <math>b=3y</math> cu <math>(\,x, y)\,=1</math>. Deoarece <math>a<b</math> avem <math>x<y</math>. Cum x și y sunt numere naturale avem <math>y-x \geq 1</math>. Atunci <math>b-a=3(\,y-x)\, \geq 3 \cdot 1=3</math>, de unde <math>b \geq a+3</math>.

14380

2023-12-04T12:57:47Z

Diana Butuza: Pagină nouă: '''14380 (Vasile Ienuțaș)''' ''Determinați cifrele a și b știind că <math>\overline{\rm ab}=(a+b)(a+b-1)</math>.'' '''Soluție.''' Observăm că membrul stâng al egalității reprezintă produsul a două numere consecutive. Ultima cifră a unui produs de două numere consecutive poate fi 0, 2 sau 6 și atunci <math>b\in\{0,2,6\}</math>. Prin încercări găsim soluția unică <math>\overline{\rm ab}=72</math>.

'''14380 (Vasile Ienuțaș)'''

''Determinați cifrele a și b știind că <math>\overline{\rm ab}=(a+b)(a+b-1)</math>.''

'''Soluție.'''

Observăm că membrul stâng al egalității reprezintă produsul a două numere consecutive. Ultima cifră a unui produs de două numere consecutive poate fi 0, 2 sau 6 și atunci <math>b\in\{0,2,6\}</math>. Prin încercări găsim soluția unică <math>\overline{\rm ab}=72</math>.

3308 - N Div Tri

2023-05-09T12:24:30Z

Diana Butuza: /* Cerinţa */

== 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.

0443 - Divizori Primi

2023-05-09T12:01:48Z

Diana Butuza: /* Explicație */

== 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 '''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-05-09T11:57:51Z

Diana Butuza: /* Rezolvare */

== 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 cei mai multi 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.

1780 - Fractie

2023-05-09T11:50:54Z

Diana Butuza: /* Cerinţa */

== 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>

0435 - Factori Primi

2023-05-08T15:10:17Z

Diana Butuza: /* Rezolvare */

== 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):
aceeasi_factori = True
d = 2
while n > 1:
if n % d == 0:
if m % d != 0:
aceeasi_factori = False
while n % d == 0:
n /= d
while m % d == 0:
m /= d
d += 1
if d * d > n:
d = n
if aceeasi_factori and m == 1:
print("DA")
else:
print("NU")

</syntaxhighlight>

==Explicație rezolvare==
În această problemă se verifică dacă două numere naturale au aceeaș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ă aceeaș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 aceeași factori primi. La sfârșit, codul afișează dacă cele două numere au aceeași factori primi sau nu.

0435 - Factori Primi

2023-05-08T15:09:44Z

Diana Butuza: /* Explicație rezolvare */

== 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 verifică dacă două numere naturale au aceeaș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ă aceeaș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 aceeași factori primi. La sfârșit, codul afișează dacă cele două numere au aceeași factori primi sau nu.

2913 - Proth Number

2023-05-08T14:27:22Z

Diana Butuza: /* Exemplu */

== 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
: 25 este numar Proth.

== 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-05-08T14:21:04Z

Diana Butuza: /* Explicație rezolvare */

== 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.

4295 - Factor Exp Max

2023-05-08T14:10:20Z

Diana Butuza: /* Explicație rezolvare */

== 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 parcurs apoi 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.

0967 - Cifre 8

2023-05-08T13:51:23Z

Diana Butuza: /* Rezolvare */

== 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

if __name__ == '__main__':
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.

1316 - Prim Aproape Prim - Patrat Prim - Compus

2023-05-08T13:35:41Z

Diana Butuza: /* Explicație rezolvare */

== Cerinţa ==
*Un număr natural nenul este '''prim''', dacă are exact doi divizori (ex. '''7''').
*Un număr natural nenul se va numi '''pătrat prim''', dacă este pătratul unui număr prim (ex. '''49 = 7 * 7''').
*Un număr natural nenul se va numi '''aproape prim''', dacă este produsul a două numere prime distincte (ex. '''10 = 2 * 5''').
*Un număr natural nenul ce nu se încadrează în niciuna din cazurile de mai sus, se numeşte '''compus''' (ex. '''8=2*2*2, 100=2*2*5*5''').
Se citeşte un număr natural '''n'''. Să se identifice din ce categorie de mai sus face parte.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul va afișa pe ecran unul dintre mesajele: '''prim''', '''aproape prim''', '''patrat prim''' sau '''compus'''.
== Restricții și precizări ==
* '''1 < n ≤ 2.000.000.000'''
== Exemplu ==
; Intrare
: 20
; Ieșire
: compus
== Explicație ==
Numărul '''20=2*2*5''', deci este număr compus.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def prim(n):
cnt = 0
for i in range(1, int(math.sqrt(n))+1):
if n % i == 0:
cnt += 2
if i * i == n:
cnt -= 1
if cnt == 2:
return 1
elif cnt == 4:
return 2
else:
return 0

def validare_date(prompt):
while True:
try:
value = int(input(prompt))
if value <= 0:
print("Introduceti un numar intreg pozitiv.")
else:
return value
except ValueError:
print("Introduceti un numar intreg pozitiv.")

if __name__ == '__main__':
n = validare_date("Introduceti un numar intreg pozitiv: ")
i = int(math.sqrt(n))
if prim(n) == 1:
print("prim")
elif prim(n) == 2:
print("aproape prim")
elif i * i == n and prim(i) == 1:
print("patrat prim")
else:
print("compus")
print("Datele de intrare corespund restrictiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest program determină dacă un număr dat este prim, aproape prim sau compus.

Pentru a verifica dacă numărul este prim, se apelează funcția '''prim(n)''', care primește ca argument numărul dat '''n'''. În interiorul funcției, se calculează numărul de divizori ai lui '''n''' prin parcurgerea tuturor numerelor întregi până la radicalul pătrat al lui '''n'''. Dacă numărul de divizori ai lui '''n''' este 2, atunci '''n''' este un număr prim.

Dacă numărul de divizori ai lui '''n''' este 4, atunci '''n''' este considerat aproape prim.

Dacă '''n''' este un pătrat perfect și radicalul pătrat al lui '''n''' este prim, atunci '''n''' este considerat patrat prim.

Dacă niciuna dintre condițiile de mai sus nu este îndeplinită, atunci '''n''' este considerat un număr compus.

Funcția '''validare_date(prompt)''' este folosită pentru a valida input-ul primit de la utilizator. Această funcție cere introducerea unui număr întreg pozitiv și afișează un mesaj de eroare dacă input-ul nu este un număr întreg pozitiv.

În cadrul programului principal, se citește input-ul utilizatorului folosind funcția '''validare_date(prompt)''' și se determină tipul de număr folosind funcția '''prim(n)'''. Programul afișează apoi tipul numărului și un mesaj care confirmă faptul că input-ul corespunde restricțiilor impuse.

0380 - A Prim 1

2023-05-08T13:34:55Z

Diana Butuza: /* Explicație rezolvare */

== Cerinţa ==
Se citește un număr natural și apoi '''n''' numere naturale. Să se determine câte dintre ele sunt aproape prime.
== 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 numărul '''C''', reprezentând câte dintre numerele citite sunt aproape prime.
== 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
: 3

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n, arr):
if not 1 <= n <= 10**5:
return False
for a in arr:
if not 1 <= a <= 10**9:
return False
return True

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

if validare_date(n, arr):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

C = 0
for i in range(n):
x = arr[i]
d = 2
cn = 1
while x > 1:
p = 0
while x % d == 0:
p += 1
x //= d
d += 1
cn *= (p + 1)
if d * d > x:
d = x
if cn == 4:
C += 1

print(C)

</syntaxhighlight>
==Explicație rezolvare==
În acest program, se dă un număr întreg '''n''' și un șir de '''n''' numere întregi '''arr'''. Scopul programului este de a găsi numărul de numere din șirul '''arr''' care au exact patru divizori.

Pentru a rezolva această problemă, se parcurge fiecare element din șirul '''arr'''. Pentru fiecare element '''x''' se calculează numărul de divizori folosind un algoritm care împarte numărul la toți divizorii săi, numărând fiecare divizor de câte ori apare. Dacă numărul total de divizori este patru, atunci elementul este adăugat la numărul total de numere cu patru divizori găsite până acum.

Pentru a verifica dacă datele de intrare sunt valide, se folosește o funcție numită '''validare_date''' care verifică dacă numărul '''n''' și toate elementele din '''arr''' sunt în limitele specificate. Dacă datele de intrare sunt invalide, programul se oprește și afișează un mesaj de eroare. În caz contrar, programul continuă și afișează un mesaj de confirmare.

0223 - Min Cols 1

2023-05-02T18:57:07Z

Diana Butuza: /* Rezolvare */

== Enunț ==
Se consideră un tablou bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere naturale cu cel mult două cifre fiecare.
== Cerinţa ==
Să se determine ultima cifră a produsului elementelor de pe diagonala secundară cu proprietatea că sunt minime pe coloanele lor.
== Date de intrare ==
Fişierul de intrare '''mincols1.in''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fişierul de ieşire '''mincols1.out''' se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou va conţine un singur număr, reprezentând valoarea cerută.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 2 &les; n &les; 30
* dacă în matrice nu există asemenea elemente, se va afișa mesajul '''NU EXISTA'''
== Exemplu ==
; mincols1.in
: 4
: 3 4 90 10
: 25 2 7 9
: 18 3 10 4
: 3 7 20 3
; mincols1.out
: Datele sunt introduse corect.
: 1
== Explicație ==
Dintre valorile de pe diagonala secundară, sunt minime pe coloanele lor '''7''' şi '''3'''. Produsul lor este '''21''', iar ultima cifră este '''1'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>

# Funcție care verifică dacă datele de intrare respectă condițiile problemei.
def validare(n, a):

if n < 2 or n > 30:
return False
for i in range(n):
for j in range(n):
if a[i][j] < 0 or a[i][j] > 99:
return False
return True

# Funcție care determină ultima cifră a produsului elementelor de pe diagonala secundară cu proprietatea că sunt minime pe coloanele lor.
def ultima_cifra_produsului_diag_sec_min_pe_coloane(n, a):

p = 1
exista_minim_pe_coloane = False
for i in range(n):
j = n - i - 1 # indicii elementelor de pe diagonala secundară
minim_pe_coloana = min(a[k][j] for k in range(n))
if a[i][j] == minim_pe_coloana:
exista_minim_pe_coloane = True
p = (p * a[i][j]) % 10
if exista_minim_pe_coloane:
return p
else:
print("NU EXISTA")

if __name__ == "__main__":
# Citim datele de intrare din fișierul "mincols1.in".
with open("mincols1.in") as f:
n = int(f.readline())
a = [list(map(int, f.readline().split())) for _ in range(n)]
# Verificăm dacă datele de intrare sunt valide.
if validare(n, a):
# Apelăm funcția care calculează rezultatul cerut.
rezultat = ultima_cifra_produsului_diag_sec_min_pe_coloane(n, a)
if rezultat is not None:
# Scriem rezultatul în fișierul de ieșire "mincols1.out".
with open("mincols1.out", "w") as g:
g.write("Datele sunt introduse corect.\n")
g.write(str(rezultat))
else:
# Scriem un mesaj de eroare în fișierul de ieșire "mincols1.out".
with open("mincols1.out", "w") as g:
g.write("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

3352 - Factori 1

2023-05-02T12:42:44Z

Diana Butuza: /* Exemplu */

== 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
: Datele de intrare corespund restricțiilor impuse.
: 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.

1422 - Ograda

2023-04-25T10:26:09Z

Diana Butuza: /* Exemplu2 */

== Enunţ ==
În ograda lui Gigel se găsesc găini și văcuțe. Se dau două numere naturale: '''C''' – numărul de capete și '''P''' – numărul de picioare din curte.
== Cerinţa ==
1. Să se afișeze câte găini și câte văcuțe sunt în ograda lui Gigel.
2. Maria, colega lui Gigel, îl provoacă pe acesta să calculeze numărul de divizori impari pentru numărul C și numărul de divizori pari pentru numărul P. Deoarece Gigel nu este bun la matematică, vă cere ajutorul. Să se afișeze cele două numere calculate
== Date de intrare ==
Fișierul de intrare '''ograda.in''' conține pe prima linie un număr natural '''X''' ('''1''' sau '''2''') reprezentând numărul cerinței ce trebuie rezolvată.

A doua linie conține două numere '''C''' și '''P''', separate printr-un spațiu, cu semnificațiile din cerință.
== Date de ieşire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:'''"Datele sunt introduse corect."''', apoi pe urmatorul rand fișierul de ieșire ograda.out va conține:
Pentru cerința 1: pe prima linie se vor afișa două numere, separate printr-un spațiu, '''G''' și '''V''' reprezentând numărul de găini, respectiv numărul de văcuțe din ogradă.
Pentru cerința 2: pe prima linie se vor afişa două numere, separate printr-un spațiu, reprezentând numărul de divizori impari pentru numărul '''C''' și numărul de divizori pari pentru numărul '''P'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran:''' "Datele nu corespund restricțiilor impuse."'''

== Restricții și precizări ==
* C și P ∈ Ν , 2*C &les; P &les; 4*C, iar P este un număr par.
* Pentru cerința 1:C,P &les; 200000000000
* Pentru cerința 2: C, P &les;50000000
* 0 &les; numar1 &les; numar2 &les; 1.000.000.000
* Se consideră că toate găinile au 2 picioare și 1 cap, iar toate văcuțele au 4 picioare și 1 cap. Gigel nu se
* află în ogradă în momentul numărării capetelor și picioarelor.
* Pentru X = 1 se va rezolva doar cerința 1. Pentru X = 2 se va rezolva doar cerința 2.
* d este divizorul lui a dacă restul împărţirii lui a la d este 0.
== Exemplul 1 ==
; ograda.in
: 1
: 5 16
; ograda.out
: Datele introduse corespund restricțiilor impuse.
: 2 3
== Explicație ==
Cerința este '''1'''. În ogradă sunt '''2''' găini și '''3''' văcuțe.
== Exemplu2 ==
; ograda.in
: 2
: 5 16
; ograda.out
: Datele introduse corespund restricțiilor impuse.
: 2 5

== Explicație ==
Cerința este '''2'''. Numărul '''5''' are '''2''' divizori impari ('''1''' și '''5'''), iar numărul '''16''' are '''4''' divizori pari ('''2''', '''4''', '''8''', '''16''').
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Verificăm dacă toate valorile de intrare respectă restricțiile
def validare_date(C, P, X):
if not (isinstance(C, int) and isinstance(P, int) and isinstance(X, int)):
return False

if not (0 < C <= 200000000000 and 0 < P <= 200000000000):
if X == 1:
return False
elif not (0 < C <= 50000000 and 0 < P <= 50000000):
return False

if not (2 * C <= P <= 4 * C and P % 2 == 0):
return False

return True

if __name__ == "__main__":
# Citire date de intrare
with open("ograda.in", "r") as f:
X = int(f.readline())
C, P = map(int, f.readline().split())

# Verificare validare date
if validare_date(C, P, X):
with open("ograda.out", "w") as f_out:
f_out.write("Datele sunt introduse corect.\n")

# Rezolvare cerinta 1
if X == 1:
# Numarul total de capete
t = C
# Numarul total de picioare
l = P
# Numarul de gaini (cu 2 picioare si 1 cap)
g = (4*t - l) // 2
# Numarul de vacute (cu 4 picioare si 1 cap)
v = t - g
# Afisare rezultat
with open("ograda.out", "a") as f_out:
f_out.write(str(g) + " " + str(v))

# Rezolvare cerinta 2
elif X == 2:
# Numarul de divizori impari pentru numarul C
d1 = 1
for i in range(3, C+1, 2):
if C % i == 0:
d1 += 1
# Numarul de divizori pari pentru numarul P
d2 = 1
for i in range(2, P+1, 2):
if P % i == 0:
d2 += 1
# Afisare rezultat
with open("ograda.out", "a") as f_out:
f_out.write(str(d1) + " " + str(d2))
else:
with open("ograda.out", "w") as f_out:
f_out.write("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

1437 - Fractii 4

2023-04-25T10:06:52Z

Diana Butuza: /* Exemplul 1 */

== Enunţ ==
Se dă un șir de n fracții. Fiecare fracție este dată printr-o pereche de numere reprezentând numărătorul și numitorul fracției. De exemplu '''2010 34''' reprezintă fracția '''2010/34'''. O fracție poate fi ireductibilă sau se poate simplifica. În exemplul precedent, '''2010/34''' se simplifică prin '''2''' și rezultă '''1005/17'''.
== Cerinţa ==
Să se afișeze, pentru fiecare fracție:

1) Prin câte moduri distincte se poate simplifica.
2) Fracția ireductibilă.
== Date de intrare ==
În fișierul de intrare '''fractii4.in''' pe prima linie se găsesc numerele '''P''' și '''n''', iar pe următoarele '''n''' linii se găsesc '''n''' perechi de numere, reprezentând numărătorul și numitorul fiecărei fracții, separate printr-un spațiu.
== Date de iesire ==
Dacă datele sunt introduse corect, în fișier se va afișa:''' "Datele de intrare sunt introduse corect."''', apoi pe fiecare din cele '''n''' linii ale fișierului '''fractii4.out''' se găsesc, pentru fiecare fracție, în ordinea dată în fișierul de intrare:
1) Dacă '''P = 1''', numărul de simplificări distincte posibile. Dacă nu este posibilă nicio simplificare (fracția este ireductibilă) se va afișa -1.
2) Dacă '''P = 2''' , fracția ireductibilă, numărătorul și numitorul fiind separați prin /. În cazul în care datele nu respectă restricțiile, se va afișa în fișier: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* n &les; 100 000
* 0 < numitor, numărător < 2 000 000
* P este 1 sau 2
== Exemplul 1 ==
; fractii4.in
: 11 4
: 8 4
: 3 2
: 1 6
: 12 6
; fractii4.out
: Datele de intrare sunt introduse corect.
: 2
: -1
: -1
: 3

== Explicație ==
Pentru acest test ''''P = 1''', deci se va rezolva doar cerinţa 1).
Prima fracție se poate simplifica prin '''2''' moduri: prin '''2''' și '''4'''.
A doua este ireductibilă, deci se va afișa '''-1'''.
A treia este ireductibilă, deci se va afișa '''-1'''.
A patra se poate simplifica prin '''3''' moduri: '''2''', '''3''' și '''6'''.
== Exemplul 2 ==
; fractii4.in
: 12 3
: 22 6
: 11 4
: 125 25
; fractii4.out
: Datele de intrare sunt introduse corect.
: 11/3
: 11/4
: 5/1

== Explicație ==
Pentru acest test '''P = 2''', deci se va rezolva doar cerinţa 2).
Prima fracție se simplifică prin '''2'''.
A doua fracție este ireductibilă, deci va fi afișată fără schimbare.
Ultima fracție poate fi redusă prin '''25''' și devine ireductibilă. Chiar dacă
numitorul este '''1''', acesta va fi afișat.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

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

def prime(a, b):
if b == 0:
return a
else:
return prime(b, a % b)

def validare_date(n, p):
if n <= 100000 and p in [1, 2]:
return True
else:
return False

if __name__ == '__main__':
fin = open("fractii4.in", "r")
fout = open("fractii4.out", "w")
p, n = map(int, fin.readline().split())
if validare_date(n, p):
print("\nDatele de intrare sunt introduse corect.\n")
for i in range(n):
a, b = map(int, fin.readline().split())
x, y = a, b
if p == 1:
if prim(a) == 0 and prim(b) == 0 and prime(a, b) == 1:
d = 0
d1 = prime(a, b)
for j in range(1, int(math.sqrt(d1))+1):
if d1 % j == 0:
d += 2
if j * j == d1:
d -= 1
fout.write(str(d-1) + '\n')
else:
fout.write("-1\n")
else:
t = prime(a, b)
fout.write(str(x//t) + '/' + str(y//t) + '\n')
fin.close()
fout.close()
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

1437 - Fractii 4

2023-04-25T10:06:28Z

Diana Butuza: /* Date de iesire */

== Enunţ ==
Se dă un șir de n fracții. Fiecare fracție este dată printr-o pereche de numere reprezentând numărătorul și numitorul fracției. De exemplu '''2010 34''' reprezintă fracția '''2010/34'''. O fracție poate fi ireductibilă sau se poate simplifica. În exemplul precedent, '''2010/34''' se simplifică prin '''2''' și rezultă '''1005/17'''.
== Cerinţa ==
Să se afișeze, pentru fiecare fracție:

1) Prin câte moduri distincte se poate simplifica.
2) Fracția ireductibilă.
== Date de intrare ==
În fișierul de intrare '''fractii4.in''' pe prima linie se găsesc numerele '''P''' și '''n''', iar pe următoarele '''n''' linii se găsesc '''n''' perechi de numere, reprezentând numărătorul și numitorul fiecărei fracții, separate printr-un spațiu.
== Date de iesire ==
Dacă datele sunt introduse corect, în fișier se va afișa:''' "Datele de intrare sunt introduse corect."''', apoi pe fiecare din cele '''n''' linii ale fișierului '''fractii4.out''' se găsesc, pentru fiecare fracție, în ordinea dată în fișierul de intrare:
1) Dacă '''P = 1''', numărul de simplificări distincte posibile. Dacă nu este posibilă nicio simplificare (fracția este ireductibilă) se va afișa -1.
2) Dacă '''P = 2''' , fracția ireductibilă, numărătorul și numitorul fiind separați prin /. În cazul în care datele nu respectă restricțiile, se va afișa în fișier: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* n &les; 100 000
* 0 < numitor, numărător < 2 000 000
* P este 1 sau 2
== Exemplul 1 ==
; fractii4.in
: 11 4
: 8 4
: 3 2
: 1 6
: 12 6
; fractii4.out
: Datele sunt introduse corect.
: 2
: -1
: -1
: 3

== Explicație ==
Pentru acest test ''''P = 1''', deci se va rezolva doar cerinţa 1).
Prima fracție se poate simplifica prin '''2''' moduri: prin '''2''' și '''4'''.
A doua este ireductibilă, deci se va afișa '''-1'''.
A treia este ireductibilă, deci se va afișa '''-1'''.
A patra se poate simplifica prin '''3''' moduri: '''2''', '''3''' și '''6'''.
== Exemplul 2 ==
; fractii4.in
: 12 3
: 22 6
: 11 4
: 125 25
; fractii4.out
: Datele de intrare sunt introduse corect.
: 11/3
: 11/4
: 5/1

== Explicație ==
Pentru acest test '''P = 2''', deci se va rezolva doar cerinţa 2).
Prima fracție se simplifică prin '''2'''.
A doua fracție este ireductibilă, deci va fi afișată fără schimbare.
Ultima fracție poate fi redusă prin '''25''' și devine ireductibilă. Chiar dacă
numitorul este '''1''', acesta va fi afișat.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

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

def prime(a, b):
if b == 0:
return a
else:
return prime(b, a % b)

def validare_date(n, p):
if n <= 100000 and p in [1, 2]:
return True
else:
return False

if __name__ == '__main__':
fin = open("fractii4.in", "r")
fout = open("fractii4.out", "w")
p, n = map(int, fin.readline().split())
if validare_date(n, p):
print("\nDatele de intrare sunt introduse corect.\n")
for i in range(n):
a, b = map(int, fin.readline().split())
x, y = a, b
if p == 1:
if prim(a) == 0 and prim(b) == 0 and prime(a, b) == 1:
d = 0
d1 = prime(a, b)
for j in range(1, int(math.sqrt(d1))+1):
if d1 % j == 0:
d += 2
if j * j == d1:
d -= 1
fout.write(str(d-1) + '\n')
else:
fout.write("-1\n")
else:
t = prime(a, b)
fout.write(str(x//t) + '/' + str(y//t) + '\n')
fin.close()
fout.close()
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

1437 - Fractii 4

2023-04-25T10:06:04Z

Diana Butuza: /* Exemplul 2 */

== Enunţ ==
Se dă un șir de n fracții. Fiecare fracție este dată printr-o pereche de numere reprezentând numărătorul și numitorul fracției. De exemplu '''2010 34''' reprezintă fracția '''2010/34'''. O fracție poate fi ireductibilă sau se poate simplifica. În exemplul precedent, '''2010/34''' se simplifică prin '''2''' și rezultă '''1005/17'''.
== Cerinţa ==
Să se afișeze, pentru fiecare fracție:

1) Prin câte moduri distincte se poate simplifica.
2) Fracția ireductibilă.
== Date de intrare ==
În fișierul de intrare '''fractii4.in''' pe prima linie se găsesc numerele '''P''' și '''n''', iar pe următoarele '''n''' linii se găsesc '''n''' perechi de numere, reprezentând numărătorul și numitorul fiecărei fracții, separate printr-un spațiu.
== Date de iesire ==
Dacă datele sunt introduse corect, în fișier se va afișa:''' "Datele sunt introduse corect."''', apoi pe fiecare din cele '''n''' linii ale fișierului '''fractii4.out''' se găsesc, pentru fiecare fracție, în ordinea dată în fișierul de intrare:
1) Dacă '''P = 1''', numărul de simplificări distincte posibile. Dacă nu este posibilă nicio simplificare (fracția este ireductibilă) se va afișa -1.
2) Dacă '''P = 2''' , fracția ireductibilă, numărătorul și numitorul fiind separați prin /. În cazul în care datele nu respectă restricțiile, se va afișa în fișier: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* n &les; 100 000
* 0 < numitor, numărător < 2 000 000
* P este 1 sau 2
== Exemplul 1 ==
; fractii4.in
: 11 4
: 8 4
: 3 2
: 1 6
: 12 6
; fractii4.out
: Datele sunt introduse corect.
: 2
: -1
: -1
: 3

== Explicație ==
Pentru acest test ''''P = 1''', deci se va rezolva doar cerinţa 1).
Prima fracție se poate simplifica prin '''2''' moduri: prin '''2''' și '''4'''.
A doua este ireductibilă, deci se va afișa '''-1'''.
A treia este ireductibilă, deci se va afișa '''-1'''.
A patra se poate simplifica prin '''3''' moduri: '''2''', '''3''' și '''6'''.
== Exemplul 2 ==
; fractii4.in
: 12 3
: 22 6
: 11 4
: 125 25
; fractii4.out
: Datele de intrare sunt introduse corect.
: 11/3
: 11/4
: 5/1

== Explicație ==
Pentru acest test '''P = 2''', deci se va rezolva doar cerinţa 2).
Prima fracție se simplifică prin '''2'''.
A doua fracție este ireductibilă, deci va fi afișată fără schimbare.
Ultima fracție poate fi redusă prin '''25''' și devine ireductibilă. Chiar dacă
numitorul este '''1''', acesta va fi afișat.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

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

def prime(a, b):
if b == 0:
return a
else:
return prime(b, a % b)

def validare_date(n, p):
if n <= 100000 and p in [1, 2]:
return True
else:
return False

if __name__ == '__main__':
fin = open("fractii4.in", "r")
fout = open("fractii4.out", "w")
p, n = map(int, fin.readline().split())
if validare_date(n, p):
print("\nDatele de intrare sunt introduse corect.\n")
for i in range(n):
a, b = map(int, fin.readline().split())
x, y = a, b
if p == 1:
if prim(a) == 0 and prim(b) == 0 and prime(a, b) == 1:
d = 0
d1 = prime(a, b)
for j in range(1, int(math.sqrt(d1))+1):
if d1 % j == 0:
d += 2
if j * j == d1:
d -= 1
fout.write(str(d-1) + '\n')
else:
fout.write("-1\n")
else:
t = prime(a, b)
fout.write(str(x//t) + '/' + str(y//t) + '\n')
fin.close()
fout.close()
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

1437 - Fractii 4

2023-04-25T10:05:44Z

Diana Butuza: /* Rezolvare */

== Enunţ ==
Se dă un șir de n fracții. Fiecare fracție este dată printr-o pereche de numere reprezentând numărătorul și numitorul fracției. De exemplu '''2010 34''' reprezintă fracția '''2010/34'''. O fracție poate fi ireductibilă sau se poate simplifica. În exemplul precedent, '''2010/34''' se simplifică prin '''2''' și rezultă '''1005/17'''.
== Cerinţa ==
Să se afișeze, pentru fiecare fracție:

1) Prin câte moduri distincte se poate simplifica.
2) Fracția ireductibilă.
== Date de intrare ==
În fișierul de intrare '''fractii4.in''' pe prima linie se găsesc numerele '''P''' și '''n''', iar pe următoarele '''n''' linii se găsesc '''n''' perechi de numere, reprezentând numărătorul și numitorul fiecărei fracții, separate printr-un spațiu.
== Date de iesire ==
Dacă datele sunt introduse corect, în fișier se va afișa:''' "Datele sunt introduse corect."''', apoi pe fiecare din cele '''n''' linii ale fișierului '''fractii4.out''' se găsesc, pentru fiecare fracție, în ordinea dată în fișierul de intrare:
1) Dacă '''P = 1''', numărul de simplificări distincte posibile. Dacă nu este posibilă nicio simplificare (fracția este ireductibilă) se va afișa -1.
2) Dacă '''P = 2''' , fracția ireductibilă, numărătorul și numitorul fiind separați prin /. În cazul în care datele nu respectă restricțiile, se va afișa în fișier: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* n &les; 100 000
* 0 < numitor, numărător < 2 000 000
* P este 1 sau 2
== Exemplul 1 ==
; fractii4.in
: 11 4
: 8 4
: 3 2
: 1 6
: 12 6
; fractii4.out
: Datele sunt introduse corect.
: 2
: -1
: -1
: 3

== Explicație ==
Pentru acest test ''''P = 1''', deci se va rezolva doar cerinţa 1).
Prima fracție se poate simplifica prin '''2''' moduri: prin '''2''' și '''4'''.
A doua este ireductibilă, deci se va afișa '''-1'''.
A treia este ireductibilă, deci se va afișa '''-1'''.
A patra se poate simplifica prin '''3''' moduri: '''2''', '''3''' și '''6'''.
== Exemplul 2 ==
; fractii4.in
: 12 3
: 22 6
: 11 4
: 125 25
; fractii4.out
: 11/3
: 11/4
: 5/1
== Explicație ==
Pentru acest test '''P = 2''', deci se va rezolva doar cerinţa 2).
Prima fracție se simplifică prin '''2'''.
A doua fracție este ireductibilă, deci va fi afișată fără schimbare.
Ultima fracție poate fi redusă prin '''25''' și devine ireductibilă. Chiar dacă
numitorul este '''1''', acesta va fi afișat.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

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

def prime(a, b):
if b == 0:
return a
else:
return prime(b, a % b)

def validare_date(n, p):
if n <= 100000 and p in [1, 2]:
return True
else:
return False

if __name__ == '__main__':
fin = open("fractii4.in", "r")
fout = open("fractii4.out", "w")
p, n = map(int, fin.readline().split())
if validare_date(n, p):
print("\nDatele de intrare sunt introduse corect.\n")
for i in range(n):
a, b = map(int, fin.readline().split())
x, y = a, b
if p == 1:
if prim(a) == 0 and prim(b) == 0 and prime(a, b) == 1:
d = 0
d1 = prime(a, b)
for j in range(1, int(math.sqrt(d1))+1):
if d1 % j == 0:
d += 2
if j * j == d1:
d -= 1
fout.write(str(d-1) + '\n')
else:
fout.write("-1\n")
else:
t = prime(a, b)
fout.write(str(x//t) + '/' + str(y//t) + '\n')
fin.close()
fout.close()
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

0434 - Perechi Prime

2023-04-25T09:41:36Z

Diana Butuza: /* Explicație rezolvare */

== Cerinţa ==
Se dă un număr natural '''n'''. Afișați primele '''n''' perechi de numere naturale impare consecutive prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran '''n''' primele perechi de numere naturale impare consecutive prime, câte o pereche pe linie, numerele dintr-o pereche fiind separate printr-un spațiu.
== Restricții și precizări ==
* 1 ≤ n ≤ 100
* pentru fiecare pereche p q afișată, p < q
== Exemplu ==
; Intrare
: 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3 5
: 5 7
: 11 13
: 17 19
: 29 31

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

def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 100:
flag = True
return flag

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

def print_prime_consecutive(n):
count = 0
numar = 3
while count < n:
if prim(numar) and prim(numar+2):
print(numar, numar+2)
count += 1
numar += 2

if __name__ == '__main__':
numar = input("Introduceți numărul n: ")
if validare_date(numar):
n = int(numar)
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print("Primele", n, "perechi de numere naturale impare consecutive prime sunt:")
print_prime_consecutive(n)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Funcția '''validare_date''' primește un număr sub formă de șir de caractere și returnează o valoare booleană, '''True''' dacă numărul este un număr natural între '''0 și 100''', inclusiv, altfel returnează '''False'''.

Funcția '''prim''' primește un număr și returnează o valoare booleană, '''True''' dacă numărul este prim, altfel returnează '''False'''. Funcția utilizează o buclă for care verifică dacă numărul este divizibil cu orice număr între 2 și rădăcina pătrată a numărului dat, iar dacă este, returnează '''False'''.

Funcția '''print_prime_consecutive''' primește un număr întreg '''n''' și afișează primele n perechi de numere naturale impare consecutive prime. Funcția începe cu numărul 3 și, utilizând o buclă '''while''', verifică dacă numerele sunt prime și consecutive impare și le afișează în caz afirmativ. Dacă găsește o pereche, crește numărul de perechi găsite '''(count)''' cu 1 și trece la următorul număr.

Funcția '''main''' începe prin a cere utilizatorului să introducă un număr întreg '''n''' și apoi verifică dacă acesta este valid utilizând funcția '''validare_date'''. Dacă numărul este valid, afișează mesajul '''Datele de intrare corespund restricțiilor impuse.''' și apoi utilizează funcția '''print_prime_consecutive''' pentru a afișa primele '''n''' perechi de numere naturale impare consecutive prime. Dacă numărul nu este valid, afișează mesajul '''Datele de intrare nu corespund restricțiilor impuse.'''

0434 - Perechi Prime

2023-04-25T09:41:14Z

Diana Butuza: /* Explicație rezolvare */

== Cerinţa ==
Se dă un număr natural '''n'''. Afișați primele '''n''' perechi de numere naturale impare consecutive prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran '''n''' primele perechi de numere naturale impare consecutive prime, câte o pereche pe linie, numerele dintr-o pereche fiind separate printr-un spațiu.
== Restricții și precizări ==
* 1 ≤ n ≤ 100
* pentru fiecare pereche p q afișată, p < q
== Exemplu ==
; Intrare
: 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3 5
: 5 7
: 11 13
: 17 19
: 29 31

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

def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 100:
flag = True
return flag

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

def print_prime_consecutive(n):
count = 0
numar = 3
while count < n:
if prim(numar) and prim(numar+2):
print(numar, numar+2)
count += 1
numar += 2

if __name__ == '__main__':
numar = input("Introduceți numărul n: ")
if validare_date(numar):
n = int(numar)
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print("Primele", n, "perechi de numere naturale impare consecutive prime sunt:")
print_prime_consecutive(n)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Funcția '''validare_date''' primește un număr sub formă de șir de caractere și returnează o valoare booleană, '''True''' dacă numărul este un număr natural între '''0 și 100''', inclusiv, altfel returnează '''False'''.

Funcția '''prim''' primește un număr și returnează o valoare booleană, '''True''' dacă numărul este prim, altfel returnează '''False'''. Funcția utilizează o buclă for care verifică dacă numărul este divizibil cu orice număr între 2 și rădăcina pătrată a numărului dat, iar dacă este, returnează '''False'''.

Funcția '''print_prime_consecutive''' primește un număr întreg '''n''' și afișează primele n perechi de numere naturale impare consecutive prime. Funcția începe cu numărul 3 și, utilizând o buclă '''while''', verifică dacă numerele sunt prime și consecutive impare și le afișează în caz afirmativ. Dacă găsește o pereche, crește numărul de perechi găsite '''(count)''' cu 1 și trece la următorul număr.

Funcția '''main''' începe prin a cere utilizatorului să introducă un număr întreg '''n''' și apoi verifică dacă acesta este valid utilizând funcția '''validare_date'''. Dacă numărul este valid, afișează mesajul '''Datele de intrare corespund restricțiilor impuse.''' și apoi utilizează funcția '''print_consecutive_primes''' pentru a afișa primele '''n''' perechi de numere naturale impare consecutive prime. Dacă numărul nu este valid, afișează mesajul '''Datele de intrare nu corespund restricțiilor impuse.'''

0434 - Perechi Prime

2023-04-25T09:40:37Z

Diana Butuza: /* Explicație rezolvare */

== Cerinţa ==
Se dă un număr natural '''n'''. Afișați primele '''n''' perechi de numere naturale impare consecutive prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran '''n''' primele perechi de numere naturale impare consecutive prime, câte o pereche pe linie, numerele dintr-o pereche fiind separate printr-un spațiu.
== Restricții și precizări ==
* 1 ≤ n ≤ 100
* pentru fiecare pereche p q afișată, p < q
== Exemplu ==
; Intrare
: 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3 5
: 5 7
: 11 13
: 17 19
: 29 31

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

def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 100:
flag = True
return flag

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

def print_prime_consecutive(n):
count = 0
numar = 3
while count < n:
if prim(numar) and prim(numar+2):
print(numar, numar+2)
count += 1
numar += 2

if __name__ == '__main__':
numar = input("Introduceți numărul n: ")
if validare_date(numar):
n = int(numar)
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print("Primele", n, "perechi de numere naturale impare consecutive prime sunt:")
print_prime_consecutive(n)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Funcția '''validare_date''' primește un număr sub formă de șir de caractere și returnează o valoare booleană, '''True''' dacă numărul este un număr natural între '''0 și 100''', inclusiv, altfel returnează '''False'''.

Funcția '''is_prime''' primește un număr și returnează o valoare booleană, '''True''' dacă numărul este prim, altfel returnează '''False'''. Funcția utilizează o buclă for care verifică dacă numărul este divizibil cu orice număr între 2 și rădăcina pătrată a numărului dat, iar dacă este, returnează '''False'''.

Funcția '''print_consecutive_primes''' primește un număr întreg '''n''' și afișează primele n perechi de numere naturale impare consecutive prime. Funcția începe cu numărul 3 și, utilizând o buclă '''while''', verifică dacă numerele sunt prime și consecutive impare și le afișează în caz afirmativ. Dacă găsește o pereche, crește numărul de perechi găsite '''(count)''' cu 1 și trece la următorul număr.

Funcția '''main''' începe prin a cere utilizatorului să introducă un număr întreg '''n''' și apoi verifică dacă acesta este valid utilizând funcția '''validare_date'''. Dacă numărul este valid, afișează mesajul '''Datele de intrare corespund restricțiilor impuse.''' și apoi utilizează funcția '''print_consecutive_primes''' pentru a afișa primele '''n''' perechi de numere naturale impare consecutive prime. Dacă numărul nu este valid, afișează mesajul '''Datele de intrare nu corespund restricțiilor impuse.'''

0434 - Perechi Prime

2023-04-25T09:40:15Z

Diana Butuza: /* Rezolvare */

== Cerinţa ==
Se dă un număr natural '''n'''. Afișați primele '''n''' perechi de numere naturale impare consecutive prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran '''n''' primele perechi de numere naturale impare consecutive prime, câte o pereche pe linie, numerele dintr-o pereche fiind separate printr-un spațiu.
== Restricții și precizări ==
* 1 ≤ n ≤ 100
* pentru fiecare pereche p q afișată, p < q
== Exemplu ==
; Intrare
: 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3 5
: 5 7
: 11 13
: 17 19
: 29 31

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

def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 100:
flag = True
return flag

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

def print_prime_consecutive(n):
count = 0
numar = 3
while count < n:
if prim(numar) and prim(numar+2):
print(numar, numar+2)
count += 1
numar += 2

if __name__ == '__main__':
numar = input("Introduceți numărul n: ")
if validare_date(numar):
n = int(numar)
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print("Primele", n, "perechi de numere naturale impare consecutive prime sunt:")
print_prime_consecutive(n)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Acest cod este un program Python care își propune să găsească primele '''n''' perechi de numere naturale impare consecutive prime.

Funcția '''validare_date''' primește un număr sub formă de șir de caractere și returnează o valoare booleană, '''True''' dacă numărul este un număr natural între '''0 și 100''', inclusiv, altfel returnează '''False'''.

Funcția '''is_prime''' primește un număr și returnează o valoare booleană, '''True''' dacă numărul este prim, altfel returnează '''False'''. Funcția utilizează o buclă for care verifică dacă numărul este divizibil cu orice număr între 2 și rădăcina pătrată a numărului dat, iar dacă este, returnează '''False'''.

Funcția '''print_consecutive_primes''' primește un număr întreg '''n''' și afișează primele n perechi de numere naturale impare consecutive prime. Funcția începe cu numărul 3 și, utilizând o buclă '''while''', verifică dacă numerele sunt prime și consecutive impare și le afișează în caz afirmativ. Dacă găsește o pereche, crește numărul de perechi găsite '''(count)''' cu 1 și trece la următorul număr.

Funcția '''main''' începe prin a cere utilizatorului să introducă un număr întreg '''n''' și apoi verifică dacă acesta este valid utilizând funcția '''validare_date'''. Dacă numărul este valid, afișează mesajul '''Datele de intrare corespund restricțiilor impuse.''' și apoi utilizează funcția '''print_consecutive_primes''' pentru a afișa primele '''n''' perechi de numere naturale impare consecutive prime. Dacă numărul nu este valid, afișează mesajul '''Datele de intrare nu corespund restricțiilor impuse.'''

0434 - Perechi Prime

2023-04-25T09:36:46Z

Diana Butuza: /* Rezolvare */

== Cerinţa ==
Se dă un număr natural '''n'''. Afișați primele '''n''' perechi de numere naturale impare consecutive prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran '''n''' primele perechi de numere naturale impare consecutive prime, câte o pereche pe linie, numerele dintr-o pereche fiind separate printr-un spațiu.
== Restricții și precizări ==
* 1 ≤ n ≤ 100
* pentru fiecare pereche p q afișată, p < q
== Exemplu ==
; Intrare
: 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3 5
: 5 7
: 11 13
: 17 19
: 29 31

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

def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 100:
flag = True
return flag

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

def print_consecutive_primes(n):
count = 0
numar = 3
while count < n:
if is_prime(numar) and is_prime(numar+2):
print(numar, numar+2)
count += 1
numar += 2

if __name__ == '__main__':
numar = input("Introduceți numărul n: ")
if validare_date(numar):
n = int(numar)
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print("Primele", n, "perechi de numere naturale impare consecutive prime sunt:")
print_consecutive_primes(n)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Acest cod este un program Python care își propune să găsească primele '''n''' perechi de numere naturale impare consecutive prime.

Funcția '''validare_date''' primește un număr sub formă de șir de caractere și returnează o valoare booleană, '''True''' dacă numărul este un număr natural între '''0 și 100''', inclusiv, altfel returnează '''False'''.

Funcția '''is_prime''' primește un număr și returnează o valoare booleană, '''True''' dacă numărul este prim, altfel returnează '''False'''. Funcția utilizează o buclă for care verifică dacă numărul este divizibil cu orice număr între 2 și rădăcina pătrată a numărului dat, iar dacă este, returnează '''False'''.

Funcția '''print_consecutive_primes''' primește un număr întreg '''n''' și afișează primele n perechi de numere naturale impare consecutive prime. Funcția începe cu numărul 3 și, utilizând o buclă '''while''', verifică dacă numerele sunt prime și consecutive impare și le afișează în caz afirmativ. Dacă găsește o pereche, crește numărul de perechi găsite '''(count)''' cu 1 și trece la următorul număr.

Funcția '''main''' începe prin a cere utilizatorului să introducă un număr întreg '''n''' și apoi verifică dacă acesta este valid utilizând funcția '''validare_date'''. Dacă numărul este valid, afișează mesajul '''Datele de intrare corespund restricțiilor impuse.''' și apoi utilizează funcția '''print_consecutive_primes''' pentru a afișa primele '''n''' perechi de numere naturale impare consecutive prime. Dacă numărul nu este valid, afișează mesajul '''Datele de intrare nu corespund restricțiilor impuse.'''

0434 - Perechi Prime

2023-04-25T09:36:26Z

Diana Butuza: /* Exemplu */

== Cerinţa ==
Se dă un număr natural '''n'''. Afișați primele '''n''' perechi de numere naturale impare consecutive prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran '''n''' primele perechi de numere naturale impare consecutive prime, câte o pereche pe linie, numerele dintr-o pereche fiind separate printr-un spațiu.
== Restricții și precizări ==
* 1 ≤ n ≤ 100
* pentru fiecare pereche p q afișată, p < q
== Exemplu ==
; Intrare
: 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3 5
: 5 7
: 11 13
: 17 19
: 29 31

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

def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 100:
flag = True
return flag

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

def print_consecutive_primes(n):
count = 0
numar = 3
while count < n:
if is_prime(numar) and is_prime(numar+2):
print(numar, numar+2)
count += 1
numar += 2

def main():
numar = input("Introduceți numărul n: ")
if validare_date(numar):
n = int(numar)
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print("Primele", n, "perechi de numere naturale impare consecutive prime sunt:")
print_consecutive_primes(n)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

if __name__ == '__main__':
main()
</syntaxhighlight>
==Explicație rezolvare==
Acest cod este un program Python care își propune să găsească primele '''n''' perechi de numere naturale impare consecutive prime.

Funcția '''validare_date''' primește un număr sub formă de șir de caractere și returnează o valoare booleană, '''True''' dacă numărul este un număr natural între '''0 și 100''', inclusiv, altfel returnează '''False'''.

Funcția '''is_prime''' primește un număr și returnează o valoare booleană, '''True''' dacă numărul este prim, altfel returnează '''False'''. Funcția utilizează o buclă for care verifică dacă numărul este divizibil cu orice număr între 2 și rădăcina pătrată a numărului dat, iar dacă este, returnează '''False'''.

Funcția '''print_consecutive_primes''' primește un număr întreg '''n''' și afișează primele n perechi de numere naturale impare consecutive prime. Funcția începe cu numărul 3 și, utilizând o buclă '''while''', verifică dacă numerele sunt prime și consecutive impare și le afișează în caz afirmativ. Dacă găsește o pereche, crește numărul de perechi găsite '''(count)''' cu 1 și trece la următorul număr.

Funcția '''main''' începe prin a cere utilizatorului să introducă un număr întreg '''n''' și apoi verifică dacă acesta este valid utilizând funcția '''validare_date'''. Dacă numărul este valid, afișează mesajul '''Datele de intrare corespund restricțiilor impuse.''' și apoi utilizează funcția '''print_consecutive_primes''' pentru a afișa primele '''n''' perechi de numere naturale impare consecutive prime. Dacă numărul nu este valid, afișează mesajul '''Datele de intrare nu corespund restricțiilor impuse.'''

3081 - Truncatable Left

2023-04-10T09:46:59Z

Diana Butuza: /* Explicație rezolvare */

== Cerinţa ==
Un număr prim se numește '''trunchiabil-stânga''' dacă, prin eliminare repetată a primei cifre, toate numerele rezultate sunt prime.
Se dă un număr natural, să se verifice dacă numărul este prim '''trunchiabil-stânga'''.
== Date de intrare ==
Programul citește un număr natural nenul '''n'''.
== Date de ieşire ==
Programul va afișa '''DA''' dacă '''n''' este prim '''trunchiabil-stânga''', altfel va afișa '''NU'''.
== Restricții și precizări ==
* n este mai mic decât 1.000.000.
* Cel mai mare prim trunchiabil-stânga este 357686312646216567629137.

== Exemplu ==
; Intrare
:1223
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:DA
== Explicație ==
Exemplu 1: 1223 e prim. Eliminăm 1, 223 e prim. Eliminăm 2, 23 e prim. Eliminăm 2, 3 e prim.
Deci, numărul 1223 e prim trunchiabil-stânga.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 1_000_000_000:
flag = True
return flag

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 prim_trunchiabil_stanga(numar):
while numar > 0:
if not este_prim(numar):
return False
numar = numar % (10 ** (len(str(numar))-1))
return True

if __name__ == '__main__':
numar = input("Introduceti un numar natural: ")
if validare_date(numar):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
numar = int(numar)
if prim_trunchiabil_stanga(numar):
print("DA")
else:
print("NU")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Acest cod reprezintă un program care verifică dacă un număr natural dat este un număr prim trunchiabil stânga.

Funcția '''validare_date''' verifică dacă numărul dat este un șir de cifre și dacă valoarea sa se află în intervalul [0, 1000000000].

Funcția '''este_prim''' verifică dacă un număr dat este prim sau nu, folosind metoda de testare a divizibilității.

Funcția '''prim_trunchiabil_stanga''' verifică dacă un număr dat este un număr prim trunchiabil stânga sau nu. În cazul în care numărul nu este prim, se returnează '''False'''. Dacă numărul este prim, se elimină ultima cifră și se continuă cu verificarea până când se ajunge la o singură cifră, moment în care se returnează '''True'''.

În cazul în care numărul dat de la tastatură trece validarea, programul afișează '''Datele de intrare corespund restricțiilor impuse''' și convertește valoarea la un număr întreg, apoi utilizează funcția '''prim_trunchiabil_stanga''' pentru a verifica dacă numărul dat este un număr prim trunchiabil stânga. Dacă este, programul afișează '''DA''', altfel afișează '''NU'''. În caz contrar, dacă numărul nu este valid, programul afișează '''Datele de intrare nu corespund restricțiilor impuse'''.

3081 - Truncatable Left

2023-04-10T09:45:37Z

Diana Butuza: /* Rezolvare */

== Cerinţa ==
Un număr prim se numește '''trunchiabil-stânga''' dacă, prin eliminare repetată a primei cifre, toate numerele rezultate sunt prime.
Se dă un număr natural, să se verifice dacă numărul este prim '''trunchiabil-stânga'''.
== Date de intrare ==
Programul citește un număr natural nenul '''n'''.
== Date de ieşire ==
Programul va afișa '''DA''' dacă '''n''' este prim '''trunchiabil-stânga''', altfel va afișa '''NU'''.
== Restricții și precizări ==
* n este mai mic decât 1.000.000.
* Cel mai mare prim trunchiabil-stânga este 357686312646216567629137.

== Exemplu ==
; Intrare
:1223
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:DA
== Explicație ==
Exemplu 1: 1223 e prim. Eliminăm 1, 223 e prim. Eliminăm 2, 23 e prim. Eliminăm 2, 3 e prim.
Deci, numărul 1223 e prim trunchiabil-stânga.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 1_000_000_000:
flag = True
return flag

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 prim_trunchiabil_stanga(numar):
while numar > 0:
if not este_prim(numar):
return False
numar = numar % (10 ** (len(str(numar))-1))
return True

if __name__ == '__main__':
numar = input("Introduceti un numar natural: ")
if validare_date(numar):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
numar = int(numar)
if prim_trunchiabil_stanga(numar):
print("DA")
else:
print("NU")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Acest cod reprezintă un program care verifică dacă un număr natural dat este un număr prim trunchiabil stânga.

Funcția '''validare_date''' verifică dacă numărul dat este un șir de cifre și dacă valoarea sa se află în intervalul [0, 1000000000].

Funcția '''is_prime''' verifică dacă un număr dat este prim sau nu, folosind metoda de testare a divizibilității.

Funcția '''is_left_truncatable_prime''' verifică dacă un număr dat este un număr prim trunchiabil stânga sau nu. În cazul în care numărul nu este prim, se returnează '''False'''. Dacă numărul este prim, se elimină ultima cifră și se continuă cu verificarea până când se ajunge la o singură cifră, moment în care se returnează '''True'''.

În cazul în care numărul dat de la tastatură trece validarea, programul afișează '''Datele de intrare corespund restricțiilor impuse''' și converteste valoarea la un număr întreg, apoi utilizează funcția '''is_left_truncatable_prime''' pentru a verifica dacă numărul dat este un număr prim trunchiabil stânga. Dacă este, programul afișează '''DA''', altfel afișează '''NU'''. În caz contrar, dacă numărul nu este valid, programul afișează '''Datele de intrare nu corespund restricțiilor impuse'''.

3081 - Truncatable Left

2023-04-10T09:42:22Z

Diana Butuza: /* Restricții și precizări */

== Cerinţa ==
Un număr prim se numește '''trunchiabil-stânga''' dacă, prin eliminare repetată a primei cifre, toate numerele rezultate sunt prime.
Se dă un număr natural, să se verifice dacă numărul este prim '''trunchiabil-stânga'''.
== Date de intrare ==
Programul citește un număr natural nenul '''n'''.
== Date de ieşire ==
Programul va afișa '''DA''' dacă '''n''' este prim '''trunchiabil-stânga''', altfel va afișa '''NU'''.
== Restricții și precizări ==
* n este mai mic decât 1.000.000.
* Cel mai mare prim trunchiabil-stânga este 357686312646216567629137.

== Exemplu ==
; Intrare
:1223
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:DA
== Explicație ==
Exemplu 1: 1223 e prim. Eliminăm 1, 223 e prim. Eliminăm 2, 23 e prim. Eliminăm 2, 3 e prim.
Deci, numărul 1223 e prim trunchiabil-stânga.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 1_000_000_000:
flag = True
return flag

def is_prime(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 is_left_truncatable_prime(numar):
while numar > 0:
if not is_prime(numar):
return False
numar = numar % (10 ** (len(str(numar))-1))
return True

if __name__ == '__main__':
numar = input("Introduceti un numar natural: ")
if validare_date(numar):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
numar = int(numar)
if is_left_truncatable_prime(numar):
print("DA")
else:
print("NU")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Acest cod reprezintă un program care verifică dacă un număr natural dat este un număr prim trunchiabil stânga.

Funcția '''validare_date''' verifică dacă numărul dat este un șir de cifre și dacă valoarea sa se află în intervalul [0, 1000000000].

Funcția '''is_prime''' verifică dacă un număr dat este prim sau nu, folosind metoda de testare a divizibilității.

Funcția '''is_left_truncatable_prime''' verifică dacă un număr dat este un număr prim trunchiabil stânga sau nu. În cazul în care numărul nu este prim, se returnează '''False'''. Dacă numărul este prim, se elimină ultima cifră și se continuă cu verificarea până când se ajunge la o singură cifră, moment în care se returnează '''True'''.

În cazul în care numărul dat de la tastatură trece validarea, programul afișează '''Datele de intrare corespund restricțiilor impuse''' și converteste valoarea la un număr întreg, apoi utilizează funcția '''is_left_truncatable_prime''' pentru a verifica dacă numărul dat este un număr prim trunchiabil stânga. Dacă este, programul afișează '''DA''', altfel afișează '''NU'''. În caz contrar, dacă numărul nu este valid, programul afișează '''Datele de intrare nu corespund restricțiilor impuse'''.

0116 - Medie Prime

2023-04-10T09:41:46Z

Diana Butuza: /* Explicație rezolvare */

== Cerinţa ==
Să se scrie un program care citeşte de la tastatură un număr natural '''numar''' şi apoi un şir de '''n''' numere naturale şi determină media aritmetică a celor prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''numar''', iar apoi '''n''' numere naturale..
== Date de ieşire ==
Programul afișează pe ecran numărul '''M''', reprezentând media aritmetică a valorilor prime.

== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; n &les; 1.000
* cele n numere citite vor fi mai mici decât 10000
*rezultatul se va afişa cu cel puțin două zecimale exacte
*printre cele n numere va exista cel puțin un număr prim

== Exemplu ==
; Intrare
: 5
: 8 7 5 9 11
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 7.666666666666667

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date_numar(numar):
if numar.isdigit():
if 0 <= int(numar) <= 1000:
return True
return False

def validare_date_numere(n):
if n.isdigit():
if 0 <= int(n) <= 10000:
return True
return False

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 lista_numere_prime(numere):
numere_prime = [numar for numar in numere if este_prim(numar)]
if len(numere_prime) > 0:
return sum(numere_prime) / len(numere_prime)
else:
return None

if __name__ == "__main__":
n = input("Introduceti numarul de elemente: ")
if validare_date_numere(n):
print("Datele de intrare corespund restricțiilor impuse.")
numere = list(map(int, input("Introduceti numerele: ").split()))
if validare_date_numere(str(len(numere))):
print("Datele de intrare corespund restricțiilor impuse.")
rezultat = lista_numere_prime(numere)
if rezultat is not None:
print("Media aritmetica a numerelor prime din lista este:", rezultat)
else:
print("Nu exista numere prime in lista!")
else:
print("Numarul de numere introdus nu corespunde cu numarul specificat anterior.")
else:
print("Numarul de elemente introdus nu corespunde cu restrictiile impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Programul începe prin definirea a trei funcții:

1.'''validare_date_numar(numar)''': Această funcție verifică dacă un șir de caractere numar dat poate fi convertit la un număr întreg între 0 și 1000. Ea returnează '''True''' dacă condiția este satisfăcută și '''False''' în caz contrar.

2.'''validare_date_numere(n)''': Această funcție verifică dacă un șir de caractere n dat poate fi convertit la un număr întreg între 0 și 10000. Ea returnează '''True''' dacă condiția este satisfăcută și '''False''' în caz contrar.

3.'''este_prim(numar)''': Această funcție verifică dacă un număr întreg dat numar este un număr prim. Ea returnează '''True''' dacă numărul este prim și '''False''' în caz contrar.

După definirea acestor funcții, se verifică dacă introducerea primită de la utilizator este validă, apoi calculează media aritmetică a numerelor prime din lista utilizând funcția '''lista_numere_prime'''. Dacă nu există numere prime în listă, se returnează un mesaj care indică acest lucru.

0116 - Medie Prime

2023-04-10T09:40:27Z

Diana Butuza: /* Rezolvare */

== Cerinţa ==
Să se scrie un program care citeşte de la tastatură un număr natural '''numar''' şi apoi un şir de '''n''' numere naturale şi determină media aritmetică a celor prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''numar''', iar apoi '''n''' numere naturale..
== Date de ieşire ==
Programul afișează pe ecran numărul '''M''', reprezentând media aritmetică a valorilor prime.

== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; n &les; 1.000
* cele n numere citite vor fi mai mici decât 10000
*rezultatul se va afişa cu cel puțin două zecimale exacte
*printre cele n numere va exista cel puțin un număr prim

== Exemplu ==
; Intrare
: 5
: 8 7 5 9 11
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 7.666666666666667

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date_numar(numar):
if numar.isdigit():
if 0 <= int(numar) <= 1000:
return True
return False

def validare_date_numere(n):
if n.isdigit():
if 0 <= int(n) <= 10000:
return True
return False

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 lista_numere_prime(numere):
numere_prime = [numar for numar in numere if este_prim(numar)]
if len(numere_prime) > 0:
return sum(numere_prime) / len(numere_prime)
else:
return None

if __name__ == "__main__":
n = input("Introduceti numarul de elemente: ")
if validare_date_numere(n):
print("Datele de intrare corespund restricțiilor impuse.")
numere = list(map(int, input("Introduceti numerele: ").split()))
if validare_date_numere(str(len(numere))):
print("Datele de intrare corespund restricțiilor impuse.")
rezultat = lista_numere_prime(numere)
if rezultat is not None:
print("Media aritmetica a numerelor prime din lista este:", rezultat)
else:
print("Nu exista numere prime in lista!")
else:
print("Numarul de numere introdus nu corespunde cu numarul specificat anterior.")
else:
print("Numarul de elemente introdus nu corespunde cu restrictiile impuse.")

</syntaxhighlight>

==Explicație rezolvare==
Programul începe prin definirea a trei funcții:

1.'''validare_date_numar(numar)''': Această funcție verifică dacă un șir de caractere numar dat poate fi convertit la un număr întreg între 0 și 1000. Ea returnează '''True''' dacă condiția este satisfăcută și '''False''' în caz contrar.

2.'''validare_date_numere(n)''': Această funcție verifică dacă un șir de caractere n dat poate fi convertit la un număr întreg între 0 și 10000. Ea returnează '''True''' dacă condiția este satisfăcută și '''False''' în caz contrar.

3.'''is_prime(numar)''': Această funcție verifică dacă un număr întreg dat numar este un număr prim. Ea returnează '''True''' dacă numărul este prim și '''False''' în caz contrar.

După definirea acestor funcții, se verifică dacă introducerea primită de la utilizator este validă, apoi calculează media aritmetică a numerelor prime din lista utilizând funcția '''avg_prime'''. Dacă nu există numere prime în listă, se returnează un mesaj care indică acest lucru.

0116 - Medie Prime

2023-04-10T09:35:12Z

Diana Butuza: /* Exemplu */

== Cerinţa ==
Să se scrie un program care citeşte de la tastatură un număr natural '''numar''' şi apoi un şir de '''n''' numere naturale şi determină media aritmetică a celor prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''numar''', iar apoi '''n''' numere naturale..
== Date de ieşire ==
Programul afișează pe ecran numărul '''M''', reprezentând media aritmetică a valorilor prime.

== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; n &les; 1.000
* cele n numere citite vor fi mai mici decât 10000
*rezultatul se va afişa cu cel puțin două zecimale exacte
*printre cele n numere va exista cel puțin un număr prim

== Exemplu ==
; Intrare
: 5
: 8 7 5 9 11
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 7.666666666666667

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date_numar(numar):
if numar.isdigit():
if 0 <= int(numar) <= 1000:
return True
return False

def validare_date_numere(n):
if n.isdigit():
if 0 <= int(n) <= 10000:
return True
return False

def is_prime(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 avg_prime(numere):
prime_numere = [numar for numar in numere if is_prime(numar)]
if len(prime_numere) > 0:
return sum(prime_numere) / len(prime_numere)
else:
return None

if __name__ == "__main__":
n = input("Introduceti numarul de elemente: ")
if validare_date_numere(n):
print("Datele de intrare corespund restricțiilor impuse.")
numere = list(map(int, input("Introduceti numerele: ").split()))
if validare_date_numere(str(len(numere))):
print("Datele de intrare corespund restricțiilor impuse.")
result = avg_prime(numere)
if result is not None:
print("Media aritmetica a numerelor prime din lista este:", result)
else:
print("Nu exista numere prime in lista!")
else:
print("Numarul de numere introdus nu corespunde cu numarul specificat anterior.")
else:
print("Numarul de elemente introdus nu corespunde cu restrictiile impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Programul începe prin definirea a trei funcții:

1.'''validare_date_numar(numar)''': Această funcție verifică dacă un șir de caractere numar dat poate fi convertit la un număr întreg între 0 și 1000. Ea returnează '''True''' dacă condiția este satisfăcută și '''False''' în caz contrar.

2.'''validare_date_numere(n)''': Această funcție verifică dacă un șir de caractere n dat poate fi convertit la un număr întreg între 0 și 10000. Ea returnează '''True''' dacă condiția este satisfăcută și '''False''' în caz contrar.

3.'''is_prime(numar)''': Această funcție verifică dacă un număr întreg dat numar este un număr prim. Ea returnează '''True''' dacă numărul este prim și '''False''' în caz contrar.

După definirea acestor funcții, se verifică dacă introducerea primită de la utilizator este validă, apoi calculează media aritmetică a numerelor prime din lista utilizând funcția '''avg_prime'''. Dacă nu există numere prime în listă, se returnează un mesaj care indică acest lucru.

2312 - GuIT

2023-04-10T09:34:14Z

Diana Butuza: /* Explicație rezolvare */

== 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==
Acest cod implementează o funcție numită "print_num" care primește două argumente "n" și "k". Funcția calculează suma tuturor divizorilor primi ai lui "n" care sunt mai mici sau egali cu "k".

Mai întâi, codul validează datele de intrare prin intermediul a două funcții separate, "validare_date_numar" și "validare_date", care se asigură că "n" și "k" sunt în limitele specificate (1 <= n <= 1000000 și 1 <= k <= 1000).

Apoi, în interiorul funcției "print_num", se inițializează o variabilă "s" la 0 și se stabilește o variabilă "d" la 2. Se utilizează un buclă while care rulează până când "n" devine mai mic sau egal cu 1.

În interiorul buclei while, se verifică dacă "n" este divizibil cu "d". Dacă este, se împarte "n" la "d" și se adaugă "d" la suma "s". Se continuă acest proces până când "n" nu mai este divizibil cu "d". Apoi, variabila "d" este incrementată cu 1 și se verifică dacă "d" la pătrat este mai mare decât "n". Dacă este, se atribuie lui "d" valoarea "n", în caz contrar, bucla continuă.

La final, funcția returnează suma divizorilor primi ai lui "n" care sunt mai mici sau egali cu "k".

În blocul "if __name__ == '__main__'", se verifică dacă datele de intrare sunt valide folosind cele două funcții de validare și se afișează un mesaj corespunzător. Dacă datele de intrare sunt valide, se calculează suma divizorilor primi ai lui "n" și se afișează rezultatul. În caz contrar, se afișează un mesaj de eroare.

0116 - Medie Prime

2023-04-10T09:29:31Z

Diana Butuza: /* Explicație rezolvare */

== Cerinţa ==
Să se scrie un program care citeşte de la tastatură un număr natural '''numar''' şi apoi un şir de '''n''' numere naturale şi determină media aritmetică a celor prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''numar''', iar apoi '''n''' numere naturale..
== Date de ieşire ==
Programul afișează pe ecran numărul '''M''', reprezentând media aritmetică a valorilor prime.

== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; n &les; 1.000
* cele n numere citite vor fi mai mici decât 10000
*rezultatul se va afişa cu cel puțin două zecimale exacte
*printre cele n numere va exista cel puțin un număr prim

== Exemplu ==
; Intrare
: 5
: 8 7 5 9 11
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 7.666666666666667

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date_numar(numar):
if numar.isdigit():
if 0 <= int(numar) <= 1000:
return True
return False

def validare_date_numere(n):
if n.isdigit():
if 0 <= int(n) <= 10000:
return True
return False

def is_prime(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 avg_prime(numere):
prime_numere = [numar for numar in numere if is_prime(numar)]
if len(prime_numere) > 0:
return sum(prime_numere) / len(prime_numere)
else:
return None

if __name__ == "__main__":
n = input("Introduceti numarul de elemente: ")
if validare_date_numere(n):
print("Datele de intrare corespund restricțiilor impuse.")
numere = list(map(int, input("Introduceti numerele: ").split()))
if validare_date_numere(str(len(numere))):
print("Datele de intrare corespund restricțiilor impuse.")
result = avg_prime(numere)
if result is not None:
print("Media aritmetica a numerelor prime din lista este:", result)
else:
print("Nu exista numere prime in lista!")
else:
print("Numarul de numere introdus nu corespunde cu numarul specificat anterior.")
else:
print("Numarul de elemente introdus nu corespunde cu restrictiile impuse.")

</syntaxhighlight>
==Explicație rezolvare==
Programul începe prin definirea a trei funcții:

1.'''validare_date_numar(numar)''': Această funcție verifică dacă un șir de caractere numar dat poate fi convertit la un număr întreg între 0 și 1000. Ea returnează '''True''' dacă condiția este satisfăcută și '''False''' în caz contrar.

2.'''validare_date_numere(n)''': Această funcție verifică dacă un șir de caractere n dat poate fi convertit la un număr întreg între 0 și 10000. Ea returnează '''True''' dacă condiția este satisfăcută și '''False''' în caz contrar.

3.'''is_prime(numar)''': Această funcție verifică dacă un număr întreg dat numar este un număr prim. Ea returnează '''True''' dacă numărul este prim și '''False''' în caz contrar.

După definirea acestor funcții, se verifică dacă introducerea primită de la utilizator este validă, apoi calculează media aritmetică a numerelor prime din lista utilizând funcția '''avg_prime'''. Dacă nu există numere prime în listă, se returnează un mesaj care indică acest lucru.

0080 - Numarare Perechi Prime Intre Ele

2023-04-10T09:21:29Z

Diana Butuza: /* Exemplu2 */

== Cerinţa ==
Se dau numere naturale de la tastatură până la apariția lui zero. Să se determine câte perechi de numere citite consecutiv sunt prime între ele.
== Date de intrare ==
Programul citește de la tastatură numere naturale. Citirea se încheie la introducerea valorii '''0'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''numar_perechi_prime''', reprezentând numărul de perechi citite care respectă condiția cerută.
== Restricții și precizări ==
* n ∈ Ν
* numerele citite aparțin intervalului '''[0 ; 1.000.000.000)'''
* valoarea zero, care încheie citirile, nu se va prelucra
== Exemplu1 ==
; Intrare
: 15 63 43 129 55 15 4 0
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3

== Explicație ==
Perechile care respectă condiția cerută sunt: '''(63,43), (129,55), (15,4)'''.
== Exemplu2 ==
; Intrare
: 2 9 6 15 12 21 24 0
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 1

== Explicație ==
Perechile care respectă condiția cerută sunt: '''(2,9)'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = all(isinstance(x, int) and 0 <= x < 1_000_000_000 for x in n)
return flag

def prim(numar1, numar2):
rest = 0
while numar2:
rest = numar1 % numar2
numar1 = numar2
numar2 = rest
if numar1 == 1:
return 1
else:
return 0

if __name__ == '__main__':
n = list(map(int, input().split()))
numar_perechi_prime = 0
if validare_date(n):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
for i in range(1, len(n)):
if prim(n[i - 1], n[i]):
numar_perechi_prime += 1
print(numar_perechi_prime)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

0080 - Numarare Perechi Prime Intre Ele

2023-04-10T09:21:16Z

Diana Butuza: /* Exemplu1 */

== Cerinţa ==
Se dau numere naturale de la tastatură până la apariția lui zero. Să se determine câte perechi de numere citite consecutiv sunt prime între ele.
== Date de intrare ==
Programul citește de la tastatură numere naturale. Citirea se încheie la introducerea valorii '''0'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''numar_perechi_prime''', reprezentând numărul de perechi citite care respectă condiția cerută.
== Restricții și precizări ==
* n ∈ Ν
* numerele citite aparțin intervalului '''[0 ; 1.000.000.000)'''
* valoarea zero, care încheie citirile, nu se va prelucra
== Exemplu1 ==
; Intrare
: 15 63 43 129 55 15 4 0
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3

== Explicație ==
Perechile care respectă condiția cerută sunt: '''(63,43), (129,55), (15,4)'''.
== Exemplu2 ==
; Intrare
: 2 9 6 15 12 21 24 0
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1
== Explicație ==
Perechile care respectă condiția cerută sunt: '''(2,9)'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = all(isinstance(x, int) and 0 <= x < 1_000_000_000 for x in n)
return flag

def prim(numar1, numar2):
rest = 0
while numar2:
rest = numar1 % numar2
numar1 = numar2
numar2 = rest
if numar1 == 1:
return 1
else:
return 0

if __name__ == '__main__':
n = list(map(int, input().split()))
numar_perechi_prime = 0
if validare_date(n):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
for i in range(1, len(n)):
if prim(n[i - 1], n[i]):
numar_perechi_prime += 1
print(numar_perechi_prime)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3268 - CMMDC CMMMC

2023-04-10T09:20:38Z

Diana Butuza: /* Exemplu */

== Cerinţa ==
Se dau două numere naturale nenule. Determinați cel mai mare divizor comun și cel mai mic multiplu comun al lor.
== Date de intrare ==
Programul citește de la tastatură cele două numere.
== Date de ieşire ==
Programul va afișa pe ecran numere '''cmmdc''' '''cmmmc''', separate printr-un spațiu, reprezentând cel mai mare divizor comun, respectiv cel mai mic multiplu comun al celor două numere.
== Restricții și precizări ==
* numar1, numar2 ∈ Ν
* 0 &les; numar1, numar2 &les; 1.000.000.000
== Exemplu ==
; Intrare
: 24 42
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 6 168

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar1, numar2):
flag = False
if numar1.isdigit() and numar2.isdigit():
if 0 < int(numar1) < 1_000_000_000 and 0 < int(numar2) < 1_000_000_000:
flag = True
return flag

def cmmdc(numar1, numar2):
while numar2:
numar1, numar2 = numar2, numar1 % numar2
cmmdc = numar1
return cmmdc

def cmmmc(numar1, numar2):
cmmmc = (numar1 * numar2) // cmmdc(numar1, numar2)
return cmmmc

if __name__ == '__main__':
numar1, numar2 = input().split()
if validare_date(numar1, numar2):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
if int(numar1) == int(numar2) == 0:
print("-1")
else:
print(cmmdc(int(numar1), int(numar2)), cmmmc(int(numar1), int(numar2)))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3270 - Suma Divizori Pari

2023-04-10T09:19:36Z

Diana Butuza: /* Exemplu */

== Cerinţa ==
Se dă un număr natural numit ”'''numar'''”. Să se determine suma divizorilor pari ai acestuia.
== Date de intrare ==
Programul citește de la tastatură numărul natural ”'''numar'''”.
== Date de ieşire ==
Programul afișează pe ecran numărul ”'''suma_divizorilor_pari'''”, reprezentând suma divizorilor pari ai lui ”'''numar'''”.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar &les; 1.000.000.000
== Exemplu ==
; Intrare
: 30
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 48
 
; Intrare
: 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 0
 
; Intrare
: xyz
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.

== Explicație ==
Divizorii pari lui '''30''' sunt '''2''', '''6''', '''10''' și '''30''' . Suma lor este '''48'''. 
Suma divizorilor pari lui '''5''' este '''0''' fiindcă nu are divizori pari.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 1_000_000_000:
flag = True
return flag

def suma(numar):
if numar % 2 == 0:
suma_divizorilor_pari = numar
else:
suma_divizorilor_pari = 0
for i in range(1, numar // 2 + 1):
if numar % i == 0:
if i % 2 == 0:
suma_divizorilor_pari += i
print(suma_divizorilor_pari)

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

</syntaxhighlight>

0387 - Suma Divizori Impari

2023-04-10T09:19:05Z

Diana Butuza: /* Exemplu */

== Cerinţa ==
Se dă un număr natural numit ”'''numar'''”. Să se determine suma divizorilor impari ai acestuia.
== Date de intrare ==
Programul citește de la tastatură numărul natural ”'''numar'''”.
== Date de ieşire ==
Programul afișează pe ecran numărul ”'''suma_divizorilor_impari'''”, reprezentând suma divizorilor impari ai lui ”'''numar'''”.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar &les; 1.000.000.000
== Exemplu ==
; Intrare
: 30
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 24
 
; Intrare
: 13
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 14
 
; Intrare
: -5
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.

== Explicație ==
Divizorii impari ai lui '''30''' sunt '''1''', '''3''', '''5''', '''15'''. Suma lor este '''24'''. 
Divizorii impari ai lui '''13''' este '''1''' și '''13'''. Suma lor este '''14'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 1_000_000_000:
flag = True
return flag

def suma(numar):
if numar % 2 == 1:
suma_divizorilor_impari = numar
else:
suma_divizorilor_impari = 0
for i in range(1, numar // 2 + 1):
if numar % i == 0:
if i % 2 == 1:
suma_divizorilor_impari += i
print(suma_divizorilor_impari)

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

</syntaxhighlight>

0376 - Suma Divizori

2023-04-10T09:18:29Z

Diana Butuza: /* Exemplu */

== Cerinţa ==
Se dă un număr natural numit ”'''numar'''”. Să se determine suma divizorilor ai acestuia.
== Date de intrare ==
Programul citește de la tastatură un număr natural ”'''numar'''”.
== Date de ieşire ==
Programul afișează pe ecran numărul ”'''suma'''”, reprezentând suma divizorilor lui ”'''numar'''”.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar &les; 1.000.000.000
== Exemplu ==
; Intrare
: 6
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 12
 
; Intrare
: -5
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.

== Explicație ==
Divizorii lui '''6''' sunt '''1''', '''2''', '''3''', '''6'''. Suma lor este '''12'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 1_000_000_000:
flag = True
return flag

def suma(numar):
suma_divizorilor = 0
for i in range(1, numar // 2 + 1):
if numar % i == 0:
suma_divizorilor += i
suma_divizorilor += numar
print(suma_divizorilor)

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

</syntaxhighlight>

3663 - PPDP

2023-04-10T09:17:14Z

Diana Butuza: /* Rezolvare */

== Cerinţa ==
Se dă un număr natural numit ”'''numar'''”. Calculați pătratul celui mai mic divizor propriu al său.
== Date de intrare ==
Programul citește de la tastatură un număr natural numit ”'''numar'''”.
== Date de ieşire ==
Programul va afișa pe ecran numărul calculat.
== Restricții și precizări ==
* numar ∈ Ν
* 4 &les; numar &les; 1.000.000.000
* se garantează că ”'''numar'''” nu este prim
== Exemplu ==
; Intrare
: 12
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 4
== Explicație ==
Cel mai mic divizor al lui '''12''' este '''2''' iar pătratul acestei valori este '''4'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar):
flag = False
if numar.isdigit() and 4 <= int(numar) <= 1_000_000_000:
flag = True
if prim(int(numar)):
flag = False
return flag

def prim(numar):
if numar <= 1:
return False
for i in range(2, numar // 2 + 1):
if numar % i == 0:
return False
return True

def patrat_cel_mai_mic_divizor(numar):
divizor = 2
while numar % divizor != 0:
divizor += 1
return divizor**2

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

</syntaxhighlight>

3272 - Sum Div Ogl

2023-04-10T09:14:57Z

Diana Butuza: /* Rezolvare */

== Cerinţa ==
Se dau '''n''' numere naturale. Determinați suma divizorilor oglinditelor celor '''n''' numere.
== 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 va afișa pe ecran numărul '''suma''', reprezentând suma cerută.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; n &les; 1.000
* 0 &les; numar &les; 1.000.000.000
== Exemplu ==
; Intrare
: 3
: 12 23 30
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 99
== Explicație ==
Oglinditul lui '''12''' este '''21'''; suma divizorilor săi este '''32'''. Oglinditul lui '''23''' este '''32'''; suma divizorilor săi este '''63'''. Oglinditul lui '''30''' este '''3'''; suma divizorilor săi este '''4'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date_numar(numar):
flag = False
if numar.isdigit():
if 0 <= int(numar) <= 1_000_000_000:
flag = True
return flag

def validare_date_numere(n):
flag = False
if 0 <= int(n) <= 1000:
flag = True
return flag

def oglindit(numar):
return int(str(numar)[::-1])

def suma_divizori(numar):
suma = 0
for i in range(1, numar//2 + 1):
if numar % i == 0:
suma += i
suma += numar # adăugăm și numărul în sumă, deoarece este divizor al lui numar
return suma

def suma_divizori_oglindite(lista_numere):
suma_totala = 0
for numar in lista_numere:
oglinditul = oglindit(numar)
suma_divizori_oglindit = suma_divizori(oglinditul)
suma_totala += suma_divizori_oglindit
return suma_totala

if __name__ == '__main__':
n = int(input())
if validare_date_numere(n):
print("\nDatele introduse corespund restricțiilor impuse.\n")
lista_numere = []
for i in range(n):
while True:
numar = input(f"Introduceți numărul {i + 1}: ")
if validare_date_numar(numar):
lista_numere.append(int(numar))
break
else:
print("Numărul introdus nu corespunde restricțiilor impuse.")
print(f"\nSuma divizorilor oglinditelor este: {suma_divizori_oglindite(lista_numere)}")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

2745 - Intrebari

2023-04-10T09:14:13Z

Diana Butuza: /* Rezolvare */

== Cerinţa ==
Se dau '''nr_elemente''' numere naturale. Dându-se totodată un număr '''p''', apare o intrebare care poate fi de unul dintre următoarele două feluri posibile: care este suma cifrelor valorii minime dintre primele '''p''' ale șirului (tipul '''1''') respectiv, care este numărul de divizori ai valorii maxime dintre primele '''p''' elemente ale șirului (tipul '''2''').
== Date de intrare ==
Programul citește de la tastatură mai întâi numerele '''nr_elemente''', '''tip_cerinta''' și '''p''' iar apoi '''sir''' numere naturale (elementele șirului).
== Date de ieşire ==
Dacă valoarea '''tip_cerinta''', este '''1''', programul va afișa pe ecran răspunsul la cerința de tipul '''1'''.
Dacă valoarea '''tip_cerinta''', este '''2''', programul va afișa pe ecran răspunsul la cerința de tipul '''2'''.

'''Indiferent de tipul cerinței, pe linia următoare se va afișa suma elementelor șirului.'''
== Restricții și precizări ==
* nr_elemente ∈ Ν
* 0 &les; nr_elemente &les; 10
* cele '''sir''' numere citite vor fi naturale nenule și mai mici decât '''1.000.000.000'''
* numerele șirului sunt numerotate începând cu '''1'''
* valoarea lui '''p''' este cuprinsă între '''1''' și '''n''', inclusiv
* 1 &les; tip_cerinta &les; 2
== Exemplu1 ==
; Intrare
: 6 1 3
: 14 13 16 22 15 1
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 4
: 81
== Explicație ==
Este vorba despre o interogare de tipul '''1''' și minimul dintre primele trei elemente ale șirului este 13 iar suma cifrelor sale este 4.
== Exemplu2 ==
; Intrare
: 6 2 3
: 14 13 16 22 15 1
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 5
: 81
== Explicație ==
Este vorba despre o interogare de tipul '''2''' și maximul dintre primele trei elemente ale șirului este 16 iar numărul său de divizori este 5.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date(nr_elemente, tip_cerinta, p, sir):
flag = False
if 0 <= int(nr_elemente) <= 10 and 1 <= int(tip_cerinta) <= 2 and 1 <= int(p) <= nr_elemente:
flag = all(isinstance(x, int) and 1 <= x <= 1_000_000_000 for x in sir)
return flag

def nr_divizori(n):
cnt = 0
for i in range(1, int(math.sqrt(n))+1):
if n % i == 0:
cnt += 2
if i * i == n:
cnt -= 1
return cnt

def suma_cifre(min_val):
suma = 0
for i in str(min_val):
suma = suma + min_val % 10
min_val = min_val // 10
return suma

if __name__ == '__main__':
nr_elemente, tip_cerinta, p = map(int, input().split())
sir = list(map(int, input().split()))
suma = sum(sir)
min_val = min(sir[:p])
max_val = max(sir[:p])
if validare_date(nr_elemente, tip_cerinta, p, sir):
print("\nDatele introduse corespund restricțiilor impuse.\n")
if tip_cerinta == 1:
print(suma_cifre(min_val))
print(suma)
else:
print(nr_divizori(max_val))
print(suma)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

1517 - Clatite

2023-04-10T08:43:04Z

Diana Butuza: /* Exemplu */

== Enunț ==
Arpsod adoră două lucruri: matematica și clătitele bunicii sale. Într-o zi, aceasta s-a apucat să prepare clătite. Arpsod mănâncă toate clătitele începând de la a N-a clătită preparată, până la a M-a clătită preparată (inclusiv N și M). Pentru că el vrea să mănânce clătite cu diferite umpluturi și-a făcut următoarea regulă:

“Dacă numărul de ordine al clătitei este prim atunci aceasta va fi cu ciocolată. Dacă numărul de ordine este pătrat perfect sau cub perfect aceasta va fi cu gem. Dacă suma divizorilor numărului este egală cu însuși numărul de ordine atunci aceasta va fi cu înghețată. (se iau în considerare toți divizorii în afară de numărul în sine, inclusiv 1).

În cazul în care o clătită îndeplinește simultan mai multe condiții, se respectă prioritatea sortimentelor: ciocolată > gem > înghețată.
Dacă niciuna dintre condițiile de mai sus nu este îndeplinită, pentru cele cu numărul de ordine par, clătita va fi cu zahar, iar pentru numărul de ordine impar, clătita va fi simplă.”
== Cerinţa ==
Cunoscându-se '''N''' și '''M''', numere naturale, să se determine câte clătite a mâncat Arpsod în total și numărul de clătite din fiecare tip.
== Date de intrare ==
Fișierul '''clatite.in''' conține pe prima linie numerele '''N''' și '''M''' separate printr-un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, în fișier se va afișa: '''"Datele sunt introduse corect."''', apoi prima linie a fişierului de ieşire '''clatite.out''' va conține numărul total de clătite mâncate de Arpsod iar a doua linie 5 numere naturale separate printr-un spațiu reprezentând numărul de clătite mâncate, din fiecare tip (ordinea: ciocolata, gem, înghețată, zahăr, simplă).În cazul în care datele nu respectă restricțiile, se va afișa în fișier : '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 0 &les; N, M &les; 300.000
== Exemplu ==
; clatite.in
: 3 11
; clatite.out
: Datele sunt introduse corect.
: 9
: 4 3 1 1 0

== Explicație ==
Arpsod a mâncat '''9''' clătite dintre care:
'''4''' cu ciocolată ( '''3, 5, 7, 11''' )
'''3''' cu gem ( '''4, 8, 9''' )
'''1''' cu înghețată ( '''6''' )
'''1''' cu zahăr ( '''10''' ).
'''0''' simple

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

def pătrat_perfect(n):
d = int(math.sqrt(n))
ok = 0
if d * d == n:
ok += 1
if ok == 0:
for i in range(1, int(n ** (1 / 3)) + 1):
if i * i * i == n:
ok += 1
if ok:
return True
else:
return False

def suma_divizori(n):
s = 1
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
s += i + n // i
if i * i == n:
s -= i
if s == n:
return True
else:
return False

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

def validare_date(n, m):
if not (1 <= n <= 300000) or not (1 <= m <= 300000):
return False
return True

if __name__ == "__main__":
with open("clatite.in", "r") as f:
n, m = map(int, f.readline().split())
p = 0
line = f.readline().strip()
if line:
p = int(line)

if not validare_date(n, m):
f.write("Datele nu corespund restricțiilor impuse.")
exit()

c = 0
g = 0
ing = 0
z = 0
s = 0

for i in range(n, m + 1):
if prim(i):
c += 1
elif pătrat_perfect(i):
g += 1
elif suma_divizori(i):
ing += 1
elif i % 2 == 0:
z += 1
else:
s += 1

total = c + g + ing + z + s

with open("clatite.out", "w") as f:
f.write("Datele sunt introduse corect.\n")
f.write(str(total) + "\n")
f.write(f"{c} {g} {ing} {z} {s}")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția pătrat_perfect(n) verifică dacă numărul n este un pătrat perfect sau un cub perfect. Verificarea se face prin calcularea rădăcinii pătrate sau cubice a lui n și compararea cu valoarea întreagă a rădăcinii. Dacă rădăcina este egală cu valoarea întreagă, atunci n este pătrat perfect sau cub perfect și funcția returnează True. Dacă nu, se parcurge un alt interval și se verifică dacă n este cub perfect. Dacă n este cub perfect, funcția returnează True, altfel returnează False. Funcția suma_divizori(n) calculează suma divizorilor lui n și verifică dacă aceasta este egală cu n. Suma divizorilor se calculează prin parcurgerea tuturor divizorilor lui n, cu excepția lui n și a lui 1, și adăugarea lor la o variabilă s. Dacă s este egală cu n, funcția returnează True, altfel returnează False. Funcția prim(n) verifică dacă numărul n este prim și calculează numărul său de divizori. Pentru a verifica dacă n este prim, se împarte succesiv la divizorii mai mici sau egali cu rădăcina pătrată a lui n. Dacă n este divizibil cu un divizor, acesta este înmulțit cu un contor cnt și n este împărțit la acel divizor. Dacă n nu mai poate fi împărțit la vreun divizor mai mic sau egal cu rădăcina pătrată a lui n, atunci n este fie prim, fie este egal cu un produs de două numere prime care sunt mai mari decât rădăcina pătrată a lui n. În cazul în care n este prim, numărul de divizori este 2 și funcția returnează True. Dacă n nu este prim, numărul de divizori se calculează din contorul cnt și funcția returnează False. Funcția validare_date(n, m) verifică dacă valorile n și m sunt cuprinse între 1 și 300000. Dacă nu sunt, funcția returnează False, altfel returnează True
Funcția main citește datele de intrare dintr-un fișier numit "clatite.in", validează dacă acestea respectă restricțiile impuse și apoi efectuează diferite calcule pe intervalele din intervalul [n, m], unde n și m sunt numerele citite inițial din fișierul de intrare.Se inițializează câteva variabile (c, g, ing, z, s) pentru a număra diferite tipuri de numere între n și m. Apoi, pentru fiecare număr între n și m, main verifică dacă numărul este prim, pătrat perfect, are suma divizorilor egală cu numărul, este par sau impar și mărește corespunzător variabila adecvată în funcție de ce tip de număr este.La sfârșit se afișează "Datele sunt introduse corect.", numărul total de numere de diferite tipuri găsite și numărul de numere din fiecare tip. Apoi, aceste informații sunt scrise într-un fișier numit "clatite.out".

1517 - Clatite

2023-04-10T08:39:22Z

Diana Butuza: /* Date de iesire */

== Enunț ==
Arpsod adoră două lucruri: matematica și clătitele bunicii sale. Într-o zi, aceasta s-a apucat să prepare clătite. Arpsod mănâncă toate clătitele începând de la a N-a clătită preparată, până la a M-a clătită preparată (inclusiv N și M). Pentru că el vrea să mănânce clătite cu diferite umpluturi și-a făcut următoarea regulă:

“Dacă numărul de ordine al clătitei este prim atunci aceasta va fi cu ciocolată. Dacă numărul de ordine este pătrat perfect sau cub perfect aceasta va fi cu gem. Dacă suma divizorilor numărului este egală cu însuși numărul de ordine atunci aceasta va fi cu înghețată. (se iau în considerare toți divizorii în afară de numărul în sine, inclusiv 1).

În cazul în care o clătită îndeplinește simultan mai multe condiții, se respectă prioritatea sortimentelor: ciocolată > gem > înghețată.
Dacă niciuna dintre condițiile de mai sus nu este îndeplinită, pentru cele cu numărul de ordine par, clătita va fi cu zahar, iar pentru numărul de ordine impar, clătita va fi simplă.”
== Cerinţa ==
Cunoscându-se '''N''' și '''M''', numere naturale, să se determine câte clătite a mâncat Arpsod în total și numărul de clătite din fiecare tip.
== Date de intrare ==
Fișierul '''clatite.in''' conține pe prima linie numerele '''N''' și '''M''' separate printr-un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, în fișier se va afișa: '''"Datele sunt introduse corect."''', apoi prima linie a fişierului de ieşire '''clatite.out''' va conține numărul total de clătite mâncate de Arpsod iar a doua linie 5 numere naturale separate printr-un spațiu reprezentând numărul de clătite mâncate, din fiecare tip (ordinea: ciocolata, gem, înghețată, zahăr, simplă).În cazul în care datele nu respectă restricțiile, se va afișa în fișier : '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 0 &les; N, M &les; 300.000
== Exemplu ==
; clatite.in
: 3 11
; clatite.out
: Datele introduse corespund restricțiilor impuse.
: 9
: 4 3 1 1 0
== Explicație ==
Arpsod a mâncat '''9''' clătite dintre care:
'''4''' cu ciocolată ( '''3, 5, 7, 11''' )
'''3''' cu gem ( '''4, 8, 9''' )
'''1''' cu înghețată ( '''6''' )
'''1''' cu zahăr ( '''10''' ).
'''0''' simple

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

def pătrat_perfect(n):
d = int(math.sqrt(n))
ok = 0
if d * d == n:
ok += 1
if ok == 0:
for i in range(1, int(n ** (1 / 3)) + 1):
if i * i * i == n:
ok += 1
if ok:
return True
else:
return False

def suma_divizori(n):
s = 1
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
s += i + n // i
if i * i == n:
s -= i
if s == n:
return True
else:
return False

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

def validare_date(n, m):
if not (1 <= n <= 300000) or not (1 <= m <= 300000):
return False
return True

if __name__ == "__main__":
with open("clatite.in", "r") as f:
n, m = map(int, f.readline().split())
p = 0
line = f.readline().strip()
if line:
p = int(line)

if not validare_date(n, m):
f.write("Datele nu corespund restricțiilor impuse.")
exit()

c = 0
g = 0
ing = 0
z = 0
s = 0

for i in range(n, m + 1):
if prim(i):
c += 1
elif pătrat_perfect(i):
g += 1
elif suma_divizori(i):
ing += 1
elif i % 2 == 0:
z += 1
else:
s += 1

total = c + g + ing + z + s

with open("clatite.out", "w") as f:
f.write("Datele sunt introduse corect.\n")
f.write(str(total) + "\n")
f.write(f"{c} {g} {ing} {z} {s}")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția pătrat_perfect(n) verifică dacă numărul n este un pătrat perfect sau un cub perfect. Verificarea se face prin calcularea rădăcinii pătrate sau cubice a lui n și compararea cu valoarea întreagă a rădăcinii. Dacă rădăcina este egală cu valoarea întreagă, atunci n este pătrat perfect sau cub perfect și funcția returnează True. Dacă nu, se parcurge un alt interval și se verifică dacă n este cub perfect. Dacă n este cub perfect, funcția returnează True, altfel returnează False. Funcția suma_divizori(n) calculează suma divizorilor lui n și verifică dacă aceasta este egală cu n. Suma divizorilor se calculează prin parcurgerea tuturor divizorilor lui n, cu excepția lui n și a lui 1, și adăugarea lor la o variabilă s. Dacă s este egală cu n, funcția returnează True, altfel returnează False. Funcția prim(n) verifică dacă numărul n este prim și calculează numărul său de divizori. Pentru a verifica dacă n este prim, se împarte succesiv la divizorii mai mici sau egali cu rădăcina pătrată a lui n. Dacă n este divizibil cu un divizor, acesta este înmulțit cu un contor cnt și n este împărțit la acel divizor. Dacă n nu mai poate fi împărțit la vreun divizor mai mic sau egal cu rădăcina pătrată a lui n, atunci n este fie prim, fie este egal cu un produs de două numere prime care sunt mai mari decât rădăcina pătrată a lui n. În cazul în care n este prim, numărul de divizori este 2 și funcția returnează True. Dacă n nu este prim, numărul de divizori se calculează din contorul cnt și funcția returnează False. Funcția validare_date(n, m) verifică dacă valorile n și m sunt cuprinse între 1 și 300000. Dacă nu sunt, funcția returnează False, altfel returnează True
Funcția main citește datele de intrare dintr-un fișier numit "clatite.in", validează dacă acestea respectă restricțiile impuse și apoi efectuează diferite calcule pe intervalele din intervalul [n, m], unde n și m sunt numerele citite inițial din fișierul de intrare.Se inițializează câteva variabile (c, g, ing, z, s) pentru a număra diferite tipuri de numere între n și m. Apoi, pentru fiecare număr între n și m, main verifică dacă numărul este prim, pătrat perfect, are suma divizorilor egală cu numărul, este par sau impar și mărește corespunzător variabila adecvată în funcție de ce tip de număr este.La sfârșit se afișează "Datele sunt introduse corect.", numărul total de numere de diferite tipuri găsite și numărul de numere din fiecare tip. Apoi, aceste informații sunt scrise într-un fișier numit "clatite.out".

1481 - Gradina Piticului

2023-04-10T08:34:23Z

Diana Butuza: /* Date de ieşire */

== Enunț ==
Un pitic pasionat de numere trebuie să-și pună flori în grădină. El are de plantat m rânduri cu flori, aceeași floare pe tot rândul. Rândurile sunt numerotate de la 1 la m. Având la dispoziție suficiente specii de flori, piticul nostru s-a gândit să le planteze folosind următorul algoritm matematic: pe rândurile care sunt numere prime, va planta exact floarea numerotată cu numărul prim respectiv, iar pe celelalte rânduri va planta floarea numerotată cu suma divizorilor primi ai numărului neprim.
== Cerinţa ==
Să se realizeze un program care să afişeze ordinea de așezare a florilor pe cele '''m''' rânduri.
== Date de intrare ==
Fișierul de intrare '''pitic.in''' conține pe prima linie numărul '''m'''.
== Date de ieşire ==
Dacă datele sunt introduse corect, în fișier se va afișa: "Datele sunt introduse corect.", apoi fişierul de ieşire '''pitic.out''' va conține pe prima linie un șir de '''m''' numere, separate prin câte un spațiu, fiecare număr reprezentând specia de floare ce urmează să fie plantată pe rândul respectiv. În cazul în care datele nu respectă restricțiile, se va afișa în fișier : "Datele nu corespund restricțiilor impuse.".

== Restricții și precizări ==
* 1 &les; m &les; 1000
== Exemplu ==
; pitic.in
: 6
; pitic.out
: Datele de intrare corespund restricțiilor impuse.
: 0 2 3 2 5 5

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

def validare_date(m):
return 1 <= m <= 1000

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

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

if __name__ == "__main__":
with open("pitic.in") as fin, open("pitic.out", "w") as fout:
m = int(fin.readline().strip())
if validare_date(m):
fout.write("Datele de intrare corespund restrictiilor impuse.\n")
for i in range(1, m + 1):
if prim(i):
fout.write(str(i) + " ")
else:
fout.write(str(sumprim(i)) + " ")
else:
fout.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare ==
Funcția validare_date(m) verifică dacă numărul m este între 1 și 1000, returnând True dacă este și False altfel. Funcția prim(n) verifică dacă numărul n este prim. Mai exact, aceasta determină factorii primi ai lui n și verifică dacă n are exact doi factori primi distincți. Dacă da, atunci n este prim și funcția returnează 1, altfel funcția returnează 0. Funcția sumprim(n) calculează suma divizorilor primi ai lui n, cu excepția lui n . Pentru aceasta, se determină factorii primi ai lui n și se adună doar aceia care sunt prima putere a unui număr prim. În funcția principală, se citește numărul m din fișierul de intrare și se verifică dacă este valid. Dacă da, se scrie mesajul "Datele de intrare corespund restrictiilor impuse." în fișierul de ieșire și se parcurg toate rândurile de la 1 la m. Pentru fiecare rând, se determină dacă este prim și, dacă da, se scrie numărul prim respectiv în fișierul de ieșire. În caz contrar, se calculează suma divizorilor primi ai rândului respectiv și se scrie acea sumă în fișierul de ieșire. Dacă m nu este valid, se scrie în fișierul de ieșire mesajul "Datele de intrare nu corespund restrictiilor impuse."

1481 - Gradina Piticului

2023-04-10T08:31:08Z

Diana Butuza: /* Exemplu */

== Enunț ==
Un pitic pasionat de numere trebuie să-și pună flori în grădină. El are de plantat m rânduri cu flori, aceeași floare pe tot rândul. Rândurile sunt numerotate de la 1 la m. Având la dispoziție suficiente specii de flori, piticul nostru s-a gândit să le planteze folosind următorul algoritm matematic: pe rândurile care sunt numere prime, va planta exact floarea numerotată cu numărul prim respectiv, iar pe celelalte rânduri va planta floarea numerotată cu suma divizorilor primi ai numărului neprim.
== Cerinţa ==
Să se realizeze un program care să afişeze ordinea de așezare a florilor pe cele '''m''' rânduri.
== Date de intrare ==
Fișierul de intrare '''pitic.in''' conține pe prima linie numărul '''m'''.
== Date de ieşire ==
Dacă datele sunt introduse corect, în fișier se va afișa: "Datele sunt introduse corect.", apoi fişierul de ieşire '''pitic.out''' va conține pe prima un șir de '''m''' numere, separate prin câte un spațiu, fiecare număr reprezentând specia de floare ce urmează să fie plantată pe rândul respectiv. În cazul în care datele nu respectă restricțiile, se va afișa în fișier : "Datele nu corespund restricțiilor impuse.".

== Restricții și precizări ==
* 1 &les; m &les; 1000
== Exemplu ==
; pitic.in
: 6
; pitic.out
: Datele de intrare corespund restricțiilor impuse.
: 0 2 3 2 5 5

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

def validare_date(m):
return 1 <= m <= 1000

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

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

if __name__ == "__main__":
with open("pitic.in") as fin, open("pitic.out", "w") as fout:
m = int(fin.readline().strip())
if validare_date(m):
fout.write("Datele de intrare corespund restrictiilor impuse.\n")
for i in range(1, m + 1):
if prim(i):
fout.write(str(i) + " ")
else:
fout.write(str(sumprim(i)) + " ")
else:
fout.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare ==
Funcția validare_date(m) verifică dacă numărul m este între 1 și 1000, returnând True dacă este și False altfel. Funcția prim(n) verifică dacă numărul n este prim. Mai exact, aceasta determină factorii primi ai lui n și verifică dacă n are exact doi factori primi distincți. Dacă da, atunci n este prim și funcția returnează 1, altfel funcția returnează 0. Funcția sumprim(n) calculează suma divizorilor primi ai lui n, cu excepția lui n . Pentru aceasta, se determină factorii primi ai lui n și se adună doar aceia care sunt prima putere a unui număr prim. În funcția principală, se citește numărul m din fișierul de intrare și se verifică dacă este valid. Dacă da, se scrie mesajul "Datele de intrare corespund restrictiilor impuse." în fișierul de ieșire și se parcurg toate rândurile de la 1 la m. Pentru fiecare rând, se determină dacă este prim și, dacă da, se scrie numărul prim respectiv în fișierul de ieșire. În caz contrar, se calculează suma divizorilor primi ai rândului respectiv și se scrie acea sumă în fișierul de ieșire. Dacă m nu este valid, se scrie în fișierul de ieșire mesajul "Datele de intrare nu corespund restrictiilor impuse."