Bitnami MediaWiki - User contributions [en]

S:E18.128

2024-01-16T07:57:06Z

Paul Ungur: Soluția

'''S:E18.128 (Vasile Ienuțaș)'''

''Scrieți numărul <math>2018^{2017}</math> ca sumă de patru pătrate perfecte nenule distincte.''

'''Soluție:'''

''Din <math>2018 = 3^2+4^2+12^2+43^2</math> se obține''

''<math display="block">2018^{2017} = 2018 \cdot 2018^{2016} = \left ( 3^2 + 4^2 + 12^2 + 43^2 \right ) \cdot \left( 2018^{1008}\right)^2 </math>''

''Deci''

''<math display="block">2018^{2017} = \left( 3 \cdot 2018^{1008}\right)^2 + \left( 4 \cdot 2018^{1008}\right)^2 + \left( 12 \cdot 2018^{1008}\right)^2 + \left( 43 \cdot 2018^{1008}\right)^2</math>''

2112 - Tablita

2023-06-29T19:10:01Z

Paul Ungur:

Adrian participă la o expediţie, împreună cu colegii lui. La un moment dat, copiii descoperă, lângă un copac, 5 tăbliţe vechi. Primele 4 tăbliţe sunt inscripţionate complet. Prima tăbliţă conţinea textul : “Grupa 1 conţine numărul 1”, a doua tăbliţă avea textul : „Grupa 2 conţine numerele 2 şi 3”, a treia tăbliţă avea textul: „Grupa 3 contine numerele 4, 5 şi 6” , a patra tăbliţă avea textul: „Grupa 4 conţine numerele 7, 8, 9 şi 10.” Pe următoarea tăbliţă găsită era înscris un singur număr, celelalte numere şi numărul grupei erau şterse. Adrian le solicită colegilor lui să descopere ce grupă era scrisă pe a cincea tabliţă găsită.

==Cerința==
Descoperiţi regula de inscripţionare a tăbliţelor şi pentru numărul găsit pe a cincea tăbliţă, determinaţi din ce grupă face parte.

==Date de intrare==
Fişierul de intrare tablita.in conţine pe prima linie un număr natural N, ce reprezintă numărul care era înscris pe a cincea tăbliţă descoperită de Adrian.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi fişierul de ieşire tablita.out va conţine un număr natural ce reprezintă grupa în care se află numărul N, înscris pe a cincea tabliţă găsită. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
Un număr înscris pe o tăbliţă este nenul şi conţine cel mult 8 cifre;

==Exemplu:==
 tablita.in
: 100

Iesire
: Date de intrare valide
 tablita.out
: 14

==Explicație==
Numărul 100 ce apare pe a cincea tăbliţă face parte din grupa 14.

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(n):
if not (1 <= n <= 100_000_000):
return False
return True

def tablita(n):
x, cnt = 1, 1
while x < n:
cnt += 1
x += cnt

with open("tablita.out", "w") as fout:
fout.write(str(cnt))

if __name__ == '__main__':
fin = open("tablita.in")
fout = open("tablita.out", "w")

n = int(fin.readline())
if validare(n):
print("Date de intrare valide")
tablita(n)
else:
print("Date de intrare invalide")

fin.close()
fout.close()
</syntaxhighlight>
==Explicatie cod:==
validare(n): Această funcție primește un număr întreg n și verifică dacă acesta se află în intervalul specificat, adică între 1 și 100.000.000. Dacă n nu se află în acest interval, funcția returnează False, altfel returnează True.
tablita(n): Această funcție primește un număr întreg n și calculează valoarea cnt reprezentând numărul de iterații necesare pentru a ajunge la x >= n. Inițial, x este setat la 1 și cnt este setat la 1. Apoi, se crește cnt cu 1 și se adaugă valoarea cnt la x până când x devine mai mare sau egal cu n. La final, rezultatul cnt este scris în fișierul "tablita.out".
În blocul __main__, se deschide fișierul de intrare "tablita.in" pentru citire și fișierul de ieșire "tablita.out" pentru scriere. Se citește numărul n din fișierul de intrare și se validează folosind funcția validare(). Dacă n este valid, se afișează "Date de intrare valide" și se apelează funcția tablita(n) pentru a calcula rezultatul și a-l scrie în fișierul de ieșire. În caz contrar, se afișează "Date de intrare invalide". La final, fișierele de intrare și de ieșire sunt închise.

0555 - Overflow

2023-06-29T19:08:59Z

Paul Ungur:

==Cerința==
Lui Gigel i s-a cerut să scrie un program care realizează înmulțirea dintre două numere naturale. Pentru a-i da o provocare lui Gigel, profesorul îi dă ca date de intrare un set de perechi de numere naturale pentru care produsul poate depăși 2 64. Gigel trebuie acum să-și modifice programul pentru ca să poată detecta cazurile speciale.

==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n perechi de numere naturale, care trebuie înmulțite.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran rezultatele pentru cele n operații, fiecare pe câte o linie. Rezultatul operației este produsul celor două numere, dacă acesta se poate reprezenta pe 8 octeți fără semn, sau mesajul Overflow!, în caz contrar. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
 1 ≤ n ≤ 100.000
pentru fiecare pereche, cele două numere se pot reprezenta pe 8 octeți, fără semn
valorile care se pot reprezenta pe 8 octeți fără semn sunt cuprinse între 0 și 18.446.744.073.709.551.615

==Exemplu:==
Intrare
: 3
: 2147483647 2147483647
: 18446744073709551615 2
: 666013 1

Ieșire
: Date de intrare valide
: 4611686014132420609
: Overflow!
: 666013

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(n):
if not (1 <= n <= 100_000):
return False
return True

def overflow(nr1, nr2):
return nr2 and nr1 > 18446744073709551615 // nr2

def produs(nr1, nr2):
return nr1 * nr2

def verificare(n):
nr = []
for i in range(n):
nr1, nr2 = map(int, input().split())
nr.append((nr1, nr2))
for i in range(n):
if overflow(nr[i][0], nr[i][1]):
print("Overflow!")
else:
print(produs(nr[i][0], nr[i][1]))

if __name__ == '__main__':
n = int(input())
if validare(n):
print("Date de intrare valide")
verificare(n)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Acest cod Python realizează următoarele acțiuni:

Funcția validare(n) primește un parametru n de tip întreg și verifică dacă acesta se află în intervalul [1, 100_000]. Dacă condiția este îndeplinită, funcția returnează True, altfel returnează False.
Funcția overflow(nr1, nr2) primește două parametri nr1 și nr2 de tip întreg și verifică dacă există un overflow în timpul efectuării operației de înmulțire nr1 * nr2. Dacă nr2 este diferit de zero și rezultatul înmulțirii depășește valoarea maximă acceptată de un număr întreg în Python (18446744073709551615), funcția returnează True, altfel returnează False.
Funcția produs(nr1, nr2) primește două parametri nr1 și nr2 de tip întreg și returnează rezultatul înmulțirii lor.
Funcția verificare(n) primește un parametru n de tip întreg și efectuează verificarea și afișarea produselor pentru perechile de numere citite de la intrare. În cadrul unei bucle, se citește fiecare pereche de numere și se apelează funcția overflow(nr1, nr2) pentru a verifica dacă există un overflow. Dacă există un overflow, se afișează mesajul "Overflow!", altfel se calculează produsul folosind funcția produs(nr1, nr2) și se afișează rezultatul.
În blocul if __name__ == '__main__':, se citește n de la intrare folosind funcția input(). Se validează datele de intrare utilizând funcția validare(n). Dacă datele de intrare sunt valide, se afișează un mesaj de confirmare, se apelează funcția verificare(n) și se afișează rezultatele pe ecran. Altfel, se afișează un mesaj de eroare.
Codul primește un număr de la intrare, validează datele și verifică dacă există un overflow în timpul înmulțirii perechilor de numere citite. Produsele sau mesajele de overflow sunt afișate pe ecran.

1006 - Pal Munte

2023-06-29T19:07:51Z

Paul Ungur:

==Cerința==
Să se afișeze pe ecran, în ordine crescătoare, toate palindromurile de tip munte cu exact 9 cifre.

Un palindrom este de tip munte dacă cifrele sale sunt în ordine strict crescătoare până la jumătatea numărului.

==Date de intrare==
Nu există!

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran în ordine crescătoare, toate palindromurile de tip munte cu exact 9 cifre. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Exemplu:==
Ieșire
: Date de intrare valide
: 123454321
: 123464321
: 123474321
...
: 457898754
: 467898764
: 567898765

==Explicație==
Lista palindromurilor din exemplu nu este completă.

==Rezolvare==
<syntaxhighlight lang="python" line>
def palindrom():
for i in range(1, 6):
for j in range(i + 1, 7):
for n in range(j + 1, 8):
for m in range(n + 1, 9):
for k in range(m + 1, 10):
print(i, j, n, m, k, m, n, j, i)

if __name__ == '__main__':
palindrom()
</syntaxhighlight>
==Explicatie cod:==
Funcția palindrom generează și afișează toate palindroamele de lungime 9 compuse din cifrele de la 1 la 9. Un palindrom este un număr sau o secvență care poate fi citită în aceeași ordine și în ordine inversă.

Explicația funcției:

Funcția palindrom nu primește niciun argument.
Folosind instrucțiunea for, se realizează bucle înlănțuite pentru fiecare cifră în intervalul de la 1 la 5 pentru variabila i, de la i + 1 la 6 pentru variabila j, de la j + 1 la 7 pentru variabila n, de la n + 1 la 8 pentru variabila m, și de la m + 1 la 9 pentru variabila k.
În interiorul buclelor înlănțuite, se afișează palindromul format din valorile variabilelor i, j, n, m, k, m, n, j, i. Ordinea acestor cifre generează un palindrom de lungime 9, deoarece palindroamele sunt citite în aceeași ordine și în ordine inversă.

1504 - Comori 1

2023-06-29T19:06:55Z

Paul Ungur:

Diriginta clasei a V-a organizează cu cei n elevi ai clasei sale concursul „Căutătorii de comori”. În concurs, fiecare elev trebuie să treacă prin n puncte de control și să răspundă la o întrebare la care primește un punctaj cuprins între 0 și 100.
Mihai, elev în clasa a V-a, participă cu mare plăcere la concurs și își notează punctajele obținute la fiecare punct de control.

==Cerința==
Să se specifice numerele de ordine ale punctelor de control la care Mihai a obținut un punctaj mai mic decât cel obținut la punctul de control anterior. Dacă punctajele obținute de Mihai au fost în ordine crescătoare, se va afișa valoarea 0.

==Date de intrare==
Fișierul de intrare comori1.in conține:
pe prima linie, un număr natural n reprezentând numărul punctelor de control,
pe a doua linie, un șir format din n numere naturale reprezentând punctajele lui Mihai la fiecare punct de control, separate prin câte un spațiu.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi fișierul de ieșire comori1.out va conține numerele de ordine ale punctele de control la care Mihai a obținut un punctaj mai mic decât cel obținut la punctul de control anterior sau valoarea 0 dacă punctajele obținute de Mihai au fost în ordine crescătoare. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
1 ≤ n ≤ 1000
Numerele din şir nu depăşesc 100.

==Exemplul 1==
comori1.in

: 6
: 50 60 65 70 70 80

comori1.out
: Date de intrare valide
: 0

==Explicație==
Mihai realizează la cele 6 puncte de control punctajele
50 ≤ 60 ≤ 65 ≤ 70 ≤ 70 ≤ 80
Pentru că punctajele au fost în ordine crescătoare afișăm 0.

==Exemplul 2==
comori1.in
9
66 70 20 35 50 34 69 80 12

comori1.out
3 6 9

==Explicație==
La punctul de control 3 Mihai are punctajul 20 ≤ 70;
La punctul de control 6 Mihai are punctajul 34 ≤ 50;
La punctul de control 9 Mihai are punctajul 12 ≤ 80.

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(n, nums):
if not (1 <= n <= 1_000):
return False
if not all(0 <= nums <= 100 for nums in nums):
return False
return True

def comori(n, a):
cnt = 0
for i in range(n-1):
if a[i] > a[i+1]:
cnt += 1
fout.write(f"{i+2} ")
if cnt == 0:
fout.write("0 ")

if __name__ == '__main__':
fin = open("comori1.in")
fout = open("comori1.out", "w")

n = int(fin.readline().strip())
nums = list(map(int, fin.readline().split()))
if validare(n, nums):
print("Date de intrare valide")
comori(n, nums)
else:
print("Date de intrare invalide")

fin.close()
fout.close()
</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n, nums) primește doi parametri: n de tip întreg și nums o listă de numere întregi. Funcția verifică dacă n se află în intervalul [1, 1000] și dacă toate valorile din lista nums sunt în intervalul [0, 100]. Dacă toate aceste condiții sunt îndeplinite, funcția returnează True, altfel returnează False.
Funcția comori(n, a) primește doi parametri: n de tip întreg și a o listă de numere întregi. Funcția parcurge lista a și numără de câte ori un element este mai mare decât elementul următor. Dacă se găsește o astfel de situație, se incrementează un contor cnt și se scrie în fișierul de ieșire indexul elementului următor. Dacă cnt rămâne 0, înseamnă că nu s-au găsit astfel de situații și se scrie "0" în fișierul de ieșire.
În blocul if __name__ == '__main__':, se deschid fișierele de intrare și de ieșire. Se citește n de la intrarea din fișier și se inițializează lista nums cu valorile citite. Se validează datele de intrare utilizând funcția validare(n, nums). Dacă datele de intrare sunt valide, se afișează un mesaj de confirmare, se apelează funcția comori(n, nums) și se scriu rezultatele în fișierul de ieșire. Altfel, se afișează un mesaj de eroare.
Codul primește datele de intrare din fișier, validează datele și efectuează operațiile specifice pentru a determina și afișa rezultatele în fișierul de ieșire.

0352 - Sum Cons

2023-06-29T19:06:02Z

Paul Ungur:

==Cerinţa==
Se citește numărul natural nenul n. Determinați toate modalitățile de a-l scrie pe n ca sumă de cel puțin două numere naturale consecutive nenule.

==Date de intrare==
Programul citește de la tastatură numărul n.

==Date de ieşire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul afișează pe ecran descompunerile cerute, câte o descompunere pe o linie a ecranului, în ordine crescătoare a numărului de termeni din descompunere, termenii unei descompuneri fiind scriși în ordine crescătoare și separați prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricţii şi precizări==
1 ≤ n ≤ 10.000.000
pentru fiecare test, numărul n se poate scrie ca sumă de cel puțin 2 numere naturale consecutive nenule în cel puțin un mod.

==Exemplu:==
Date de intrare
: 30

Date de ieșire
: Date de intrare valide
: 9 10 11
: 6 7 8 9
: 4 5 6 7 8

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(n):
if not (1 <= n <= 10_000_000):
return False
return True

def gasire_secventa(n):
for i in range(1, n // 2 + 1):
a = int((2 * n - i - i ** 2) / (2 * i + 2))
if a >= 1 and n == (i + 1) * (2 * a + i) // 2:
for k in range(i + 1):
print(k + a, end=" ")
print()

if __name__ == '__main__':
n = int(input())

if validare(n):
print("Date de intrare valide")
gasire_secventa(n)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n) primește un parametru n de tip întreg și verifică dacă acesta se află în intervalul [1, 10_000_000]. Dacă condiția este îndeplinită, funcția returnează True, altfel returnează False.
Funcția gasire_secventa(n) primește un parametru n de tip întreg și găsește secvențele de numere care satisfac o anumită condiție matematică. Aceasta parcurge un interval de la 1 până la jumătatea valorii lui n și verifică dacă există un număr a astfel încât formula (i + 1) * (2 * a + i) // 2 să fie egală cu n, unde i este un contor. Dacă găsește o astfel de secvență, o afișează pe ecran.
În blocul if __name__ == '__main__':, se citește n de la intrare folosind funcția input(). Se validează datele de intrare utilizând funcția validare(n). Dacă datele de intrare sunt valide, se afișează un mesaj de confirmare, se apelează funcția gasire_secventa(n) și se afișează secvența găsită pe ecran. Altfel, se afișează un mesaj de eroare.
Codul primește un număr de la intrare, validează datele și găsește secvențele care îndeplinesc condiția specificată. Acestea sunt afișate pe ecran.

0254 - Puteri

2023-06-29T19:05:01Z

Paul Ungur:

==Cerinţa==
Se dau n perechi de numere naturale a, b. Să se determine pentru fiecare pereche, dacă există, cea mai mare putere a lui 2 din intervalul închis determinat de a şi b.

==Date de intrare==
Programul citeşte de la tastatură numărul n, apoi n perechi de numere a, b.

==Date de ieşire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afişa pe câte o linie ecranului, pentru fiecare interval dat, cea mai mare putere a lui 2 din interval, sau 0, dacă intervalul nu conţine nici o putere al lui 2. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricţii şi precizări==
 1 ≤ n ≤ 10000
fiecare dintre numerele a şi b au cel mult 9 cifre.
intervalele sunt închise

==Exemplu:==
Date de intrare
: 3
: 2 69
: 20 10
: 19 25

Date de ieşire
: Date de intrare valide
: 64
: 16
: 0

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(n, a, b):
for i in range(n):
if not (1 <= n <= 10_000):
return False
if not (0 <= a[i] < 1_000_000_000 and 0 <= b[i] < 1_000_000_000):
return False
return True

def puteri(n, a, b):
for i in range(n):
p = 1
while p * 2 <= max(b[i], a[i]):
p = p * 2
if p >= min(a[i], b[i]):
print(p)
else:
print(0)

if __name__ == '__main__':
n = int(input())
a, b = [], []
for i in range(n):
ai, bi = map(int, input().split())
a.append(ai)
b.append(bi)

if validare(n, a, b):
print("Date de intrare valide")
puteri(n, a, b)
else:
print("Date de intrare invalide")

</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n, a, b) primește trei parametri: n de tip întreg, a și b liste de numere întregi. Funcția parcurge fiecare element din listele a și b și verifică dacă n este în intervalul [1, 10000], iar valorile din listele a și b sunt în intervalul [0, 999999999]. Dacă toate aceste condiții sunt îndeplinite pentru fiecare pereche de numere, funcția returnează True, altfel returnează False.
Funcția puteri(n, a, b) primește trei parametri: n de tip întreg și a și b liste de numere întregi. Funcția parcurge fiecare element din listele a și b și calculează cea mai mare putere a lui 2 (p) care este mai mică sau egală cu maximul dintre cele două numere. Apoi, verifică dacă p este mai mare sau egal cu minimul dintre cele două numere. În funcție de această verificare, se afișează p sau 0.
În blocul if __name__ == '__main__':, se citește n de la intrarea standard și se inițializează listele goale a și b. Se citește perechea de numere ai și bi de n ori și se adaugă valorile în listele corespunzătoare. Se validează datele de intrare utilizând funcția validare(n, a, b). Dacă datele de intrare sunt valide, se afișează un mesaj de confirmare, se apelează funcția puteri(n, a, b) și se afișează rezultatele. Altfel, se afișează un mesaj de eroare.
Codul primește datele de intrare de la utilizator, validează datele și efectuează operațiile specifice pentru a determina și afișa rezultatele.

1932 - PC

2023-06-29T19:03:45Z

Paul Ungur:

