Bitnami MediaWiki - User contributions [en]

27024

2023-12-05T15:52:47Z

Robert Manc:

'''27024 (Gheorghe Szöllösy)'''

''Fie '' <math> I_n = \int_{0}^{\pi} \frac{\cos nx}{13-12\cos x}\,dx, n\ge0.</math>'' Să se calculeze '' <math>\lim_{n \to \infty}(I_0+I_1+I_2+\ldots+I_n).</math>

'''Soluție. ''' ''Să observăm că''

<math display="block">I_{n+2}+I_n = \int_{0}^{\pi}\frac{2\cos x-\cos(n_1)x}{13-12\cos x}\,dx = \frac{1}{6}\int_{0}^{\pi}\frac{(12\cos x-13+13)\cos(n+1)x}{13-12\cos x}\,dx=</math>

<math display="block">=\frac{1}{6(n+1)}\sin(n+1)x\Biggr|_{0}^{\pi}+\frac{13}{6}I_{n+1},</math>

'' oricare ar fi ''<math>n\in \mathbb{N}.</math>'' Atunci ''<math>I_n=\alpha\left(\frac{2}{3}\right)^n+\beta\left(\frac{3}{2}\right)^n</math>'', unde ''<math>\alpha+\beta=I_0=\frac{\pi}{5}</math>'' și '' <math> \frac{2}{3}\alpha+\frac{3}{2}\beta=I_1=\frac{2\pi}{15}.</math>

''Obținem ''<math>\alpha=\frac{\pi}{5}, \beta=0</math>'' și ''<math>I_n=\frac{\pi}{5}\left(\frac{2}{3}\right)^n</math>.

În consecință, <math>\lim_{n \to \infty}(I_0+I_1+I_2+\ldots+I_n)= \frac{\frac{\pi}{5}}{1-\frac{2}{3}}=\frac{3\pi}{5}</math>.

27024

2023-12-05T15:28:39Z

Robert Manc: Pagină nouă: '''27024 (Gheorghe Szöllösy)''' ''Fie '' <math> I_n = \int_{0}^{\pi} \frac{\cos nx}{13-12\cos x}\,dx, n\ge0.</math>'' Să se calculeze '' <math>\lim_{n \to \infty}(I_0+I_1+I_2+\ldots+I_n).</math> '''Soluție. ''' ''Să observăm că'' <math>I_{n+2}+I_n = \int_{0}^{\pi}\frac{2\cos x-\cos(n_1)x}{13-12\cos x}\,dx = \frac{1}{6}\int_{0}^{\pi}\frac{(12\cos x-13+13)\cos(n+1)x}{13-12\cos x}\,dx= =\frac{1}{6(n+1)}\sin(n+1)x\Biggr|_{0}^{\pi}+\frac{13}{6}I_{n+1}, </math>'' oricare...

'''27024 (Gheorghe Szöllösy)'''

''Fie '' <math> I_n = \int_{0}^{\pi} \frac{\cos nx}{13-12\cos x}\,dx, n\ge0.</math>'' Să se calculeze '' <math>\lim_{n \to \infty}(I_0+I_1+I_2+\ldots+I_n).</math>

'''Soluție. ''' ''Să observăm că''

<math>I_{n+2}+I_n = \int_{0}^{\pi}\frac{2\cos x-\cos(n_1)x}{13-12\cos x}\,dx = \frac{1}{6}\int_{0}^{\pi}\frac{(12\cos x-13+13)\cos(n+1)x}{13-12\cos x}\,dx=
=\frac{1}{6(n+1)}\sin(n+1)x\Biggr|_{0}^{\pi}+\frac{13}{6}I_{n+1},
</math>'' oricare ar fi ''<math>n\in \mathbb{N}.</math>'' Atunci ''<math>I_n=\alpha\left(\frac{2}{3}\right)^n+\beta\left(\frac{3}{2}\right)^n</math>'', unde ''<math>\alpha+\beta=I_0=\frac{\pi}{5}</math>'' și ''<math>
\frac{2}{3}\alpha+\frac{3}{2}\beta=I_1=\frac{2\pi}{15}.</math>''Obținem ''<math>\alpha=\frac{\pi}{5}, \beta=0</math>'' și ''<math>I_n=\frac{\pi}{5}\left(\frac{2}{3}\right)^n</math>.

În consecință, <math>\lim_{n \to \infty}(I_0+I_1+I_2+\ldots+I_n)= \frac{\frac{\pi}{5}}{1-\frac{2}{3}}=\frac{3\pi}{5}</math>.

Gazeta Matematică

2023-12-05T15:12:08Z

Robert Manc:

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="3" |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
|-
|3 - [[Gazeta Matematică nr 2 2015|link]]
|[[27024]]
|12
|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
|}

0436 - Prim Maxim

2023-04-28T16:41:09Z

Robert Manc:

== Cerinţa ==
Să se scrie un program care citeşte de la tastatură un număr natural '''nr''' şi apoi un şir de '''nr''' '''numere''' naturale şi determină cel mai mare număr prim din șir și de câte ori apare.
== Date de intrare ==
Programul citește de la tastatură numărul '''nr''', iar apoi '''nr''' '''numere''' naturale.
== Date de ieşire ==
Programul afișează pe ecran numerele '''max_prim''' '''numar_aparitie''', separate printr-un spațiu, reprezentând cel mai mare număr prim din șir și de câte ori apare acest număr în șir.
== Restricții și precizări ==
* '''nr ∈ Ν'''
* '''0 < nr < 1.000'''
* cele '''nr''' '''numere''' citite vor fi mai mici decât '''2.000.000.000'''
* pentru toate testele de evaluare, datele de intrare vor conține cel puțin un număr prim
== Exemplu1 ==
; Intrare
: 5
: 8 7 11 9 11
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 11 2
== Exemplu2 ==
; Intrare
: 6
: 3 17 17 8 15 17
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 17 3
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(nr, numere):
flag = False
if 0 < int(nr) < 1_000:
flag = all(isinstance(x, int) and 1 <= x <= 2_000_000_000 for x in numere)
return flag

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

def numarare(numere, prim):
numar_aparitie = 0
for numar in numere:
if numar == prim:
numar_aparitie += 1
return numar_aparitie

def max_prim(numere):
max_prim = None
for numar in numere:
if verif_prim(numar):
if max_prim is None or numar > max_prim:
max_prim = numar
numar_aparitie = numarare(numere, max_prim)
print(max_prim, numar_aparitie)

if __name__ == '__main__':
nr = int(input())
numere = list(map(int, input().split()))
if validare_date(nr, numere):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
max_prim(numere)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul primește de la tastatură un număr și o listă de numere întregi și verifică dacă acestea respectă anumite restricții. Dacă da, atunci calculează cel mai mare număr prim din listă și afișează acest număr și numărul de apariții ale acestuia în listă.

Funcția '''verif_prim''' primește un număr și returnează '''True''' dacă este prim și '''False''' în caz contrar.

Funcția '''numarare''' numără numărul de apariții ale unui număr dat într-o listă dată.

Funcția '''max_prim''' găsește cel mai mare număr prim din listă și numărul de apariții ale acestuia, folosind funcțiile '''verif_prim''' și '''numarare'''.

1408 - Numere 10

2023-04-28T16:39:12Z

Robert Manc:

== Cerinţa ==
Se dau '''nr''' numere naturale. Calculați câte dintre ele sunt prime, cel mai mare și cel mai mic număr prim.
== Date de intrare ==
Programul citește de la tastatură numărul '''nr''', iar apoi '''nr''' '''numere''' naturale.
== Date de ieşire ==
Programul va afișa pe ecran numărul '''numere_prime''', '''min_prim''', '''max_prim''', reprezentând câte dintre numerele date sunt prime, cel mai mic și cel mai pare număr prim.
== Restricții și precizări ==
* '''nr ∈ Ν'''
* '''1 &les; nr &les; 10.000'''
* cele '''nr''' '''numere''' citite vor fi mai mici decât '''1.000.000.000'''
* în fiecare test va exista cel puțin un număr prim
== Exemplu1 ==
; Intrare
: 9
: 7 3 10 17 14 1 9 3 13
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 5 3 17
== Exemplu2 ==
; Intrare
: 10
: 77 64 39 81 6 15 3 79 94 32
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 2 3 79
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(nr, numere):
flag = False
if 0 < int(nr) <= 10_000:
flag = all(isinstance(x, int) and 1 <= x <= 1_000_000_000 for x in numere)
return flag

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

def numarare_prim(numere):
numere_prime = 0
for numar in numere:
if verif_prim(numar):
numere_prime += 1
return numere_prime

def gaseste_min_max_prim(numere):
numere_prime = numarare_prim(numere)
min_prim = None
max_prim = None
for numar in numere:
if verif_prim(numar):
if min_prim is None or numar < min_prim:
min_prim = numar
if max_prim is None or numar > max_prim:
max_prim = numar
print(numere_prime, min_prim, max_prim)

if __name__ == '__main__':
nr = int(input())
numere = list(map(int, input().split()))
if validare_date(nr, numere):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
gaseste_min_max_prim(numere)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Acest program primește ca date de intrare un număr întreg '''nr''' urmat de o listă de '''nr''' numere întregi '''numere'''. Programul validează datele de intrare și afișează numărul total de numere prime din listă și cel mai mic și cel mai mare număr prim din listă.

Funcția '''verif_prim''' verifică dacă un număr '''n''' este prim sau nu. Funcția '''numarare_prim''' numără numerele prime din lista de numere primite ca parametru, iar funcția '''gaseste_min_max_prim''' găsește cel mai mic și cel mai mare număr prim din listă.

În funcția '''gaseste_min_max_prim''', numărul total de numere prime este calculat utilizând funcția '''numarare_prim'''. Prin iterarea prin lista de numere, se găsesc cele mai mici și cele mai mari numere prime din listă. Acestea sunt stocate în variabilele '''min_prim''' și '''max_prim''', respectiv. Dacă niciun număr prim nu este găsit, '''min_prim''' și '''max_prim''' rămân '''None'''. La final, cele trei valori (numărul total de numere prime și cele mai mici și cele mai mari numere prime) sunt afișate.

0044 - Prime Interval

2023-04-28T16:36:28Z

Robert Manc:

== Cerinţa ==
Să se scrie un program care citește două numere naturale '''numar1''' și '''numar2''' și determină câte numere prime sunt în intervalul închis determinat de '''numar1''' și '''numar2'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''numar1''' și '''numar2'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''numere_prime''', reprezentând numărul de numere prime din intervalul închis determinat de '''numar1''' și '''numar2'''.
== Restricții și precizări ==
* '''numar1, numar2 ∈ Ν'''
* '''0 < numar1, numar2 < 100.000'''
* numerele citite nu respectă obligatoriu relația '''numar1 ≤ numar2'''
* un număr natural este '''prim''' dacă are exact doi divizori distincți: '''1''' și el însuși.
== Exemplu1 ==
; Intrare
: 10 20
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 4
== Explicație ==
În intervalul '''[10,20]''' sunt '''4''' numere prime: '''11''', '''13''', '''17''', '''19'''.
== Exemplu2 ==
; Intrare
: 5 17
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 5
== Explicație ==
În intervalul '''[5,17]''' sunt '''5''' numere prime: '''5''', '''7''', '''11''', '''13''', '''17'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar1, numar2):
flag = False
if 0 < int(numar1) < 100_000 and 0 < int(numar2) < 100_000:
flag = True
return flag

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

def numarare_prime(numar1, numar2):
if numar1 > numar2:
numar1, numar2 = numar2, numar1
numere_prime = 0
for numar in range(numar1, numar2+1):
if verif_prim(numar):
numere_prime += 1
print(numere_prime)

if __name__ == '__main__':
numar1, numar2 = input().split()
if validare_date(numar1, numar2):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
numarare_prime(int(numar1), int(numar2))
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul primește două numere de la tastatură și verifică dacă acestea se încadrează în limitele impuse de funcția '''validare_date'''. Dacă numerele sunt valide, programul numără câte numere prime sunt între cele două numere primite, folosind funcția '''numarare_prime'''. Pentru a număra numerele prime, se folosește funcția '''verif_prim''', care primește un număr și returnează '''True''' dacă numărul este prim, sau '''False''' altfel.

3351 - Prime 3

2023-04-28T16:33:15Z

Robert Manc:

== Cerinţa ==
Se dau '''nr''' numere naturale. Determinați suma celor prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''nr''', iar apoi '''nr''' '''numere''' naturale.
== Date de ieşire ==
Programul va afișa pe ecran numărul '''suma''', reprezentând suma celor prime.
== Restricții și precizări ==
* '''nr ∈ Ν'''
* '''1 &les; nr &les; 1.000'''
* cele '''nr''' '''numere''' citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu1 ==
; Intrare
: 5
: 11 25 3 4 1
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 14
== Explicație ==
Dintre cele '''5''' numere citite sunt prime numerele '''11''' și '''3'''.
== Exemplu2 ==
; Intrare
: 4
: 3 23 8 7
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 33
== Explicație ==
Dintre cele '''4''' numere citite sunt prime numerele '''3''', '''23''' și '''7'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(nr, numere):
flag = False
if 0 < int(nr) <= 1000:
flag = all(isinstance(x, int) and 1 <= x <= 1_000_000_000 for x in numere)
return flag

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

def suma_celor_prime(numere):
suma = 0
for numar in numere:
if verif_prim(numar):
suma += numar
print(suma)

if __name__ == '__main__':
nr = int(input())
numere = list(map(int, input().split()))
if validare_date(nr, numere):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
suma_celor_prime(numere)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul primește de la utilizator un număr de elemente urmat de o listă de numere și calculează suma tuturor numerelor prime din listă.

Funcția '''verif_prim''' primește un număr și returnează '''True''' dacă numărul este prim și '''False''' în caz contrar. Algoritmul folosit verifică dacă numărul este divizibil cu un număr între 2 și radicalul pătrat al numărului, iar în caz afirmativ, consideră numărul ca neprim și se oprește din căutare.

Funcția '''suma_celor_prime''' primește lista de numere și calculează suma tuturor numerelor prime din listă. Se parcurge fiecare element al listei, iar dacă acesta este prim, se adaugă la suma totală. Rezultatul final este afișat.

Dacă datele de intrare sunt valide, programul afișează un mesaj corespunzător și calculează suma numerelor prime din listă. În caz contrar, se afișează un mesaj de eroare.

3350 - Prime 2

2023-04-28T16:31:30Z

Robert Manc:

== Cerinţa ==
Se dau '''nr''' numere naturale. Determinați câte dintre ele sunt prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''nr''', iar apoi '''nr''' '''numere''' naturale.
== Date de ieşire ==
Programul va afișa pe ecran numărul '''numere_prime''', reprezentând câte dintre numerele citite sunt prime.
== Restricții și precizări ==
* '''nr ∈ Ν'''
* '''1 &les; nr &les; 1.000'''
* cele '''nr''' '''numere''' citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu1 ==
; Intrare
: 5
: 11 25 3 4 1
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 2
== Explicație ==
Dintre cele '''5''' numere citite sunt prime numerele '''11''' și '''3'''.
== Exemplu2 ==
; Intrare
: 4
: 3 23 8 7
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3
== Explicație ==
Dintre cele '''4''' numere citite sunt prime numerele '''3''', '''23''' și '''7'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(nr, numere):
flag = False
if 0 < int(nr) <= 1000:
flag = all(isinstance(x, int) and 1 <= x <= 1_000_000_000 for x in numere)
return flag

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

def numarare_prim(numere):
numere_prime = 0
for numar in numere:
if verif_prim(numar):
numere_prime += 1
print(numere_prime)

if __name__ == '__main__':
nr = int(input())
numere = list(map(int, input().split()))
if validare_date(nr, numere):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
numarare_prim(numere)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Acest cod are ca scop să primească o listă de numere și să numere câte dintre ele sunt numere prime. Funcția '''validare_date(nr, numere)''' verifică dacă numărul de numere și dacă fiecare dintre acestea corespund restricțiilor impuse. Dacă acesta este cazul, funcția '''numarare_prim(numere)''' verifică fiecare număr din listă și, dacă este prim, incrementează variabila '''numere_prime'''. La final, este afișat numărul de numere prime din listă.

0375 - Urmatorul Prim

2023-04-28T16:29:04Z

Robert Manc:

== Cerinţa ==
Se dă numărul natural '''n'''. Să se determine cel mai mic număr prim, strict mai mare decât '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran numărul cerut.
== Restricții și precizări ==
* '''n ∈ Ν'''
* '''1 &les; n &les; 1.000.000.000'''
== Exemplu1 ==
; Intrare
: 20
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 23
== Exemplu2 ==
; Intrare
: 112
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 127
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = False
if 0 < int(n) < 1_000_000_000:
flag = True
return flag

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

def urmatorul_prim(n):
i = n + 1
while not verif_prim(i):
i += 1
print(i)

if __name__ == '__main__':
n = int(input())
if validare_date(n):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
urmatorul_prim(n)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul primește un număr întreg de la utilizator. Dacă numărul este valid, programul calculează următorul număr prim după numărul dat.

Funcția '''verif_prim''' primește un număr întreg '''n''' și returnează '''True''' dacă '''n''' este prim și '''False''' altfel. Verifică dacă '''n''' este mai mare sau egal cu 2 și dacă există un divizor între 2 și rădăcina pătrată a lui '''n'''.

Funcția '''urmatorul_prim''' primește un număr întreg '''n''' și găsește următorul număr prim după '''n'''. Folosește un buclă while pentru a găsi următorul număr prim începând cu '''n+1'''. Când găsește un număr prim, îl afișează și se oprește.

0375 - Urmatorul Prim

2023-04-28T16:28:40Z

Robert Manc:

== Cerinţa ==
Se dă numărul natural '''n'''. Să se determine cel mai mic număr prim, strict mai mare decât '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran numărul cerut.
== Restricții și precizări ==
* '''n ∈ Ν'''
* '''1 &les; n &les; 1.000.000.000'''
== Exemplu1 ==
; Intrare
: 20
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 23
== Exemplu2 ==
; Intrare
: 112
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 127
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = False
if 0 < int(n) < 1_000_000_000:
flag = True
return flag

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

def urmatorul_prim(n):
i = n + 1
while not verif_prim(i):
i += 1
print(i)

if __name__ == '__main__':
n = int(input())
if validare_date(n):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
urmatorul_prim(n)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>
Programul primește un număr întreg de la utilizator. Dacă numărul este valid, programul calculează următorul număr prim după numărul dat.

Funcția '''verif_prim''' primește un număr întreg '''n''' și returnează '''True''' dacă '''n''' este prim și '''False''' altfel. Verifică dacă '''n''' este mai mare sau egal cu 2 și dacă există un divizor între 2 și rădăcina pătrată a lui '''n'''.

Funcția '''urmatorul_prim''' primește un număr întreg '''n''' și găsește următorul număr prim după '''n'''. Folosește un buclă while pentru a găsi următorul număr prim începând cu '''n+1'''. Când găsește un număr prim, îl afișează și se oprește.

0374 - N Prime 1

2023-04-28T16:26:28Z

Robert Manc:

== Cerinţa ==
Se dă numărul natural '''n'''. Să se afișeze numerele naturale prime mai mici sau egale cu '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran numerele naturale prime mai mici decât '''n''' în ordine crescătoare, separate prin exact un spațiu.
== Restricții și precizări ==
* '''n ∈ Ν'''
* '''2 &les; n &les; 1.000'''
== Exemplu1 ==
; Intrare
: 15
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 2 3 5 7 11 13
== Exemplu2 ==
; Intrare
: 11
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 2 3 5 7 11
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = False
if 2 <= int(n) <= 1_000:
flag = True
return flag

def prime_mai_mici(n):
for i in range(2, n + 1):
prim = True
for j in range(2, int(i ** 0.5) + 1):
if i % j == 0:
prim = False
break
if prim:
print(i, end=' ')

if __name__ == '__main__':
n = int(input())
if validare_date(n):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
prime_mai_mici(n)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Codul citește un număr întreg n și verifică dacă se încadrează în anumite restricții. Funcția '''prime_mai_mici''' afișează toate numerele prime mai mici sau egale cu n folosind două bucle for: o buclă for se ocupă de numerele de la 2 la n și o altă buclă for verifică dacă fiecare număr este prim prin testarea tuturor divizorilor săi posibili. Dacă numărul este prim, se afișează. Dacă datele de intrare nu respectă restricțiile impuse, se afișează un mesaj corespunzător.

0373 - N Prime

2023-04-28T16:24:08Z

Robert Manc:

== Cerinţa ==
Se dă numărul natural '''n'''. Să se afișeze primele '''n''' numere naturale prime.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran primele '''n''' numere naturale prime, în ordine crescătoare, separate prin exact un spațiu.
== Restricții și precizări ==
* '''n ∈ Ν'''
* '''1 &les; n &les; 1.000'''
== Exemplu1 ==
; Intrare
: 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 2 3 5 7 11
== Exemplu2 ==
; Intrare
: 8
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 2 3 5 7 11 13 17 19
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = False
if 0 < int(n) <= 1_000:
flag = True
return flag

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

def nprime(n):
count = 0 # numărul de numere prime găsite
num = 2 # numărul curent
while count < n:
if verif_prim(num):
print(num, end=" ")
count += 1
num += 1

if __name__ == '__main__':
n = int(input())
if validare_date(n):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
nprime(n)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul verifică dacă un număr dat este prim și apoi afișează primele n numere prime.

Funcția '''verif_prim''' primește un număr întreg și verifică dacă acesta este prim sau nu. Funcția utilizează un loop '''for''' pentru a itera prin numerele de la 2 la rădăcina pătrată a lui '''n'''. Dacă există un divizor între aceste valori, atunci numărul nu este prim și se returnează valoarea '''False'''. În caz contrar, se returnează valoarea '''True'''.

Funcția '''nprime''' primește un număr întreg și afișează primele n numere prime utilizând funcția verif_prim''' pentru a verifica dacă fiecare număr este prim. Variabila '''count''' numără numerele prime găsite, iar variabila '''num''' reprezintă numărul curent verificat. Loop-ul se oprește atunci când '''count''' devine egal cu '''n'''.

0045 - Verif Prim

2023-04-28T16:20:52Z

Robert Manc:

== Cerinţa ==
Să se scrie un program care citește de la tastatură un număr natural '''n''' și verifică dacă este prim.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran mesajul '''DA''', dacă '''n''' este număr prim, respectiv '''NU''' în caz contrar.
== Restricții și precizări ==
* '''n ∈ Ν'''
* '''1 &les; n &les; 1.000.000.000'''
* un număr natural este '''prim''' dacă are exact doi divizori distincți: '''1''' și el însuși.
== Exemplu1 ==
; Intrare
: 17
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: DA
== Exemplu2 ==
; Intrare
: 14
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: NU
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = False
if 0 <= int(n) < 1_000_000_000:
flag = True
return flag

def verif_prim(n):
if n <= 1:
print("NU")
else:
# Verificăm dacă există un divizor între 2 și rădăcina pătrată a lui n
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
print("NU")
break
else:
print("DA")

if __name__ == '__main__':
n = int(input())
if validare_date(n):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
verif_prim(n)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul verifică dacă un număr dat este prim sau nu și face o validare a datelor de intrare.

Funcția '''verif_prim''' primește numărul și verifică dacă este mai mare decât 1. Dacă da, parcurge numerele de la 2 la rădăcina pătrată a numărului și verifică dacă numărul este divizibil cu vreunul dintre aceste numere. Dacă este, afișează "NU", dacă nu, afișează "DA".

Funcția '''main''' citește numărul de la intrare, verifică dacă este valid și apoi apelează funcția '''verif_prim''' pentru a verifica dacă este prim sau nu.

2748 - Patrula 3

2023-04-28T16:19:01Z

Robert Manc:

== Cerinţa ==
Un domeniu pătrat (cu albastru), ca cel din figură trebuie apărat. Domeniul e împărțit în pătrățele. Latura domeniului este de n pătrățele, n≥7. Pe culoarele colorate patrulează 3 soldați, care încep patrularea din colțul stânga sus în același moment (poziția inițială). În exemplul de mai jos avem n=9.
Cei 3 soldați (garda) se vor schimba cu alți 3 soldați în momentul în care ajung în poziția inițială, simultan.
Soldații patrulează în sensul acelor de ceasornic fiecare cu aceeași viteză constantă, și fiecare pe culoarul său.
Să se scrie un program care determină numărul de circuite complete pentru fiecare soldat (un circuit complet este făcut de un soldat oarecare, pe același culoar până ajunge în poziția inițială), pentru schimbarea gărzii.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul va afișa pe ecran numerele '''circuit1''', '''circuit2''' și '''circuit3''' reprezentând numărul de circuite complete pe care le face fiecare soldat.
== Restricții și precizări ==
* '''n ∈ Ν'''
* '''7 &les; n &les; 1.000'''
== Exemplu1 ==
; Intrare
: 9
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3 4 6
== Explicație ==
Primul soldat face 3 ture complete, al doilea 4, iar cel de-al treilea 6.
== Exemplu2 ==
; Intrare
: 14
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 99 117 143
== Explicație ==
Primul soldat face 99 ture complete, al doilea 117, iar cel de-al treilea 143.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
if 7 <= int(n) <= 1_000:
return True
return False

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

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

def patrula(n):
circuit1 = n * 2 + (n - 2) * 2
n -= 2
circuit2 = n * 2 + (n - 2) * 2
n -= 2
circuit3 = n * 2 + (n - 2) * 2
circuit4 = cmmmc(circuit1, circuit2)
rez = cmmmc(circuit3, circuit4)
circuit1 = rez // circuit1
circuit2 = rez // circuit2
circuit3 = rez // circuit3
print(circuit1, circuit2, circuit3)