==Cerința==
Gigel vrea un calculator nou care are prețul x. Tatăl acestuia, fiind profesor de matematica, i-a spus ca îi va cumpăra calculatorul dacă prețul x al acestuia este norocos. Un număr x este norocos dacă pătratul acestuia se poate scrie ca sumă de x numere consecutive. De exemplu, x = 7 este număr norocos deoarece, 7 * 7 = 4 + 5 + 6 + 7 + 8 + 9 + 10.
Gigel a obţinut T oferte de preț și dorește să știe pentru fiecare dintre acestea dacă prețul este corespunzătar restricției pe care i-a impus-o tatăl său.

==Date de intrare==
Fișierul de intrare pc.in conține pe prima linie un singur număr natural T, reprezentând numărul de oferte. Pe a doua linie se află T numere naturale x1 x2 x3 … xT separate prin câte un spaţiu, cu semnificația din enunț.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi fișierul de ieșire pc.out va conține pe prima linie, separate prin câte un spațiu, cele T răspunsuri, în ordine: 1 dacă oferta este corespunzătoare restricției impuse și 0 în caz contrar. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
 x < 2.000.000.000
T < 10

==Exemplu:==
<syntaxhighlight lang="python" line>
def validare(n, nums):
if not (1 <= n <= 2_000_000_000):
return False
if not all(0 <= nums < 10 for nums in nums):
return False
return True

def pc(n, nums):
for i in range(n):
if nums[i] % 2 == 0:
fout.write("0 ")
else:
fout.write("1 ")

if __name__ == '__main__':
fin = open("pc.in")
fout = open("pc.out", "w")

n = int(fin.readline().strip())
nums = list(map(int, fin.readline().split()))
if validare(n, nums):
print("Date de intrare valide")
pc(n, nums)
else:
print("Date de intrare invalide")

fin.close()
fout.close()
</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n, nums) primește doi parametri: n de tip întreg și nums o listă de numere întregi. Funcția verifică dacă n este în intervalul [1, 2000000000] și dacă toate numerele din lista nums sunt în intervalul [0, 9]. Dacă toate aceste condiții sunt îndeplinite, funcția returnează True, altfel returnează False.
Funcția pc(n, nums) primește doi parametri: n de tip întreg și nums o listă de numere întregi. Funcția parcurge fiecare element din lista nums și verifică dacă elementul este par sau impar. Dacă este par, se scrie în fișierul de ieșire valoarea "0 ", altfel se scrie "1 ".
În blocul if __name__ == '__main__':, se deschid fișierele de intrare și de ieșire. Se citește prima linie din fișierul de intrare și se extrage valoarea n. Apoi, se citește a doua linie și se obține lista de numere nums. Se validează datele de intrare utilizând funcția validare(n, nums). Dacă datele de intrare sunt valide, se afișează un mesaj de confirmare, se apelează funcția pc(n, nums) și se scriu rezultatele în fișierul de ieșire. Altfel, se afișează un mesaj de eroare.
Codul primește datele de intrare dintr-un fișier, validează datele și efectuează operațiile specifice pentru a determina și afișa rezultatele. La final, fișierele de intrare și de ieșire sunt închise.

2160 - Prize

2023-06-29T19:02:52Z

Paul Ungur:

Am câștigat un concurs și primim la școală foarte foarte multe echipamente pentru un nou laborator. Pentru amenajarea laboratorului am primit și o sală de clasă. Din păcate în sala de clasă există doar o singură priză, în care ar putea fi conectat doar un singur echipament. Cum nu putem reface imediat instalația electrică, am hotărât să utilizăm prelungitoare.

Un prelungitor poate avea una sau mai multe prize în care pot fi conectate echipamente și eventual alte prelungitoare. Evident, pentru ca prelungitorul să poată fi utilizat el trebuie să fie alimentat la curentul electric.

==Cerința==
Cunoscând configurația prelungitoarelor să se determine numărul maxim de echipamente ce pot fi alimentate la curentul electric.

==Date de intrare==
Fișierul de intrare prize.in conține pe prima linie numărul natural N, care reprezintă numărul de prelungitoare. Pe următoarele N linii se află N numere naturale nenule, câte un număr pe o linie, reprezentând numărul de prize din fiecare dintre cele N prelungitoare.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi fișierul de ieșire prize.out va conține o singură linie pe care va fi scris numărul maxim de echipamente ce pot fi alimentate la curent, utilizând cele N prelungitoare descrise în fișierul de intrare. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
 1 ≤ N ≤ 1000
 1 ≤ numărul de prize dintr-un prelungitor ≤ 5 000 000

==Exemplu:==
 prize.in
: 3
: 3
: 2
: 5

: Date de intrare valide
 prize.out
: 8

==Explicație==
O modalitate de conectare a prelungitoarelor pentru a alimenta la curent echipamente ar fi:

punem în priză prelungitorul 3;
prelungitorul 1 îl punem în una dintre prizele prelungitorului 3 (mai rămân în prelungitorul 3 patru prize libere pentru echipamente)
prelungitorul 2 îl punem în una dintre prizele prelungitorului 1 (mai rămân în prelungitorul 1 două prize libere pentru echipamente).
În total vor exista 4+2+2=8 prize disponibile pentru echipamente.

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(n, nums):
if not (1 <= n <= 1000):
return False
if not all(0 <= nums <= 5_000_000 for nums in nums):
return False
return True

def prize(n, nums):
s = sum(nums)
fout.write(str(s - (n - 1)))
fin.close()
fout.close()

if __name__ == '__main__':
fin = open("prize.in")
fout = open("prize.out", "w")

lines = fin.readlines()
n = int(lines[0].strip())
nums = list(map(int, lines[1:]))
if validare(n, nums):
print("Date de intrare valide")
prize(n, nums)
else:
print("Date de intrare invalide")

fin.close()
fout.close()

</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n, nums) primește doi parametri: n de tip întreg și nums o listă de numere întregi. Funcția verifică dacă n este în intervalul [1, 1000] și dacă toate numerele din lista nums sunt în intervalul [0, 5000000]. Dacă toate aceste condiții sunt îndeplinite, funcția returnează True, altfel returnează False.
Funcția prize(n, nums) primește doi parametri: n de tip întreg și nums o listă de numere întregi. Funcția calculează suma tuturor numerelor din lista nums utilizând funcția sum(), iar apoi scade n - 1 din această sumă. Rezultatul obținut este scris în fișierul de ieșire.
În blocul if __name__ == '__main__':, se deschid fișierele de intrare și de ieșire. Se citește fiecare linie din fișierul de intrare și se extrag valorile corespunzătoare. Prima linie este citită ca n, iar liniile următoare sunt convertite într-o listă de numere nums. Se validează datele de intrare utilizând funcția validare(n, nums). Dacă datele de intrare sunt valide, se afișează un mesaj de confirmare, se apelează funcția prize(n, nums) și se scrie rezultatul în fișierul de ieșire. Altfel, se afișează un mesaj de eroare.

3568 - Max Cadou

2023-06-29T19:01:28Z

Paul Ungur:

==Cerința==
Spiridușii lui Moș Crăciun au făcut un număr N de cadouri. Totuși, Moșul este nemulțumit de munca lor, așa că, prin interschimbarea cifrelor numărului N, el poate modifica numărul de cadouri existente. Fiind foarte bătrân și greșind mult la calcule, vă roagă să îl ajutați să determine numărul maxim de cadouri ce se pot obține.

==Date de intrare==
Fișierul de intrare maxcadou.in conține pe prima linie numărul N.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi fișierul de ieșire maxcadou.out va conține pe prima linie numărul maxim de cadouri pe care îl poate obține moșul doar cu cifrele vechiului număr.

==Restricții și precizări==
1 ≤ n ≤ 1017
interschimbarea cifrelor = schimbarea cifrelor între ele
Pentru 60% din punctaj n ≤ 103

==Exemplu:==
maxcadou.in
: 1729

: Date de intrare valide
maxcadou.out
: 9721

==Explicație==
Din toate numerele care se pot forma cu cele 4 cifre ale numărului inițial, 9721 este cel maximal

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(n):
if not isinstance(n, int):
raise ValueError("k trebuie sa fie un numar intreg")

if n < 1 or n > 1_000_000_000:
raise ValueError("k trebuie sa fie intre 1 si 1.000.000.000")

return True

def max_cadou(n):
temp = n
nrcif = 0
mmz = 0
v = [0] * 11
if n == 0:
print(0)
return
elif n < 10:
print(n)
return
else:
mmz = 1

while temp != 0:
nrcif += 1
temp //= 10

for i in range(nrcif):
v[i] = n % 10
n //= 10

v = sorted(v[:nrcif], reverse=True)

if mmz == 1:
for i in range(nrcif):
fout.write(str(v[i]))

fout.write("\n")
fin.close()
fout.close()

if __name__ == "__main__":
fin = open("maxcadou.in")
fout = open("maxcadou.out", "w")

n = int(fin.readline().strip())
if validare(n):
print("Date de intrare valide")
max_cadou(n)
</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n) primește un număr întreg n și verifică dacă acesta este un întreg și se încadrează în intervalul [1, 1.000.000.000]. Dacă n nu respectă aceste condiții, funcția aruncă o excepție de tip ValueError cu un mesaj corespunzător. În caz contrar, returnează True.
Funcția max_cadou(n) primește un număr întreg n și efectuează următoarele operații:
Inițializează variabilele temporare temp, nrcif și mmz.
Verifică cazurile particulare în care n este 0 sau un număr cu o singură cifră, și afișează rezultatul corespunzător.
Altfel, se calculează numărul de cifre nrcif din n și se stochează cifrele într-un vector v.
Se sortează vectorul v în ordine descrescătoare.
Dacă n are cifra 0 pe prima poziție, se scriu cifrele în fișierul de ieșire fout.
La final, se închid fișierele de intrare și de ieșire.
În blocul if __name__ == "__main__":, se deschid fișierele de intrare și de ieșire (maxcadou.in și maxcadou.out). Se citește prima linie din fișierul de intrare pentru a obține valoarea n. Apoi, se verifică dacă datele de intrare sunt valide utilizând funcția validare(n). Dacă datele sunt valide, se afișează un mesaj de confirmare, se apelează funcția max_cadou() și se efectuează operațiile corespunzătoare. În final, se închid fișierele de intrare și de ieșire.

3381 - K Sir 1

2023-06-29T19:00:36Z

Paul Ungur:

Se dă următorul şir de numere:
1 1 2 2 1 2 3 3 3 1 2 3 4 4 4 4 1 2 3 4 5 5 5 5 5...
În şir avem grupe formate după următoarea regulă: grupa g conţine numerele naturale de la 1 la g în ordine crescătoare, urmate de g-1 valori egale cu g (g=1, 2, ...).

==Cerința==
Scrieţi un program care citeşte o valoare k şi afişează al k-lea termen al şirului de mai sus.

==Date de intrare==
Fișierul de intrare ksir.in conţine pe prima linie numărul natural k.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi fișierul de ieșire ksir.out va conţine o singură linie pe care va fi scris un număr natural ce reprezintă al k-lea element din şir. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide"'''.

==Restricții și precizări==
1 ≤ k ≤ 20.000.000.000
Poziţiile termenilor din şir sunt numerotate începând cu 1.

==Exemplu:==
ksir.in
: 8

: Date de intrare valide
ksir.out
: 3

==Explicație==
Al 8-lea element din şir este 3.

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(k):
if not isinstance(k, int):
raise ValueError("k trebuie sa fie un numar intreg")

if k < 1 or k > 20000000000:
raise ValueError("k trebuie sa fie intre 1 si 20.000.000.000")

return True

def k_sir(k):
n, cnt = 1, 1
while (1 * (n + 1) * (n + 1) // 4 < k):
n += 2
cnt += 1
n -= 2
k -= 1 * (n + 1) * (n + 1) // 4
nr = 0
while k:
if nr != cnt:
nr += 1
k -= 1
fout.write(str(nr))

fin.close()
fout.close()

if __name__ == "__main__":
fin = open("ksir.in")
fout = open("ksir.out", "w")

k = int(fin.readline().strip())
if validare(k):
print("Date de intrare valide")
k_sir(k)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare(k) primește un număr întreg k și verifică dacă acesta este un întreg și se încadrează în intervalul [1, 20.000.000.000]. Dacă k nu respectă aceste condiții, funcția aruncă o excepție de tip ValueError cu un mesaj corespunzător. În caz contrar, returnează True.
Funcția k_sir(k) primește un număr întreg k și efectuează un set de operații. Folosind o buclă while, se calculează valorile n și cnt până când expresia 1 * (n + 1) * (n + 1) // 4 < k devine falsă. Apoi, se ajustează valorile n și k în funcție de formula specificată. Se parcurge o buclă while în care se scade valoarea k până când acesta devine zero, în timp ce nr este incrementat cu 1 în fiecare iterație. La final, se scrie rezultatul în fișierul de ieșire.
În blocul if __name__ == "__main__":, se deschid fișierele de intrare și de ieșire (ksir.in și ksir.out). Se citește prima linie din fișierul de intrare pentru a obține valoarea k. Apoi, se verifică dacă datele de intrare sunt valide utilizând funcția validare(k). Dacă datele sunt valide, se afișează un mesaj de confirmare, se apelează funcția k_sir() și se efectuează operațiile corespunzătoare. În final, se închid fișierele de intrare și de ieșire.

1767 - Multiple

2023-06-29T18:58:58Z

Paul Ungur:

Sergiu, fiind un elev talentat în ceea ce priveşte informatica, doreşte pe cât posibil să-şi ajute prietenii în rezolvarea problemelor. Prietenii lui au venit la el, fiind foarte confuzi în legătură cu o anumită problemă: Ei au un set de T întrebări de forma: Care este cel mai mic număr strict mai mare decât n, divizibil cu k?
Fiind ocupat cu pregătirea pentru OJI, el vă roagă pe voi să-l ajutaţi!

==Cerința==
Pentru fiecare din cele T întrebări, să se afle cel mai mic număr strict mai mare decât n care este divizibil cu k.

==Date de intrare==
Fișierul de intrare multiple.in conține pe prima linie numărul T, iar următoarele T linii conţin câte două numere, n şi k, cu semnificaţia din enunţ.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi fișierul de ieșire multiple.out va conține pe T linii, pentru fiecare întrebare, numărul cerut.

==Restricții și precizări==
 1 ≤ T ≤ 10000
se recomandă utilizarea tipurilor de date pe 8 octeţi (64 de biţi)
dacă reuşiţi să-l ajutaţi pe Sergiu, pe lângă cele 100 de puncte, probabil el vă va face cinste şi cu o sticlă de apă minerală

==Exemplu:==
 multiple.in
: 5
: 1 2
: 3 7
: 24 9
: 13 223
: 45 9

: Date de intrare valide
 multiple.out
: 2
: 7
: 27
: 223
: 54

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare_date(n):
if n < 1 or n > 10000:
print("n trebuie sa fie intre 1 si 10000")
return False
return True

def multiple(n):
for i in range(n):
a, b = map(int, fin.readline().strip().split())
if a == b:
fout.write(str(2 * b) + "\n")
elif a < b:
fout.write(str(b) + "\n")
else:
fout.write(str(b - (a % b) + a) + "\n")
fin.close()
fout.close()

if __name__ == '__main__':
fin = open("multiple.in")
fout = open("multiple.out", "w")

n = int(fin.readline().strip())
if validare_date(n):
print("Date de intrare valide")
multiple(n)
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n) primește un număr n și verifică dacă acesta se încadrează în intervalul [1, 10000]. Dacă n nu respectă această condiție, se afișează un mesaj de eroare și funcția returnează False. În caz contrar, returnează True.
Funcția multiple(n) primește un număr n și efectuează un set de operații pentru n iterații. În fiecare iterație, se citesc două numere a și b folosind funcția fin.readline().strip().split(). Apoi, se efectuează următoarele verificări:
Dacă a este egal cu b, se înmulțește b cu 2 și rezultatul este scris în fișierul de ieșire.
Dacă a este mai mic decât b, se scrie b în fișierul de ieșire.
Dacă a este mai mare decât b, se calculează diferența b - (a % b) + a și rezultatul este scris în fișierul de ieșire.
În blocul if __name__ == '__main__':, se deschid fișierele de intrare și de ieșire (multiple.in și multiple.out). Se citește prima linie din fișierul de intrare pentru a obține n. Apoi, se verifică dacă datele de intrare sunt valide utilizând funcția validare_date(). Dacă datele sunt valide, se afișează un mesaj de confirmare, se apelează funcția multiple() și se efectuează operațiile pentru n iterații. În final, se închid fișierele de intrare și de ieșire.
Codul primește date de intrare din fișierul "multiple.in", validează datele și efectuează operații pentru n iterații, în funcție de valorile citite din fișier. Rezultatele sunt scrise în fișierul "multiple.out".

2757 - Cifre Zecimale 1

2023-06-29T18:57:34Z

Paul Ungur:

==Cerința==
Se consideră șirul de cifre zecimale obținut prin scrierea consecutivă a numerelor naturale de la 100 la 999: 100101102103104105…995996997998999. Să se afișeze cifra ce apare pe poziția k în acest șir.

==Date de intrare==
Programul citește de la tastatură un număr natural n și apoi n numere naturale nenule, k.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi Programul va afișa pe ecran, pe un singur rând și separate printr-un spațiu, n numere reprezentând cifrele din șir de pe pozițiile k, citite. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
 1 ≤ n ≤ 100.000
1 ≤ k ≤ 2700

==Exemplu:==
Intrare
: 3
: 5 10 18

Ieșire
: Date de intrare valide
: 0 1 5

==Explicație==
A cinceaa cifră din șir este 0, cea de pe poziția 10 este 1, iar cea de pe poziția 18 este 5.

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare_date(n, k_values):
# Verificăm dacă n este în intervalul permis
if n < 1 or n > 100000:
return False
# Verificăm dacă toate valorile de k sunt în intervalul permis
for k in k_values:
if k < 1 or k > 2700:
return False
# Dacă am trecut de toate verificările, înseamnă că datele de intrare sunt valide
return True

def citeste_input():
n = int(input())
k_values = list(map(int, input().split()))
return n, k_values

def cifre(k):
# Vom construi șirul de cifre folosind o buclă while
num = 100
digit_count = 0
while True:
# Obținem cifrele numărului curent
digits = [int(d) for d in str(num)]
# Adăugăm numărul de cifre din numărul curent la contorul de cifre
digit_count += len(digits)
# Dacă numărul de cifre depășește poziția k, ne oprim
if digit_count >= k:
# Obținem cifra de pe poziția k
return digits[k - digit_count + len(digits) - 1]
# Dacă nu am ajuns încă la poziția k, trecem la următorul număr
num += 1

def obtine_cifrele_pentru_k(n, k_values):
# Verificăm dacă datele de intrare sunt valide
if not validare_date(n, k_values):
return "Date de intrare invalide"
# Obținem cifra de pe fiecare poziție k și o adăugăm la lista de rezultate
results = [cifre(k) for k in k_values]
# Afișăm lista de rezultate
return results

if __name__ == '__main__':
n, k_values = citeste_input()
# Obținem cifrele corespunzătoare pozițiilor k și le afișăm
if validare_date(n, k_values):
print("Date de intrare valide")
results = obtine_cifrele_pentru_k(n, k_values)
print(*results)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n, k_values) primește un număr n și o listă de valori k_values și verifică dacă acestea respectă anumite condiții. Verificările includ verificarea ca n să fie în intervalul [1, 100000], iar fiecare valoare k din lista k_values să fie în intervalul [1, 2700]. Dacă datele nu respectă aceste condiții, funcția returnează False. În caz contrar, returnează True.
Funcția citeste_input() primește input-ul utilizatorului, citind n și lista de valori k_values de la intrare folosind funcția input(). Valoarea n este citită ca un număr întreg, iar lista k_values este citită ca o listă de numere întregi utilizând map() și split(). Funcția returnează n și k_values sub formă de tuplu.
Funcția cifre(k) primește un număr k și calculează cifra de pe poziția k. Acest lucru se face construind un șir de cifre folosind o buclă while. La fiecare iterație, se obțin cifrele numărului curent și se adaugă numărul de cifre la digit_count. Dacă digit_count depășește sau ajunge la poziția k, se returnează cifra corespunzătoare. Se adaugă un offset la k pentru a ajusta indexarea în lista de cifre.
Funcția obtine_cifrele_pentru_k(n, k_values) primește un număr n și o listă de valori k_values și returnează lista de cifre corespunzătoare pozițiilor k din k_values. Verifică mai întâi dacă datele de intrare sunt valide folosind funcția validare_date(). Apoi, utilizează funcția cifre() pentru a obține cifra corespunzătoare fiecărei valori k din lista k_values. Rezultatele sunt stocate într-o listă și returnate.
În blocul if __name__ == '__main__':, se apelează funcția citeste_input() pentru a obține n și k_values de la intrare. Apoi, se verifică dacă datele de intrare sunt valide utilizând funcția validare_date(). Dacă datele sunt valide, se afișează un mesaj de confirmare, se apelează funcția obtine_cifrele_pentru_k() și se afișează rezultatele. În caz contrar, se afișează un mesaj de eroare.

2915 - Sum Square

2023-06-29T18:56:34Z

Paul Ungur:

==Cerința==
Se dă numărul natural n. Determinați dacă numărul se poate scrie ca sumă de două pătrate perfecte. Dacă da, afișați două pătrate perfecte a căror sumă este n, în ordine crescătoare, sau mesajul NU în caz contrar.

==Date de intrare==
Programul citește de la tastatură numărul n;

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran cele 2 pătrate care alcătuiesc numărul sau mesajul NU în cazul în care nu există. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
1≤n≤1015
dacă există mai multe perechi de pătrate perfecte a căror sumă este n, poate fi afișată oricare

==Exemplu:==
Intrare
: 169

Ieșire
: Date de intrare valide
: 25 144

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

def validare_date(n):
"""Functie de validare"""
if not 1 <= n <= 10**15:
print("Numarul introdus trebuie sa fie intre 1 si 10^15.")
return False
return True

def sum_square(n):
ok = False
for i in range(1, int(math.sqrt(n // 2)) + 1):
x = i * i
y = n - x
j = int(math.sqrt(y))

if j * j == y and not ok:
print(min(y, x), max(x, y))
ok = True

if not ok:
print("NU")

if __name__ == '__main__':
n = int(input())
if validare_date(n):
print("Date de intrare valide")
sum_square(n)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod: ==
Funcția validare_date(n) primește un număr n și verifică dacă acesta se află în intervalul [1, 10^15]. Dacă numărul nu respectă această condiție, se afișează un mesaj de eroare și se returnează False. În caz contrar, se returnează True.
Funcția sum_square(n) primește un număr n și calculează perechile de numere x și y, astfel încât x^2 + y^2 = n. Pentru a verifica această condiție, se utilizează două bucle for. Prima buclă iterează de la 1 până la radicalul pătrat al lui n // 2, iar în interiorul primei bucle se calculează x = i*i și y = n - x. Apoi, se verifică dacă y este un pătrat perfect (adica j * j == y) și se afișează perechea (x, y) dacă această condiție este îndeplinită. Se folosește o variabilă ok pentru a se asigura că se afișează doar prima pereche găsită.
În blocul if __name__ == '__main__':, se citește de la intrare un număr n utilizând funcția input(). Apoi, se verifică dacă numărul este valid utilizând funcția validare_date(). Dacă numărul este valid, se afișează un mesaj de confirmare și se apelează funcția sum_square() pentru a găsi și afișa perechile (x, y). În caz contrar, se afișează un mesaj de eroare.

0115 - Medie

2023-06-29T18:55:31Z

Paul Ungur:

==Cerinţa==
Să se scrie un program care citeşte de la tastatură un număr natural n şi apoi un şir de n numere naturale şi determină media aritmetică a celor pare.

==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale.

==Date de ieşire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul afișează pe ecran numărul M, reprezentând media aritmetică a valorilor pare. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricţii şi precizări==
 0 < n < 1000
cele n numere citite vor fi mai mici decât 1.000.000
rezultatul va fi punctat dacă diferența dintre cel afișat de program și cel corect este mai mică decât 0.01.
În toate seturile de date de intrare se vor afla şi valori pare.

==Exemplu:==
Intrare
: 5
: 8 7 8 9 10

Ieșire
: Date de intrare valide
: 8.66

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare_date(n, numere):
if n < 1 or n > 999:
return False
for numar in numere:
if numar < 0 or numar > 1_000_000:
return False
return True

def suma_numerelor_pare(numere):
suma = 0
cate_pare = 0
for numar in numere:
if numar % 2 == 0:
suma += numar
cate_pare += 1
return suma, cate_pare

def medie(numere):
suma, cate_pare = suma_numerelor_pare(numere)
medie = suma / cate_pare
print(medie)

if __name__ == '__main__':
n = int(input())
numere = list(map(int, input().split()))
if validare_date(n, numere):
print("Date de intrare valide")
medie(numere)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n, numere) primește un număr n și o listă de numere numere și verifică dacă n se află în intervalul [1, 999] și dacă fiecare număr din numere se încadrează în intervalul [0, 1_000_000]. Dacă una dintre condiții nu este îndeplinită, funcția returnează False. În caz contrar, returnează True.
Funcția suma_numerelor_pare(numere) primește o listă de numere numere și calculează suma tuturor numerelor pare din listă. De asemenea, numără câte numere pare sunt în listă. Pentru fiecare număr din listă, se verifică dacă este par (adică are restul împărțirii la 2 egal cu zero), iar în caz afirmativ, se adaugă la suma și se incrementează un contor. Funcția returnează suma și numărul de numere pare găsite.
Funcția medie(numere) primește o listă de numere numere și calculează media aritmetică a numerelor pare din listă. Se utilizează funcția suma_numerelor_pare() pentru a obține suma și numărul de numere pare, apoi se calculează media împărțind suma la numărul de numere pare. Rezultatul este afișat.
În blocul if __name__ == '__main__':, se citește de la intrare un număr n și o serie de numere separate prin spațiu utilizând funcția input() și split(), și se stochează într-o variabilă numere. Apoi, se verifică dacă valorile citite sunt valide utilizând funcția validare_date(). Dacă valorile sunt valide, se afișează un mesaj de confirmare și se apelează funcția medie() pentru a calcula și afișa media numerelor pare. În caz contrar, se afișează un mesaj de eroare.

0053 - Cate Impare

2023-06-29T18:54:29Z

Paul Ungur:

==Cerinţa==
Se citesc numere de la tastatură până la apariția lui zero. Să se determine câte dintre ele erau impare.

==Date de intrare==
Programul citește de la tastatură numere naturale. Citirea se încheie la introducerea valorii 0.

==Date de ieşire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul afișează pe ecran numărul '''C''', reprezentând numărul de numere impare citite. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricţii şi precizări==
numerele citite aparțin intervalului [0; 1.000.000.000)

==Exemplu:==
Intrare
: 5 6 2 1 0

Ieșire
: Date de intrare valide
: 2

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare_date(numere):
for numar in numere:
if numar < 0 or numar > 1_000_000_000:
return False
return True

def cate_impare(numere):
numere_impare = 0
for numar in numere:
if numar % 2 == 1:
numere_impare += 1
print(numere_impare)

if __name__ == '__main__':
numere = list(map(int, input().split()))
if validare_date(numere):
print("Date de intrare valide")
cate_impare(numere)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(numere) primește o listă de numere și verifică dacă fiecare număr din listă se încadrează în intervalul specificat [0, 1_000_000_000]. Dacă există cel puțin un număr care nu respectă această condiție, funcția returnează False. În caz contrar, returnează True.
Funcția cate_impare(numere) primește o listă de numere și numără câte dintre acestea sunt impare. Se verifică fiecare număr din listă, iar dacă numărul este impar (adică are restul împărțirii la 2 diferit de zero), se incrementează un contor. La final, se afișează numărul de numere impare găsite.
În blocul if __name__ == '__main__':, se citește de la intrare o serie de numere separate prin spațiu utilizând funcția input() și split(), și se stochează într-o listă numită numere. Apoi, se verifică dacă valorile citite sunt valide utilizând funcția validare_date(). Dacă valorile sunt valide, se afișează un mesaj de confirmare și se apelează funcția cate_impare() pentru a număra numerele impare. În caz contrar, se afișează un mesaj de eroare.

3094 - Excursie 0

2023-06-29T18:53:09Z

Paul Ungur:

==Cerința==
Un băiat și tatăl lui se decid să plece într-o excursie prin lume, fiecare de la casa lui pe același traseu. Deoarece nu au reușit să găsească destule zile libere de la serviciu încât să aibă timp să se întâlnească înainte de plecarea programată, se hotărăsc să plece separat și dacă se întâlnesc pe drum consideră excursia un succes. Considerăm traseul excursiei o linie dreaptă cu coordonate unidimensionale reprezentate de numere naturale (0,1,2,3…). Tatăl parcurge exact t km/zi, după care trebuie să înnopteze la o pensiune. Băiatul parcurge exact b km/zi, după care de asemenea trebuie să înnopteze la o pensiune. Tatăl pleacă de la el de acasă(poziția pt), iar fiul pleacă de la casa lui(poziția pb). Amândoi pleacă în aceeași zi, merg în aceeași direcție, iar excursia durează z zile. Pensiunile se află la fiecare coordonată 0, 1, 2, 3, …. Tatăl și băiatul se pot întâlni numai dacă se află la aceeași coordonată în același timp. Se cere să se determine dacă pe parcursul celor z zile ale excursiei, băiatul și tatăl se întâlnesc. Dacă da, se afișează coordonata unde se întâlnesc, altfel se afișează -1.
==Date de intrare==
Programul citește de la tastatură numerele z pb b pt t, separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran coordonata unde se întâlnesc sau -1 dacă nu se întâlnesc. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''
==Restricții și precizări==
1 ≤ z ≤ 30 1 ≤ pb,pt,b,t ≤ 10000
==Exemplu:==
Intrare

: 5 0 3 4 2

Ieșire
: Date de intrare valide
: 12
==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(z, pb, b, pt, t):
if 1 <= z <= 30 and 0 <= pb <= 10_000 and 0 <= b <= 10_000 and 0 <= pt <= 10_000 and 0 <= t <= 10_000:
return True
return False

def excursie(z, pb, b, pt, t, poz):
while z:
if pb == pt and poz == -1:
poz = pb
pb += b
pt += t
z -= 1

if pb == pt and poz == -1:
poz = pb

print(poz)

if __name__ == '__main__':
z, pb, b, pt, t = map(int, input().split())
poz = -1
if validare(z, pb, b, pt, t):
print("Date de intrare valide")
excursie(z, pb, b, pt, t, poz)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare(z, pb, b, pt, t) primește cinci parametri care reprezintă diferite valori. Această funcție verifică dacă toate valorile se încadrează în anumite intervale specifice. Dacă toate valorile sunt în limitele acceptate, funcția returnează True. În caz contrar, returnează False.
Funcția excursie(z, pb, b, pt, t, poz) primește șase parametri și implementează o iterație while pentru a simula o excursie. În fiecare iterație, verifică dacă pb este egal cu pt și dacă poz este -1. Dacă această condiție este îndeplinită, valoarea pb devine valoarea poz. Se adaugă b la pb și t la pt, iar valoarea z este decrementată cu 1. Procesul se repetă până când z devine 0. La sfârșit, se verifică din nou dacă pb este egal cu pt și dacă poz este -1. Dacă această condiție este îndeplinită, valoarea pb devine valoarea poz. La final, se afișează valoarea poz.
În blocul if __name__ == '__main__':, se citește de la intrare valorile z, pb, b, pt, t utilizând funcția map și input(). De asemenea, se inițializează valoarea poz cu -1. Apoi, se verifică dacă valorile citite sunt valide utilizând funcția validare(). Dacă valorile sunt valide, se afișează un mesaj de confirmare și se apelează funcția excursie() pentru a efectua excursia. În caz contrar, se afișează un mesaj de eroare.
Codul prezentat verifică datele de intrare, simulează o excursie și afișează rezultatul în funcție de anumite condiții.

2641 - AF

2023-06-29T18:51:57Z

Paul Ungur:

Sursa: [https://www.pbinfo.ro/probleme/161/inlocuire 0161 - inlocuire]
----
== Cerinţa ==
Gigel are ca temă la matematică să precizeze valoarea de adevăr a unor expresii de forma '''nr1 semn nr2 = nr3''', unde '''nr1''', '''nr2''' și '''nr3''' sunt numere naturale, iar '''semn''' poate fi +, -, x sau : reprezentând adunarea, scăderea, înmulțirea și împărțirea. Ajutați-l pe Gigel să rezolve tema la matematică.
== Date de intrare ==
Fișierul de intrare '''af.in''' conține pe prima linie numărul de expresii '''n''', iar pe următoarele '''n''' linii cele '''n''' expresii. Cele trei numere, semnul operației și egal sunt separate câte un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Datele citite din fisier sunt corecte"''', apoi Fișierul de ieșire '''af.out''' va conține pe fiecare linie valoarea de adevăr ('''Adevarat''' sau '''Fals''') a expresiei corespunzătoare din fișierul de intrare.

== Restricţii şi precizări ==
'''1''' &les; '''n''' &les; '''10''';
'''0''' ≤ '''nr1''', '''nr2''', '''nr3''' și rezultatul operației din membrul stâng ≤ '''1017''';
'''nr1''' ≥ '''nr2''';
rezultatul operației '''nr1 : nr2''' este câtul împărțirii lui '''nr1''' la '''nr2''';
dacă expresia este de forma '''nr1 : 0 = nr3''' atunci este considerată falsă.

== Exemple ==

; af.in
<pre>
4
1 + 1 = 2
3 x 3 = 6
5 - 1 = 4
8 : 2 = 3
</pre>
: Datele citite din fisier sunt corecte
; af.out
<pre>
Adevarat
Fals
Adevarat
Fals
</pre>

 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(expresii):
if len(expresii) > 10:
print("Datele citite din fisier nu sunt corecte")
return False
else:
for expresie in expresii:
expresie = expresie.strip().split()
primul = int(expresie[0])
semn = int(expresie[1])
al_doilea = int(expresie[2])
rezultatul = int(expresie[-1])
if operatie(primul, al_doilea, semn)<= 10**17:
if primul >= al_doilea:
print("Datele citite din fisier sunt corecte")
return True

def citire_expresii():
with open('af.in', 'r') as f:
n = int(f.readline().strip())
expresii = [f.readline().strip() for _ in range(n)]
return expresii

def scriere_rezultat(continut):
with open('af.out', 'a') as f:
if continut:
f.write("Adevarat\n")
else:
f.write("Fals\n")

def operatie(nr1, nr2, semn):
if semn == '+':
return nr1 + nr2
elif semn == '-':
return nr1 - nr2
elif semn == 'x':
return nr1 * nr2
elif semn == ':':
if nr2 == 0:
return False
return nr1 // nr2

if __name__ == '__main__':
expresii = citire_expresii()
for expresie in expresii:
expresie = expresie.strip().split()
nr1 = int(expresie[0])
semn = expresie[1]
nr2 = int(expresie[2])
nr3 = int(expresie[-1])
if semn == '+':
scriere_rezultat(nr1 + nr2 == nr3)
elif semn == '-':
scriere_rezultat(nr1 - nr2 == nr3)
elif semn == 'x':
scriere_rezultat(nr1 * nr2 == nr3)
elif semn == ':':
if nr2 == 0:
scriere_rezultat(False)
else:
scriere_rezultat(nr1 // nr2 == nr3)
else:
scriere_rezultat(False)
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(expresii) primește o listă de expresii și verifică dacă aceasta are mai mult de 10 elemente. Dacă numărul de expresii depășește 10, se afișează un mesaj de eroare și se returnează False. În caz contrar, se parcurge fiecare expresie și se verifică dacă valorile și semnele din expresie respectă anumite condiții. Dacă condițiile sunt îndeplinite, se afișează un mesaj de confirmare și se returnează True.
Funcția citire_expresii() citeste expresiile din fișierul 'af.in'. Prima linie a fișierului reprezintă numărul de expresii, iar următoarele linii conțin expresiile propriu-zise. Expresiile sunt stocate într-o listă și returnate.
Funcția scriere_rezultat(continut) primește un argument continut și scrie rezultatul în fișierul 'af.out'. Dacă continut este adevărat (True), se scrie "Adevarat\n" în fișier. În caz contrar, se scrie "Fals\n".
Funcția operatie(nr1, nr2, semn) primește două numere (nr1 și nr2) și un semn al unei operații matematice. În funcție de semn, se realizează operația corespunzătoare și se returnează rezultatul. Dacă semnul este ':' și nr2 este 0, se returnează False pentru a evita împărțirea la zero.
În blocul if __name__ == '__main__':, se apelează funcția citire_expresii() pentru a obține lista de expresii din fișierul de intrare. Apoi, se parcurge fiecare expresie și se verifică rezultatul evaluării expresiei în funcție de semnul operației. Rezultatele sunt scrise în fișierul de ieșire utilizând funcția scriere_rezultat(continut). Dacă semnul operației nu este recunoscut, se scrie False în fișier.
Codul citeste expresiile din fișierul de intrare, validează datele de intrare, evaluează expresiile și scrie rezultatele în fișierul de ieșire.

0052 - Suma Pare 1

2023-06-29T18:42:24Z

Paul Ungur:

==Cerinţa==
Se citesc numere de la tastatură până la apariția lui zero. Să se determine suma celor pare.

==Date de intrare==
Programul citește de la tastatură numere întregi. Citirea se încheie la introducerea valorii 0.

==Date de ieşire==
Programul afișează pe ecran numărul S, reprezentând suma numerelor pare.
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide"'''

În caz contrar, se va afișa pe ecran: '''"Date de intrare invalide."'''

==Restricţii şi precizări==
numerele citite aparține intervalului (-1.000.000; 1.000.000)
valoarea absolută a sumei nu va depăși 1.000.000.000

==Exemplu:==
Intrare

: 5 6 2 1 0

Ieșire
: Datele de intrare valide.
: 8

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare_date(numere):
for numar in numere:
if numar < -1000000 or numar > 1000000:
return False
return True

def suma_numerelor_pare(numere):
suma = 0
for numar in numere:
if numar % 2 == 0:
suma += numar
print(suma)

if __name__ == '__main__':
numere = list(map(int, input().split()))
if validare_date(numere):
print("Date de intrare valide")
suma_numerelor_pare(numere)
else:
print("Date de intrare invalide")

</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(numere) primește o listă de numere și verifică dacă fiecare număr din listă se încadrează în intervalul specificat [-1000000, 1000000]. Dacă există cel puțin un număr care nu respectă această condiție, funcția returnează False. În caz contrar, returnează True.
Funcția suma_numerelor_pare(numere) primește o listă de numere și calculează suma numerelor pare din acea listă. Se verifică fiecare număr din listă, iar dacă numărul este par (adică împărțit exact la 2), se adaugă la suma totală. La final, suma este afișată.
În blocul if __name__ == '__main__':, se citește de la intrare o serie de numere separate prin spațiu utilizând funcția input() și split(), și se stochează într-o listă numită numere. Apoi, se verifică dacă valorile citite sunt valide utilizând funcția validare_date(). Dacă valorile sunt valide, se afișează un mesaj de confirmare și se apelează funcția suma_numerelor_pare() pentru a calcula suma numerelor pare. În caz contrar, se afișează un mesaj de eroare.

2911 - Write Digits

2023-06-29T18:37:16Z

Paul Ungur:

Sursa: [https://www.pbinfo.ro/probleme/4294/perechin 4294 - Perechi N]
----
== Cerinţa ==
Se dă un număr natural '''n'''. Să se afișeze fiecare cifră a numărului folosind simbolul @, ca în exemplu.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi Programul va afișa pe ecran fiecare cifră a numărului citit scrisă. După fiecare cifră se va lăsa un rând gol. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''
== Restricţii şi precizări ==
1 ≤ n ≤ 1010

== Exemplu ==
; Intrare
: 1234567890
; Ieșire
: Date de intrare valide
<pre>
@
@@
@
@
@@@@@

@@@@
@ @
@
@
@@@@

@@@@@
@
@@@@@
@
@@@@@

@ @
@ @
@@@@@
@
@

@@@@@
@
@@@@@
@
@@@@@

@@@@@
@
@@@@@
@ @
@@@@@

@@@@
@
@@@
@
@

@@@@@
@ @
@@@@@
@ @
@@@@@

@@@@@
@ @
@@@@@
@
@

@@@@@
@ @
@ @
@ @
@@@@@
</pre>

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 2911- WriteDigits

def afisare_cifra(cifra: int) -> None:
if cifra == 0:
print("@@@@@")
print("@ @")
print("@ @")
print("@ @")
print("@@@@@")
print('\n')
elif cifra == 1:
print(" @")
print(" @@")
print(" @")
print(" @")
print("@@@@@")
print('\n')
elif cifra == 2:
print("@@@@")
print(" @")
print("@@@@")
print("@")
print("@@@@@")
print('\n')
elif cifra == 3:
print("@@@@")
print(" @")
print("@@@@")
print(" @")
print("@@@@")
print('\n')
elif cifra == 4:
print("@ @")
print("@ @")
print("@@@@@")
print(" @")
print(" @")
print('\n')
elif cifra == 5:
print("@@@@@")
print("@")
print("@@@@@")
print(" @")
print("@@@@@")
print('\n')
elif cifra == 6:
print("@@@@@")
print("@")
print("@@@@@")
print("@ @")
print("@@@@@")
print('\n')
elif cifra == 7:
print("@@@@@")
print(" @")
print(" @")
print(" @")
print(" @")
print('\n')
elif cifra == 8:
print("@@@@@")
print("@ @")
print("@@@@@")
print("@ @")
print("@@@@@")
print('\n')
elif cifra == 9:
print("@@@@@")
print("@ @")
print("@@@@@")
print(" @")
print(" @")
print('\n')

def validare_date_numar(numar: str) -> bool:
if numar.isdigit():
if int(numar) > 10 ** 10:
return False
return True
return False

if __name__ == "__main__":
n = input()
if validare_date_numar(n):
print("Datele de intrare corespund restricțiilor impuse.")
for digit in n:
afisare_cifra(int(digit))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație rezolvare==
<pre>
Acest cod Python are două funcții. Funcția afisare_cifra primește o cifră între 0 și 9 și afișează modelul corespunzător acelei cifre folosind caractere speciale. Funcția validare_date_numar primește un șir de caractere și verifică dacă acesta conține doar cifre și dacă numărul reprezentat de aceste cifre este mai mic sau egal cu 10^10. Dacă numărul este valid, funcția returnează True, altfel returnează False.

În funcția principală, programul citește un număr de la intrare și verifică dacă acesta este un număr valid folosind funcția validare_date_numar. Dacă numărul este valid, programul afișează un mesaj corespunzător și apoi afișează fiecare cifră din număr folosind funcția afisare_cifra. Dacă numărul nu este valid, programul afișează un mesaj corespunzător.

În general, acest program poate fi folosit pentru a afișa cifrele sub forma unui model special și pentru a valida datele de intrare pentru a evita erorile.
</pre>

3829 - Octogon

2023-06-29T18:36:25Z

Paul Ungur:

==Cerința==
Să se afișeze un octogon de latură n umplut cu caractere * iar spațiul spațiul exterior umplut cu #, ca în exemplu.

==Date de intrare==
Programul citește de la tastatură numărul n.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa octogonul cerut. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
 2 ≤ n ≤ 40

==Exemplu:==
Intrare

: 5

Ieșire
: Date de intrare valide

<nowiki>####*****####</nowiki>

<nowiki>###*******###</nowiki>

<nowiki>##*********##</nowiki>

<nowiki>#***********#</nowiki>

<nowiki>*************</nowiki>

<nowiki>*************</nowiki>

<nowiki>*************</nowiki>

<nowiki>*************</nowiki>

<nowiki>*************</nowiki>

<nowiki>#***********#</nowiki>

<nowiki>##*********##</nowiki>

<nowiki>###*******###</nowiki>

<nowiki>####*****####</nowiki>
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n):
if n < 2 or n > 40:
print("Numarul introdus nu este valid!")
return False
return True

def afisare_octogon(n):
for j in range(n - 1):
# scriem primele j+1 caractere #
for i in range(j + 1, n):
print('#', end='')
# scriem urmatoarele j2+n caractere *
for i in range(j * 2 + n):
print('*', end='')
# scriem ultimele j+1 caractere #
for i in range(j + 1, n):
print('#', end='')
# trecem la linia urmatoare
print()

for i in range(n):
for j in range(n * 3 - 2):
print('*', end='')
print()

for j in range(n - 1):
# scriem primele n-j-1 caractere #
for i in range(n - j - 1, n):
print('#', end='')
# scriem urmatoarele (n-j-1)*2+n-2 caractere *
for i in range((n - j - 1) * 2 + n - 2):
print('*', end='')
# scriem ultimele n-j-1 caractere #
for i in range(n - j - 1, n):
print('#', end='')
# trecem la linia urmatoare
print()

if __name__ == "__main__":
n = int(input("Introduceti numarul n: "))
if validare(n):
print("Date de intrare valide")
afisare_octogon(n)
else:
print("Date de intrare invalide")

</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n) verifică dacă numărul n se află în intervalul [2, 40]. Dacă n este în afara acestui interval, se afișează mesajul "Numărul introdus nu este valid!" și se returnează False. În caz contrar, se returnează True.
Funcția afisare_octogon(n) afișează octogonul folosind caracterele '#' și ''. Pentru prima jumătate a octogonului, se parcurge un loop pentru variabila j de la 0 la n - 2. În fiecare iterație, se afișează primele j + 1 caractere '#' (n - j - 1 spații și j + 1 caractere '#'), apoi se afișează următoarele j * 2 + n caractere '', iar apoi se afișează ultimele j + 1 caractere '#' (n - j - 1 spații și j + 1 caractere '#'). După fiecare linie, se afișează un rând gol cu print().
După afișarea primei jumătăți a octogonului, se afișează linia centrală formată din n * 3 - 2 caractere ''. Apoi, se afișează a doua jumătate a octogonului utilizând aceeași logică ca în prima jumătate, dar în ordine inversă. Se parcurge un loop pentru variabila j de la 0 la n - 2, se afișează primele n - j - 1 caractere '#' (n - j - 1 spații și j + 1 caractere '#'), apoi se afișează următoarele (n - j - 1) * 2 + n - 2 caractere '', iar apoi se afișează ultimele n - j - 1 caractere '#' (n - j - 1 spații și j + 1 caractere '#'). După fiecare linie, se afișează un rând gol cu print().
În blocul if __name__ == "__main__":, se citește numărul n de la utilizator folosind funcția input() și int(input()). Apoi, se validează numărul utilizând funcția validare(n). Dacă numărul este valid, se afișează mesajul "Date de intrare valide" și se apelează funcția afisare_octogon(n) pentru a afișa octogonul. Dacă numărul nu este valid, se afișează mesajul "Date de intrare invalide".

3804 - Raza Cerc Inscris

2023-06-29T18:35:26Z

Paul Ungur:

==Cerința==
Se dau lungimile laturilor unui triunghi. Aflați raza cercului înscris triunghiului.

==Date de intrare==
Programul citește de la tastatură numerele a, b, c, reprezentand lungimile laturilor triunghiului.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran numărul r, reprezentând lungimea razei cercului înscris cu 2 zecimale exacte, daca triunghiul este valid, altfel se va afisa mesajul Imposibil. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
 1 ≤ a, b, c ≤ 1000

==Exemplul 1:==

Intrare
: 3 4 5

Ieșire
: Date de intrare valide
: 1.00

==Exemplul 2:==

Intrare

: 4 5 10

Ieșire
: Date de intrare invalide
: Imposibil

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

def validare(a, b, c):
flag = True
if not (a + b > c and b + c > a and c + a > b):
flag = False
return flag

def rezolvare(a, b, c):
p = (a + b + c) / 2
raza = math.sqrt(((p - a) * (p - b) * (p - c)) / p)
print("{:.2f}".format(raza))

if __name__ == '__main__':
a, b, c = map(int, input("Introduceți laturile triunghiului (separate prin spații): ").split())
if validare(a, b, c):
rezolvare(a, b, c)
print("Posibil")
else:
print("Imposibil")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare(a, b, c) verifică dacă laturile a, b și c pot forma un triunghi valid. Aceasta se realizează prin verificarea inegalității triunghiului, care afirmă că suma oricăror două laturi trebuie să fie mai mare decât lungimea celei de-a treia laturi. Dacă această condiție este îndeplinită, funcția returnează True. În caz contrar, se returnează False.
Funcția rezolvare(a, b, c) calculează raza cercului circumscris triunghiului utilizând formula razei circumscrisului unui triunghi dreptunghic. În primul rând, se calculează semiperimetrul triunghiului folosind formula (a + b + c) / 2. Apoi, se calculează raza circumscrisului utilizând formula raza = sqrt(((p - a) * (p - b) * (p - c)) / p), unde p este semiperimetrul. Rezultatul este afișat cu două zecimale folosind formatarea de string "{:.2f}".
În blocul if __name__ == '__main__':, se citesc laturile a, b și c ale triunghiului de la utilizator folosind funcția input() și map(int, input().split()). Apoi, se validează laturile utilizând funcția validare(a, b, c). Dacă laturile formează un triunghi valid, se apelează funcția rezolvare(a, b, c) pentru a calcula și afișa raza cercului circumscris. Dacă laturile nu formează un triunghi valid, se afișează mesajul "Imposibil".

1405 - Desen Romb 2

2023-06-29T18:34:04Z

Paul Ungur:

==Cerința==
Se dă n un număr natural. Să se afișeze un romb de latură n umplut cu caractere * iar spațiul spațiul exterior umplut cu #, ca în exemplu.

==Date de intrare==
Programul citește de la tastatură numărul n.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran rombul cerut. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
 1 ≤ n ≤ 10

==Exemplu:==
Intrare

: 5

Ieșire

: Date de intrare valide
<nowiki>####*####</nowiki>

<nowiki>###***###</nowiki>

<nowiki>##*****##</nowiki>

<nowiki>#*******#</nowiki>

<nowiki>*********</nowiki>

<nowiki>#*******#</nowiki>

<nowiki>##*****##</nowiki>

<nowiki>###***###</nowiki>

<nowiki>####*####</nowiki>

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n):
if not isinstance(n, int) or n < 1 or n > 10:
print("n trebuie sa fie un numar natural cu o cifra (1-10)")
return False
return True

def rezolvare(n):
# prima jumatate
for i in range(1, n + 1):
# scriu n - i caractere #
for j in range(n - i):
print('#', end='')

# scriu 2 * i - 1 carcatere *
for j in range(2 * i - 1):
print('*', end='')

# scriu n - i carcatere #
for j in range(n - i):
print('#', end='')

print() # coboram pe linia urmatoare

# a doua jumatate
for i in range(1, n):
# scriu i caractere #
for j in range(i):
print('#', end='')

# scriu 2 * n - 1 - 2 * i carcatere *
for j in range(2 * n - 1 - 2 * i):
print('*', end='')

# scriu i carctere #
for j in range(i):
print('#', end='')

print()

if __name__ == '__main__':
n = int(input("Introduceti un numar natural intre 1 si 10: "))
if validare(n):
print("Date de intrare valide")
rezolvare(n)
</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n) verifică dacă valoarea n este un număr natural cu o singură cifră, adică între 1 și 10. Dacă valoarea n respectă această restricție, funcția returnează True. În caz contrar, se afișează un mesaj de eroare și funcția returnează False.
Funcția rezolvare(n) construiește și afișează piramida formată din caractere # și * folosind două bucle for. Prima buclă for parcurge de la 1 până la n și afișează rândurile superioare ale piramidei. Pe fiecare rând, se afișează un număr specific de caractere #, urmat de o secvență de caractere *, apoi din nou un număr de caractere #. A doua buclă for afișează partea inferioară a piramidei, inversând procesul pentru caracterele #, * și din nou #.
În blocul if __name__ == '__main__':, se citește valoarea n de la utilizator folosind funcția input() și se validează această valoare utilizând funcția validare(n). Dacă valoarea introdusă este validă, se afișează un mesaj de confirmare și se apelează funcția rezolvare(n) pentru a afișa piramida corespunzătoare. Dacă valoarea introdusă nu este validă, se afișează un mesaj de eroare.

1393 - Desen Romb

2023-06-29T18:33:13Z

Paul Ungur:

==Cerința==
Se citește un număr natural n cu o cifră. Afișați pe ecran o figură sub forma de romb formata cu numerele naturale de la 1 la n, ca în exemplu.

==Date de intrare==
Programul citește de la tastatură numărul n.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran un romb ce conține numerele naturale de la 1 la n În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
1 ≤n ≤9

==Exemplu:==
Intrare
: 5

Ieșire
: Date de intrare valide
1
222
33333
4444444
555555555
4444444
33333
222
1

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n):
if not isinstance(n, int) or n < 1 or n > 9:
print("n trebuie sa fie un numar natural cu o cifra (1-9)")
return False
return True