if __name__ == '__main__':
n = int(input())
if validare_date(n):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
patrula(n)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul calculează numărul minim de runde pe care trebuie să le parcurgă o patrulă pentru a acoperi un poligon cu n laturi.
Funcția '''cmmdc''' calculează cel mai mare divizor comun dintre două numere date.
Funcția '''cmmmc''' calculează cel mai mic multiplu comun dintre două numere date.
Funcția '''patrula''' calculează lungimea circuitelor pe care trebuie să le parcurgă patrula și apoi le înmulțește pentru a obține cel mai mic multiplu comun al lungimilor acestora. Astfel, se obține numărul total de unități de lungime pe care trebuie să le parcurgă patrula. Ulterior, se împarte acest număr la lungimea fiecărui circuit, obținându-se astfel numărul de runde pe care trebuie să le parcurgă patrula pe fiecare circuit.

2611 - Raza

2023-04-28T16:16:52Z

Robert Manc:

== Cerinţa ==
Avem la dispoziție un chenar dreptunghiular format din oglinzi. O rază de lumină pornește din colțul stânga jos al dreptunghiului sub un unghi de 45 de grade față de latura de jos a dreptunghiului și lovește latura de sus sau latura din dreapta. Aici se reflectă (pornește spre o altă latură tot sub un unghi de 45 de grade față de latura de care s-a lovit). Își continuă drumul până când ajunge într-un colț al dreptunghiului.
== Date de intrare ==
Programul citește de la tastatură dimensiunile chenarului a și b.
== Date de ieşire ==
Programul va afișa pe ecran numărul de atingeri ale marginilor chenarului. Punctul de pornire și cel final nu se numără.
== Restricții și precizări ==
* '''dim1, dim2 ∈ Ν'''
* '''1 &les; dim1, dim2 &les; 2.000.000.000'''
== Exemplu1 ==
; Intrare
: 3 8
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 9
== Exemplu2 ==
; Intrare
: 8 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 1
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(dim1, dim2):
if 0 < int(dim1) <= 2_000_000_000 and 0 <= int(dim2) <= 2_000_000_000:
return True
return False

def raza(dim1, dim2):
n, m = dim1, dim2
while dim2:
r = dim1 % dim2
dim1 = dim2
dim2 = r
numar_atingeri = n // dim1 + m // dim1 - 2
print(numar_atingeri)

if __name__ == '__main__':
dim1, dim2 = map(int, input().split())
if validare_date(dim1, dim2):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
raza(dim1, dim2)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul primește două dimensiuni ca date de intrare și verifică dacă acestea sunt între 1 și 2 miliarde. Dacă valorile introduse sunt corecte, programul calculează numărul de puncte de pe circumferința cea mai mare posibilă, astfel încât aceste puncte să atingă două linii ce reprezintă dimensiunile introduse. Programul folosește algoritmul lui Euclid pentru a determina cel mai mare divizor comun (CMMD) între cele două dimensiuni și apoi calculează numărul de puncte de pe circumferința cea mai mare posibilă, astfel încât acestea să atingă liniile.

3073 - Repartitie

2023-04-28T16:15:24Z

Robert Manc:

== Enunț ==
Într-o școală sunt '''nr_clase_7''' clase a VII-a, fiecare de câte '''elevi_clasa_7''' elevi, și '''nr_clase_8''' clase a VIII-a, fiecare de câte '''elevi_clasa_8''' elevi. Directorul școlii vrea să facă o nouă repartizare a elevilor în clase astfel încât în fiecare clasă: a) să fie același număr de elevi; b) să fie doar elevi de clasa a VII-a sau doar elevi de clasa a VIII-a.
== Cerinţa ==
Cunoscându-se valorile '''nr_clase_7''', '''elevi_clasa_7''', '''nr_clase_8''' și '''elevi_clasa_8''', numere naturale nenule, scrieți un program pentru a determina '''nr_clase_necesare''' numărul de clase necesar acestei noi repartizări, noul număr '''nr_clase_repartizate_7''' de clase a VII-a, respectiv '''nr_clase_repartizate_8''' de clase a VIII-a, precum și numărul '''nr_elevi_repartizati''' maxim de elevi repartizați într-o clasă.
== Date de intrare ==
Programul citește de la tastatură numerele naturale '''nr_clase_7''', '''elevi_clasa_7''', '''nr_clase_8''' și '''elevi_clasa_8''', separate prin spații.
== Date de ieşire ==
Programul va afișa pe ecran numerele naturale: '''nr_clase_necesare''', '''nr_clase_repartizate_7''', '''nr_clase_repartizate_8''', '''nr_elevi_repartizati''', separate prin câte un spațiu.
== Restricții și precizări ==
* '''nr_clase_7, elevi_clasa_7, nr_clase_8 și elevi_clasa_8 ∈ Ν'''
* '''1 &les; nr_clase_7, elevi_clasa_7, nr_clase_8, elevi_clasa_8, nr_clase_necesare, nr_clase_repartizate_7, nr_clase_repartizate_8, nr_elevi_repartizati &les; 1.000.000.000'''
== Exemplu1 ==
; Intrare
: 4 30 5 27
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 17 8 9 15
== Explicație ==
Pentru '''nr_clase_7=4''', '''elevi_clasa_7=30''', '''nr_clase_8=5''', '''elevi_clasa_8=27''', numărul de clase necesar acestei noi repartizări este '''nr_clase_necesare=17''', dintre care vor fi '''nr_clase_repartizate_7=8''' clase a VII-a și '''nr_clase_repartizate_8=9''' clase a VIII-a, iar în fiecare clasă vor fi repartizați maxim '''nr_elevi_repartizati=15''' elevi.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(nr_clase_7, elevi_clasa_7, nr_clase_8, elevi_clasa_8):
if 0 <= int(nr_clase_7) <= 1_000_000 and 0 <= int(elevi_clasa_7) <= 1_000_000 \
and 0 <= int(nr_clase_8) <= 1_000_000 and 0 <= int(elevi_clasa_8) <= 1_000_000:
return True
return False

def cmmdc(nr_elevi_7, nr_elevi_8):
while nr_elevi_8:
r = nr_elevi_7 % nr_elevi_8
nr_elevi_7 = nr_elevi_8
nr_elevi_8 = r
return nr_elevi_7

def calculare_repartizare(nr_clase_7, elevi_clasa_7, nr_clase_8, elevi_clasa_8):
nr_elevi_7 = nr_clase_7 * elevi_clasa_7
nr_elevi_8 = nr_clase_8 * elevi_clasa_8
nr_elevi_repartizati = cmmdc(nr_elevi_7, nr_elevi_8)
nr_clase_repartizate_7 = nr_elevi_7 // nr_elevi_repartizati
nr_clase_repartizate_8 = nr_elevi_8 // nr_elevi_repartizati
nr_clase_necesare = nr_clase_repartizate_7 + nr_clase_repartizate_8
print(nr_clase_necesare, nr_clase_repartizate_7, nr_clase_repartizate_8, nr_elevi_repartizati)

if __name__ == '__main__':
nr_clase_7, elevi_clasa_7, nr_clase_8, elevi_clasa_8 = map(int, input().split())
if validare_date(nr_clase_7, elevi_clasa_7, nr_clase_8, elevi_clasa_8):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
calculare_repartizare(nr_clase_7, elevi_clasa_7, nr_clase_8, elevi_clasa_8)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul citește de la tastatură numărul de clase și numărul de elevi pe clasă pentru două niveluri de învățământ (clasele a 7-a și a 8-a) și calculează numărul total de clase necesare pentru a repartiza toți elevii în grupuri de același număr. Înainte de a face calculele, se verifică dacă valorile introduse sunt cuprinse între 0 și 1.000.000. Funcția cmmdc este utilizată pentru a calcula cel mai mare divizor comun al numărului de elevi din cele două niveluri. Se calculează, de asemenea, numărul de clase necesare pentru nivelul 7 și nivelul 8, precum și numărul total de clase necesare. Rezultatele sunt afișate într-un format specific.

2771 - Covorul

2023-04-28T16:13:10Z

Robert Manc:

== Cerinţa ==
Mama vrea să acopere cu covoare o cameră cu lungimea de '''dimensiunea_x''' metri și lățimea de '''dimensiunea_y''' metri. Ea are la dispoziție oricâte covoare în formă de pătrat, de orice dimensiune, număr natural și respectă următoarele reguli:

fiecare covor plasat are laturile paralele cu laturile camerei;
covoarele așezate nu se suprapun;
de fiecare dată se folosește cel mai mare covor care poate fi ales în acel moment;
de fiecare dată covorul ales se plasează în așa fel încât zona neacoperită încă să fie un dreptunghi.
Știind dimensiunile camerei să se determine care este dimensiunea maximă a unui covor folosit și numărul total de covoare folosite.
== Date de intrare ==
Programul citește de la tastatură numerele '''dimensiunea_x''' și '''dimensiunea_y''', reprezentând dimensiunile camerei.
== Date de ieşire ==
Programul va afișa pe ecran numerele '''dim_max''' și '''numar_total''' reprezentând în ordine dimensiunea maximă a unui covor folosit și numărul total de covoare folosite.
== Restricții și precizări ==
* '''dimensiunea_x, dimensiunea_y ∈ Ν'''
* '''1 &les; dimensiunea_x, dimensiunea_y &les; 1.000.000.000'''
* dimensiunile covoarelor sunt numere naturale nenule
== Exemplu1 ==
; Intrare
: 10 3
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3 6
== Explicație ==
Se folosesc '''3''' covoare de latură '''3''' și '''3''' covoare de latură '''1'''. Dimensiunea maximă este '''3'''.
== Exemplu2 ==
; Intrare
: 1 100
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 1 100
== Explicație ==
Se folosesc '''100''' covoare de latură '''1'''. Dimensiunea maximă este '''1'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(dimensiunea_x, dimensiunea_y):
if 0 <= int(dimensiunea_x) <= 1_000_000_000 and 0 <= int(dimensiunea_y) <= 1_000_000_000:
return True
return False

def calculeaza_numarul_covoarelor(dimensiunea_x, dimensiunea_y):
dim_max = min(dimensiunea_x, dimensiunea_y)
print(dim_max, end=' ')
numar_total = 0
while dimensiunea_x != 0 and dimensiunea_y != 0:
if dimensiunea_x > dimensiunea_y:
x = dimensiunea_x // dimensiunea_y
dimensiunea_x -= x * dimensiunea_y
numar_total += x
else:
x = dimensiunea_y // dimensiunea_x
dimensiunea_y -= x * dimensiunea_x
numar_total += x
print(numar_total)

if __name__ == '__main__':
dimensiunea_x, dimensiunea_y = map(int, input().split())
if validare_date(dimensiunea_x, dimensiunea_y):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
calculeaza_numarul_covoarelor(dimensiunea_x, dimensiunea_y)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul citește de la tastatură dimensiunile unei camere si calculează numărul minim de covoare necesare pentru a acoperi podeaua întregii camere, folosind algoritmul lui Euclid pentru determinarea CMMDC-ului. Mai întâi se valideaza dimensiunile, apoi se calculeaza CMMDC-ul dintre cele două dimensiuni, pentru a obține dimensiunea maxima a unui covor. Apoi, se calculeaza numărul total de covoare necesare prin împărțirea produsului celor două dimensiuni la pătratul dimensiunii maxime si se afișează dimensiunea maximă a covorului și numărul total de covoare necesare.

0378 - Pavare

2023-04-28T16:10:52Z

Robert Manc:

== Cerinţa ==
Curtea bunicului este de formă dreptunghiulară cu dimensiunile cunoscute. Bunicul dorește pavarea curții cu plăci de piatră. Firma furnizoare produce plăci de piatră de formă pătrată, de orice dimensiune, iar bunicul dorește să folosească plăci de o singură dimensiune, astfel încât să folosească cât mai puține plăci. NU este posibilă tăierea plăcilor de piatră, iar curtea trebuie pavată în întregime.

Cunoscând dimensiunile curții, determinați numărul minim de plăci cu care poate fi pavată curtea și dimensiunea acestora.
== Date de intrare ==
Programul citește de la tastatură două numere naturale '''dim1 dim2''', reprezentând dimensiunile curții.
== Date de ieşire ==
Programul afișează pe ecran numerele '''numar_placi''' și '''dim_max''', separate prin exact un spațiu, reprezentând numărul minim de plăci cu care poate fi pavată curtea și dimensiunea acestora.
== Restricții și precizări ==
* '''dim1, dim2 ∈ Ν'''
* 1 &les; dim1, dim2&les; 1.000.000.000
== Exemplu1 ==
; Intrare
: 12 16
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 12 4
== Explicație ==
Dimensiunea maximă plăcilor cu care se poate pava curtea este '''4'''. Se vor folosi '''12''' plăci.
== Exemplu2 ==
; Intrare
: 26 8
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 52 2
== Explicație ==
Dimensiunea maximă plăcilor cu care se poate pava curtea este '''2'''. Se vor folosi '''52''' plăci.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date(dim1, dim2):
flag = False
if 0 <= int(dim1) < 1_000_000_000 and 0 <= int(dim2) < 1_000_000_000:
flag = True
return flag

def pavare_curte(dim1, dim2):
if dim1 < dim2:
dim1, dim2 = dim2, dim1
cmmdc = math.gcd(dim1, dim2)
dim_max = cmmdc
numar_placi = dim1 * dim2 // (dim_max ** 2)
print(numar_placi, dim_max)

if __name__ == '__main__':
dim1, dim2 = map(int, input().split())
if validare_date(dim1, dim2):
print("\nDatele de intrare corespund restrictiilor impuse.\n")
pavare_curte(dim1, dim2)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație =='''
Codul are rol de a calcula numărul de plăci necesare și dimensiunea acestora pentru a pava o curte dreptunghiulară cu dimensiunile date. Funcția '''pavare_curte''' calculează cmmdc-ul (cel mai mare divizor comun) al celor două dimensiuni, care este de fapt dimensiunea plăcii, și apoi calculează numărul de plăci necesare pentru a acoperi curtea. Rezultatele sunt afișate la consolă.