def rezolvare(n):
for i in range(1, n + 1):
# pe linia i scriu n - i spatii
for j in range(1, n - i + 1):
print(' ', end='')

# mai scriu 2 * i - 1 valori de i
for j in range(1, 2 * i):
print(i, end='')
print()

for i in range(1, n):
# scriem i spatii pe linia i
for j in range(1, i + 1):
print(' ', end='')

for j in range(1, 2 * (n - i)):
print(n - i, end='')
print()

if __name__ == '__main__':
n = int(input("Introduceti un numar natural cu o cifra: "))
if validare(n):
print("Date de intrare valide")
rezolvare(n)

</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n) verifică dacă valoarea n este un număr natural cu o singură cifră, adică între 1 și 9. Dacă valoarea n respectă această restricție, funcția returnează True. În caz contrar, se afișează un mesaj de eroare și funcția returnează False.
Funcția rezolvare(n) construiește și afișează piramida numerică specială folosind două bucle for. Prima buclă for parcurge de la 1 până la n și afișează rândurile piramidei. Pe fiecare rând, se afișează un număr specific de spații, urmat de o secvență de cifre consecutive până la valoarea i. A doua buclă for afișează partea inferioară a piramidei, inversând procesul pentru spații și cifre.
În blocul if __name__ == '__main__':, se citește valoarea n de la utilizator folosind funcția input() și se validează această valoare utilizând funcția validare(n). Dacă valoarea introdusă este validă, se afișează un mesaj de confirmare și se apelează funcția rezolvare(n) pentru a afișa piramida numerică corespunzătoare. Dacă valoarea introdusă nu este validă, se afișează un mesaj de eroare.

1564 - Triunghi Dublu

2023-06-29T18:32:23Z

Paul Ungur:

==Cerința==
Se dă un număr n. Afișați figura din exemplu.

==Date de intrare==
Programul citește de la tastatură numărul n.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran figura. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
1 ≤ n ≤ 10

==Exemplu:==
Intrare

: 5

Ieșire
: Date de intrare valide
<nowiki>*</nowiki>

<nowiki>**</nowiki>

<nowiki>***</nowiki>

<nowiki>****</nowiki>

<nowiki>*****</nowiki>

<nowiki>*</nowiki>

<nowiki>**</nowiki>

<nowiki>***</nowiki>

<nowiki>****</nowiki>

<nowiki>*****</nowiki>

==Explicație==
S-au afișat 2 triunghiuri, formate din 15 steluțe fiecare.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n):
if 1 <= n <= 10:
return True
else:
return False

def afisare_triunghi(n):
for i in range(1, n + 1):
for j in range(1, i + 1):
print('*', end='')
print()

for i in range(1, n + 1):
for j in range(1, 2 * n + 1):
if j >= n + i:
print('*', end='')
else:
print(' ', end='')
print()

if __name__ == '__main__':
n = int(input("Introduceti un numar: "))
if validare(n):
print("Date de intrare valide")
afisare_triunghi(n)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n) verifică dacă valoarea n se află în intervalul [1, 10]. Dacă valoarea n respectă restricțiile, funcția returnează True. În caz contrar, returnează False.
Funcția afisare_triunghi(n) afișează triunghiul format din caractere "" utilizând două bucle for. Prima buclă for parcurge de la 1 până la n și afișează un triunghi format din "". A doua buclă for parcurge de la 1 până la n și afișează restul triunghiului prin afișarea spațiilor și a "*" în funcție de poziția celulei.
În blocul if __name__ == '__main__':, se citște valoarea n de la utilizator folosind funcția input() și se validează această valoare utilizând funcția validare(n). Dacă valoarea introdusă este validă, se afișează un mesaj de confirmare și se apelează funcția afisare_triunghi(n) pentru a afișa triunghiul corespunzător. Dacă valoarea introdusă nu este validă, se afișează un mesaj de eroare.

2574 - Val 1

2023-06-29T18:31:34Z

Paul Ungur:

==Cerința==
Se citeste n și m. Să se reprezinte următoarea diagramă în funcție de n și m, în care n reprezintă înălțimea, iar m numărul de valuri care compun diagrama. Diagrama este formată din caractere 0, interiorul și exteriorul valurilor sunt alcătuite din caractere _.

==Date de intrare==
Programul citește numerele n m.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa o diagrama cerută. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
1 ≤ n ≤ m ≤ 20

==Exemplul 1:==
Intrare
: 5 4

Ieșire
: Date de intrare valide

__0_0_____0_0_____0_0_____0_0___

_0___0___0___0___0___0___0___0__

_0___0___0___0___0___0___0___0__

_0___0___0___0___0___0___0___0__

0_____0_0_____0_0_____0_0_____0_

Exemplul 2:

Intrare

6 8

Ieșire

__0_0_____0_0_____0_0_____0_0_____0_0_____0_0_____0_0_____0_0___

_0___0___0___0___0___0___0___0___0___0___0___0___0___0___0___0__

_0___0___0___0___0___0___0___0___0___0___0___0___0___0___0___0__

_0___0___0___0___0___0___0___0___0___0___0___0___0___0___0___0__

_0___0___0___0___0___0___0___0___0___0___0___0___0___0___0___0__

0_____0_0_____0_0_____0_0_____0_0_____0_0_____0_0_____0_0_____0_

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n, m):
"""
Functie care verifica daca valorile citite pentru n si m respecta restrictiile problemei.
"""
if not (1 <= n <= 20 and 1 <= m <= 20):
print("Date de intrare incorecte!")
exit()

def rezolvare(n, m):
"""
Functie care construieste si afiseaza figura ceruta in functie de valorile lui n si m.
"""
# initializam matricea cu caractere "_"
for j in range(1, n + 1):
for i in range(1, 8 * m + 1):
if j == 1:
if i % 8 == 3 or i % 8 == 5:
print('0', end='')
else:
print('_', end='')
elif j == n:
if i % 8 == 1 or i % 8 == 7:
print('0', end='')
else:
print('_', end='')
else:
if i % 8 == 2 or i % 8 == 6:
print('0', end='')
else:
print('_', end='')
print()

if __name__ == "__main__":
# citim valorile n si m
n, m = map(int, input().split())
# validam datele de intrare
if validare(n, m):
print("Date de intrare valide")
# rezolvam problema si afisam rezultatul
rezolvare(n, m)

</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n, m) verifică dacă valorile n și m respectă restricțiile problemei. Verifică dacă n și m se află în intervalul [1, 20]. Dacă valorile nu respectă restricțiile, se afișează un mesaj de eroare și programul se încheie folosind funcția exit().
Funcția rezolvare(n, m) construiește și afișează figura cerută în funcție de valorile n și m. Folosind două bucle for, se parcurg rândurile și coloanele figurii. Fiecare celulă a figurii este afișată ca un caracter "_" sau "0" în funcție de poziția sa în figură.
În blocul if __name__ == "__main__":, se citesc valorile n și m de la utilizator folosind funcția input() și se validează aceste date utilizând funcția validare(n, m). Dacă valorile introduse sunt valide, se afișează un mesaj de confirmare și se apelează funcția rezolvare(n, m) pentru a construi și afișa figura. Dacă valorile introduse nu sunt valide, se afișează un mesaj de eroare.

1569 - Scara Numerelor

2023-06-29T18:30:34Z

Paul Ungur:

==Cerința==
Se citește un număr natural n</span.. Să se afișeze o figură similară cu cea din exemplu.

==Date de intrare==
Programul citește de la tastatură numărul n.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa figura, similar cu exemplul. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
1 ≤ n ≤ 9

==Exemplu:==
Intrare

: 3

Ieșire
: Date de intrare valide
: 1

: 22

: 22

: 333

: 333

: 333

==Explicație==
Cifra 1 s-a afisat o singura data, pe un singur rand. Cifra 2 s-a afista de 2 ori, pe 2 randuri. Cifra 3 s-a afisat de 3 ori, pe 3 randuri.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n):
"""
Verifică dacă numărul n este între 1 și 9.
"""
if 1 <= n <= 9:
return True
else:
print("Numărul trebuie să fie între 1 și 9.")
return False

def print_figure(n):
"""
Afișează cifrele de la 1 la n pe câte n rânduri.
"""
for i in range(1, n + 1):
for j in range(1, i + 1):
for k in range(1, i + 1):
print(i, end='')
print()

if __name__ == "__main__":
n = int(input("Introduceți un număr natural n: "))
if validare_date(n):
print("Date de intrare valide")
print_figure(n)
else:
print("Date de intrare invalide")

</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n) verifică dacă valoarea n este un număr valid pentru a rezolva problema dată. Verifică dacă n se află în intervalul [1, 9]. Dacă este în intervalul valid, funcția returnează True. În caz contrar, se afișează un mesaj de eroare și funcția returnează False.
Funcția print_figure(n) rezolvă problema și afișează cifrele de la 1 la n într-un model specific. Funcția utilizează trei bucle for pentru a controla afișarea în modelul dorit. Cu fiecare iterație, se afișează rândul respectiv de cifre. La fiecare iterație a celei de-a doua bucle for, se afișează valoarea cifrei i de i ori, iar la fiecare iterație a celei de-a treia bucle for, se afișează numărul i pe un rând nou.
În blocul if __name__ == "__main__":, se citește valoarea n de la utilizator utilizând funcția input() și se verifică dacă valoarea introdusă este validă utilizând funcția validare_date(n). Dacă nu este validă, se afișează un mesaj de eroare și se cere introducerea unei valori valide. Dacă valoarea introdusă este validă, se apelează funcția print_figure(n) pentru a rezolva problema și a afișa cifrele în modelul specific.

1630 - Morisca

2023-06-29T18:29:21Z

Paul Ungur:

==Cerința==
Se dă un număr n. Afișați figura din exemplu.

==Date de intrare==
Programul citește de la tastatură numărul n.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran figura. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
1 ≤ n ≤ 10

==Exemplu:==
Intrare

: 4

Ieșire
: Date de intrare valide
<nowiki>*</nowiki> *
<nowiki>**</nowiki> **
<nowiki>***</nowiki> ***
<nowiki>****</nowiki> ****
<nowiki/>****
<nowiki/>****
<nowiki/>****
<nowiki/>****
<nowiki>****</nowiki> ****
<nowiki>***</nowiki> ***
<nowiki>**</nowiki> **
<nowiki>*</nowiki> *
==Explicație==
S-au afișat 4 triunghiuri și un pătrat, figuri formate din caracterul steluță.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n):
if n < 1 or n > 10:
print("Valoarea introdusa pentru n este incorecta!")
return False
return True

def rezolvare(n):
# Prima parte a figurii
for i in range(1, n + 1):
for j in range(1, i + 1):
print('*', end='')
for k in range(1, n * 3 - i * 2 + 1):
print(' ', end='')
for f in range(1, i + 1):
print('*', end='')
print()

# A doua parte a figurii
for i in range(1, n + 1):
for j in range(1, n + 1):
print(' ', end='')
for k in range(1, n + 1):
print('*', end='')
print()

# A treia parte a figurii
for i in range(n, 0, -1):
for j in range(1, i + 1):
print('*', end='')
for k in range(1, n * 3 - i * 2 + 1):
print(' ', end='')
for f in range(1, i + 1):
print('*', end='')
print()

if __name__ == '__main__':
n = int(input("Introduceti valoarea pentru n: "))
if validare(n):
print("Date de intrare valide")
rezolvare(n)
</syntaxhighlight>
==Explicatie cod:==
Funcția validare(n) verifică dacă valoarea n este un număr valid pentru a rezolva problema dată. Verifică dacă n este mai mic decât 1 sau mai mare decât 10. Dacă nu este valid, se afișează un mesaj de eroare și funcția returnează False. În caz contrar, funcția returnează True.
Funcția rezolvare(n) rezolvă problema și afișează figura compusă din caracterele * și spații. Aceasta constă în trei părți distincte:
Prima parte a figurii: Afișează o secțiune în formă de triunghi în care linia i are i caractere *, urmate de spații și apoi încă i caractere *.
A doua parte a figurii: Afișează o secțiune de n linii, fiecare linie conținând n caractere *. Aceasta reprezintă o secțiune cu spații goale între cele două părți ale figurii.
A treia parte a figurii: Afișează o secțiune similară primei părți a figurii, dar inversată, astfel încât linia i are i caractere * la început, urmate de spații și apoi încă i caractere *.
În blocul if __name__ == '__main__':, se citește valoarea n de la utilizator utilizând funcția input() și se verifică dacă valoarea introdusă este validă utilizând funcția validare(n). Dacă nu este validă, se afișează un mesaj de eroare și se cere introducerea unei valori valide. Dacă valoarea introdusă este validă, se apelează funcția rezolvare(n) pentru a rezolva problema și a afișa figura compusă.

1376 - Laturi Triunghi

2023-06-29T18:25:10Z

Paul Ungur:

==Cerința==
Se dă n. Afișați un triunghi cu latura de n steluțe gol înăuntru.

==Date de intrare==
Se va citi de la tastatură numărul n.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi se va afișa triunghiul cerut. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
 1 ≤ n ≤ 10

==Exemplu:==
Intrare

: 5
Ieșire
: Date de intrare valide
*
* *
* *
* *
* * * * *

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n):
if not n.isdigit():
return False
n = int(n)
if n < 1 or n > 10:
return False
return True

def afisare_triunghi(n):
margine = '*'
liber = ' '
start = 2
baza = 4
for temp in range(start, n + 1):
for temp2 in range(0, n - temp + 1):
print(liber, end="")
if temp > start:
print(margine + " ", end="")
for temp3 in range(baza, temp + 1):
print(liber + " ", end="")
print(margine + " ")
for temp4 in range(baza, n + baza):
print(margine + " ", end="")
print()

if __name__ == '__main__':
n = input("Introduceti numarul n: ")
while not validare_date(n):
n = input("Valoarea introdusa nu este valida. Introduceti un numar intre 1 si 10: ")
if validare_date(n):
print("Date de intrare valide")
n = int(n)
afisare_triunghi(n)
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n) verifică dacă valoarea n este un număr valid pentru a rezolva problema dată. Verifică dacă n este un șir de caractere numeric (isdigit()) și apoi îl converteste într-un număr întreg (int(n)). Dacă n nu este un număr întreg sau dacă este mai mic decât 1 sau mai mare decât 10, funcția returnează False. În caz contrar, returnează True.
Funcția afisare_triunghi(n) rezolvă problema dată și afișează un triunghi cu lățimea n. Folosește variabilele margine, liber, start și baza pentru a defini caracterele utilizate pentru afișare. Utilizează două bucle for pentru a itera prin rândurile triunghiului. În interiorul acestor bucle, utilizează alte bucle pentru a afișa caracterele corespunzătoare în fiecare rând. La final, afișează baza triunghiului prin repetarea caracterului margine de n+baza ori.
În blocul if __name__ == '__main__':, se citește input-ul de la utilizator utilizând funcția input(). Se verifică dacă valoarea introdusă este validă utilizând funcția validare_date(n). Dacă nu este validă, se afișează un mesaj de eroare și se cere introducerea unei valori valide. Dacă valoarea introdusă este validă, se apelează funcția afisare_triunghi(n) pentru a rezolva problema și a afișa triunghiul.

2699 - Puterile Lui N

2023-06-29T18:24:08Z

Paul Ungur:

==Date de intrare==
Programul citește de la tastatură numerele n, și p, separate prin spații.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran în ordine crescătoare, toate puterile lui n mai mici sau egale cu p, separate prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

== Restricții și precizări ==
2 ≤ n ≤ 10
1 ≤ p ≤ 1.000.000.000.000

== Exemplu: ==
Intrare

: 4 120
Ieșire
: Date de intrare valide
: 1 4 16 64

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n: int, p: int) -> bool:
"""
Functia de validare pentru input.
Verifica daca n este intre 2 si 10 si daca p este intre 1 si 1.000.000.000.000.
"""
if not (2 <= n <= 10):
print("n trebuie sa fie intre 2 si 10.")
return False
if not (1 <= p <= 10**12):
print("p trebuie sa fie intre 1 si 1.000.000.000.000.")
return False
return True

def puterea_lui_n(n: int, p: int):
"""
Functia de rezolvare pentru exercitiul dat.
Returneaza un string cu toate puterile lui n mai mici sau egale cu p, separate prin exact un spatiu.
"""
puteri = []
i = 0
while n ** i <= p:
puteri.append(n ** i)
i += 1
print(' '.join(map(str, puteri)))

if __name__ == '__main__':
"""
Functia if __name__ care citeste datele de intrare, verifica validitatea lor si afiseaza rezultatul.
"""
n, p = map(int, input().split())
if validare_date(n, p):
print("Date de intrare valide")
puterea_lui_n(n, p)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n, p) verifică dacă valorile n și p sunt valide pentru a rezolva problema dată. Verifică dacă n este între 2 și 10, iar p este între 1 și 1.000.000.000.000. Dacă nu se îndeplinesc aceste condiții, returnează False. Altfel, returnează True.
Funcția puterea_lui_n(n, p) rezolvă problema dată. Utilizează o buclă while pentru a genera puterile lui n mai mici sau egale cu p. Adaugă fiecare putere la lista puteri și crește exponentul i cu 1 la fiecare iterație. La final, afișează elementele listei puteri, separate printr-un singur spațiu, utilizând funcția join() și funcția print().
În blocul if __name__ == '__main__':, se citește input-ul de la utilizator utilizând funcția input(). Valorile citite sunt convertite în numere întregi utilizând funcția map(int, input().split()). Se verifică dacă valorile introduse sunt valide utilizând funcția validare_date(n, p). Dacă nu sunt valide, se afișează mesajul "Date de intrare invalide". Dacă valorile introduse sunt valide, se apelează funcția puterea_lui_n(n, p) pentru a rezolva problema și a afișa rezultatul.

0458 - Patrat 1

2023-06-29T18:22:00Z

Paul Ungur:

==Cerinţa:==
Se citește numărul natural impar n, şi două caractere c şi d. Să se afișeze următorul pătrat, format din n linii şi n coloane, în care cele două caractere alternează:

cdc...dc
dcd...cd
....
dcd...cd
cdc...dc

==Date de intrare:==
Programul citește de la tastatură numărul n şi caracterele c d .

==Date de ieşire:==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul afișează pe ecran pătratul descris mai sus. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricţii şi precizări==
1 ≤ n ≤ 19
c şi d sunt caractere cu codul ASCII cuprins între 33 şi 126, inclusiv.

==Exemplu:==
Intrare
: 5 * #

Ieșire
: Date de intrare valide
<nowiki>*#*#*</nowiki>
<nowiki>#*#*#</nowiki>
<nowiki>*#*#*</nowiki>
<nowiki>#*#*#</nowiki>
<nowiki>*#*#*</nowiki>

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n, c, d):
if n % 2 == 0 or not (33 <= ord(c) <= 126) or not (33 <= ord(d) <= 126):
return False
return True

def construire_matrice(n, c, d):
matrice = []
for i in range(n):
rand = []
for j in range(n):
if (i + j) % 2 == 0:
rand.append(c)
else:
rand.append(d)
matrice.append(rand)
return matrice

def print_matrix(matrice):
for rand in matrice:
print("".join(rand))

if __name__ == '__main__':
n = int(input("Introduceti numarul de linii si coloane (impar): "))
c = input("Introduceti primul caracter: ")
d = input("Introduceti al doilea caracter: ")
if validare_date(n, c, d):
print("Date de intrare valide")
matrice = construire_matrice(n, c, d)
print_matrix(matrice)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n, c, d) verifică dacă valorile n, c și d sunt valide pentru a construi o matrice. Verifică dacă n este un număr impar, și dacă caracterele c și d au coduri ASCII între 33 și 126. Dacă nu se îndeplinesc aceste condiții, returnează False. Altfel, returnează True.
Funcția construire_matrice(n, c, d) construiește o matrice cu n linii și coloane utilizând caracterele c și d. Folosește două bucle for pentru a itera prin rânduri și coloane. Pentru fiecare element al matricei, determină suma i + j a coordonatelor rândului și coloanei. Dacă suma este un număr par, se adaugă caracterul c în matrice, altfel se adaugă caracterul d. Matricea rezultată este returnată.
Funcția print_matrix(matrice) afișează conținutul matricei pe ecran. Folosește o buclă for pentru a itera prin rândurile matricei. Pentru fiecare rând, concatenează elementele și le afișează pe aceeași linie.
În blocul if __name__ == '__main__':, se solicită utilizatorului să introducă numărul impar n, primul caracter c și al doilea caracter d. Se verifică dacă valorile introduse sunt valide utilizând funcția validare_date(n, c, d). Dacă nu sunt valide, se afișează mesajul "Date de intrare invalide". Dacă valorile introduse sunt valide, se apelează funcția construire_matrice(n, c, d) pentru a construi matricea și se apelează funcția print_matrix(matrice) pentru a o afișa.

0457 - Patrat

2023-06-29T18:20:58Z

Paul Ungur:

==Cerinţa:==
Se citește numărul natural n, şi două caractere c şi d. Să se afișeze următorul pătrat, format din n linii şi n coloane:
ccc...cc
cdd...dc
....
cdd...dc
ccc...cc

==Date de intrare:==
Programul citește de la tastatură numărul n şi caracterele c d .

==Date de ieşire:==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul afișează pe ecran pătratul descris mai sus. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricţii şi precizări:==
3 ≤ n ≤ 20
c şi d sunt caractere cu codul ASCII cuprins între 33 şi 126, inclusiv.

==Exemplu:==
Intrare

: 4 * #

Ieșire
: Date de intrare valide
<nowiki>****</nowiki> *##* *##* ****
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n: int, c: str, d: str) -> bool:
if n < 3 or n > 20:
print("n trebuie sa fie intre 3 si 20")
return False
if not (33 <= ord(c) <= 126) or not (33 <= ord(d) <= 126):
print("c si d trebuie sa fie caractere cu codul ASCII cuprins intre 33 si 126, inclusiv")
return False
return True

def construire_patrat(n: int, c: str, d: str) -> str:
patrat = ""
for i in range(n):
if i == 0 or i == n - 1:
row = c * n
else:
row = c + d * (n - 2) + c
patrat += row + "\n"
return patrat

def afisare_patrat(patrat):
print(patrat.strip())

if __name__ == "__main__":
n = int(input("Introduceti numarul n: "))
c = input("Introduceti caracterul c: ")
d = input("Introduceti caracterul d: ")
if validare_date(n, c, d):
print("Date de intrare valide")
patrat = construire_patrat(n, c, d)
afisare_patrat(patrat)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n, c, d) verifică dacă valorile n, c și d sunt valide pentru a construi un pătrat. Verifică dacă n se încadrează în intervalul [3, 20] și dacă caracterele c și d au coduri ASCII între 33 și 126. Dacă nu se îndeplinesc aceste condiții, afișează mesajele corespunzătoare și returnează False. Altfel, returnează True.
Funcția construire_patrat(n, c, d) construiește un șir de caractere care reprezintă un pătrat utilizând numărul n și caracterele c și d. Folosește o buclă for pentru a itera prin rândurile pătratului. Pentru rândurile de pe margine (primul și ultimul rând), se construiește un rând format din caracterul c repetat de n ori. Pentru celelalte rânduri, se construiește un rând format din caracterul c, apoi caracterul d repetat de n-2 ori, și în final caracterul c. Șirurile de caractere ale fiecărui rând sunt concatenate pentru a forma pătratul final.
Funcția afisare_patrat(patrat) afișează șirul de caractere patrat, eliminând spațiile dinaintea și de după șir folosind metoda strip().
În blocul if __name__ == '__main__':, se solicită utilizatorului să introducă numărul natural n, caracterul c și caracterul d. Se verifică dacă valorile introduse sunt valide utilizând funcția validare_date(n, c, d). Dacă nu sunt valide, se afișează mesajul "Date de intrare invalide". Dacă valorile introduse sunt valide, se apelează funcția construire_patrat(n, c, d) pentru a construi pătratul și se apelează funcția afisare_patrat(patrat) pentru a-l afișa.

4275 - Para 2

2023-06-29T18:19:52Z

Paul Ungur:

==Cerinta:==
Se citește numărul natural n, şi un caracter c. Să se afișeze următorul paralelogram:
c
cc
ccc
....ccc...c
ccc...c
cc...c
....
cc
c
==Date de intrare:==
Programul citește de la tastatură numărul n şi caracterul c .

==Date de ieşire:==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul afișează pe ecran figura descrisă în enunț. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricţii şi precizări:==
1 ≤ n ≤ 20
c este un caracter cu codul ASCII cuprins între 33 şi 126, inclusiv.