3407 - Aoc 2020

2023-04-28T16:08:34Z

Robert Manc:

== Cerinţa ==
Gigel a fost prins de doamna profesoară de matematică în timp ce se juca Art of conquest pe telefon în timpul orei de matematică. Drept pedeapsă, aceasta i-a dat să calculeze cel mai mic multiplu comun al unui șir de '''n''' numere naturale. Dorind să termine cât mai repede ceea ce are de făcut și să reia jocul fără să fie dat afară din alianță, Gigel apelează la ajutorul tău și te roagă să scrii un program care să îi rezolve problema primită ca pedeapsă.
== Date de intrare ==
Fișierul de intrare '''aoc2020.in''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieşire ==
Fișierul de ieșire '''aoc2020.out''' va conține pe prima linie numărul '''cmmmc_total''', reprezentând cel mai mic multiplu comun ale celor '''n''' numere citite .
== Restricții și precizări ==
* '''n ∈ Ν'''
* '''1 &les; n &les; 100'''
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici sau egale cu '''1.000'''
* '''cmmmc_total''' are cel mult '''18''' cifre;
== Exemplu1 ==
; aoc2020.in
: 4
: 18 54 24 42
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
; aoc2020.out
: 1512
== Explicație ==
Cel mai mic multiplu comun al numerelor '''18''', '''54''', '''24''' și '''42''' este '''1512'''.
== Exemplu2 ==
; Intrare
: 6
: 12 65 18 32 9 15
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
; aoc2020.out
: 18720
== Explicație ==
Cel mai mic multiplu comun al numerelor '''12''', '''65''', '''18''', '''32''', '''9''' și '''15''' este '''18720'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar, numere):
if not 1 <= numar <= 100:
return False
if not all(isinstance(x, int) and 1 <= x <= 1000 for x in numere):
return False
return True

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

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

def calculeaza_cmmmc_total(numere):
cmmmc_total = numere[0]
for i in range(1, len(numere)):
cmmmc_total = cmmmc(cmmmc_total, numere[i])
output.write(str(cmmmc_total))
output.close()

if __name__ == '__main__':
with open('aoc2020.in') as f:
n = int(f.readline())
numere = list(map(int, f.readline().split()))
if not validare_date(n, numere):
print("Datele de intrare nu corespund restrictiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
output = open("aoc2020.out", "w")
calculeaza_cmmmc_total(numere)

</syntaxhighlight>

== Explicație ==
Acest cod citeste dintr-un fisier numarul de elemente si o lista de numere, verifica daca datele sunt valide, calculeaza cel mai mic multiplu comun pentru intreaga lista de numere si scrie rezultatul intr-un fisier de iesire. Functia '''validare_date''' verifica daca numarul de elemente este intre 1 si 100 si daca fiecare numar din lista este intre 1 si 1000. Functia '''cmmdc''' calculeaza cel mai mare divizor comun intre doua numere folosind algoritmul lui Euclid. Functia '''cmmmc''' calculeaza cel mai mic multiplu comun intre doua numere folosind formula cmmmc = (numar1 * numar2) / cmmdc(numar1, numar2). Functia '''calculeaza_cmmmc_total''' calculeaza cmmmc pentru intreaga lista de numere folosind functia '''cmmmc''' si scrie rezultatul in fisierul de iesire.

0305 - CMMDC N

2023-04-28T16:06:00Z

Robert Manc:

== Cerinţa ==
Se dau '''n''' numere naturale nenule. Calculaţi cel mai mare divizor comun al lor.
== 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 '''cmmdcn''', reprezentând cel mai mare divizor comun al celor '''n''' numere citite.
== Restricții și precizări ==
* n ∈ Ν
* 1 &les; n &les; 1.000
* cele '''n''' numere citite vor avea cel mult '''9''' cifre
== Exemplu1 ==
; Intrare
: 4
: 18 54 24 42
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 6
== Exemplu2 ==
; Intrare
: 5
: 12 156 60 24 96
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 12
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar, numere):
if 1 <= numar <= 1000:
return all(isinstance(x, int) and 0 <= x < 1000000000 for x in numere)
return False

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

def cmmdc_multiplu(numere):
cmmdcn = numere[0]
for i in range(1, len(numere)):
cmmdcn = cmmdc(cmmdcn, numere[i])
return cmmdcn

if __name__ == '__main__':
n = int(input())
numere = list(map(int, input().split()))
if validare_date(n, numere):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print(cmmdc_multiplu(numere))
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul calculează cel mai mare divizor comun (CMMDC) al unui număr de numere. Funcția '''validare_date''' verifică dacă numărul de numere și fiecare număr în parte respectă anumite restricții, în timp ce funcția '''cmmdc''' calculează CMMDC folosind algoritmul Euclid. Funcția '''cmmdc_multiplu''' este folosită pentru a calcula CMMDC pentru mai multe numere simultan. Dacă toate datele de intrare sunt valide, codul afișează CMMDC-ul.

3307 - Fractie 6

2023-04-28T16:04:04Z

Robert Manc:

== Cerinţa ==
Se dă un numar '''n''' și '''n''' perechi de numere naturale '''numar1''' și '''numar2'''.Să se determine dacă '''numar1/numar2''' este fracție finită sau periodică, iar dacă este fracție periodică să se determine dacă este fracție periodică simplă sau mixtă.
== Date de intrare ==
Se citește de la tastatură un număr '''n''' și apoi '''n''' perechi de numere '''numar1 numar2'''.
== Date de ieşire ==
Programul afișează pentru fiecare pereche citită, pe câte un rând, mesajul '''fractie finita''', '''fractie periodica simpla''' sau '''fractie periodica mixta''' în funcție de caz.
== Restricții și precizări ==
* n ∈ Ν
* 1 &les; n &les; 100
* 1 &les; numar1, numar2 &les; 1.000.000.000, numere naturale
== Exemplu1 ==
; Intrare
: 5
: 2 5
: 7 90
: 90 270
: 50 81000
: 9 3
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: fractie finita
: fractie periodica mixta
: fractie periodica simpla
: fractie periodica mixta
: fractie finita
== Exemplu2 ==
; Intrare
: 4
: 5 10
: 65 34
: 88 168
: 91 71
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: fractie finita
: fractie periodica simpla
: fractie periodica simpla
: fractie periodica simpla
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_n(n):
return 1 <= n <= 100

def validare_numere(numar1, numar2):
return 1 <= numar1 <= 1_000_000_000 and 1 <= numar2 <= 1_000_000_000

def gcd(numar1, numar2):
if numar2 == 0:
return numar1

return gcd(numar2, numar1 % numar2)

def fractie(n, numere):
rezultate = []
for i in range(n):
numar1, numar2 = numere[i]
if not validare_numere(numar1, numar2):
print("Datele de intrare nu corespund restrictiilor impuse.")
break
g = gcd(numar1, numar2)
numar2 //= g

twos, fives = 0, 0

while numar2 % 2 == 0:
twos += 1
numar2 //= 2

while numar2 % 5 == 0:
fives += 1
numar2 //= 5

if numar2 == 1:
rezultate.append("fractie finita")
elif twos or fives:
rezultate.append("fractie periodica mixta")
else:
rezultate.append("fractie periodica simpla")

if len(rezultate) == n:
print("\nDatele de intrare corespund restrictiilor impuse.\n")
for r in rezultate:
print(r)

if __name__ == '__main__':
n = int(input())
if validare_n(n):
numere = [tuple(map(int, input().split())) for _ in range(n)]
fractie(n, numere)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul verifică dacă numerele introduse de utilizator reprezintă fracții finite sau periodice, și afișează tipul fracției pentru fiecare număr.

Funcția '''gcd''' calculează cel mai mare divizor comun dintre cele două numere date, iar funcția '''fractie''' calculează tipul fracției pentru fiecare număr. Dacă numărul este o fracție finită, se adaugă în lista '''rezultate''' string-ul "fractie finita", altfel se calculează numărul de doi și cinci din descompunerea în factori primi ai numitorului. Dacă numitorul are factori diferiți de 2 și 5, atunci este o fracție periodică simplă, altfel este o fracție periodică mixtă.

Dacă toate fracțiile au fost verificate, lista '''rezultate''' este afișată, altfel se afișează un mesaj de eroare.

0391 - Fractii

2023-04-28T16:01:53Z

Robert Manc:

== Cerinţa ==
Se dau '''n''' perechi de numere naturale nenule, fiecare reprezentând câte o fracţie. Calculaţi suma celor '''n''' fracţii, aducând rezultatul la forma ireductibilă.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' perechi de numere naturale, reprezentând numărătorul şi numitorul unei fracţii.
== Date de ieşire ==
Programul afișează pe ecran numerele '''numarator1''' '''numitor1''', separate prin exact un spaţiu, reprezentând numărătorul şi numitorul fracţiei sumă, adusă la forma ireductibilă.
== Restricții și precizări ==
* n ∈ Ν
* 1 &les; n &les; 10
* numărătorul şi numitorul fiecărei fracţii sunt numere naturale cu cel mult două cifre
== Exemplu1 ==
; Intrare
: 4
: 1 3
: 5 6
: 1 2
: 4 2
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 11 3
== Exemplu2 ==
; Intrare
: 3
: 4 5
: 8 2
: 9 10
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 57 10
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date(numar, numere):
flag = False
if 0 < int(numar) < 10 and len(numere) == 2:
flag = all(isinstance(x, int) and 1 <= x <= 1_000_000_000 for x in numere)
return flag

def suma(n, numarator1, numitor1):
date = True
for i in range(n-1):
pereche = input().split()
if validare_date(pereche[0], [int(pereche[0]), int(pereche[1])]):
numarator2, numitor2 = int(pereche[0]), int(pereche[1])
numarator1 = numarator1 * numitor2 + numarator2 * numitor1
numitor1 = numitor1 * numitor2
cmmdc = math.gcd(numarator1, numitor1)
numarator1 = numarator1 // cmmdc
numitor1 = numitor1 // cmmdc
else:
print("Datele de intrare nu corespund restrictiilor impuse.")
date = False
break
if date:
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print(numarator1, numitor1)

if __name__ == '__main__':
n = int(input())
a, b = map(int, input().split())
if validare_date(n, [a, b]):
suma(n, a, b)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicație ==
Codul primește la intrare un număr întreg n, urmat de două numere întregi a și b, și apoi primește încă n-1 perechi de numere întregi. Programul calculează suma fracțiilor primite la intrare și afișează rezultatul sub forma unei fracții ireductibile.

Funcția '''suma''' primește numărul de fracții ce urmează a fi adunate, numărătorul și numitorul primei fracții. Apoi, pentru fiecare fracție următoare, se face următoarele: se citește perechea de numere, se verifică dacă aceasta respectă restricțiile impuse prin intermediul funcției '''validare_date''', se adună fracția la suma totală și se simplifică rezultatul.

Dacă toate datele de intrare sunt valide, programul afișează suma fracțiilor.

0390 - SPFractii

2023-04-28T16:00:11Z

Robert Manc:

== Cerinţa ==
Se dau '''4''' numere naturale '''a b c d''', reprezentând fracțiile '''a/b''' și '''c/d'''. Calculați suma și produsul celor două fracții, aduse la forma ireductibilă.
== Date de intrare ==
Programul citește de la tastatură numerele '''a b c d'''.
== Date de ieşire ==
Programul afișează pe ecran numerele '''suma_numarator''' și '''suma_numitor''', reprezentând numărătorul și numitorul sumei celor două fracţii, adusă la forma ireductibilă, iar linia următoare numerele '''produs_numarator''' și '''produs_numitor''', reprezentând numărătorul și numitorul produsului celor două fracții, adus la forma ireductibilă.
== Restricții și precizări ==
* a, b, c, d ∈ Ν
* 1 &les; a, b, c, d &les; 10.000
== Exemplu1 ==
; Intrare
: 1 2 4 3
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 11 6
: 2 3
== Explicație ==
Suma fractiilor '''1/2''' și '''4/3''' este '''11/6''', iar produsul este '''2/3'''.
== Exemplu2 ==
; Intrare
: 4 2 8 2
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 6 1
: 8 1
== Explicație ==
Suma fractiilor '''4/2''' și '''8/2''' este '''12/2''', care adus la forma lui ireductibila este '''6/1''', iar produsul este '''8/1'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = all(isinstance(x, int) and 0 < x <= 10000 for x in n)
return flag

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

def impartire_la_cmmdc(numar1, numar2):
cmmdc_nr = cmmdc(numar1, numar2)
return numar1 // cmmdc_nr, numar2 // cmmdc_nr

def calculeaza(n):
a, b, c, d = n
suma_numarator = a*d + b*c
suma_numitor = b*d
produs_numarator = a*c
produs_numitor = b*d
suma_numarator, suma_numitor = impartire_la_cmmdc(suma_numarator, suma_numitor)
produs_numarator, produs_numitor = impartire_la_cmmdc(produs_numarator, produs_numitor)
print(suma_numarator, suma_numitor)
print(produs_numarator, produs_numitor)

if __name__ == '__main__':
n = list(map(int, input().split()))
if validare_date(n):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
calculeaza(n)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul citește de la tastatură o listă de 4 numere întregi și verifică dacă acestea îndeplinesc anumite restricții. Dacă aceste restricții sunt îndeplinite, programul calculează suma și produsul fracțiilor corespunzătoare numerelor din listă, simplifică fracțiile obținute și afișează rezultatele.

Funcția '''cmmdc''' calculează cel mai mare divizor comun dintre două numere utilizând algoritmul lui Euclid.

Funcția '''impartire_la_cmmdc''' simplifică o fracție prin împărțirea numărătorului și numitorului la cel mai mare divizor comun al acestora.

Funcția '''calculeaza''' primește lista de numere, descompune fiecare număr într-o fracție corespunzătoare și calculează suma și produsul acestora. Fracțiile obținute sunt simplificate prin împărțirea la cel mai mare divizor comun și afișate.

0410 - CMMDC 2

2023-04-28T15:58:18Z

Robert Manc:

== Cerinţa ==
Se dă un număr natural '''n'''. Acest număr se “împarte” în alte două numere '''a''' și '''b''', astfel: '''a''' este format din cifrele din prima jumătate a lui '''n''', '''b''' este format din cifrele din a doua jumătate a lui '''n'''. Dacă '''n''' are număr impar de cifre, cifra din mijloc se ignoră. De exemplu, dacă '''n=9183792''', atunci '''a=918''', iar '''b=792'''. Să se determine cel mai mare divizor comun al lui '''a''' și '''b'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''cmmdc''', reprezentând valoarea cerută.
== Restricții și precizări ==
* n ∈ Ν
* 0 &les; n &les; 1.000.000.000
== Exemplu1 ==
; Intrare
: 9183792
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 18
== Exemplu2 ==
; Intrare
: 2847956
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 4
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar):
flag = False
if numar.isdigit():
if 10 <= int(numar) <= 1_000_000_000:
flag = True
return flag

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

def cel_mai_mare_divizor(numar):
n = str(numar)
if len(n) % 2 == 1:
n = n[:len(n) // 2] + n[len(n) // 2 + 1:]
jumatate = len(n) // 2
a = int(n[:jumatate])
b = int(n[jumatate:])
cmmdc = CMD(a, b)
print(cmmdc)

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

</syntaxhighlight>

== Explicație ==
Codul calculează cel mai mare divizor comun dintre două numere, reprezentate de jumătățile unui număr introdus de la tastatură. Mai întâi, se validează inputul pentru a se asigura că respectă restricțiile impuse, apoi se calculează jumătățile numărului și se aplică algoritmul lui Euclid pentru a găsi cel mai mare divizor comun. Rezultatul este afișat în final.

0112 - Fractie Minima

2023-04-28T15:56:49Z

Robert Manc:

== Cerinţa ==
Să se scrie un program care citește un șir de '''n''' numere naturale şi determină cea mai mică fracţie care poate fi scrisă cu numărătorul şi numitorul dintre cele '''n''' numere.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale nenule, separate prin spaţii.
== Date de ieşire ==
Programul afișează pe ecran numărul fracţia cerută, în forma '''fractie'''.
== Restricții și precizări ==
* n ∈ Ν
* 0 < n < 1.001
* cele '''n''' numere citite vor fi mai mici decât '''2.000.000.000'''
* fracţia afişată va fi ireductibilă
== Exemplu1 ==
; Intrare
: 5
: 6 10 3 2 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 1/5
== Explicație ==
Cea mai mică fracţie care se poate scrie cu numerele din şire este '''2/10'''. Prin simplificare se obţine fracţia ireductibilă '''1/5'''.
== Exemplu2 ==
; Intrare
: 4
: 5 9 2 14
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 1/7
== Explicație ==
Cea mai mică fracţie care se poate scrie cu numerele din şire este '''2/14'''. Prin simplificare se obţine fracţia ireductibilă '''1/7'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar, numere):
flag = False
if 0 < int(numar) < 1001:
flag = all(isinstance(x, int) and 1 <= x <= 2_000_000_000 for x in numere)
return flag

def gcd(a, b):
while b:
a, b = b, a % b
return a

def fractie_minima(numere):
max_numar = -1
min_numar = float('inf')
for numar in numere:
if numar < min_numar:
min_numar = numar
if numar > max_numar:
max_numar = numar
div = gcd(max_numar, min_numar)
x = min_numar // div
y = max_numar // div
m = gcd(x, y)
return str(x // m) + '/' + str(y // m)

if __name__ == '__main__':
n = int(input())
numere = list(map(int, input().split()))
if validare_date(n, numere):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
fractie = fractie_minima(numere)
print(fractie)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Acest program primește la intrare un număr întreg '''n''' și o listă de '''n''' numere întregi '''numere'''. Scopul programului este să găsească cea mai mică fracție care poate fi obținută prin împărțirea oricărui număr din listă la alt număr din listă, și să o afișeze în formă de fracție simplificată.

Funcția '''gcd''' calculează cel mai mare divizor comun al doi întregi folosind algoritmul lui Euclid.

Funcția '''fractie_minima''' găsește cea mai mică fracție care poate fi obținută prin împărțirea oricărui număr din listă la alt număr din listă, și o afișează în formă de fracție simplificată. Funcția ia fiecare pereche de numere din listă și calculează fracția obținută prin împărțirea celui mai mic dintre ele la cel mai mare dintre ele. Apoi, calculează cel mai mare divizor comun al celor două numere, simplifică fracția și o stochează în variabila '''fractie'''. La sfârșit, funcția returnează fracția sub forma unui șir de caractere.

În funcția principală, programul citeste valorile de intrare și apoi verifică dacă respectă condițiile impuse de funcția '''validare_date'''. Dacă valorile sunt valide, programul apelează funcția '''fractie_minima''' și afișează rezultatul.

0409 - Oglindit 4

2023-04-28T15:53:54Z

Robert Manc:

== Cerinţa ==
Se dau '''n''' numere naturale. Determinați câte dintre ele au proprietatea că sunt prime cu oglinditul lor.
== 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 '''suma_perechi_oglindite''', reprezentând valoarea ceruta.
== Restricții și precizări ==
* n ∈ Ν
* 1 &les; numar1, numar2 &les; 1.000
* cele '''n''' numere citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu1 ==
; Intrare
: 5
: 24 50 25 81 359
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 1
== Explicație ==
Numărul care este prim cu oglinditul lui este '''359 (prim cu 953)'''.
== Exemplu2 ==
; Intrare
: 6
: 37 95 79 101 12 48
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3
== Explicație ==
Numerele care sunt prime cu oglinditul lor sunt '''37 (prim cu 73)''', '''79 (prim cu 997)''' și '''101 (prim cu 101)'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar, numere):
flag = False
if 0 <= int(numar) <= 1000:
flag = all(isinstance(x, int) and 1 <= x <= 1000000000 for x in numere)
return flag

def oglindit(nr):
ogl = 0
while nr:
ogl = ogl * 10 + nr % 10
nr //= 10
return ogl

def este_prim(n):
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())
numere = list(map(int, input().split()))
if validare_date(n, numere):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
oglindite = [oglindit(nr) for nr in numere]
suma_perechi_oglindite = [(nr, ogl) for nr, ogl in zip(numere, oglindite)
if este_prim(nr) and este_prim(ogl)]
print(len(suma_perechi_oglindite))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul citește de la tastatură un număr întreg '''n''' și o listă de '''n''' numere întregi '''numere'''. Verifică dacă datele introduse respectă restricțiile impuse, adică '''0 <= n <= 1000''' și '''1 <= numere[i] <= 10^9''' pentru orice '''i''' între '''0''' și '''n-1'''. Dacă datele introduse sunt valide, atunci pentru fiecare număr întreg din lista '''numere''' se calculează numărul oglindit al acestuia (se inversează ordinea cifrelor). Pentru fiecare pereche de numere din lista '''numere''' și '''oglindite''', se verifică dacă ambele numere din pereche sunt prime. Dacă ambele numere dintr-o pereche sunt prime, atunci perechea este inclusă într-o listă numită '''suma_perechi_oglindite'''. La final, se afișează numărul de perechi de numere prime din lista '''numere''' și '''oglindite'''.

3271 - Pereche CMMDC

2023-04-28T15:50:01Z

Robert Manc:

== Cerinţa ==
Se dă un șir de '''n''' perechi de numere naturale nenule. Să se determine perechea pentru care cel mai mare divizor comun este maxim. Dacă există mai multe asemenea perechi, se va determina aceea pentru care suma valorilor este maximă. Dacă există mai multe asemenea perechi, se va determina prima din șir.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' perechi de numere naturale.
== Date de ieşire ==
Programul va afișa pe ecran două numere, separate printr-un spațiu, reprezentând perechea determinată.
== Restricții și precizări ==
* n ∈ Ν
* 0 &les; n &les; 1.000
* valorile din cele '''n''' numere citite vor fi mai mici decât '''2^31'''
== Exemplu1 ==
; Intrare
: 4
: 12 18
: 16 12
: 18 30
: 25 35
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 18 30
== Exemplu2 ==
; Intrare
: 3
: 29 31
: 16 12
: 15 45
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 15 45
== Rezolvare ==
<syntaxhighlight lang="python" line>
def verificare_numar(numar):
if numar.isdigit() and 0 <= int(numar) <= 2**31-1:
return True
return False

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

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

if __name__ == '__main__':
n = int(input())
cmmdc_maxim = 0
suma_maxima_perechiilor = 0
perechea_cu_suma_maxima = None
if verificare_n(n):
date = True

for i in range(n):
pereche = input().split()
numar1, numar2 = pereche[0], pereche[1]
if verificare_numar(numar1) and verificare_numar(numar2):
numar1, numar2 = int(numar1), int(numar2)
cmmdc = CMD(numar1, numar2)
suma_perechii = numar1 + numar2
if cmmdc > cmmdc_maxim:
cmmdc_maxim = cmmdc
suma_maxima_perechiilor = suma_perechii
perechea_cu_suma_maxima = (numar1, numar2)
elif cmmdc == cmmdc_maxim and suma_perechii > suma_maxima_perechiilor:
suma_maxima_perechiilor = suma_perechii
perechea_cu_suma_maxima = (numar1, numar2)
else:
date = False

if date:
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print(perechea_cu_suma_maxima[0], perechea_cu_suma_maxima[1])
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
Acest program citeste un numar '''n''', citeste '''n''' perechi de numere întregi (citite ca string-uri), și determină perechea cu suma maximă dintre toate perechile care au cel mai mare divizor comun (cmmdc). Pentru fiecare pereche de numere, programul calculează cmmdc-ul și suma acestora și le compară cu valorile maxime până în prezent. Dacă cmmdc-ul este mai mare decât cel mai mare cmmdc de până acum, valorile maxime sunt actualizate cu valorile perechii curente, altfel dacă cmmdc-ul este același cu cel mai mare cmmdc de până acum, atunci se compară suma curentă a perechii cu suma maximă de până acum și se actualizează valorile maxime în consecință. Programul afișează perechea cu cea mai mare sumă. Programul verifică dacă datele de intrare corespund restricțiilor impuse.

0080 - Numarare Perechi Prime Intre Ele

2023-04-28T15:46:46Z

Robert Manc:

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

== Explicație ==
Programul primește o listă de numere și verifică dacă numerele sunt întregi și sunt cuprinse între 0 și 1 miliard. Apoi, calculează numărul de perechi de numere din listă care sunt prime între ele și afișează rezultatul. Funcția prim() este utilizată pentru a verifica dacă două numere sunt prime între ele.

0411 - Prime intre ele 1

2023-04-28T15:44:47Z

Robert Manc:

== Cerinţa ==
Se dă un număr natural '''n''', '''n>1'''. Să se determine câte perechi '''(a,b)''', '''1 ≤ a ≤ b ≤ n''' de numere naturale sunt prime între ele.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''numar_perechi''', reprezentând valoarea dorită.
== Restricții și precizări ==
* n ∈ Ν
* 1 < n &les; 1.000
== Exemplu1 ==
; Intrare
: 6
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 12
== Explicație ==
Perechile sunt: '''(1 1) (1 2) (1 3) (1 4) (1 5) ( 1 6) (2 3) (2 5) (3 4) (3 5) (4 5) (5 6)''' .
== Exemplu2 ==
; Intrare
: 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 6
== Explicație ==
Perechile sunt: '''(1 1) (1 2) (1 3) (1 4) (2 3) (3 4)''' .
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

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

def numar_perechi_prime(numar):
numar_perechi = 0
for a in range(1, numar+1):
for b in range(a, numar+1):
if math.gcd(a, b) == 1: #verifică dacă numerele a și b sunt prime între ele
numar_perechi += 1
print(numar_perechi)

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

</syntaxhighlight>

== Explicație ==
Programul verifică dacă un număr dat respectă restricțiile impuse și calculează numărul de perechi de numere prime între ele, mai mici sau egale cu numărul dat, utilizând o buclă dublă. Pentru a determina dacă două numere sunt prime între ele, se folosește funcția math.gcd() din Python, care calculează cel mai mare divizor comun al acestora și verifică dacă acesta este egal cu 1. La final, numărul de perechi de numere prime între ele este afișat.

0060 - Prime intre ele

2023-04-28T15:41:40Z

Robert Manc:

== Cerinţa ==
Să se scrie un program care să verifică dacă două numere naturale citite de la tastatură sunt prime între ele.
== Date de intrare ==
Programul citește de la tastatură două numere naturale '''numar1''' și '''numar2'''.
== Date de ieşire ==
Programul afișează pe ecran mesajul '''PIE''', dacă '''numar1''' și '''numar2''' sunt prime între ele, respectiv '''NOPIE''' în caz contrar.
== Restricții și precizări ==
* numar1, numar2 ∈ Ν
* 0 &les; numar1, numar2 &les; 1.000.000.000
* două numere naturale sunt prime între ele dacă cel mai mare divizor comun al lor este '''1'''
== Exemplu1 ==
; Intrare
: 24 36
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: NOPIE
== Exemplu2 ==
; Intrare
: 24 35
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: PIE
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

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

if __name__ == '__main__':
numar1, numar2 = input().split()
if validare_date(numar1, numar2):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
cmmd = math.gcd(int(numar1), int(numar2)) #În Python, putem folosi funcția math.gcd() pentru a calcula cel mai mare divizor comun între două numere.
if cmmd == 1:
print("PIE")
else:
print("NOPIE")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Acest cod verifică dacă două numere date ca input respectă restricțiile impuse și calculează cel mai mare divizor comun dintre ele folosind funcția math.gcd() din Python. Dacă cel mai mare divizor comun este 1, atunci se afișează mesajul "PIE", altfel se afișează mesajul "NOPIE".

3268 - CMMDC CMMMC

2023-04-28T15:39:30Z

Robert Manc:

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

== Explicație ==
Codul implementează două funcții matematice, cmmdc și cmmmc, și verifică dacă două numere de intrare îndeplinesc anumite restricții prin intermediul funcției validare_date.

Funcția cmmdc primește două argumente de tip întreg numar1 și numar2 și calculează cel mai mare divizor comun (CMMDC) dintre cele două numere folosind algoritmul lui Euclid. Algoritmul își schimbă parametrii până când al doilea parametru devine zero, iar primul parametru va fi CMMDC-ul celor două numere.

Funcția cmmmc primește două argumente de tip întreg numar1 și numar2 și calculează cel mai mic multiplu comun (CMMMC) dintre cele două numere folosind formula CMMMC = (numar1 * numar2) / CMMDC(numar1, numar2).

În programul principal, se citește două numere de intrare numar1 și numar2 folosind funcția input și se verifică dacă îndeplinesc restricțiile prin apelarea funcției validare_date. Dacă cele două numere sunt valabile, se calculează CMMDC-ul și CMMMC-ul lor folosind funcțiile cmmdc și cmmmc, respectiv, și se afișează rezultatele. Dacă cele două numere nu sunt valabile, se afișează un mesaj de eroare.

0059 - CMMMC

2023-04-28T15:38:02Z

Robert Manc:

== Cerinţa ==
Să se scrie un program care să determine cel mai mic multiplu comun a două numere naturale citite de la tastatură.
== Date de intrare ==
Programul citește de la tastatură două numere naturale '''numar1''' și '''numar2'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''cmmmc''', cel mai mic multiplu comun al numerelor '''numar1''' și '''numar2'''.
== Restricții și precizări ==
* numar1, numar2 ∈ Ν
* 0 < numar1, numar2 < 1.000.000.000
* pentru toate seturile de date de intrare, '''cmmmc<2.000.000.000'''
== Exemplu ==
; Intrare
: 24 36
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 72
== 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
return numar1

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(cmmmc(int(numar1), int(numar2)))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Codul implementează două funcții matematice, cmmdc și cmmmc, și verifică dacă două numere de intrare îndeplinesc anumite restricții prin intermediul funcției validare_date.

Funcția validare_date primește două argumente de tip string numar1 și numar2 și verifică dacă ambele sunt numere întregi pozitive mai mici decât 1 miliard. Dacă cele două argumente sunt numere întregi pozitive mai mici decât 1 miliard, funcția returnează True, altfel returnează False.

Funcția cmmdc primește două argumente de tip întreg numar1 și numar2 și calculează cel mai mare divizor comun (CMMDC) dintre cele două numere folosind algoritmul lui Euclid.

Funcția cmmmc primește două argumente de tip întreg numar1 și numar2 și calculează cel mai mic multiplu comun (CMMMC) dintre cele două numere folosind formula CMMMC = (numar1 * numar2) / CMMDC(numar1, numar2).

În programul principal, se citește două numere de intrare numar1 și numar2 folosind funcția input și se verifică dacă îndeplinesc restricțiile prin apelarea funcției validare_date. Dacă cele două numere sunt valabile, se calculează CMMMC-ul lor folosind funcția cmmmc și se afișează rezultatul. Dacă cele două numere nu sunt valabile, se afișează un mesaj de eroare.

0058 - CMMDC

2023-04-28T15:36:11Z

Robert Manc:

== Cerinţa ==
Să se scrie un program care să determine cel mai mare divizor comun a două numere naturale citite de la tastatură.
== Date de intrare ==
Programul citește de la tastatură două numere naturale '''numar1''' și '''numar2'''.
== Date de ieşire ==
Programul afișează pe ecran numărul '''cmmdc''', cel mai mare divizor comun al numerelor '''numar1''' și '''numar2'''.
== Restricții și precizări ==
* numar1, numar2 ∈ Ν
* 0 &les; numar1, numar2 &les; 1.000.000.000
* dacă ambele numere sunt egale cu '''0''' se va afișa valoarea '''-1'''
== Exemplu ==
; Intrare
: 24 36
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 12
== 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 CMD(numar1, numar2):
while numar2:
r = numar1 % numar2
numar1, numar2 = numar2, r
cmmdc = numar1
return cmmdc

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(CMD(int(numar1), int(numar2)))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Acest cod primește două numere întregi de la utilizator și verifică dacă acestea sunt valide înainte de a calcula CMMDC (cel mai mare divizor comun) folosind algoritmul lui Euclid. Verificarea validității se face prin verificarea dacă ambele numere sunt numere întregi și dacă sunt cuprinse între 0 și 1.000.000.000. În cazul în care ambele numere sunt egale cu 0, se va afișa -1, altfel se va afișa CMMDC-ul lor.

2372 - Divizori XYZ

2023-04-28T15:34:11Z

Robert Manc:

== Cerinţa ==
Se dă un număr natural numit '''numar'''. Afișați toate tripletele de numere naturale '''x''', '''y''', '''z''' '''(1<x<y<z<n)''' care sunt divizori ai lui '''numar''' și care au proprietatea că '''x+y+z=n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''numar'''.
== Date de ieşire ==
Programul va afișa pe ecran pe rânduri separate câte un triplet conform cerinței, numerele din triplet fiind in ordine strict crescatoare și separate prin cate un spațiu. Dacă nu există astfel de triplete, atunci se va afișa pe ecran '''nu exista'''.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar &les; 1.000.000.000
== Exemplu1 ==
; Intrare
: 24
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 4 8 12
== Exemplu2 ==
; Intrare
: 20
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: nu exista
== 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 triplet(numar):
divizori = [d for d in range(1, numar // 2 + 1) if numar % d == 0]
triplete = [(x, y, z) for x in divizori for y in divizori for z in divizori
if x < y < z and x + y + z == numar]
if triplete:
for x, y, z in triplete:
print(x, y, z)
else:
print("nu exista")

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

</syntaxhighlight>

== Explicație ==
Acest program are ca scop afișarea tuturor tripletelor de numere întregi pozitive (x, y, z), astfel încât x + y + z = numar.

Funcția "validare_date" are rolul de a verifica dacă numarul dat ca intrare este un număr pozitiv mai mic sau egal cu 1_000_000_000.

Funcția "triplet" primește ca argument numărul dat ca input și creează o listă de divizori pentru numărul dat, apoi generează o listă cu toate tripletel de numere întregi pozitive (x, y, z) din această listă de divizori, astfel încât x < y < z și x + y + z = numar. Dacă există cel puțin o astfel de tripletă, aceasta va fi afișată. în caz contrar, se va afișa un mesaj corespunzător.

Funcția "main" primește numărul dat ca input și verifică dacă acesta corespunde restricțiilor impuse de "validare_date". În caz afirmativ, se afișează un mesaj corespunzător, iar apoi se apelează funcția "triplet" cu argumentul numărul dat.

0664 - Nr Perechi

2023-04-28T15:31:05Z

Robert Manc:

== Cerinţa ==
Gigel a învăţat la matematică despre cel mai mic multiplu comun a două numere şi acum trebuie să determine pentru fiecare valoare '''x''' dintr-un set de valori date câte perechi ordonate de numere naturale '''(a,b)''' au cel mai mic multiplu comun '''x'''.
== Date de intrare ==
Programul citește de la tastatură număr '''numar''', apoi '''numere''' valori '''x'''.
== Date de ieşire ==
Programul va afișa pe ecran '''n''' valori, separate prin exact un spaţiu; fiecare valoare afișată reprezintă numărul de perechi care au cel mai mic multiplu comun egal cu valoarea x corespunzătoare.
== Restricții și precizări ==
* numar ∈ Ν
* 1 &les; numar &les; 1.000
* 1 &les; x &les; 2.000.000.000
== Exemplu ==
; Intrare
: 2
: 12 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 15 5
== Explicație ==
Cele '''15''' perechi pentru care cel mai mic multiplu comun este '''12''' sunt: '''(1,12)''', '''(2,12)''', '''(3,4)''', '''(3,12)''', '''(4,3)''', '''(4,6)''', '''(4,12)''', '''(6,4)''', '''(6,12)''', '''(12,1)''', '''(12,2)''', '''(12,3)''', '''(12,4)''', '''(12,6)''', '''(12,12)'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar, numere):
flag = False
if 0 <= int(numar) <= 1_000:
flag = all(isinstance(x, int) and 1 <= x <= 1_000_000 for x in numere)
return flag

def numar_perechi_cu_cmmmc_x(x):
divizor = 2
putere_divizor = 1
while x > 1:
if x % divizor == 0:
exponent_divizor = 0
while x % divizor == 0:
exponent_divizor += 1
x //= divizor
putere_divizor *= 2 * exponent_divizor + 1
else:
divizor += 1
if x > 1 and divizor * divizor > x:
putere_divizor *= 3
break
return putere_divizor

if __name__ == '__main__':
numar = int(input())
numere = list(map(int, input().split()))
if validare_date(numar, numere):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
for x in numere:
print(numar_perechi_cu_cmmmc_x(x), end=' ')
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul primește ca date de intrare un număr și o listă de numere, apoi calculează numărul de perechi de elemente din listă care au cel mai mic multiplu comun (CMMMC) egal cu numărul dat.

Validarea datelor de intrare este realizată prin funcția validare_date(), care verifică dacă numărul dat și toate numerele din lista se încadrează într-un anumit interval.

Funcția numar_perechi_cu_cmmmc_x(x) primește un număr x și calculează numărul de perechi de numere întregi pozitive din intervalul [1, x] a căror CMMMC este egal cu x. Acest calcul se face prin descompunerea numărului x în factori primi, iar apoi se calculează puterea fiecărui factor în CMMMC. În final, se folosește formula matematică a lui Euler pentru a calcula numărul de perechi de numere cu CMMMC x.

În funcție de validarea datelor de intrare, se afișează pentru fiecare număr din listă numărul de perechi de numere cu CMMMC egal cu numărul dat sau un mesaj corespunzător.

3200 - Nea Dragulin

2023-04-28T15:29:31Z

Robert Manc:

== Cerinţa ==
Nea Drăgulin are un '''numar''' natural pe care îl scrie de '''k''' ori, unul după altul. Aflaţi restul împărţirii numărului astfel obţinut la '''72'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''numar''' şi '''k'''.
== Date de ieşire ==
Programul va afișa pe ecran restul împărţirii numărului obţinut la '''72'''.
== Restricții și precizări ==
* numar, k ∈ Ν
* 1 &les; numar, k &les; 2.000.000.000
== Exemplu ==
; Intrare
: 51 3
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 63
== Explicație ==
Nea Drăgulin scrie numărul '''51''' de '''3''' ori obţinând numărul '''515151'''. Restul împărţirii acestuia la '''72''' este '''63'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar, k):
flag = False
if 0 <= int(numar) <= 2_000_000_000 and 0 <= int(k) <= 2_000_000_000:
flag = True
return flag

def rest_impartire(numar, k):
numar_concatenat = int(str(numar) * k)
rest = numar_concatenat % 72
return rest

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

</syntaxhighlight>

== Explicație ==
Acest program primește ca date de intrare două numere întregi: numărul și k, iar apoi calculează restul împărțirii numărului format prin concatenarea numărului dat de k ori, la 72.

Validarea datelor de intrare este realizată prin funcția validare_date(), care verifică dacă cele două numere date se încadrează într-un anumit interval.

Funcția rest_impartire() primește ca parametri numărul și k și îi concatenează k ori într-un număr întreg numit numar_concatenat. Apoi, funcția calculează restul împărțirii numar_concatenat la 72, utilizând operatorul modulo %.

În funcție de validarea datelor de intrare, se afișează restul împărțirii, sau un mesaj corespunzător.

4296 - Sum Div

2023-04-28T15:26:47Z

Robert Manc:

== Cerinţa ==
Se dă un șir de '''n''' numere naturale nenule și de asemenea un număr natural '''p'''. Să se calculeze suma numerelor din șir care au cel puțin '''p''' divizori.
== Date de intrare ==
Programul citește de la tastatură numerele '''nr''' și '''p''', iar apoi șirul de '''n''' numere naturale, separate prin spații.
== Date de ieşire ==
Programul va afișa pe ecran numărul '''suma''', reprezentând suma numerelor din șir care au cel puțin '''p''' divizori.
== Restricții și precizări ==
* nr ∈ Ν
* 1 &les; nr &les; 100.000
* 1 &les; p &les; 100.000
* cele '''n''' numere din șir vor fi numere naturale nenule mai mici decât '''1.000.000'''
== Exemplu1 ==
; Intrare
: 5 3
: 7 4 10 17 1
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 14
== Explicație ==
Numerele din șir care au cel puțin '''3''' divizori sunt '''4''' și '''10''', iar suma lor este '''14'''.
== Exemplu2 ==
; Intrare
: 5 100
: 5 12 24 3 72
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 0
== Explicație ==
Niciun număr nu are cel puțin '''100''' de divizori, deci suma este '''0'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare_date(nr, p, n):
flag = False
if 0 <= int(nr) <= 1_000 and 1 <= int(p) <= 1_0000:
flag = all(isinstance(x, int) and 1 <= x <= 1_000_000 for x in n)
return flag

def nrdiv(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_p_divizori(n, p):
suma = 0
for i in n:
if nrdiv(i) >= p:
suma += i
return suma

if __name__ == '__main__':
nr, p = map(int, input().split())
n = list(map(int, input().split()))
if validare_date(nr, p, n):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
suma = suma_p_divizori(n, p)
print(suma)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Codul calculează suma numerelor dintr-o listă dată, care au cel puțin p divizori. Datele de intrare sunt primite de la utilizator și sunt validate prin funcția validare_date(). Funcția nrdiv() calculează numărul de divizori ai unui număr dat, iar funcția suma_p_divizori() calculează suma numerelor din listă care au cel puțin p divizori. Dacă datele de intrare corespund restricțiilor impuse, se afișează suma calculată, altfel se afișează un mesaj corespunzător.

2745 - Intrebari

2023-04-25T10:38:26Z

Robert Manc:

== 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): #Calculează numărul de divizori ai lui "n" folosind o buclă "for" și o serie de expresii condiționale.
cnt = 0
for i in range(1, int(math.sqrt(n))+1):
if n % i == 0:
cnt += 2
if i * i == n:
cnt -= 1
print(cnt)

def suma_cifre(min_val): #Calculează suma cifrelor lui "min_val" folosind o buclă "for"
suma = 0
for i in str(min_val):
suma = suma + min_val % 10
min_val = min_val // 10
print(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 de intrare corespund restricțiilor impuse.\n")
if tip_cerinta == 1:
suma_cifre(min_val)
print(suma)
else:
nr_divizori(max_val)
print(suma)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Acest cod definește trei funcții:

: "validare_date" - care primește patru argumente și verifică dacă acestea respectă anumite restricții de valori și tipuri, returnând un flag boolean.
: "nr_divizori" - care primește un număr întreg "n" și calculează numărul său de divizori, afișând rezultatul.
: "suma_cifre" - care primește un număr întreg "min_val" și calculează suma cifrelor sale.

În funcția principală "main", utilizatorul este invitat să introducă trei numere întregi separate prin spațiu: "nr_elemente", "tip_cerinta" și "p", urmate de "nr_elemente" numere întregi separate prin spațiu și reprezentând elementele unei liste "sir".

Înainte de a apela funcțiile "nr_divizori" și "suma_cifre", se verifică dacă datele de intrare sunt valide folosind funcția "validare_date". Dacă datele de intrare sunt valide, se calculează și se afișează rezultatele în funcție de tipul cerinței ("tip_cerinta"). În caz contrar, se afișează un mesaj de eroare.

0377 - Difi Min

2023-04-25T10:24:08Z

Robert Manc:

== Cerinţa ==
Se citește numărul natural nenul numit '''numar'''. Determinați două numere naturale '''a''' , '''b''', cu proprietatea că:
*'''a * b = n'''
* '''a &les; b'''
* diferența '''b-a''' este minimă
== Date de intrare ==
Programul citește de la tastatură un număr natural ”'''numar'''”.
== Date de ieşire ==
Programul afișează pe ecran numerele '''a b''', separate prin exact un spațiu, cu semnificația din enunț.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar &les; 1.000.000.000
== Exemplu ==
; Intrare
: 70
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 7 10
== 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 radical(numar): # Această funcție calculează radicalul pătrat dintr-un număr întreg
x = numar
y = (x + 1) // 2
while y < x:
x = y
y = (x + numar // x) // 2
return x

def difi_min(numar): # Această funcție găsește cea mai mică pereche de numere întregi a și b astfel încât a * b = numar.
a = sqrt(numar) # Începe prin a calcula radicalul pătrat al numărului și apoi scade 1 din a până când numărul este divizibil cu a.
while numar % a != 0:
a -= 1
b = numar // a # La fiecare pas, calculează și valoarea corespunzătoare a lui b și le afișează pe ambele.
print(a, b)

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

</syntaxhighlight>

== Explicație ==
Acest cod definește trei funcții:

: "validare_date" verifică dacă un număr dat este un întreg pozitiv mai mic sau egal cu 1.000.000.000.
: "radical" calculează radicalul pătrat dintr-un număr întreg.
: "difi_min" găsește cea mai mică pereche de numere întregi a și b astfel încât a * b = numar.
În funcția principală, se citește un număr de la tastatură, se verifică dacă acesta este valid utilizând funcția "validare_date" și, dacă da, se apelează funcția "difi_min" cu numărul dat ca argument. Dacă numărul nu este valid, se afișează un mesaj corespunzător.

0377 - Difi Min

2023-04-25T10:23:09Z

Robert Manc:

== Cerinţa ==
Se citește numărul natural nenul numit '''numar'''. Determinați două numere naturale '''a''' , '''b''', cu proprietatea că:
*'''a * b = n'''
* '''a &les; b'''
* diferența '''b-a''' este minimă
== Date de intrare ==
Programul citește de la tastatură un număr natural ”'''numar'''”.
== Date de ieşire ==
Programul afișează pe ecran numerele '''a b''', separate prin exact un spațiu, cu semnificația din enunț.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar &les; 1.000.000.000
== Exemplu ==
; Intrare
: 70
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 7 10
== 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 radical(numar): # Această funcție calculează radicalul pătrat dintr-un număr întreg
x = numar
y = (x + 1) // 2
while y < x:
x = y
y = (x + numar // x) // 2
return x

def difi_min(numar): # Această funcție găsește cea mai mică pereche de numere întregi a și b astfel încât a * b = numar.
a = sqrt(numar) # Începe prin a calcula radicalul pătrat al numărului și apoi scade 1 din a până când numărul este divizibil cu a.
while numar % a != 0:
a -= 1
b = numar // a # La fiecare pas, calculează și valoarea corespunzătoare a lui b și le afișează pe ambele.
print(a, b)

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

</syntaxhighlight>

== Explicație ==
Acest cod definește trei funcții:

: "validare_date" verifică dacă un număr dat este un întreg pozitiv mai mic sau egal cu 1.000.000.000.
: "sqrt" calculează radicalul pătrat dintr-un număr întreg utilizând metoda lui Newton.
: "difi_min" găsește cea mai mică pereche de numere întregi a și b astfel încât a * b = numar.
În funcția principală, se citește un număr de la tastatură, se verifică dacă acesta este valid utilizând funcția "validare_date" și, dacă da, se apelează funcția "difi_min" cu numărul dat ca argument. Dacă numărul nu este valid, se afișează un mesaj corespunzător.

1574 - Prietene

2023-04-25T10:11:26Z

Robert Manc:

== Cerinţa ==
Se dau două numere naturale. Să se afle dacă aceste numere sunt prietene. Numerele prietene sunt perechile de numere în care fiecare număr în parte este suma tuturor divizorilor celuilalt număr, mai puțin acesta.
== Date de intrare ==
Programul citește de la tastatură două numere '''numar1''' și '''numar2'''.
== Date de ieşire ==
Programul va afișa pe ecran mesajul '''PRIETENE''' dacă cele două numere sunt prietene, respectiv '''NU SUNT PRIETENE''' dacă aceste numere nu sunt prietene.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar1 &les; 100.000
* 0 &les; numar2 &les; 100.000
== Exemplu ==
; Intrare
: 220 284
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: PRIETENE
== Explicație ==
Divizorii lui '''220''' sunt '''1''', '''2''', '''4''', '''5''', '''10''', '''11''', '''20''', '''22''', '''44''', '''55''' și '''110''', iar suma acestora este '''284'''. Divizorii lui '''284''' sunt '''1''', '''2''', '''4''', '''71''' și '''142''', iar suma acestora este '''220'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar1, numar2):
flag = False
if numar1.isdigit() and numar2.isdigit():
if 0 <= int(numar1) <= 100_000 and 0 <= int(numar2) <= 100_000:
flag = True
return flag

def prietene(numar1, numar2):
suma_div_num1 = sum(i for i in range(1, numar1) if numar1 % i == 0)
suma_div_num2 = sum(i for i in range(1, numar2) if numar2 % i == 0)
if suma_div_num1 == numar2 and suma_div_num2 == numar1:
print("PRIETENE")
else:
print("NU SUNT PRIETENE")

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

</syntaxhighlight>

== Explicație ==
Acest program primește la intrare două numere naturale și verifică dacă ele sunt numere prietene. Pentru a valida datele de intrare, se verifică dacă cele două numere sunt numere întregi și dacă se încadrează în intervalul 0-100000.

Funcția prietene(numar1, numar2) calculează suma divizorilor fiecărui număr și verifică dacă suma divizorilor primului număr este egală cu al doilea număr și invers. Dacă condiția este îndeplinită, programul afișează "PRIETENE", în caz contrar afișează "NU SUNT PRIETENE".

0445 - Pseudo Perfect

2023-04-25T10:09:12Z

Robert Manc:

== Cerinţa ==
Să se scrie un program care verifică dacă un număr natural citit de la tastatură este pseudoperfect. Un număr natural este pseudoperfect dacă este divizor al sumei divizorilor săi.
== Date de intrare ==
Programul citește de la tastatură un număr natural ”'''numar'''”.
== Date de ieşire ==
Programul afișează pe ecran mesajul '''DA''', dacă '''numar''' este număr pseudoperfect, respectiv '''NU''', în caz contrar
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar &les; 1.000.000.000
== Exemplu ==
; Intrare
: 120
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: DA
== Explicație ==
Suma divizorilor lui '''120''' este '''360''', care este multiplu al lui '''120'''.
== 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 pseudo(numar):
suma_divizorilor = 0
for i in range(1, numar + 1):
if numar % i == 0:
suma_divizorilor += i
if suma_divizorilor % numar == 0:
print("DA")
else:
print("NU")

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

</syntaxhighlight>

== Explicație ==
Programul primește un număr de la utilizator și determină dacă acesta este "pseudo". Un număr este considerat pseudo dacă suma divizorilor săi este un multiplu al numărului în sine.

Funcția validare_date verifică dacă numărul introdus este un număr întreg valid și se află în intervalul [0, 1_000_000_000].

Funcția pseudo primește un număr și calculează suma divizorilor săi. Dacă suma divizorilor este un multiplu al numărului în sine, atunci funcția afișează "DA", altfel afișează "NU".

Programul afișează mesaje corespunzătoare dacă datele introduse nu corespund restricțiilor impuse sau dacă numărul este pseudo sau nu.

0064 - Numar Perfect

2023-04-25T10:07:51Z

Robert Manc:

== Cerinţa ==
Să se scrie un program care verifică dacă un număr natural citit de la tastatură este perfect. Un număr natural este perfect dacă dublul său este egal cu suma divizorilor săi.
== Date de intrare ==
Programul citește de la tastatură numărul ”'''numar'''”
== Date de ieşire ==
Programul afișează pe ecran mesajul '''numar este perfect''', dacă ”'''numar'''” este număr perfect, respectiv '''numar nu este perfect''', în caz contrar.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar &les; 2.000.000.000
== Exemplu ==
; Intrare
: 6
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 6 este perfect
== Explicație ==
Divizorii lui '''6''' sunt '''1''', '''2''', '''3''', '''6'''. Suma lor este '''12''', iar '''2*6=12'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>

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

def perfect(numar):
suma_divizorilor = 0
for i in range(1, numar + 1):
if numar % i == 0:
suma_divizorilor += i
if suma_divizorilor == numar * 2:
print(numar, "este perfect")
else:
print(numar, "nu este perfect")

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

</syntaxhighlight>

== Explicație ==
Codul verifică dacă un număr dat este perfect sau nu.

Funcția validare_date verifică dacă numărul introdus este un întreg pozitiv și se încadrează între 0 și 2 miliarde.

Funcția perfect primește un număr și calculează suma divizorilor săi, verificând apoi dacă suma este dublul numărului. Dacă este, afișează că numărul este perfect, altfel afișează că nu este perfect.

În if __name__ == '__main__', codul citește un număr de la tastatură, verifică dacă este valid folosind funcția validare_date și, dacă este, apelează funcția perfect.

3272 - Sum Div Ogl

2023-04-25T10:06:29Z

Robert Manc:

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

== Explicație ==
Acest program calculează suma divizorilor oglinditelor a n numere date de la tastatură. Mai întâi, programul verifică dacă numărul de numere introduse este valid, folosind funcția validare_date_numere. Dacă da, utilizatorul este rugat să introducă cele n numere, iar acestea sunt stocate într-o listă. Pentru fiecare număr din listă, se calculează oglinditul folosind funcția oglindit și apoi se calculează suma divizorilor oglinditelor acestui număr, folosind funcția suma_divizori_oglindite. Suma totală a divizorilor oglinditelor este calculată prin adăugarea sumei divizorilor oglinditelor pentru fiecare număr din listă și este afișată la sfârșit. Funcțiile validare_date_numar și validare_date verifică dacă numerele sunt valide și respectă anumite restricții.

0408 - Divizorii Oglinditului

2023-04-25T10:04:45Z

Robert Manc:

== Cerinţa ==
Se dă un număr natural numit ”'''numar'''”. Să se determine numărul de divizori ai oglinditului lui ”'''numar'''”.
== Date de intrare ==
Programul citește de la tastatură un număr natural ”'''numar'''”.
== Date de ieşire ==
Programul afișează pe ecran '''numar_divizori''' , reprezentând rezultatul cerut.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar &les; 1.000.000.000
== Exemplu ==
; Intrare
: 63
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 9
== Explicație ==
Oglinditul lui '''63''' este '''36''', care are '''9''' divizori.
== 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 numar_divizori_oglindit(n):
oglindit = int(str(n)[::-1])
numar_divizori = 0
for i in range(1, oglindit+1):
if oglindit % i == 0:
numar_divizori += 1
print(numar_divizori)

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

</syntaxhighlight>

== Explicație ==
Funcția validare_date(numar) primește un singur parametru numar și verifică dacă acesta este un număr întreg pozitiv și se află între 0 și 1_000_000_000. Dacă aceste condiții sunt îndeplinite, funcția returnează True, altfel returnează False.

Funcția numar_divizori_oglindit(n) primește un singur parametru n și calculează numărul de divizori ai numărului oglindit al lui n. Mai întâi, se calculează numărul oglindit al lui n și se salvează în variabila oglindit. Apoi, se calculează numărul de divizori ai oglindit prin iterarea prin numerele de la 1 la oglindit și verificarea dacă acestea sunt divizori ai lui oglindit. Numărul de divizori este stocat în variabila numar_divizori. Rezultatul este afișat prin apelul funcției print().

În funcția main(), utilizatorul introduce un număr, care este verificat folosind funcția validare_date(). Dacă numărul respectă restricțiile, se afișează un mesaj corespunzător și se calculează și se afișează numărul de divizori ai numărului oglindit al numărului dat, prin apelul funcției numar_divizori_oglindit(). Dacă numărul nu respectă restricțiile, se afișează un mesaj de eroare.

0061 - Afisare Divizori Comuni

2023-04-25T10:01:05Z

Robert Manc:

== Cerinţa ==
Să se scrie un program care afișează divizorii comuni ai două numere naturale citite de la tastatură
== Date de intrare ==
Programul citește de la tastatură numerele '''numar1''' și '''numar2'''.
== Date de ieşire ==
Programul afișează pe ecran, în ordine crescătoare, divizorii comuni ai numerelor '''numar1''' și '''numar2''', separați printr-un spațiu.
== Restricții și precizări ==
* numar ∈ Ν
* 0 < numar1, numar2 < 1.000.000.000
== Exemplu ==
; Intrare
: 24 36
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 1 2 3 4 6 12
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar1, numar2):
flag = False
if numar1.isdigit() and numar2.isdigit():
if 0 < int(numar1) < int(numar2) <= 1_000_000_000:
flag = True
return flag

def divizori_comuni(numar1, numar2):
divizori = []
for i in range(1, min(numar1, numar2) + 1):
if numar1 % i == 0 and numar2 % i == 0:
divizori.append(i)
return divizori

if __name__ == "__main__":
numar1 = input()
numar2 = input()
if validare_date(numar1, numar2):
print("\nDatele de intrare corespund restricțiilor impuse.\n")
divizori = divizori_comuni(int(numar1), int(numar2))
for divizor in divizori:
print(divizor, end=" ")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul citește două numere întregi de la utilizator și afișează divizorii comuni ai acestora. În primul rând, funcția validare_date() validează datele introduse de utilizator, verificând dacă acestea sunt numere întregi și dacă se încadrează în intervalul 1 - 1.000.000.000. Funcția divizori_comuni() primește cele două numere întregi și returnează o listă cu divizorii comuni ai celor două numere, prin parcurgerea tuturor numerelor întregi între 1 și cel mai mic dintre cele două numere și verificarea dacă acestea sunt divizori ai ambelor numere. Dacă datele de intrare nu sunt valide, programul afișează un mesaj corespunzător.

3663 - PPDP

2023-04-25T09:59:20Z

Robert Manc:

== 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 de intrare 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 de intrare corespund restricțiilor impuse.\n")
print(patrat_cel_mai_mic_divizor(int(numar)))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Programul primește un număr și verifică dacă acesta îndeplinește anumite condiții de validare, adică trebuie să fie un număr întreg cuprins între 4 și 1.000.000.000 și să nu fie prim. Dacă numărul nu îndeplinește aceste condiții, programul afișează un mesaj de eroare. În caz contrar, se calculează pătratul celui mai mic divizor al numărului și se afișează rezultatul. Pentru a găsi pătratul celui mai mic divizor, se caută cel mai mic divizor al numărului și se ridică acesta la pătrat.

0389 - Divizori Pari Interval

2023-04-25T09:57:46Z

Robert Manc:

== Cerinţa ==
Se dau două numere naturale '''numar1''' și '''numar2'''. Să se determine cel mai mic și cel mai mare număr din intervalul '''[numar1,numar2]''' cu număr maxim de divizori pari şi numărul maxim de divizori pari.
== Date de intrare ==
Programul citește de la tastatură numerele '''numar1''' și '''numar2'''.
== Date de ieşire ==
Programul afișează pe ecran numerele '''nr_divizori_pari''' '''min_numar''' '''max_numar''', separate prin exact un spațiu , reprezentând numărul maxim de divizori pari ai numerelor din '''[numar1,numar2]''', cel mai mic şi respectiv cel mai mare număr din interval cu număr maxim de divizori pari.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar1 &les; numar2 &les; 1.000.000.000
* numar2 - numar1 &les; 1.000
== Exemplu ==
; Intrare
: 10 20
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 4 12 20
== Explicație ==
Numărul maxim de divizori pari pentru numerele din intervalul '''[10,20]''' este '''4'''. Numerele din interval cu '''4''' divizori pari sunt '''12''', '''16''' şi '''20'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(numar1, numar2):
flag = False
if numar1.isdigit() and numar2.isdigit():
if 0 < int(numar1) < int(numar2) <= 1_000_000_000 and int(numar2) - int(numar1) <= 1000:
flag = True

return flag

def numar_divizori_pari(divizori_pari):
count = 0
for divizor in range(1, divizori_pari+1):
if divizori_pari % divizor == 0 and divizor % 2 == 0:
count += 1
return count

def maxim_divizori_pari(numar1, numar2):
max_divizori = 0
min_numar = 0
max_numar = 0
for numar in range(int(numar1), int(numar2)+1):
divizori_pari = numar_divizori_pari(numar)
if divizori_pari > max_divizori:
max_divizori = divizori_pari
min_numar = numar
max_numar = numar
elif divizori_pari == max_divizori:
max_numar = numar
return max_divizori, min_numar, max_numar

if __name__ == "__main__":
numar1 = input()
numar2 = input()
if validare_date(numar1, numar2):
nr_divizori_pari, min_numar, max_numar = maxim_divizori_pari(int(numar1), int(numar2))
print("\nDatele de intrare corespund restricțiilor impuse.\n")
print(f"{nr_divizori_pari} {min_numar} {max_numar}")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație ==
Acest program primește ca intrare două numere naturale (numar1 și numar2) și calculează numărul maxim de divizori pari ai unui număr din intervalul [numar1, numar2] și afișează numărul maxim de divizori pari și cele două numere care au acest număr maxim de divizori pari. Programul include funcțiile validare_date, numar_divizori_pari și maxim_divizori_pari.

1568 - Medie Div

2023-04-25T09:55:30Z

Robert Manc:

== Cerinţa ==
Se dă un număr natural numit ”'''numar'''”. Să se calculeze şi să se afişeze media aritmetică a tuturor divizorilor săi. Media va fi cu fix '''2''' zecimale dupa virgula.
== Date de intrare ==
Programul citește de la tastatură numărul natural ”'''numar'''”.
== Date de ieşire ==
Programul afișează pe ecran numărul ”'''media'''”, reprezentând media aritmetica.
== Restricții și precizări ==
* numar ∈ Ν
* 0 &les; numar &les; 1.000.000.000
== Exemplu ==
; Intrare
: 9
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 4.33
 
; Intrare
: 8
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3.75
 
; Intrare
: Ana
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
== Explicație ==
Divizorii lui '''9''' sunt: '''1''', '''3''', '''9'''. Media aritmetica este '''4.33'''. 
Divizorii lui '''8''' sunt: '''1''', '''2''', '''4''', '''8'''. Media aritmetica este '''3.75'''
== 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 medie(numar):
suma_divizorilor = numar
numarul_divizorilor = 1 #inițializăm numarul_divizorilor cu 1 pentru că suma_divizorilor deja conține numărul însuși
for i in range(1, numar // 2 + 1):
if numar % i == 0:
suma_divizorilor += i
numarul_divizorilor += 1
medie_divizori = suma_divizorilor / numarul_divizorilor
print(medie_divizori)

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

</syntaxhighlight>

== Explicație ==
În acest cod funcția de validare verifică dacă numărul este un întreg pozitiv între 0 și 1_000_000_000, iar funcția care calculează media divizorilor adună toți divizorii numărului dat și îi împarte la numărul total de divizori ai acestuia, afișând apoi rezultatul.

0388 - Numarul Divizorilor Pari

2023-04-25T09:52:29Z

Robert Manc:

== Cerinţa ==
Se dă un număr natural numit ”'''numar'''”. Să se determine câți divizori pari are acest număr.
== Date de intrare ==
Programul citește de la tastatură numărul natural ”'''numar'''”.
== Date de ieşire ==
Programul afișează pe ecran numărul ”'''numarul_divizorilor_pari'''”, reprezentând numărul divizorilor pari ai 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.
: 2
 
; Intrare
: 12
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 4
 
; Intrare
: -20
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
 
== Explicație ==
Divizorii pari ai lui '''6''' sunt '''2''' și '''6'''. 
Divizorii pari ai lui '''12''' sunt '''2''', '''4''', '''6''', '''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 nr_divizori(numar):
if numar % 2 == 0:
numarul_divizorilor_pari = 1
else:
numarul_divizorilor_pari = 0
for i in range(1, numar // 2 + 1):
if numar % i == 0:
if i % 2 == 0:
numarul_divizorilor_pari += 1
print(numarul_divizorilor_pari)

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

</syntaxhighlight>

== Explicație ==
Codul calculează numărul de divizori pari ai unui număr întreg dat și verifică validitatea datelor de intrare. Se folosește o funcție pentru validare și o funcție pentru calculul numărului de divizori pari. La rulare se verifică dacă numărul dat de utilizator este valid și se apelează funcția pentru calculul numărului de divizori pari.