==Exemplu:==
Intrare
: 4 *

Ieșire
: Date de intrare valide
*
**
***
****
****
***
**
*

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n, c):
if not 1 <= n <= 20:
print("n trebuie să fie între 1 și 20")
return False
if not 33 <= ord(c) <= 126:
print("c trebuie să aibă un cod ASCII între 33 și 126")
return False
return True

def afisare_paralelogram(n, c):
for i in range(1, n + 1):
for j in range(n, i, -1):
print(" ", end="")
for j in range(1, i + 1):
print(c, end="")
print()

for i in range(n, 0, -1):
for j in range(1, i + 1):
print(c, end="")
for j in range(n, i, -1):
print(" ", end="")
print()

if __name__ == '__main__':
n = int(input("Introduceți un număr natural n: "))
c = input("Introduceți un caracter c: ")
if validare_date(n, c):
n = int(n)
afisare_paralelogram(n, c)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n, c) verifică dacă valorile n și c sunt valide pentru a construi un paralelogram. Verifică dacă n se încadrează în intervalul [1, 20] și dacă caracterul c are un cod ASCII între 33 și 126. Dacă nu se îndeplinesc aceste condiții, afișează mesajul corespunzător și returnează False. Altfel, returnează True.
Funcția afisare_paralelogram(n, c) construiește și afișează un paralelogram utilizând numărul n și caracterul c. Folosește două bucle for pentru a itera prin rânduri și coloanele fiecărui rând. În prima buclă, iterează de la 1 la n și afișează spații în funcție de diferența dintre n și valoarea curentă a primei bucle, apoi afișează caracterele c înmulțite cu valoarea curentă a primei bucle. Astfel, fiecare rând al paralelogramului conține spații urmate de un număr crescător de caractere c. În a doua buclă, iterează de la n la 1 în ordine descrescătoare și afișează caracterele c în funcție de valoarea curentă a primei bucle, apoi afișează spații în funcție de diferența dintre n și valoarea curentă a primei bucle, pentru a construi partea inferioară a paralelogramului.
În blocul if __name__ == '__main__':, se solicită utilizatorului să introducă numărul natural n și caracterul c. Se verifică dacă valorile introduse sunt valide utilizând funcția validare_date(n, c). Dacă nu sunt valide, se afișează mesajul "Date de intrare invalide". Dacă valorile introduse sunt valide, se convertește n într-un număr întreg și se apelează funcția afisare_paralelogram(n, c) pentru a construi și afișa paralelogramul.

4274 - Para 1

2023-06-29T18:15:24Z

Paul Ungur:

==Cerinţa:==
Se citește numărul natural n, şi un caracter c. Să se afișeze următorul paralelogram:
c
cc
ccc
....
ccc...c
ccc...c
cc...c
....
cc
c

==Date de intrare:==
Programul citește de la tastatură numărul n şi caracterul c .

==Date de ieşire:==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul afișează pe ecran figura descrisă în enunț. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricţii şi precizări:==
1 ≤ n ≤ 20
c este un caracter cu codul ASCII cuprins între 33 şi 126, inclusiv.

==Exemplu:==
Intrare:
: 4 *

Ieșire:
: Date de intrare valide
: *
: **
: ***
: ****
: ****
: ***
: **
: *

==Rezolvare:==
<syntaxhighlight lang="python" line="1">
def validare_date(n, c):
if not 1 <= n <= 20:
print("n trebuie să fie între 1 și 20")
return False
if not 33 <= ord(c) <= 126:
print("c trebuie să aibă un cod ASCII între 33 și 126")
return False
return True

def afisare_paralelogram(n, c):
for i in range(1, n + 1):
for j in range(1, i + 1):
print(c, end="")
print()

for i in range(n, 0, -1):
for j in range(n, i, -1):
print(" ", end="")
for j in range(1, i + 1):
print(c, end="")
print()

if __name__ == '__main__':
n = int(input("Introduceți un număr natural n: "))
c = input("Introduceți un caracter c: ")
if validare_date(n, c):
n = int(n)
afisare_paralelogram(n, c)
print("Date de intrare valide")
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n, c) verifică dacă valorile n și c sunt valide pentru a construi un paralelogram. Verifică dacă n se încadrează în intervalul [1, 20] și dacă caracterul c are un cod ASCII între 33 și 126. Dacă nu se îndeplinesc aceste condiții, afișează mesajul corespunzător și returnează False. Altfel, returnează True.
Funcția afisare_paralelogram(n, c) construiește și afișează un paralelogram utilizând numărul n și caracterul c. Folosește două bucle for pentru a itera prin rânduri și coloanele fiecărui rând. În prima buclă, iterează de la 1 la n și afișează caracterele c înmulțite cu valoarea curentă a primei bucle. Astfel, fiecare rând al paralelogramului conține un număr crescător de caractere c. În a doua buclă, iterează de la n la 1 în ordine descrescătoare și afișează spații și caracterele c în funcție de valorile curente ale buclelor, pentru a construi partea inferioară a paralelogramului.
În blocul if __name__ == '__main__':, se solicită utilizatorului să introducă numărul natural n și caracterul c. Se verifică dacă valorile introduse sunt valide utilizând funcția validare_date(n, c). Dacă nu sunt valide, se afișează mesajul "Date de intrare invalide". Dacă valorile introduse sunt valide, se afișează mesajul "Date de intrare valide", se convertește n într-un număr întreg și se apelează funcția afisare_paralelogram(n, c) pentru a construi și afișa paralelogramul.

0456 - Piramida 1

2023-06-29T18:13:38Z

Paul Ungur:

==Cerinţa:==
Se citește numărul natural n, şi un caracter c. Să se afișeze următoarea piramidă:
c
cc
ccc
....
ccc...c

==Date de intrare:==
Programul citește de la tastatură numărul n şi caracterul c .

==Date de ieşire:==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul afișează pe ecran un caracter c, pe a doua linie două caractere c, pe a treia linie trei caractere c, etc, pe a n-a linie n caractere c. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide"'''.

==Restricţii şi precizări:==
 1 ≤ n ≤ 20
c este un caracter cu codul ASCII cuprins între 33 şi 126, inclusiv.

Exemplu:
Intrare
: 4 *

Ieșire
: Date de intrare valide
: *
: **
: ***
: ****

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n, c):
flag = True
if not isinstance(n, int) or not isinstance(c, str):
flag = False
if int(n) < 1 or int(n) > 20:
flag = False
if not 33 <= ord(c) <= 126:
flag = False
return flag

def construire_piramid(n, c):
for i in range(1, n + 1):
print(c * i)

if __name__ == "__main__":
n = input("Introduceti numarul natural n: ")
c = input("Introduceti caracterul c: ")
if validare_date(n, c):
print("Date de intrare valide")
n = int(n)
construire_piramid(n, c)
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n, c) verifică dacă valorile n și c sunt valide pentru a construi o piramidă. Verifică dacă n este de tip int și c este de tip str. Verifică apoi dacă n se încadrează în intervalul [1, 20] și dacă caracterul c are un cod ASCII între 33 și 126. Dacă nu se îndeplinesc aceste condiții, returnează False, altfel returnează True.
Funcția construire_piramid(n, c) construiește o piramidă utilizând numărul n și caracterul c. Folosește o buclă for pentru a itera de la 1 la n. La fiecare iterație, afișează caracterul c înmulțit cu valoarea curentă a iterației. Astfel, fiecare rând al piramidei conține un număr crescător de caractere c.
În blocul if __name__ == '__main__':, se solicită utilizatorului să introducă numărul natural n și caracterul c. Se verifică dacă valorile introduse sunt valide utilizând funcția validare_date(n, c). Dacă nu sunt valide, se afișează mesajul "Date de intrare invalide". Dacă valorile introduse sunt valide, se afișează mesajul "Date de intrare valide" și se apelează funcția construire_piramid(n, c) pentru a construi și afișa piramida

1684 - Numere Piramidale

2023-06-29T18:12:32Z

Paul Ungur:

==Cerința==
Amicul nostru, Zoli, a învățat la scoală despre pătrate perfecte și numere piramidale. Al n-lea număr piramidal înseamnă suma primelor n pătrate perfecte, începând de la 1. Ajutați-l pe Zoli sa afle primele n numere piramidale.

==Date de intrare==
Programul citește de la tastatură numărul n.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul va afișa pe ecran primele n numere piramidale, în ordine crescătoare, separate prin câte un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricții și precizări==
 1 ≤ n ≤ 400

==Exemplu:==
Intrare
: 3

Ieșire
: Date de intrare valide
: 1 5 14

==Explicație==
Primele 3 numere piramidale sunt 1, 5 si 14.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n):
if not n.isdigit():
return False
n = int(n)
if n < 1 or n > 400:
return False
return True

def compute_pyramid_numbers(n):
pyramid_numbers = []
for i in range(1, n+ 1):
pyramid_number = sum([j ** 2 for j in range(1, i + 1)])
pyramid_numbers.append(pyramid_number)
print("Primele", n, "numere piramidale sunt:", " ".join(str(p) for p in pyramid_numbers))

if __name__ == '__main__':
n = input("Introduceti numarul de numere piramidale: ")
while not validare_date(n):
n = input("Input invalid! Introduceti numarul de numere piramidale: ")
if validare_date(n):
print("Date de intrare valide")
compute_pyramid_numbers(int(n))

</syntaxhighlight>
==Explicatie cod:==
Funcția validare_date(n) verifică dacă valoarea n este un număr valid pentru a calcula numere piramidale. Verifică dacă n este un șir de caractere numeric și apoi convertește n la tipul int. Verifică apoi dacă n se încadrează în intervalul [1, 400]. Dacă nu se îndeplinesc aceste condiții, returnează False, altfel returnează True.
Funcția compute_pyramid_numbers(n) calculează primele n numere piramidale. Folosește o buclă for pentru a itera de la 1 la n. Pentru fiecare valoare i, calculează numărul piramidal folosind formula pyramid_number = sum([j ** 2 for j in range(1, i + 1)]). Adaugă numărul piramidal calculat în lista pyramid_numbers. La final, afișează lista pyramid_numbers într-un format adecvat.
În blocul if __name__ == '__main__':, se solicită utilizatorului să introducă numărul de numere piramidale pe care dorește să le calculeze. Se verifică dacă valoarea introdusă este validă utilizând funcția validare_date(n). Dacă nu este validă, utilizatorului i se cere să reintroducă un număr valid. Dacă valoarea introdusă este validă, se afișează mesajul "Date de intrare valide" și se apelează funcția compute_pyramid_numbers(int(n)) pentru a calcula și afișa numerele piramidale.

0351 - Piramida

2023-06-29T18:10:58Z

Paul Ungur:

==Cerinţa:==
Se citește numărul natural n. Să se afișeze următoarea piramidă de numere:
1
1 2
1 2 3
.......
1 2 3 ... n

==Date de intrare:==
Programul citește de la tastatură numărul n.

==Date de ieşire:==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul afișează pe ecran numărul 1, pe a doua linie numerele 1 2, pe a treia linie numerele 1 2 3, etc, pe a n-a linie numerele 1 2 3 ... n. Pe fiecare linie numerele sunt separate prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide."'''

==Restricţii şi precizări:==
 1 ≤ n ≤ 20

==Exemplu:==
Date de intrare
: 4

Date de ieșire
: Date de intrare valide
: 1
: 1 2
: 1 2 3
: 1 2 3 4

==Rezolvare:==
<syntaxhighlight lang="python" line="1">
def validare_date(n):
if not n.isdigit():
return False
n = int(n)
if n < 1 or n > 20:
return False
return True

def construire_piramid(n):
piramid = []
for i in range(1, n + 1):
row = []
for j in range(1, i + 1):
row.append(j)
piramid.append(row)
return piramid

def afisare_piramid(pyramid):
for rand in pyramid:
rand_str = " ".join([str(num) for num in rand])
print(rand_str)

if __name__ == '__main__':
n = input("Introduceti n: ")
while not validare_date(n):
print("Va rugam introduceti un numar natural intre 1 si 20.")
n = input("Introduceti n: ")
if validare_date(n):
print("Date de intrare valide")
n = int(n)
piramid = construire_piramid(n)
afisare_piramid(piramid)
else:
print("Date de intrare invalide")

</syntaxhighlight>
==Explicatie cod:==
Codul Python de mai sus definește următoarele funcții și acțiuni:

Funcția validare_date(n):
Această funcție primește un singur parametru, n, care este o valoare de tip string.
Verifică dacă n este un număr valid prin următoarele condiții:
Verifică dacă n conține doar cifre utilizând metoda isdigit(). Dacă n conține și alte caractere în afară de cifre, funcția returnează False, semnalând că datele introduse sunt invalide.
Converteste n la tipul int și verifică dacă este mai mic decât 1 sau mai mare decât 20. Dacă această condiție nu este îndeplinită, funcția returnează False, semnalând că datele introduse sunt invalide.
Dacă ambele verificări trec fără a găsi probleme, funcția returnează True, semnalând că datele introduse sunt valide.
Funcția construire_piramid(n):
Această funcție primește un singur parametru, n, reprezentând un număr întreg.
Construiește o piramidă formată din liste de numere întregi.
Folosind două bucle for, se construiește fiecare rând al piramidei.
La fiecare iterație, se creează un nou rând care conține numere de la 1 la i, unde i reprezintă indexul rândului curent.
Rândurile piramidei sunt adăugate într-o listă numită piramid.
La final, lista piramid este returnată.
Funcția afisare_piramid(piramid):
Această funcție primește un singur parametru, piramid, care este o listă de liste de numere întregi reprezentând piramida.
Afișează conținutul piramidei, parcurgând fiecare rând și convertind numerele la șiruri de caractere.
Folosind bucla for, se parcurge fiecare rând al piramidei.
Folosind metoda join, numerele din fiecare rând sunt transformate în șiruri de caractere separate prin spațiu.
Șirurile de caractere corespunzătoare fiecărui rând sunt afișate cu ajutorul funcției print.
În cadrul secțiunii if __name__ == '__main__': se realizează următoarele acțiuni:

Se citește de la tastatură un număr sub formă de șir de caractere n folosind funcția input().
Se verifică dacă datele introduse sunt valide folosind funcția validare_date(n). Dacă datele sunt valide, se afișeazămesajul "Date de intrare valide" și se continuă executarea programului.

În caz contrar, se afișează mesajul "Date de intrare invalide" și se cere introducerea unui nou număr până când acesta este valid.
După ce se asigură că datele introduse sunt valide, se convertește n la tipul int.
Se apelează funcția construire_piramid(n) pentru a construi piramida.
Piramida rezultată este stocată în variabila piramid.
Se apelează funcția afisare_piramid(piramid) pentru a afișa piramida construită.

2695 - Cub Perfect

2023-06-29T18:09:07Z

Paul Ungur:

==Cerința:==
Se citește un număr n și apoi n numere întregi. Să se verifice pentru fiecare număr dacă este cub perfect.

==Date de intrare:==
Programul citește de la tastatură numărul n și n numere naturale.

==Date de ieșire:==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Date de intrare valide.", apoi Programul va afișa DA sau NU pe câte o linie dacă numărul citit este sau nu cub perfect. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Date de intrare invalide.".

==Restricții și precizări:==
 1 ≤ n ≤ 1000
cele n numere sunt -1.000.000.000.000 ≤ x ≤ 1.000.000.000.000

==Exemplu:==
Intrare
: 5
: 1 -1 8 -8 9

Ieșire
: Date de intrare valide
: DA
: DA
: DA
: DA
: NU

==Explicație:==
S-au citit 5 numere, s-a verificat dacă sunt cuburi perfecte și s-a afișat răspunsul corespunzător.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n, nums):
if n < 1 or n > 1000:
return False
for num in nums:
if num < -1000000000000 or num > 1000000000000:
return False
return True

def este_cub(n):
return round(n ** (1.0 / 3)) ** 3 == n

def verificare_cub(n, nums):
result = []
for num in nums:
if este_cub(abs(num)):
result.append("DA")
else:
result.append("NU")
print("\n".join(result))

if __name__ == '__main__':
n = int(input())
nums = list(map(int, input().split()))
if validare_date(n, nums):
print("Date de intrare valide")
verificare_cub(n, nums)
else:
print("Date de intrare invalide")

</syntaxhighlight>
==Explicatie cod:==
Codul Python de mai sus definește trei funcții: validare_date, este_cub și verificare_cub. Iată o explicație pentru fiecare dintre ele:

Funcția validare_date(n, nums):
Această funcție primește doi parametri, n și nums.
Verifică mai multe condiții pentru a valida datele introduse:
Verifică dacă n este mai mic decât 1 sau mai mare decât 1000. Dacă această condiție nu este îndeplinită, funcția returnează False, semnalând că datele sunt invalide.
Verifică fiecare element num din lista nums pentru a se încadra în intervalul -1000000000000 și 1000000000000. Dacă unul dintre elementele nu se încadrează în acest interval, funcția returnează False, semnalând că datele sunt invalide.
Dacă toate verificările sunt trecute fără a găsi probleme, funcția returnează True, semnalând că datele sunt valide.
Funcția este_cub(n):
Această funcție primește un singur parametru, n, reprezentând un număr întreg.
Verifică dacă n este un cub perfect.
Folosind proprietatea unui cub perfect, se calculează rădăcina cubică a valorii absolute a lui n (abs(n)) și se verifică dacă ridicarea la puterea 3 a acestei rădăcini este egală cu n. Dacă da, funcția returnează True, semnalând că n este un cub perfect. În caz contrar, funcția returnează False.
Funcția verificare_cub(n, nums):
Această funcție primește doi parametri, n și nums, reprezentând un număr întreg și o listă de numere întregi.
Funcția verifică pentru fiecare element num din lista nums dacă valoarea absolută a acestuia este un cub perfect folosind funcția este_cub. Dacă este un cub perfect, se adaugă string-ul "DA" în lista de rezultate result. Altfel, se adaugă string-ul "NU" în lista de rezultate.
La final, funcția afișează elementele din lista result, separate prin linii noi, folosind funcția print("\n".join(result)).
În cadrul secțiunii if __name__ == '__main__': se realizează următoarele acțiuni:

Se citește de la tastatură un număr întreg n folosind funcția input().
Se citește o listă de numere întregi nums folosind funcția input().split() și convertind elementele la tipul int cu ajutorul funcției map(int, ...).
Se apelează funcția validare_date(n, nums) pentru a verifica dacă datele introduse sunt valide. Dacă sunt valide, se afișează mesajul "Date de intrare valide" și se apelează funcția verificare_cub(n, nums). În caz contrar, se afișează mesajul "Date de intrare invalide".

0348 - Afisare Puteri

2023-06-29T18:07:10Z

Paul Ungur:

==Cerinţa:==
Se dau două numere naturale nenule n și p. Afișați în ordine crescătoare puterile lui n mai mici sau egale cu p .

==Date de intrare:==
Programul citește de la tastatură numerele n și p .

==Date de ieşire:==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare valide."''', apoi programul afișează pe ecran, în ordine crescătoare, puterile lui n mai mici sau egale cu p , separate prin câte un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Date de intrare invalide".'''

==Restricţii şi precizări:==
 2 ≤ n ≤ 10
1 ≤ p < 1.000.000.000

==Exemplu:==

Date de intrare
: 3 100

Date de ieșire
: Date de intrare valide
: 1 3 9 27 81

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n, p):
if not isinstance(n, int) or not isinstance(p, int):
return False
if n <= 1 or p <= 0 or p >= 1000000000:
return False
return True

def rezolvare(n, p):
i = 0
while n ** i <= p:
print(n ** i, end=' ')
i += 1

if __name__ == "__main__":
n = int(input("Introduceti n: "))
p = int(input("Introduceti p: "))
if validare(n, p):
rezolvare(n, p)
print("Date de intrare valide")
else:
print("Date de intrare invalide")
</syntaxhighlight>
==Explicatie cod:==
Codul Python de mai sus definește două funcții: validare și rezolvare. Iată o explicație pentru fiecare dintre ele:

Funcția validare(n, p):
Această funcție primește doi parametri, n și p, reprezentând două numere întregi.
Verifică mai multe condiții pentru a valida datele introduse:
Verifică dacă atât n cât și p sunt de tipul int. Dacă nu sunt, funcția returnează False, semnalând că datele sunt invalide.
Verifică dacă n este mai mic sau egal cu 1 sau p este mai mic sau egal cu 0 sau mai mare sau egal cu 1.000.000.000. Dacă una dintre aceste condiții nu este îndeplinită, funcția returnează False, semnalând că datele sunt invalide.
Dacă toate verificările sunt trecute fără a găsi probleme, funcția returnează True, semnalând că datele sunt valide.
Funcția rezolvare(n, p):
Această funcție primește doi parametri, n și p, reprezentând două numere întregi.
Funcția calculează și afișează toate puterile lui n care sunt mai mici sau egale cu p.
Într-un ciclu while, se verifică condiția n ** i <= p, unde i este un contor inițializat cu 0. În fiecare iterație, se afișează rezultatul n ** i și se incrementează i cu 1.
Afișarea este realizată cu ajutorul funcției print, iar valorile sunt separate prin spațiu.
În cadrul secțiunii if __name__ == "__main__": se realizează următoarele acțiuni:

Se citește de la tastatură două numere întregi n și p folosind funcția input().
Se apelează funcția validare(n, p) pentru a verifica validitatea datelor. Dacă datele sunt valide, se apelează funcția rezolvare(n, p) pentru a calcula și afișa rezultatul.
Dacă datele nu sunt valide, se afișează mesajul "Date de intrare invalide". În cazul în care datele sunt valide, se afișează mesajul "Date de intrare valide" după ce funcția rezolvare(n, p) a afișat toate puterile lui n.

4049 - N Div N Len

2023-06-29T18:05:19Z

Paul Ungur:

==Cerința:==
Se dă un număr natural n. Găsiți orice număr k de exact n cifre care este divizibil cu n.

==Date de intrare:==
Se citește numărul n.

==Date de ieșire:==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare corecte.''', apoi numărul k. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

==Restricții și precizări:==
 1 ≤ n ≤ 10^5
Dacă există mai multe soluții posibile, se acceptă oricare.
Pentru 20 de puncte, n ≤6
Pentru 40 de puncte, n ≤9
Pentru 50 de puncte, n ≤18

==Exemplu:==
Intrare
: 3
Ieșire
: Date de intrare corecte
: 123

==Explicație:==
Numărul 123 are 3 cifre și este divizibil cu 3.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n):
if not isinstance(n, int) or n < 1 or n > 10**5:
return False
return True

def find_k(n):
nrCif = 1
copie_n = n
print(n, end='')
while n:
nrCif += 1
n //= 10
for i in range(1, copie_n):
print(0, end='')

if __name__ == '__main__':
n = int(input("Introduceti n: "))
if validare_date(n):
find_k(n)
else:
if not validare_date(n):
print("Date de intrare incorecte")
</syntaxhighlight>
==Explicatie cod:==
Codul Python de mai sus definește două funcții: validare_date și find_k. Iată o explicație pentru fiecare dintre ele:

Funcția validare_date(n):
Această funcție primește un singur parametru, n, reprezentând un număr întreg.
Verifică mai multe condiții pentru a valida datele introduse:
Verifică dacă n este de tipul int și dacă nu este, sau dacă n este mai mic decât 1 sau mai mare decât 100000, funcția returnează False, semnalând că datele sunt invalide.
Dacă toate verificările sunt trecute fără a găsi probleme, funcția returnează True, semnalând că datele sunt valide.
Funcția find_k(n):
Această funcție primește un singur parametru, n, reprezentând un număr întreg.
Funcția calculează și afișează rezultatul într-un format specific, care presupune afișarea numărului n, urmat de (n-1) de zerouri.
Începând cu nrCif = 1, se efectuează un ciclu while n, unde n este redus la jumătate în fiecare iterație. La fiecare iterație, nrCif este incrementat cu 1 și se afișează n de zerouri. Acest lucru este realizat de către bucla for care iterează de la 1 până la copie_n - 1, unde copie_n este copia inițială a valorii lui n.
La final, funcția afișează rezultatul.
În cadrul secțiunii if __name__ == '__main__': se realizează următoarele acțiuni:

Se citește de la tastatură un număr întreg n folosind funcția input().
Se apelează funcția validare_date(n) pentru a verifica validitatea datelor. Dacă datele sunt valide, se apelează funcția find_k(n) pentru a calcula și afișa rezultatul.
Dacă datele nu sunt valide, se afișează mesajul "Date de intrare incorecte".

4049 - N Div N Len

2023-06-29T18:03:02Z

Paul Ungur:

==Cerința:==
Se dă un număr natural n. Găsiți orice număr k de exact n cifre care este divizibil cu n.

==Date de intrare:==
Se citește numărul n.

==Date de ieșire:==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Date de intrare corecte sunt introduse corecte, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

==Restricții și precizări:==
 1 ≤ n ≤ 10^5
Dacă există mai multe soluții posibile, se acceptă oricare.
Pentru 20 de puncte, n ≤6
Pentru 40 de puncte, n ≤9
Pentru 50 de puncte, n ≤18

==Exemplu:==
Intrare
: 3
Ieșire
: Date de intrare corecte
: 123

==Explicație:==
Numărul 123 are 3 cifre și este divizibil cu 3.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n):
if not isinstance(n, int) or n < 1 or n > 10**5:
return False
return True

def find_k(n):
nrCif = 1
copie_n = n
print(n, end='')
while n:
nrCif += 1
n //= 10
for i in range(1, copie_n):
print(0, end='')

if __name__ == '__main__':
n = int(input("Introduceti n: "))
if validare_date(n):
find_k(n)
else:
if not validare_date(n):
print("Date de intrare incorecte")
</syntaxhighlight>
==Explicatie cod:==
Codul Python de mai sus definește două funcții: validare_date și find_k. Iată o explicație pentru fiecare dintre ele:

Funcția validare_date(n):
Această funcție primește un singur parametru, n, reprezentând un număr întreg.
Verifică mai multe condiții pentru a valida datele introduse:
Verifică dacă n este de tipul int și dacă nu este, sau dacă n este mai mic decât 1 sau mai mare decât 100000, funcția returnează False, semnalând că datele sunt invalide.
Dacă toate verificările sunt trecute fără a găsi probleme, funcția returnează True, semnalând că datele sunt valide.
Funcția find_k(n):
Această funcție primește un singur parametru, n, reprezentând un număr întreg.
Funcția calculează și afișează rezultatul într-un format specific, care presupune afișarea numărului n, urmat de (n-1) de zerouri.
Începând cu nrCif = 1, se efectuează un ciclu while n, unde n este redus la jumătate în fiecare iterație. La fiecare iterație, nrCif este incrementat cu 1 și se afișează n de zerouri. Acest lucru este realizat de către bucla for care iterează de la 1 până la copie_n - 1, unde copie_n este copia inițială a valorii lui n.
La final, funcția afișează rezultatul.
În cadrul secțiunii if __name__ == '__main__': se realizează următoarele acțiuni:

Se citește de la tastatură un număr întreg n folosind funcția input().
Se apelează funcția validare_date(n) pentru a verifica validitatea datelor. Dacă datele sunt valide, se apelează funcția find_k(n) pentru a calcula și afișa rezultatul.
Dacă datele nu sunt valide, se afișează mesajul "Date de intrare incorecte".

2747 - Log

2023-06-29T18:00:26Z

Paul Ungur:

==Cerința==
Se dau numerele n și m. Să se determine exponentul la care se ridică n pentru a obține m.

==Date de intrare==
Programul citește de la tastatură numerele n și m, separate prin spații.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Datele sunt introduse corect."''', apoi programul va afișa pe ecran exponentul la care se ridică n pentru a obține m. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''

==Restricții și precizări==
 1 ≤ n , m ≤ 1.000.000
n ≠ 1
se garantează ca m este putere a lui n</span.

==Exemplu:==
: Intrare
: 2 4

Ieșire
: Datele sunt introduse corect
: 2

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n, m):
if not (1 <= n <= 1000000) or not (1 <= m <= 1000000):
print("n și m trebuie să fie între 1 și 1.000.000.")
return False
if n == 1:
print("n trebuie să fie diferit de 1.")
return False
if m % n != 0:
print("m trebuie să fie putere a lui n.")
return False
return True

def compute_exponent(n, m):
#Determină exponentul la care trebuie ridicat n pentru a obține m.
exponent = 1
while m > n:
m //= n
exponent += 1
print(f"Exponentul la care trebuie ridicat {n} pentru a obține {m} este: {exponent}")

if __name__ == "__main__":
# Citire input și validare
n, m = map(int, input("Introduceți n și m, separate prin spațiu: ").split())
if validare_date(n, m):
exponent = compute_exponent(n, m)
else:
while not validare_date(n, m):
n, m = map(int, input("Introduceți n și m, separate prin spațiu: ").split())
</syntaxhighlight>
==Explicatie cod:==
Codul Python de mai sus definește două funcții: validare_date și compute_exponent. Iată o explicație pentru fiecare dintre ele:

Funcția validare_date(n, m):
Această funcție primește doi parametri, n și m, reprezentând două numere întregi.
Verifică mai multe condiții pentru a valida datele introduse:
Verifică dacă n și m sunt ambele între 1 și 1.000.000. Dacă nu sunt, afișează un mesaj de eroare și returnează False.
Verifică dacă n este diferit de 1. Dacă nu este, afișează un mesaj de eroare și returnează False.
Verifică dacă m este o putere a lui n. Dacă nu este, afișează un mesaj de eroare și returnează False.
Dacă toate verificările sunt trecute fără a găsi probleme, funcția returnează True, semnalând că datele sunt valide.
Funcția compute_exponent(n, m):
Această funcție primește doi parametri, n și m, reprezentând două numere întregi.
Funcția calculează exponentul la care trebuie ridicat n pentru a obține m.
Inițial, exponentul este setat la 1. Apoi, într-un ciclu while, m este împărțit la n până când m devine mai mic sau egal cu n. În fiecare iterație, exponentul este incrementat cu 1.
La final, funcția afișează exponentul.
În cadrul secțiunii if __name__ == "__main__": se realizează următoarele acțiuni:

Se citește de la tastatură două numere întregi separate prin spațiu, n și m, și sunt convertite în variabilele corespunzătoare.
Se apelează funcția validare_date(n, m) pentru a verifica validitatea datelor. Dacă datele sunt valide, se apelează funcția compute_exponent(n, m) pentru a calcula și afișa exponentul.
Dacă datele nu sunt valide, se intră într-un ciclu while până când se introduc date valide. În fiecare iterație se solicită introducerea valorilor n și m, iar apoi se reevaluează validitatea acestora. Ciclul se oprește când se introduc date valide și se calculează și afișează exponentul corespunzător.

1681 - Power

2023-06-29T17:58:23Z

Paul Ungur:

==Cerința==
Prietenul nostru, Zolly, a învățat la scoală despre ridicarea la putere. Ajutați-l să calculeze a^b .

==Date de intrare==
Programul citește de la tastatură numerele naturale a si b.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Datele sunt introduse corect."''', apoi programul va afișa pe ecran numărul P, reprezentând a^b . În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele NU sunt introduse corect."'''

==Restricții și precizări==
 0 ≤ P ≤ 2.000.000.000;
a + b > 0.

==Exemplu:==
Intrare
: 5
: 4

Ieșire
: Datele sunt introduse corect.
: 625

==Explicație==
 5 * 5 * 5 * 5 = 625.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(a, b):
flag = False
if 0 < a + b:
flag = True
print("Datele sunt introduse corect.")
if flag == False:
print("Datele NU sunt introduse corect.")
return flag

def Pow(a, b):
tmp = 1
for i in range(b):
tmp *= a
print(tmp)

if __name__ == "__main__":
a, b = map(int, input().split())
if validare_date(a, b):
Pow(a, b)
</syntaxhighlight>
==Explicatie cod:==
Codul Python de mai sus definește două funcții: validare_date și Pow. Iată o explicație pentru fiecare dintre ele:

Funcția validare_date(a, b):
Această funcție primește doi parametri, a și b, reprezentând două numere întregi.
Verifică dacă suma dintre a și b este strict pozitivă (mai mare decât 0). Dacă această condiție este îndeplinită, variabila flag este setată la True, iar mesajul "Datele sunt introduse corect." este afișat.
Dacă variabila flag este False, se afișează mesajul "Datele NU sunt introduse corect."
Funcția returnează valoarea variabilei flag.
Funcția Pow(a, b):
Această funcție primește doi parametri, a și b, reprezentând două numere întregi.
Funcția calculează a ridicat la puterea b utilizând un buclă for.
Rezultatul este stocat în variabila tmp.
Rezultatul este apoi afișat.
În cadrul secțiunii if __name__ == "__main__": se realizează următoarele acțiuni:

Se citește de la tastatură două numere întregi separate prin spațiu, a și b, și sunt convertite în variabilele corespunzătoare.
Se apelează funcția validare_date(a, b) pentru a verifica validitatea datelor. Dacă datele sunt valide, se apelează funcția Pow(a, b) pentru a calcula și afișa puterea, altfel se afișează mesajul "Datele NU sunt introduse corect."

2222 - P10 P10

2023-06-29T17:56:35Z

Paul Ungur:

==Cerința==
Se dau două numere naturale n , care este putere a lui 10 și k. Să se afișeze n^k .

==Date de intrare==
Programul citește de la tastatură numerele n și k.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Datele sunt introduse corect."''', apoi programul va afișa pe ecran numărul P, reprezentând n˚.. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu sunt introduse corect."'''

==Restricții și precizări==
1 ≤ n ≤ 1.000.000.000, n este putere a lui 10
0 ≤ k ≤ 1.000

==Exemplu:==

Intrare
: 100 3

Ieșire
: Datele sunt introduse corect.
: 1000000

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(n, k):
flag = False
if 0 < int(n) <= 1_000_000_000 and 0 <= int(k) <= 1_0000:
flag = True
return flag

def calculate_power(n, k):
print(n ** k)

if __name__ == "__main__":
n = int(input())
k = int(input())
if validare_date(n, k):
print("Datele sunt introduse corect.")
calculate_power(n, k)
else:
print("Datele nu sunt introduse corect.")
</syntaxhighlight>
==Explicatie cod==
Codul Python de mai sus definește două funcții: validare_date și calculate_power. Iată o explicație pentru fiecare dintre ele:

Funcția validare_date(n, k):
Această funcție primește doi parametri, n și k, reprezentând două numere întregi.
Verifică dacă n se află în intervalul deschis (0, 1_000_000_000] și dacă k se află în intervalul închis [0, 10_000]. Dacă ambele condiții sunt îndeplinite, variabila flag este setată la True.
Funcția returnează valoarea variabilei flag.
Funcția calculate_power(n, k):
Această funcție primește doi parametri, n și k, reprezentând două numere întregi.
Funcția calculează n ridicat la puterea k și afișează rezultatul.
În cadrul secțiunii if __name__ == "__main__": se realizează următoarele acțiuni:

Se citește de la tastatură un număr întreg n.
Se citește de la tastatură un număr întreg k.
Se apelează funcția validare_date(n, k) pentru a verifica validitatea datelor. Dacă datele sunt valide, se afișează mesajul "Datele sunt introduse corect.", se apelează funcția calculate_power(n, k) pentru a calcula și afișa puterea, altfel se afișează mesajul "Datele nu sunt introduse corect."

2948 - Media Patratica

2023-06-29T17:54:41Z

Paul Ungur:

== Cerința ==
Se dau n numere naturale. Calculați media pătratică a celor n numere citite cu 2 zecimale exacte.

== Date de intrare ==
Programul citește de la tastatură numărul n, iar apoi n numere naturale.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Datele sunt introduse corect."''', apoi programul va afișa pe ecran media pătratică a celor n numere cu 2 zecimale exacte.. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
 1 ≤ n ≤ 1000
cele n numere citite vor fi mai mici decât 1.000.000 

== Exemplu: ==
Intrare
: 5
: 1 2 3 4 5

Ieșire
: Datele sunt introduse corect.
: 3.31

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def validare_date_intrare(n, nums):
if not 1 <= n <= 1000:
print("Numărul n trebuie să fie între 1 și 1000!")
return False
if len(nums) != n:
print("Trebuie să introduceți exact {} numere!".format(n))
return False
for nr in nums:
if not 1 <= nr <= 1000000:
print("Numerele trebuie să fie cuprinse între 1 și 1.000.000!")
return False
print("Datele sunt introduse corect.")
return True

def media_patratica(nums):
suma_patrate = sum([num ** 2 for num in nums])
media_patratica = (suma_patrate / len(nums)) ** 0.5
print(round(media_patratica, 2))

if __name__ == '__main__':
n = int(input())
nums = list(map(int, input().split()))
if validare_date_intrare(n, nums):
media_patratica(nums)
</syntaxhighlight>
==Explicatie cod==
Codul Python de mai sus definește două funcții: validare_date_intrare și media_patratica. Iată o explicație pentru fiecare dintre ele:

Funcția validare_date_intrare(n, nums):
Această funcție primește doi parametri, n și nums, reprezentând un număr și o listă de numere întregi.
Verifică dacă n respectă restricțiile impuse: trebuie să fie între 1 și 1000. Dacă n nu respectă aceste restricții, afișează un mesaj de eroare și returnează False, semnalând că datele nu sunt valide.
Verifică apoi dacă lungimea listei nums este egală cu n. Dacă nu este, afișează un mesaj de eroare și returnează False, semnalând că datele nu sunt valide.
În final, se parcurge fiecare număr nr din lista nums și se verifică dacă fiecare număr respectă restricțiile impuse: trebuie să fie între 1 și 1.000.000. Dacă un număr nu respectă aceste restricții, afișează un mesaj de eroare și returnează False.
Dacă toate verificările sunt trecute fără a găsi probleme, funcția afișează un mesaj că datele sunt introduse corect și returnează True, semnalând că datele sunt valide.
Funcția media_patratica(nums):
Această funcție primește un singur parametru, nums, care reprezintă o listă de numere întregi.
Funcția calculează media pătratică a numerelor din lista. Inițial, se calculează suma pătratelor tuturor numerelor din lista, utilizând o listă de comprimare.
Apoi, se calculează media pătratică, împărțind suma pătratelor la lungimea listei și aplicând radicalul pătrat la rezultat.
Funcția afișează valoarea media pătratică, rotunjită la două zecimale, utilizând funcția round() și formatul "%.2f".
În cadrul secțiunii if __name__ == '__main__': se realizează următoarele acțiuni:

Se citește de la tastatură un număr întreg n.
Se citește de la tastatură o linie de numere întregi separate prin spațiu și se transformă într-o listă de numere întregi nums, folosind funcția map și split.
Se apelează funcția validare_date_intrare(n, nums) pentru a verifica validitatea datelor. Dacă datele sunt valide, se calculează media pătratică utilizând funcția media_patratica(nums) și se afișează valoarea acesteia.

2949 - Media Armonica

2023-06-29T17:52:56Z

Paul Ungur:

== Cerința ==
Se dau n numere naturale. Calculați media armonică a celor n numere citite cu 2 zecimale exacte.

== Date de intrare ==
Programul citește de la tastatură numărul n , iar apoi n numere naturale.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Datele sunt introduse corect."''', apoi programul va afișa pe ecran media armonică a celor n numere cu 2 zecimale exacte. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
 1 ≤ n ≤ 1000 
cele n numere citite vor fi mai mici decât 1.000.000

== Exemplu: ==
Intrare
: 5
: 1 2 3 4 5

Ieșire
: Datele sunt introduse corect.
: 2.18

== Rezolvare ==

<syntaxhighlight lang="python" line="1">
def validare_date_intrare(n, numere):
if not 1 <= n <= 1000:
print("Numărul n trebuie să fie între 1 și 1000!")
return False
if len(numere) != n:
print("Trebuie să introduceți exact {} numere!".format(n))
return False
for nr in numere:
if not 1 <= nr <= 1000000:
print("Numerele trebuie să fie cuprinse între 1 și 1.000.000!")
return False
print("Datele sunt introduse corect.")
return True

def calculare_media_armonica(n, numere):
suma_inverselor = 0
for nr in numere:
suma_inverselor += 1/nr
media_armonica = n / suma_inverselor
return media_armonica

if __name__ == '__main__':
n = int(input())
lista = list(map(int, input().split()))
if validare_date_intrare(n, lista):
media_armonica = calculare_media_armonica(n, lista)
print("%.2f" % media_armonica)
</syntaxhighlight>

==Explicatie cod==
Codul Python de mai sus definește două funcții: validare_date_intrare și calculare_media_armonica. Iată o explicație pentru fiecare dintre ele:

Funcția validare_date_intrare(n, numere):
Această funcție primește doi parametri, n și numere, reprezentând un număr și o listă de numere întregi.
Verifică mai întâi dacă n respectă restricțiile impuse: trebuie să fie între 1 și 1000. Dacă n nu respectă aceste restricții, afișează un mesaj de eroare și returnează False, semnalând că datele nu sunt valide.
Verifică apoi dacă lungimea listei numere este egală cu n. Dacă nu este, afișează un mesaj de eroare și returnează False, semnalând că datele nu sunt valide.
În final, se parcurge fiecare număr nr din lista numere și se verifică dacă fiecare număr respectă restricțiile impuse: trebuie să fie între 1 și 1.000.000. Dacă un număr nu respectă aceste restricții, afișează un mesaj de eroare și returnează False.
Dacă toate verificările sunt trecute fără a găsi probleme, funcția afișează un mesaj că datele sunt introduse corect și returnează True, semnalând că datele sunt valide.
Funcția calculare_media_armonica(n, numere):
Această funcție primește aceiași doi parametri, n și numere, ca și funcția validare_date_intrare.
Funcția calculează media armonică a numerelor din lista. Inițial, se inițializează o variabilă suma_inverselor cu valoarea 0.
Apoi, se parcurge fiecare număr nr din lista numere și se adaugă inversa acestuia la suma_inverselor.
După ce s-au adăugat inverselor tuturor numerelor, se calculează media armonică, împărțind n la suma_inverselor.
Funcția returnează valoarea mediei armonice.
În cadrul secțiunii if __name__ == '__main__': se realizează următoarele acțiuni:

Se citește de la tastatură un număr întreg n.
Se citește de la tastatură o linie de numere întregi separate prin spațiu și se transformă într-o listă de numere întregi lista, folosind funcția map și split.
Se apelează funcția validare_date_intrare(n, lista) pentru a verifica validitatea datelor. Dacă datele sunt valide, se calculează media armonică utilizând funcția calculare_media_armonica(n, lista) și se afișează valoarea acesteia utilizând formatul "%.2f" pentru a afișa două zecimale.

2299 - Media Geometrica

2023-06-29T17:52:15Z

Paul Ungur:

== Cerinta ==
Se dau n numere naturale. Calculați media lor geometrică.

== Date de intrare ==
Programul citește de la tastatură numărul natural n , apoi n numere naturale.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Datele sunt introduse corect."''', apoi programul va afișa pe ecran media geometrică a celor n numere. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
 1 < n ≤ 10 
numerele citite vor fi cuprinse între 0 și 50 .
rezultatul va fi punctat dacă diferența dintre cel afișat de program și cel corect este mai mică decât 0.01 .

== Exemplu ==
Intrare
: 4
: 2 4 2 1

Ieșire
: Datele sunt introduse corect.
: 2

== Explicație ==
 2⋅4⋅2⋅1−−−−−−−−√4=2 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def validare(n, lista):
# Verificăm dacă numărul n respectă restricțiile impuse
if not 1 < n <= 10:
print("Datele nu corespund restricțiilor impuse.")
return False

# Verificăm dacă numerele din listă respectă restricțiile impuse
for nr in lista:
if not 0 <= nr <= 50:
print("Datele nu corespund restricțiilor impuse.")
return False

# Toate validările au trecut
print("Datele sunt introduse corect.")
return True

def media_geometrica(n, lista):
produs = 1
for nr in lista:
produs *= nr
return produs ** (1 / n)

if __name__ == '__main__':
n = int(input())
lista = list(map(int, input().split()))
if validare(n, lista):
media = media_geometrica(n, lista)
print(int(media))

</syntaxhighlight>

==Explicatie cod==
Funcția validare(n, lista):
Această funcție primește doi parametri, n și lista, reprezentând un număr și o listă de numere întregi.
În primul rând, funcția verifică dacă n respectă restricțiile impuse: trebuie să fie mai mare decât 1 și mai mic sau egal cu 10. Dacă nu se respectă aceste restricții, afișează un mesaj de eroare și returnează False, semnalând că datele nu sunt valide.
Apoi, funcția verifică dacă fiecare număr din lista respectă restricțiile impuse: trebuie să fie între 0 și 50 (inclusiv). Dacă un număr nu respectă aceste restricții, afișează un mesaj de eroare și returnează False.
Dacă ambele verificări trec fără a găsi probleme, funcția afișează un mesaj că datele sunt introduse corect și returnează True, semnalând că datele sunt valide.
Funcția media_geometrica(n, lista):
Această funcție primește aceiași doi parametri, n și lista, ca și funcția validare.
Funcția calculează media geometrică a numerelor din lista. Inițial, se inițializează o variabilă produs cu valoarea 1.
Apoi, se parcurge fiecare număr nr din lista și se înmulțește produs cu nr.
După ce s-au înmulțit toate numerele din lista, se calculează media geometrică ridicând produs la puterea 1 / n, unde n este numărul dat ca parametru.
Funcția returnează valoarea mediei geometrice.
În cadrul secțiunii if __name__ == '__main__': se realizează următoarele acțiuni:

Se citește de la tastatură un număr întreg n.
Se citește de la tastatură o linie de numere întregi separate prin spațiu și se transformă într-o listă de numere întregi lista, folosind funcția map și split.
Se apelează funcția validare(n, lista) pentru a verifica validitatea datelor. Dacă datele sunt valide, se calculează media geometrică utilizând funcția media_geometrica(n, lista) și se afișează valoarea acesteia (convertită la întreg folosind int()).

2299 - Media Geometrica

2023-06-29T17:50:01Z

Paul Ungur:

== Cerinta ==
Se dau n numere naturale. Calculați media lor geometrică.

== Date de intrare ==
Programul citește de la tastatură numărul natural n , apoi n numere naturale.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: '''"Datele sunt introduse corect."''', apoi programul va afișa pe ecran media geometrică a celor n numere. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.
Programul va afișa pe ecran media geometrică a celor n numere.

== Restricții și precizări ==
 1 < n ≤ 10 
numerele citite vor fi cuprinse între 0 și 50 .
rezultatul va fi punctat dacă diferența dintre cel afișat de program și cel corect este mai mică decât 0.01 .

== Exemplu ==
Intrare
: 4
: 2 4 2 1

Ieșire
: Datele sunt introduse corect.
: 2

== Explicație ==
 2⋅4⋅2⋅1−−−−−−−−√4=2 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def validare(n, lista):
# Verificăm dacă numărul n respectă restricțiile impuse
if not 1 < n <= 10:
print("Datele nu corespund restricțiilor impuse.")
return False

# Verificăm dacă numerele din listă respectă restricțiile impuse
for nr in lista:
if not 0 <= nr <= 50:
print("Datele nu corespund restricțiilor impuse.")
return False

# Toate validările au trecut
print("Datele sunt introduse corect.")
return True

def media_geometrica(n, lista):
produs = 1
for nr in lista:
produs *= nr
return produs ** (1 / n)

if __name__ == '__main__':
n = int(input())
lista = list(map(int, input().split()))
if validare(n, lista):
media = media_geometrica(n, lista)
print(int(media))

</syntaxhighlight>

==Explicatie cod==
Funcția validare(n, lista):
Această funcție primește doi parametri, n și lista, reprezentând un număr și o listă de numere întregi.
În primul rând, funcția verifică dacă n respectă restricțiile impuse: trebuie să fie mai mare decât 1 și mai mic sau egal cu 10. Dacă nu se respectă aceste restricții, afișează un mesaj de eroare și returnează False, semnalând că datele nu sunt valide.
Apoi, funcția verifică dacă fiecare număr din lista respectă restricțiile impuse: trebuie să fie între 0 și 50 (inclusiv). Dacă un număr nu respectă aceste restricții, afișează un mesaj de eroare și returnează False.
Dacă ambele verificări trec fără a găsi probleme, funcția afișează un mesaj că datele sunt introduse corect și returnează True, semnalând că datele sunt valide.
Funcția media_geometrica(n, lista):
Această funcție primește aceiași doi parametri, n și lista, ca și funcția validare.
Funcția calculează media geometrică a numerelor din lista. Inițial, se inițializează o variabilă produs cu valoarea 1.
Apoi, se parcurge fiecare număr nr din lista și se înmulțește produs cu nr.
După ce s-au înmulțit toate numerele din lista, se calculează media geometrică ridicând produs la puterea 1 / n, unde n este numărul dat ca parametru.
Funcția returnează valoarea mediei geometrice.
În cadrul secțiunii if __name__ == '__main__': se realizează următoarele acțiuni:

Se citește de la tastatură un număr întreg n.
Se citește de la tastatură o linie de numere întregi separate prin spațiu și se transformă într-o listă de numere întregi lista, folosind funcția map și split.
Se apelează funcția validare(n, lista) pentru a verifica validitatea datelor. Dacă datele sunt valide, se calculează media geometrică utilizând funcția media_geometrica(n, lista) și se afișează valoarea acesteia (convertită la întreg folosind int()).

2112 - Tablita

2023-05-15T17:54:35Z

Paul Ungur:

Adrian participă la o expediţie, împreună cu colegii lui. La un moment dat, copiii descoperă, lângă un copac, 5 tăbliţe vechi. Primele 4 tăbliţe sunt inscripţionate complet. Prima tăbliţă conţinea textul : “Grupa 1 conţine numărul 1”, a doua tăbliţă avea textul : „Grupa 2 conţine numerele 2 şi 3”, a treia tăbliţă avea textul: „Grupa 3 contine numerele 4, 5 şi 6” , a patra tăbliţă avea textul: „Grupa 4 conţine numerele 7, 8, 9 şi 10.” Pe următoarea tăbliţă găsită era înscris un singur număr, celelalte numere şi numărul grupei erau şterse. Adrian le solicită colegilor lui să descopere ce grupă era scrisă pe a cincea tabliţă găsită.

==Cerința==
Descoperiţi regula de inscripţionare a tăbliţelor şi pentru numărul găsit pe a cincea tăbliţă, determinaţi din ce grupă face parte.

==Date de intrare==
Fişierul de intrare tablita.in conţine pe prima linie un număr natural N, ce reprezintă numărul care era înscris pe a cincea tăbliţă descoperită de Adrian.

==Date de ieșire==
Fişierul de ieşire tablita.out va conţine un număr natural ce reprezintă grupa în care se află numărul N, înscris pe a cincea tabliţă găsită.

==Restricții și precizări==
Un număr înscris pe o tăbliţă este nenul şi conţine cel mult 8 cifre;

==Exemplu:==
 tablita.in
100

 tablita.out
14

==Explicație==
Numărul 100 ce apare pe a cincea tăbliţă face parte din grupa 14.

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(n):
if not (1 <= n <= 100_000_000):
return False
return True

def tablita(n):
x, cnt = 1, 1
while x < n:
cnt += 1
x += cnt

with open("tablita.out", "w") as fout:
fout.write(str(cnt))

if __name__ == '__main__':
fin = open("tablita.in")
fout = open("tablita.out", "w")

n = int(fin.readline())
if validare(n):
print("Date de intrare valide")
tablita(n)
else:
print("Date de intrare invalide")

fin.close()
fout.close()
</syntaxhighlight>
==Explicatie cod:==
validare(n): Această funcție primește un număr întreg n și verifică dacă acesta se află în intervalul specificat, adică între 1 și 100.000.000. Dacă n nu se află în acest interval, funcția returnează False, altfel returnează True.
tablita(n): Această funcție primește un număr întreg n și calculează valoarea cnt reprezentând numărul de iterații necesare pentru a ajunge la x >= n. Inițial, x este setat la 1 și cnt este setat la 1. Apoi, se crește cnt cu 1 și se adaugă valoarea cnt la x până când x devine mai mare sau egal cu n. La final, rezultatul cnt este scris în fișierul "tablita.out".
În blocul __main__, se deschide fișierul de intrare "tablita.in" pentru citire și fișierul de ieșire "tablita.out" pentru scriere. Se citește numărul n din fișierul de intrare și se validează folosind funcția validare(). Dacă n este valid, se afișează "Date de intrare valide" și se apelează funcția tablita(n) pentru a calcula rezultatul și a-l scrie în fișierul de ieșire. În caz contrar, se afișează "Date de intrare invalide". La final, fișierele de intrare și de ieșire sunt închise.

2279 - Concurs Perf

2023-05-15T17:52:22Z

Paul Ungur:

==Cerința==
Chef vrea să organizeze un concurs. Previziunea nivelurilor de dificultate a problemelor poate fi o sarcină descurajantă. Chef vrea să echilibreze nivelurile de dificultate ale problemelor.

Să presupunem că un concurs a avut P participanți în total. O problemă care a fost rezolvată de cel puțin jumătate dintre participanți (adică P/2) este considerată ușoară. O problemă rezolvată de participanții de cel mult P/10 este considerată dificilă.

Chef vrea echilibru. Potrivit lui, un concurs echilibrat trebuie să aibă exact 1 problemă ușoară și exact 2 probleme grele. Vi se oferă descrierea problemelor N și numărul de participanți care rezolvă aceste probleme. Puteți spune dacă concursul a fost echilibrat sau nu?

==Date de intrare==
Primul rând conține un număr întreg T care indică numărul de cazuri de testare.
Prima linie a fiecărui caz de testat conține două numere întregi N și P indicând numărul de probleme, respectiv numărul de participanți.
Cea de-a doua linie conține N numere întregi, separate prin spațiu, al căror număr indică numărul de participanți care rezolvă problema cu numărul de ordine i.

==Date de ieșire==
Pentru fiecare caz, afișati da, dacă concursul este echilibrat, sau nu.

==Restricții și precizări==
 1 ≤ T, N ≤ 500
1 ≤ P ≤ 10^8^
1 ≤ numărul de participanți care rezolvă o problemă ≤ P

==Exemplu:==
Intrare
6
3 100
10 1 100
3 100
11 1 100
3 100
10 1 10
3 100
10 1 50
4 100
50 50 50 50
4 100
1 1 1 1

Ieșire
da
nu
nu
da
nu
nu

==Rezolvare==
<syntaxhighlight lang="python" line>
def validare(num_teste, nr_probleme, punctaj_maxim, probleme):
if num_teste <= 0 or nr_probleme <= 0 or punctaj_maxim <= 0:
return False
if len(probleme) != nr_probleme:
return False
if not all(1 <= x <= punctaj_maxim for x in probleme):
return False
return True

def citeste_input():
num_teste = int(input())
test_cases = []
for i in range(num_teste):
nr_probleme, punctaj_maxim = map(int, input().split())
probleme = list(map(int, input().split()))
if not validare(i+1, nr_probleme, punctaj_maxim, probleme):
return None
test_cases.append((nr_probleme, punctaj_maxim, probleme))
return test_cases

def este_balansata(nr_probleme, punctaj_maxim, probleme):
usor = 0
greu = 0
for i in range(nr_probleme):
if probleme[i] > punctaj_maxim // 2:
usor += 1
elif probleme[i] <= punctaj_maxim // 10:
greu += 1
return usor == 1 and greu == 2

if __name__ == '__main__':
teste = citeste_input()
if teste is None:
print("Input invalid")
for test in teste:
nr_probleme, punctaj_maxim, probleme = test
if este_balansata(nr_probleme, punctaj_maxim, probleme):
print("da")
else:
print("nu")
</syntaxhighlight>
==Explicatie cod:==
validare(num_teste, nr_probleme, punctaj_maxim, probleme): Această funcție primește ca parametri numărul de teste (num_teste), numărul de probleme (nr_probleme), punctajul maxim (punctaj_maxim) și o listă de punctaje pentru fiecare problemă (probleme). Scopul funcției este de a valida datele de intrare pentru un set de teste. Verificările includ asigurarea că numărul de teste, numărul de probleme și punctajul maxim sunt mai mari decât zero și că lungimea listei probleme este egală cu numărul de probleme. De asemenea, se verifică ca fiecare punctaj să fie cuprins între 1 și punctajul maxim inclusiv. Funcția returnează True dacă datele de intrare sunt valide și False în caz contrar.
citeste_input(): Această funcție nu primește niciun argument. Scopul ei este să citească datele de intrare și să construiască o listă de teste. Întâi se citește numărul total de teste (num_teste). Apoi, pentru fiecare test, se citește numărul de probleme (nr_probleme), punctajul maxim (punctaj_maxim) și lista de punctaje pentru fiecare problemă (probleme). După fiecare citire, se validează datele apelând funcția validare() și se verifică dacă rezultatul validării este False. Dacă datele de intrare sunt invalide, funcția returnează None. În caz contrar, se adaugă un tuplu format din numărul de probleme, punctajul maxim și lista de punctaje în lista test_cases. La final, funcția returnează lista de teste test_cases.
este_balansata(nr_probleme, punctaj_maxim, probleme): Această funcție primește numărul de probleme (nr_probleme), punctajul maxim (punctaj_maxim) și lista de punctaje pentru fiecare problemă (probleme) pentru un test specific. Scopul funcției este de a determina dacă distribuția punctajelor este echilibrată în funcție de cerințele urmărite. Se parcurge lista de punctaje și se numără de câte ori un punctaj este mai mare decât jumătate din punctajul maxim (usor) și de câte ori este mai mic sau egal cu un zecime din punctajul maxim (greu). Funcția returnează True dacă există exact o problemă ușoară (cu punctaj mai mare decât jumătate din punctajul maxim) și exact două probleme grele (cu punctaj mai mic sau egal cu un zecime din punctajul maxim). În caz contrar, funcția returnează False.