Bitnami MediaWiki - User contributions [en]

28260

2024-01-16T18:51:47Z

Sinn Erich: Pagină nouă: '''28260 (Dana Heuberger)''' '''Enunț''' Fie triunghiul echilateral ABC înscris în cercul de centru O și rază.1. Considerăm mulțimea M a punctelor X din plan cu proprietatea că <math>\overrightarrow{OX}= k</math> <math>\cdot \overrightarrow{OA} + m \cdot \overrightarrow{OB} + n \cdot \overrightarrow{OC}</math>,unde <math>k,m,n \in N^*</math>. Arătați că oricare ar fi punctele distincte <math>M,N,P \in M </math> există <math>Q\in\{M}\</math> astfel încât vecto...

'''28260 (Dana Heuberger)'''

'''Enunț'''

Fie triunghiul echilateral ABC înscris în cercul de centru O și rază.1.
Considerăm mulțimea M a punctelor X din plan cu proprietatea că <math>\overrightarrow{OX}= k</math> <math>\cdot \overrightarrow{OA} + m \cdot \overrightarrow{OB} + n \cdot \overrightarrow{OC}</math>,unde <math>k,m,n \in N^*</math>. Arătați că oricare ar fi punctele distincte <math>M,N,P \in M </math> există <math>Q\in\{M}\</math> astfel încât vectorii <math>\overrightarrow{MN}</math>, <math>\overrightarrow{PQ} </math> și <math>\overrightarrow{NM}+</math> <math>\overrightarrow{QP}</math> să formeze un triunghi echilateral.

'''Soluție'''

Formăm in plan o rețea de triunghiuri echilaterale ale căror vârfuri
se află pe drepte paralele echidistante, avand direcțiile dreptelor OA,OB și OC,
distanța ditre două drepte consecutive fiind de <math>\sqrt{3}</math>, ca în figura alăturată. Cum <math>\overrightarrow{OC}</math> = <math>-\overrightarrow{OC}</math> - <math>\overrightarrow{OC}</math> obținem că <math>X\in M</math> dacă și numai dacă există <math>p,q\in Z</math>, astfel încât <math>\overrightarrow{OX} = p</math> <math>\cdot</math> <math>\overrightarrow{OA} + q</math> <math>\cdot</math> <math>\overrightarrow{OB} </math>.

Analog,coordonatele lui <math>\overrightarrow{OX}</math> în baza <math>(\overrightarrow{OB},\,\overrightarrow{OC})</math>, precum și cele din baza <math>(\overrightarrow{OA},\,\overrightarrow{OC})</math> sunt întregi. De aici rezultă ușor că <math>M</math> este mulțimea tuturor vârfurilor rețelei.

Alegem punctele <math>M,N,P \in M </math>. Dacă vectorul <math>\overrightarrow{MN}</math> este paralel cu unul dintre vectorii <math>\overrightarrow{OA}</math>,<math>\overrightarrow{OB}</math>,<math>\overrightarrow{OA},</math> problema este evidentă. Dacă <math>\overrightarrow{MN}</math> nu este paralel cu niciunul dintre vectorii <math>\overrightarrow{OA},</math><math>\overrightarrow{OB},</math>,<math>\overrightarrow{OC},</math> fie <math>a,b\in Z^*</math> coordonatele lui <math>\overrightarrow{MN}</math> în baza <math>(\overrightarrow{OA},</math><math>\overrightarrow{OB})</math> și punctele <math>S,T,R,</math> astfel încât <math>\overrightarrow{SN} = a \cdot</math> <math>\overrightarrow{OA},</math> <math>\overrightarrow{MS} = b \cdot</math> <math>\overrightarrow{OB},</math>, <math>\overrightarrow{NR} = a \cdot</math> <math>\overrightarrow{OC},</math> și <math>\overrightarrow{RT} = b \cdot</math> <math>\overrightarrow{OA} </math>. Rezultă <math>\overrightarrow{MN} = a \cdot </math><math>\overrightarrow{OA}+ b \cdot</math> <math>\overrightarrow{OB} </math> și <math>\overrightarrow{NT} = a \cdot </math><math>\overrightarrow{OC} + b \cdot </math><math>\overrightarrow{OA} </math>.

Dacă <math>a \cdot b > 0,</math> atunci <math>m(\angle MSN) = m(\angle TRN) = 60^\circ</math> , iar daca <math>a \cdot b < 0,</math> atunci <math>m(\angle MSN) = m(\angle TRN) = 120^\circ</math>. Cum <math>MS = RT = |b|,</math> iar <math> SN = NR = |a|,</math> rezultă că triunghiurile <math>MNS</math> și <math>TNR</math> sunt congruente, deci <math>TN = MN </math> și <math>m(\angle MSN) = m(\angle TRN). </math>.

Întrucât <math>m(\angle SNR) = 60^\circ</math> , obținem și <math>m(\angle MNT) = 60^\circ</math>, deci triunghiul <math>MNT</math> este echilateral. Este suficient să alegem punctul <math>Q</math> astfel încât <math>\overrightarrow{PQ} =</math> <math>\overrightarrow{NT}</math> și problema este rezolvată.

'''Remarcă:'''
De fapt, triunghiul <math>TNR</math> este imaginea triunghiului <math>MNS</math> prin rotația de centru <math>N</math> și unghi de <math>60^/circ</math>.

Gazeta Matematică

2024-01-16T17:38:34Z

Sinn Erich:

Această pagină conține o listă cu numerele revistei ''[https://gmb.ssmr.ro/ Gazeta Matematică]'' care conțin articole/probleme cu autori membri ai [https://ssmr.cunbm.utcluj.ro/ Filialei Maramureș] a [https://ssmr.ro/ Societății de Științe Matematice din România].
{| class="wikitable mw-collapsible"
|+
!Anul
!Numărul
!Numărul problemei
!Clasa
!Domeniu
|-
|rowspan="13" |2022
|-
|rowspawn="3"|1
| [[28260]]
|
|Geometrie
|-

|rowspan="3"|1
| [[28247]]
|11
|Matrice
|-
| [[28250]]
|12
|integrala Riemann
|-
| [[28251]]
|12
|integrala Riemann
|-
|2
| [[S:L22.58]]
|10
| ecuație cu logaritmi
|-
|4 - [[Gazeta Matematică nr 4 2022|link]]
| [[28315]]
|10
|numere complexe
|-
|5
| [[28338]]
|10
|numere complexe
afixe
|-
|6-7-8
| [[28354]]
|9
|vectori
|-
|rowspan="4" |10 - [[Gazeta Matematică nr 10 2022|link]]
| [[28437]]
|11
|șir recurent
|-
|[[E:16379]]
|5
|numere naturale
|-
|[[E:16380]]
|5
|puteri
|-
|[[E:16382]]
|5
|puteri
|-
|rowspan="2"|11
| [[E:16407]]
|5
|cub perfect
|
|-
| [[28450]]
|9
|progresii aritmetice
|-
| rowspan="8" |2021
|rowspan = "3" |6-7-8 - [[Gazeta Matematică nr 6-7-8 din 2021|link]]
|[[E:15990]]
|5
|numere naturale
|-
| [[E:15991]]
|5
|numere naturale
|-
| [[E:15992]]
|5
|numere naturale
|-
|10
|[[28163]]
|
|
|-
|rowspan= "3" | 11
|[[28203]]
|12
|funcție primitivabilă
|-
|[[S:L21.287]]
|9
|puteri
|-
|[[S:E21.313]]
|8
|ecuație
|-
|rowspan= "1" | 12
|[[28208]]
|9
|vectori
|-
|rowspan ="5"|2020
|rowspan ="3"| 4 - [[Gazeta Matematică nr 4 2020|link]]
|[[15698|E:15698]]
|6
|pătrate perfecte
|-
|[[E:15694]]
|5
|teorema împărțirii cu rest
|-
|[[E:15695]]
|5
|numere naturale
|-
|5
|[[E:15714]]
|6
|divizibilitate
probabilitate
|-
|11
|[[27930]]
|
|
|-
|rowspan="3" |2018
|rowspan="3" |4 - [[Gazeta Matematică nr 4 2018|link]]
| [[S:E18.128]]
|
|
|-
|[[S:E18.131]]
|
|
|-
| [[S:E18.131]]
|
|
|-
|2017
|6-7-8
|[[27401]]
|10
|inegalitate
|-
|rowspan="10" |2015
|rowspan="2"|1
|[[27024]]
|12
|
|-
|[[27020]]
|10
|coeficienți binomiali
|-
|2 - [[Gazeta Matematică nr 2 2015|link]]
|[[27036]]
|11
|ecuații funcționale
|-
|3 - [[Gazeta Matematică nr 2 2015|link]]
|[[27024]]
|12
|ecuații funcționale
|-
|rowspan="6"|9
|[[E:14892]]
|8
|patrulater inscriptibil
|-
|[[S:E15.208]]
|5
|sumă de numere consecutive
|-
|[[S:E15.239]]
|8
|Teorema lui Pitagora
|-
|[[S:L15.236]]
|12
|funcție primitivabilă
|-
|[[S:L15.231]]
|12
|limita unui șir
|-
|[[S:L15.228]]
|11
|limita unui șir
|-
|-
|2014
|1
|[[14682]]
|6
|Geometrie
|-
|rowspan="2"| 2013
|rowspan="2"|1
|[[26713]]
|11
|șiruri, limită
|-
|E:[[14440]]
|5
|pătrat perfect
|-
|rowspan="4"| 2012
|rowspan="2"|4
|[[E:14336]]
|
|ecuație funcțională
|-
|[[E:14331]]
| 7 & 8
|numere prime
|-
|rowspan="2"|9 - [[Gazeta Matematică nr 9 2012|link]]
|E:[[14380]]
|5
|numere naturale
|-
|[[14383|E:14383]]
|6
|cmmdc & cmmmc
|-
|rowspan="2"| 2011
|rowspan="2"|7-8-9 - [[Gazeta Matematică nr 789 2011|link]]
|[[E:14223]]
|7
|rezolvarea triunghiului
|-
|[[E:14228]]
|7
|radicali
|}

1915 - Numar Minim 1

2023-04-29T20:08:51Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Georgiana nu are clipă de răgaz. Profesorul de info îi cere acum să afle cel mai mic număr natural de '''n''' cifre care împărţit la b dă restul '''rest'''. Poate o ajutaţi să treacă şi peste acest hop.

== Date de intrare ==
Programul citește de la tastatură numerele''' n, b şi rest'''.

== Date de ieșire ==
Programul va afișa pe ecran numărul cerut.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cel mai mic număr natural de n cifre care împărţit la b dă restul '''rest'''.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 100.000

2 ≤ '''b''' ≤ 1.000.000.000

0 ≤ '''rest''' < b

dacă numărul nu există se va afişa -1

== Exemplul 1 ==
; Datele de intrare
: Introduceți numărul de cifre:
: 5
:Introduceți divizorul:
: 97
:Introduceți restul:
: 14
; Datele de ieșire
: Datele sunt introduse corect.
: Cel mai mic număr de 5 cifre care împărțit la 97 dă restul 14 este 10005
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1915
def get_next_number(numar, n):
"""
Returnează următorul număr natural de n cifre care urmează după numar.
"""
return numar + 10**(n - len(str(numar))) if numar + 1 >= 10**(n - 1) else 10**(n - 1)

def find_number(n, b, rest):
"""
Găsește cel mai mic număr natural de n cifre care împărțit la b dă restul rest.
"""
numar = 0
while True:
numar = get_next_number(numar, n)
if numar > 10**n - 1:
return -1
if numar % b == rest:
return numar

def validate_input(n, b, rest):
"""
Verifică dacă valorile introduse pentru n, b și rest respectă restricțiile impuse.
"""
if n <= 0 or n > 100000 or b < 2 or b > 1000000000 or rest < 0 or rest >= b:
print("Datele nu corespund restricțiilor impuse.")
return False
print("Datele sunt introduse corect.")
return True

if __name__ == '__main__':
"""
Funcția principală care citește numerele de la tastatură și afișează numărul cerut.
"""
n = int(input("Introduceți numărul de cifre: "))
b = int(input("Introduceți divizorul: "))
rest = int(input("Introduceți restul: "))

if not validate_input(n, b, rest):
exit()

numar_cautat = find_number(n, b, rest)
print("Cel mai mic număr de", n, "cifre care împărțit la", b, "dă restul", rest, "este", numar_cautat)

</syntaxhighlight>
'''Explicatie cod:'''
Acest cod conține 3 funcții și o funcție principală:

Funcția get_next_number(numar, n) primește un număr natural numar și numărul de cifre n și returnează următorul număr natural de n cifre care urmează după numar. Pentru aceasta, funcția adaugă 10**(n - len(str(numar))) la numar dacă numar + 1 este mai mare sau egal cu 10**(n - 1) (adică numărul numar + 1 are cel puțin n cifre), altfel returnează 10**(n - 1).

Funcția find_number(n, b, rest) primește numărul de cifre n, divizorul b și restul rest și returnează cel mai mic număr natural de n cifre care împărțit la b dă restul rest. Funcția caută numărul începând de la 0, apelând funcția get_next_number() și verificând dacă numărul respectiv împărțit la b dă restul rest. Dacă da, atunci funcția returnează numărul găsit.

Funcția principală main() citește numerele de la tastatură și afișează numărul cerut apelând funcția find_number().

Astfel, programul determină cel mai mic număr natural de n cifre care împărțit la b dă restul rest folosind cele trei funcții descrise mai sus.

3166 - Vas 1

2023-04-29T20:04:48Z

Sinn Erich: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Într-un vas sunt '''apa_initiala''' litri de apă '''(apa_initiala>0)'''. După fiecare '''t''' minute, '''apa_initiala\rata_evaporare''' din cantitatea de apă rămasă se evaporă. Să se determine după câte minute vor rămâne în vas cel mult '''apa_minima''' litri de apă.

== Date de intrare ==
Programul citește de la tastatură patru numere naturale '''apa_initiala,timp_evaporare,apa_minima,rata_evaporare'''.

== Date de ieșire ==
Programul va afișa pe ecran numărul de minute necesare astfel încât in vas sa rămână cel mult '''apa_minima''' litri de apa.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează după câte minute vor rămâne în vas cel mult '''apa_minima''' litri de apă.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''apa_initiala,timp_evaporare,apa_minima''' ≤ 1.000.000.000

2 ≤ '''rata_evaporare''' ≤ 100

== Exemplul 1 ==
; Datele de intrare
:Introduceti apa initiala,timpul de evaporare,apa minima si rata de evaporare separate prin spatiu:
: 100 15 20 5
; Datele de ieșire
: Datele sunt introduse corect.
:Dupa 210 minute, vor ramane in vas cel mult 20 litri de apa
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3166
def calculate_remaining_water_time(apa_initiala, timp_evaporare, apa_minima, rata_evaporare):
remaining_water = apa_initiala
elapsed_time = 0
while remaining_water>rata_evaporare:
evaporated_water = remaining_water / rata_evaporare
remaining_water -= evaporated_water
elapsed_time += timp_evaporare
return elapsed_time

def validate_input(apa_initiala, timp_evaporare, apa_minima, rata_evaporare):
if not (1 <= apa_initiala <= 1000000000 and 1 <= timp_evaporare <= 1000000000 and 1 <= apa_minima <= 1000000000 and 2 <= rata_evaporare <= 100):
return False
return True

if __name__ == '__main__':
apa_initiala, timp_evaporare, apa_minima, rata_evaporare = map(int, input("Introduceti X T Y I, separate prin spatiu: ").split())
if not validate_input(apa_initiala, timp_evaporare, apa_minima, rata_evaporare):
print("Datele introduse nu corespund restrictiilor impuse.")
else:
elapsed_time = calculate_remaining_water_time(apa_initiala, timp_evaporare, apa_minima, rata_evaporare)
print("Datele sunt introduse corect.")
print("Dupa", elapsed_time, "minute, vor ramane in vas cel mult", apa_minima, "litri de apa")
</syntaxhighlight>

'''Explicatie cod:'''

Acest cod are rolul de a calcula timpul necesar pentru ca cantitatea de apa dintr-un vas sa ajunga la o cantitate minima dupa evaporare, pe baza datelor de intrare: cantitatea initiala de apa din vas, timpul de evaporare pentru fiecare unitate de apa, cantitatea minima de apa pe care dorim sa o lasam in vas si rata de evaporare.

Funcția calculate_remaining_water_time primește ca parametri cantitatea inițială de apă, timpul de evaporare pentru fiecare unitate de apă, cantitatea minimă de apă pe care dorim să o lăsăm în vas și rata de evaporare. Ea calculează timpul necesar pentru ca cantitatea de apă din vas să ajungă la cantitatea minimă prin scăderea continuă a cantității de apă evaporată de rata de evaporare.

Funcția validate_input primește ca parametri datele de intrare și returnează True dacă acestea respectă restricțiile impuse (cantitățile de apă trebuie să fie între 1 și 1.000.000.000, timpul de evaporare între 1 și 1.000.000.000, cantitatea minimă de apă între 1 și 1.000.000.000 și rata de evaporare între 2 și 100), altfel returnează False.

În secțiunea principală, se cere utilizatorului să introducă cantitatea inițială de apă din vas, timpul de evaporare pentru fiecare unitate de apă, cantitatea minimă de apă pe care dorim să o lăsăm în vas și rata de evaporare. Se validează datele de intrare cu ajutorul funcției validate_input, iar dacă acestea sunt valide, se calculează timpul necesar pentru evaporare cu ajutorul funcției calculate_remaining_water_time și se afișează rezultatul. În caz contrar, se afișează un mesaj de eroare.

1910 - Numar Minim 0

2023-04-29T20:00:59Z

Sinn Erich: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Georgiana a mai primit o problemă de la doamna profesor. Se dau '''n''' triplete de forma '''primul_nr, al_doilea_nr, rest,''' iar pentru fiecare triplet Georgiana trebuie să afle care este cel mai mic număr natural format cu '''primul_nr''' , care împărţit la '''al_doilea_nr''' dă restul '''rest'''.

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

== Date de ieșire ==
Programul va afișa pe ecran, pe '''linii separate''', cele '''n''' numere cerute.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează care este cel mai mic număr natural format cu n_cifre , care împărţit la m_cifre dă restul rest.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 10

1 ≤ '''primul_nr''' ≤ 100.000

2 ≤ '''al_doilea_nr''' ≤ 10

0 ≤ '''rest''' < b

== Exemplul 1 ==
; Datele de intrare
: Introduceti numarul de triplete:
: 3
: Introduceti tripletul 1 de forma m_cifre n_cifre rest:
: 2 3 1
:Introduceti tripletul 2 de forma m_cifre n_cifre rest:
: 3 5 4
:Introduceti tripletul 3 de forma m_cifre n_cifre rest:
: 4 6 0
; Datele de ieșire
: Datele sunt introduse corect.
: 10
: 104
: 1002
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1910
def gaseste_numar(m_cifre, n_cifre, rest):
for j in range(10**(m_cifre-1), 10**m_cifre):
if j % n_cifre == rest:
return j

def validate_input(m_cifre, n_cifre, rest):
if not (1 <= m_cifre <= 100000) or not (2 <= n_cifre <= 10) or not (0 <= rest < n_cifre):
return False
return True

if __name__ == '__main__':
n = int(input("Introduceti numarul de triplete: "))
for i in range(n):
m_cifre, n_cifre, rest = map(int, input("Introduceti tripletul {} de forma m_cifre n_cifre rest: ".format(i+1)).split())
if not validate_input(m_cifre, n_cifre, rest):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print(gaseste_numar(m_cifre, n_cifre, rest))

</syntaxhighlight>

'''Explicatie cod:'''

Acest program primește de la utilizator un număr n, care reprezintă numărul de triplete de forma m, b, r ce urmează să fie introduse.

Apoi, într-un for loop, pentru fiecare triplet introdus, este apelată funcția de validare validate_input care verifică dacă m respectă restricțiile de la 1 la 100000, b respectă restricțiile de la 2 la 10 și r respectă restricția de la 0 la b-1. Dacă tripletul introdus nu respectă aceste restricții, se afișează un mesaj de eroare.

Dacă tripletul este valid, atunci este apelată funcția gaseste_numar, care găsește cel mai mic număr natural cu m cifre, care împărțit la b dă restul r și îl afișează pe ecran.

Funcția gaseste_numar lucrează în felul următor: pentru fiecare număr j din intervalul [10**(m-1), 10**m), verifică dacă j împărțit la b dă restul r. Dacă da, atunci acesta este cel mai mic număr cu m cifre care împărțit la b dă restul r și îl returnează. Dacă nu, continuă cu următorul număr până găsește unul care să satisfacă condiția dată.

1915 - Numar Minim 1

2023-04-29T19:59:02Z

Sinn Erich: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Georgiana nu are clipă de răgaz. Profesorul de info îi cere acum să afle cel mai mic număr natural de '''n''' cifre care împărţit la b dă restul '''rest'''. Poate o ajutaţi să treacă şi peste acest hop.

== Date de intrare ==
Programul citește de la tastatură numerele''' n, b şi rest'''.

== Date de ieșire ==
Programul va afișa pe ecran numărul cerut.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cel mai mic număr natural de n cifre care împărţit la b dă restul '''rest'''.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 100.000

2 ≤ '''b''' ≤ 1.000.000.000

0 ≤ '''rest''' < b

dacă numărul nu există se va afişa -1

== Exemplul 1 ==
; Datele de intrare
: Introduceți numărul de cifre:
: 5
:Introduceți divizorul:
: 97
:Introduceți restul:
: 14
; Datele de ieșire
: Datele sunt introduse corect.
: Cel mai mic număr de 5 cifre care împărțit la 97 dă restul 14 este 10005
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1915
def get_next_number(numar, n):
"""
Returnează următorul număr natural de n cifre care urmează după numar.
"""
return numar + 10**(n - len(str(numar))) if numar + 1 >= 10**(n - 1) else 10**(n - 1)

def find_number(n, b, r):
"""
Găsește cel mai mic număr natural de n cifre care împărțit la b dă restul r.
"""
numar = 0
while True:
numar = get_next_number(numar, n)
if numar > 10**n - 1:
return -1
if numar % b == r:
return numar

def validate_input(n, b, r):
"""
Verifică dacă valorile introduse pentru n, b și r respectă restricțiile impuse.
"""
if n <= 0 or n > 100000 or b < 2 or b > 1000000000 or r < 0 or r >= b:
print("Datele nu corespund restricțiilor impuse.")
return False
print("Datele sunt introduse corect.")
return True

if __name__ == '__main__':
"""
Funcția principală care citește numerele de la tastatură și afișează numărul cerut.
"""
n = int(input("Introduceți numărul de cifre: "))
b = int(input("Introduceți divizorul: "))
r = int(input("Introduceți restul: "))

if not validate_input(n, b, r):
exit()

numar_cautat = find_number(n, b, r)
print("Cel mai mic număr de", n, "cifre care împărțit la", b, "dă restul", r, "este", numar_cautat)

</syntaxhighlight>
'''Explicatie cod:'''
Acest cod conține 3 funcții și o funcție principală:

Funcția get_next_number(numar, n) primește un număr natural numar și numărul de cifre n și returnează următorul număr natural de n cifre care urmează după numar. Pentru aceasta, funcția adaugă 10**(n - len(str(numar))) la numar dacă numar + 1 este mai mare sau egal cu 10**(n - 1) (adică numărul numar + 1 are cel puțin n cifre), altfel returnează 10**(n - 1).

Funcția find_number(n, b, r) primește numărul de cifre n, divizorul b și restul r și returnează cel mai mic număr natural de n cifre care împărțit la b dă restul r. Funcția caută numărul începând de la 0, apelând funcția get_next_number() și verificând dacă numărul respectiv împărțit la b dă restul r. Dacă da, atunci funcția returnează numărul găsit.

Funcția principală main() citește numerele de la tastatură și afișează numărul cerut apelând funcția find_number().

Astfel, programul determină cel mai mic număr natural de n cifre care împărțit la b dă restul r folosind cele trei funcții descrise mai sus.

2037 - Dec 2 Ord

2023-04-29T09:47:24Z

Sinn Erich: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Vrăjitorul Arpsod are foarte multă treabă, așa că s-a gândit să vă ocupe timpul cu o problemă foarte grea, astfel încât acesta să poată lucra liniștit la proiectele sale despre stăpânirea lumii.

Acesta vă dă '''N''' numere naturale. Pentru fiecare număr '''A''' trebuie să găsiți cel mai mare '''K''' cu proprietatea că există un șir '''B''' de numere naturale nenule, nu neapărat distincte, astfel încât: '''(B1 + 1)(B2 + 1)...(BK + 1) = A'''

Arătați-i vrăjitorului că problema nu e suficient de grea pentru voi, găsind numărul '''K''' cerut într-un timp cât mai scurt, pentru fiecare din cele '''N''' numere.

== Date de intrare ==
Programul va conţine pe prima linie numărul natural '''N''', reprezentând numărul de valori date. Urmează apoi '''N''' linii. Pe fiecare linie va exista un număr '''A''', numărul dat de Arpsod.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează un număr '''K''', reprezentând numărul maxim de termeni pe care îi poate avea șirul, astfel încât să respecte proprietatea cerută. Prima linie reprezintă raspunsul pentru primul număr, a doua penrtu cel de-al doilea … şamd.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==

1 ≤ '''N''' ≤ 500

2 ≤ '''A''' ≤ 2.000.000.000

== Exemplul 1 ==
; Datele de intrare
:Numarul N este:
: 1
:Numarul A este:
: 4
; Datele de ieșire
: Datele sunt introduse corect.
: 2
 

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

def validate_input(a):
if not (2 <= a <= 2000000000):
return False
return True

def calculate_k(a):
k = 0
while a % 2 == 0:
k += 1
a //= 2
for i in range(3, int(math.sqrt(a))+1, 2):
while a % i == 0:
k += 1
a //= i
if a > 2:
k += 1
return k

if __name__ == '__main__':
n = int(input("Numarul N este:"))
for i in range(n):
a = int(input("Numarul A este:"))
if not validate_input(a):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
k = calculate_k(a)
print(k)

</syntaxhighlight>

'''Explicatie cod:'''

Importul "math" este o bibliotecă standard în Python, care oferă o serie de funcții matematice.

Funcția validate_input(a) verifică dacă numărul a respectă restricțiile impuse. În caz afirmativ, returnează True, altfel returnează False.

Funcția calculate_k(a) primește ca parametru numărul a și calculează cel mai mare număr k astfel încât există un șir B de k numere naturale nenule, nu neapărat distincte, astfel încât produsul (B1 + 1)(B2 + 1)...(BK + 1) să fie egal cu a. Pentru a afla acest număr, se parcurg toți factorii primi ai lui a, iar pentru fiecare factor se împarte numărul a la factorul respectiv cât timp acesta este un divizor, crescând în același timp numărul k cu 1. Dacă la sfârșitul parcurgerii mai rămâne un factor mai mare decât 2, atunci și acesta trebuie inclus în produs, deci se adaugă încă un 1 la k.

În blocul if __name__ == '__main__': se citește numărul t de valori date, apoi se parcurg acestea. Pentru fiecare valoare se verifică dacă respectă restricțiile cu ajutorul funcției validate_input(a). Dacă nu respectă, se afișează un mesaj corespunzător. Altfel, se calculează numărul k cu ajutorul funcției calculate_k(a) și se afișează rezultatul.

2037 - Dec 2 Ord

2023-04-29T09:46:53Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Vrăjitorul Arpsod are foarte multă treabă, așa că s-a gândit să vă ocupe timpul cu o problemă foarte grea, astfel încât acesta să poată lucra liniștit la proiectele sale despre stăpânirea lumii.

Acesta vă dă '''N''' numere naturale. Pentru fiecare număr '''A''' trebuie să găsiți cel mai mare '''K''' cu proprietatea că există un șir '''B''' de numere naturale nenule, nu neapărat distincte, astfel încât: '''(B1 + 1)(B2 + 1)...(BK + 1) = A'''

Arătați-i vrăjitorului că problema nu e suficient de grea pentru voi, găsind numărul '''K''' cerut într-un timp cât mai scurt, pentru fiecare din cele '''N''' numere.

== Date de intrare ==
Programul va conţine pe prima linie numărul natural '''N''', reprezentând numărul de valori date. Urmează apoi '''N''' linii. Pe fiecare linie va exista un număr '''A''', numărul dat de Arpsod.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează un număr '''K''', reprezentând numărul maxim de termeni pe care îi poate avea șirul, astfel încât să respecte proprietatea cerută. Prima linie reprezintă raspunsul pentru primul număr, a doua penrtu cel de-al doilea … şamd.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==

1 ≤ '''N''' ≤ 500

2 ≤ '''A''' ≤ 2.000.000.000

== Exemplul 1 ==
; Datele de intrare
: 1
: 4
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

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

def validate_input(a):
if not (2 <= a <= 2000000000):
return False
return True

def calculate_k(a):
k = 0
while a % 2 == 0:
k += 1
a //= 2
for i in range(3, int(math.sqrt(a))+1, 2):
while a % i == 0:
k += 1
a //= i
if a > 2:
k += 1
return k

if __name__ == '__main__':
n = int(input("Numarul N este:"))
for i in range(n):
a = int(input("Numarul A este:"))
if not validate_input(a):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
k = calculate_k(a)
print(k)

</syntaxhighlight>

'''Explicatie cod:'''

Importul "math" este o bibliotecă standard în Python, care oferă o serie de funcții matematice.

Funcția validate_input(a) verifică dacă numărul a respectă restricțiile impuse. În caz afirmativ, returnează True, altfel returnează False.

Funcția calculate_k(a) primește ca parametru numărul a și calculează cel mai mare număr k astfel încât există un șir B de k numere naturale nenule, nu neapărat distincte, astfel încât produsul (B1 + 1)(B2 + 1)...(BK + 1) să fie egal cu a. Pentru a afla acest număr, se parcurg toți factorii primi ai lui a, iar pentru fiecare factor se împarte numărul a la factorul respectiv cât timp acesta este un divizor, crescând în același timp numărul k cu 1. Dacă la sfârșitul parcurgerii mai rămâne un factor mai mare decât 2, atunci și acesta trebuie inclus în produs, deci se adaugă încă un 1 la k.

În blocul if __name__ == '__main__': se citește numărul t de valori date, apoi se parcurg acestea. Pentru fiecare valoare se verifică dacă respectă restricțiile cu ajutorul funcției validate_input(a). Dacă nu respectă, se afișează un mesaj corespunzător. Altfel, se calculează numărul k cu ajutorul funcției calculate_k(a) și se afișează rezultatul.

2037 - Dec 2 Ord

2023-04-29T09:44:56Z

Sinn Erich: /* Restricţii şi precizări */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Vrăjitorul Arpsod are foarte multă treabă, așa că s-a gândit să vă ocupe timpul cu o problemă foarte grea, astfel încât acesta să poată lucra liniștit la proiectele sale despre stăpânirea lumii.

Acesta vă dă '''N''' numere naturale. Pentru fiecare număr '''A''' trebuie să găsiți cel mai mare '''K''' cu proprietatea că există un șir '''B''' de numere naturale nenule, nu neapărat distincte, astfel încât: '''(B1 + 1)(B2 + 1)...(BK + 1) = A'''

Arătați-i vrăjitorului că problema nu e suficient de grea pentru voi, găsind numărul '''K''' cerut într-un timp cât mai scurt, pentru fiecare din cele '''N''' numere.

== Date de intrare ==
Programul va conţine pe prima linie numărul natural '''N''', reprezentând numărul de valori date. Urmează apoi '''N''' linii. Pe fiecare linie va exista un număr '''A''', numărul dat de Arpsod.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează un număr '''K''', reprezentând numărul maxim de termeni pe care îi poate avea șirul, astfel încât să respecte proprietatea cerută. Prima linie reprezintă raspunsul pentru primul număr, a doua penrtu cel de-al doilea … şamd.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==

1 ≤ '''N''' ≤ 500

2 ≤ '''A''' ≤ 2.000.000.000

== Exemplul 1 ==
; Datele de intrare
: 1
: 4
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

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

# function for factorizing a number into prime factors
def factorize(n):
factors = []
while n % 2 == 0:
factors.append(2)
n //= 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
factors.append(i)
n //= i
if n > 2:
factors.append(n)
return factors

# function for finding the maximum value of k
def find_k(a):
factors = factorize(a)
max_k = 1
for p in set(factors):
k = factors.count(p)
while a % (p ** k) == 0:
k += 1
max_k = max(max_k, k - 1)
return max_k
def validate_input(t: int, a: int) -> bool:
if not (1 <= t <= 500):
print("Numărul de teste nu respectă restricțiile impuse.")
return False
if not (2 <= a <= 2000000000):
print("Numărul a nu respectă restricțiile impuse.")
return False
return True

if __name__ == '__main__':
t = int(input("t:"))
a = int(input("a:"))
if validate_input(t, a):
for i in range(t):
k = find_k(a)
print(k)
print("Datele sunt introduse corect.")

</syntaxhighlight>

'''Explicatie cod:'''

Importul "math" este o bibliotecă standard în Python, care oferă o serie de funcții matematice. În acest cod, este utilizată funcția "sqrt" pentru a găsi rădăcina pătrată a unui număr în funcția "factorize".

Funcția "factorize" primește un număr "n" și returnează o listă cu factorii primi ai numărului. Algoritmul utilizat este metoda divizării repetate a numerelor la 2 și apoi testarea divizorilor impari de la 3 la radicalul pătrat al numărului "n". Pentru fiecare divizor găsit, se adaugă la lista "factors" și se împarte numărul "n" la acel divizor, până când acesta nu mai poate fi împărțit.

Funcția "find_k" primește un număr "a" și calculează cel mai mare exponent "k", astfel încât numărul să poată fi scris ca un produs de numere prime ridicate la puterea "k". Pentru fiecare factor prim al numărului "a", se calculează câte apariții are în lista de factori ai lui "a". Apoi, se caută cel mai mare "k" astfel încât "a" să fie divizibil cu puterea a "p" la "k". Valoarea maximă a "k" este returnată.

La sfârșitul programului, utilizând condiția "if name == 'main'", se verifică dacă codul este rulat direct sau importat ca modul într-un alt program. În cazul în care programul este rulat direct, se citește numărul de cazuri de testare și se verifică dacă se încadrează în intervalul specificat, precum și pentru fiecare valoare a lui "a". Dacă nu se îndeplinesc restricțiile, se afișează un mesaj de eroare și programul se termină. În caz contrar, se rezolvă fiecare caz de testare și se afișează răspunsul.

2037 - Dec 2 Ord

2023-04-29T09:44:48Z

Sinn Erich: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Vrăjitorul Arpsod are foarte multă treabă, așa că s-a gândit să vă ocupe timpul cu o problemă foarte grea, astfel încât acesta să poată lucra liniștit la proiectele sale despre stăpânirea lumii.

Acesta vă dă '''N''' numere naturale. Pentru fiecare număr '''A''' trebuie să găsiți cel mai mare '''K''' cu proprietatea că există un șir '''B''' de numere naturale nenule, nu neapărat distincte, astfel încât: '''(B1 + 1)(B2 + 1)...(BK + 1) = A'''

Arătați-i vrăjitorului că problema nu e suficient de grea pentru voi, găsind numărul '''K''' cerut într-un timp cât mai scurt, pentru fiecare din cele '''N''' numere.

== Date de intrare ==
Programul va conţine pe prima linie numărul natural '''N''', reprezentând numărul de valori date. Urmează apoi '''N''' linii. Pe fiecare linie va exista un număr '''A''', numărul dat de Arpsod.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează un număr '''K''', reprezentând numărul maxim de termeni pe care îi poate avea șirul, astfel încât să respecte proprietatea cerută. Prima linie reprezintă raspunsul pentru primul număr, a doua penrtu cel de-al doilea … şamd.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==

1 ≤ '''T''' ≤ 500

2 ≤ '''A''' ≤ 2.000.000.000

== Exemplul 1 ==
; Datele de intrare
: 1
: 4
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

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

# function for factorizing a number into prime factors
def factorize(n):
factors = []
while n % 2 == 0:
factors.append(2)
n //= 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
factors.append(i)
n //= i
if n > 2:
factors.append(n)
return factors

# function for finding the maximum value of k
def find_k(a):
factors = factorize(a)
max_k = 1
for p in set(factors):
k = factors.count(p)
while a % (p ** k) == 0:
k += 1
max_k = max(max_k, k - 1)
return max_k
def validate_input(t: int, a: int) -> bool:
if not (1 <= t <= 500):
print("Numărul de teste nu respectă restricțiile impuse.")
return False
if not (2 <= a <= 2000000000):
print("Numărul a nu respectă restricțiile impuse.")
return False
return True

if __name__ == '__main__':
t = int(input("t:"))
a = int(input("a:"))
if validate_input(t, a):
for i in range(t):
k = find_k(a)
print(k)
print("Datele sunt introduse corect.")

</syntaxhighlight>

'''Explicatie cod:'''

Importul "math" este o bibliotecă standard în Python, care oferă o serie de funcții matematice. În acest cod, este utilizată funcția "sqrt" pentru a găsi rădăcina pătrată a unui număr în funcția "factorize".

Funcția "factorize" primește un număr "n" și returnează o listă cu factorii primi ai numărului. Algoritmul utilizat este metoda divizării repetate a numerelor la 2 și apoi testarea divizorilor impari de la 3 la radicalul pătrat al numărului "n". Pentru fiecare divizor găsit, se adaugă la lista "factors" și se împarte numărul "n" la acel divizor, până când acesta nu mai poate fi împărțit.

Funcția "find_k" primește un număr "a" și calculează cel mai mare exponent "k", astfel încât numărul să poată fi scris ca un produs de numere prime ridicate la puterea "k". Pentru fiecare factor prim al numărului "a", se calculează câte apariții are în lista de factori ai lui "a". Apoi, se caută cel mai mare "k" astfel încât "a" să fie divizibil cu puterea a "p" la "k". Valoarea maximă a "k" este returnată.

La sfârșitul programului, utilizând condiția "if name == 'main'", se verifică dacă codul este rulat direct sau importat ca modul într-un alt program. În cazul în care programul este rulat direct, se citește numărul de cazuri de testare și se verifică dacă se încadrează în intervalul specificat, precum și pentru fiecare valoare a lui "a". Dacă nu se îndeplinesc restricțiile, se afișează un mesaj de eroare și programul se termină. În caz contrar, se rezolvă fiecare caz de testare și se afișează răspunsul.

2037 - Dec 2 Ord

2023-04-29T09:42:54Z

Sinn Erich: /* Date de intrare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Vrăjitorul Arpsod are foarte multă treabă, așa că s-a gândit să vă ocupe timpul cu o problemă foarte grea, astfel încât acesta să poată lucra liniștit la proiectele sale despre stăpânirea lumii.

Acesta vă dă '''N''' numere naturale. Pentru fiecare număr '''A''' trebuie să găsiți cel mai mare '''K''' cu proprietatea că există un șir '''B''' de numere naturale nenule, nu neapărat distincte, astfel încât: '''(B1 + 1)(B2 + 1)...(BK + 1) = A'''

Arătați-i vrăjitorului că problema nu e suficient de grea pentru voi, găsind numărul '''K''' cerut într-un timp cât mai scurt, pentru fiecare din cele '''N''' numere.

== Date de intrare ==
Programul va conţine pe prima linie numărul natural '''N''', reprezentând numărul de valori date. Urmează apoi '''N''' linii. Pe fiecare linie va exista un număr '''A''', numărul dat de Arpsod.

== Date de ieșire ==
Programul va conţine '''T''' linii. Pe fiecare linie va exista un număr '''K''', reprezentând numărul maxim de termeni pe care îi poate avea șirul, astfel încât să respecte proprietatea cerută. Prima linie reprezintă raspunsul pentru primul număr, a doua penrtu cel de-al doilea … şamd.

Dacă datele sunt introduse corect, programul va rula.

Î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 ≤ '''T''' ≤ 500

2 ≤ '''A''' ≤ 2.000.000.000

== Exemplul 1 ==
; Datele de intrare
: 1
: 4
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

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

# function for factorizing a number into prime factors
def factorize(n):
factors = []
while n % 2 == 0:
factors.append(2)
n //= 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
factors.append(i)
n //= i
if n > 2:
factors.append(n)
return factors

# function for finding the maximum value of k
def find_k(a):
factors = factorize(a)
max_k = 1
for p in set(factors):
k = factors.count(p)
while a % (p ** k) == 0:
k += 1
max_k = max(max_k, k - 1)
return max_k
def validate_input(t: int, a: int) -> bool:
if not (1 <= t <= 500):
print("Numărul de teste nu respectă restricțiile impuse.")
return False
if not (2 <= a <= 2000000000):
print("Numărul a nu respectă restricțiile impuse.")
return False
return True

if __name__ == '__main__':
t = int(input("t:"))
a = int(input("a:"))
if validate_input(t, a):
for i in range(t):
k = find_k(a)
print(k)
print("Datele sunt introduse corect.")

</syntaxhighlight>

'''Explicatie cod:'''

Importul "math" este o bibliotecă standard în Python, care oferă o serie de funcții matematice. În acest cod, este utilizată funcția "sqrt" pentru a găsi rădăcina pătrată a unui număr în funcția "factorize".

Funcția "factorize" primește un număr "n" și returnează o listă cu factorii primi ai numărului. Algoritmul utilizat este metoda divizării repetate a numerelor la 2 și apoi testarea divizorilor impari de la 3 la radicalul pătrat al numărului "n". Pentru fiecare divizor găsit, se adaugă la lista "factors" și se împarte numărul "n" la acel divizor, până când acesta nu mai poate fi împărțit.

Funcția "find_k" primește un număr "a" și calculează cel mai mare exponent "k", astfel încât numărul să poată fi scris ca un produs de numere prime ridicate la puterea "k". Pentru fiecare factor prim al numărului "a", se calculează câte apariții are în lista de factori ai lui "a". Apoi, se caută cel mai mare "k" astfel încât "a" să fie divizibil cu puterea a "p" la "k". Valoarea maximă a "k" este returnată.

La sfârșitul programului, utilizând condiția "if name == 'main'", se verifică dacă codul este rulat direct sau importat ca modul într-un alt program. În cazul în care programul este rulat direct, se citește numărul de cazuri de testare și se verifică dacă se încadrează în intervalul specificat, precum și pentru fiecare valoare a lui "a". Dacă nu se îndeplinesc restricțiile, se afișează un mesaj de eroare și programul se termină. În caz contrar, se rezolvă fiecare caz de testare și se afișează răspunsul.

2037 - Dec 2 Ord

2023-04-29T09:42:39Z

Sinn Erich: /* Cerinţa */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Vrăjitorul Arpsod are foarte multă treabă, așa că s-a gândit să vă ocupe timpul cu o problemă foarte grea, astfel încât acesta să poată lucra liniștit la proiectele sale despre stăpânirea lumii.

Acesta vă dă '''N''' numere naturale. Pentru fiecare număr '''A''' trebuie să găsiți cel mai mare '''K''' cu proprietatea că există un șir '''B''' de numere naturale nenule, nu neapărat distincte, astfel încât: '''(B1 + 1)(B2 + 1)...(BK + 1) = A'''

Arătați-i vrăjitorului că problema nu e suficient de grea pentru voi, găsind numărul '''K''' cerut într-un timp cât mai scurt, pentru fiecare din cele '''N''' numere.

== Date de intrare ==
Programul va conţine pe prima linie numărul natural '''T''', reprezentând numărul de valori date. Urmează apoi '''T''' linii. Pe fiecare linie va exista un număr '''A''', numărul dat de Arpsod.

== Date de ieșire ==
Programul va conţine '''T''' linii. Pe fiecare linie va exista un număr '''K''', reprezentând numărul maxim de termeni pe care îi poate avea șirul, astfel încât să respecte proprietatea cerută. Prima linie reprezintă raspunsul pentru primul număr, a doua penrtu cel de-al doilea … şamd.

Dacă datele sunt introduse corect, programul va rula.

Î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 ≤ '''T''' ≤ 500

2 ≤ '''A''' ≤ 2.000.000.000

== Exemplul 1 ==
; Datele de intrare
: 1
: 4
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

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

# function for factorizing a number into prime factors
def factorize(n):
factors = []
while n % 2 == 0:
factors.append(2)
n //= 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
factors.append(i)
n //= i
if n > 2:
factors.append(n)
return factors

# function for finding the maximum value of k
def find_k(a):
factors = factorize(a)
max_k = 1
for p in set(factors):
k = factors.count(p)
while a % (p ** k) == 0:
k += 1
max_k = max(max_k, k - 1)
return max_k
def validate_input(t: int, a: int) -> bool:
if not (1 <= t <= 500):
print("Numărul de teste nu respectă restricțiile impuse.")
return False
if not (2 <= a <= 2000000000):
print("Numărul a nu respectă restricțiile impuse.")
return False
return True

if __name__ == '__main__':
t = int(input("t:"))
a = int(input("a:"))
if validate_input(t, a):
for i in range(t):
k = find_k(a)
print(k)
print("Datele sunt introduse corect.")

</syntaxhighlight>

'''Explicatie cod:'''

Importul "math" este o bibliotecă standard în Python, care oferă o serie de funcții matematice. În acest cod, este utilizată funcția "sqrt" pentru a găsi rădăcina pătrată a unui număr în funcția "factorize".

Funcția "factorize" primește un număr "n" și returnează o listă cu factorii primi ai numărului. Algoritmul utilizat este metoda divizării repetate a numerelor la 2 și apoi testarea divizorilor impari de la 3 la radicalul pătrat al numărului "n". Pentru fiecare divizor găsit, se adaugă la lista "factors" și se împarte numărul "n" la acel divizor, până când acesta nu mai poate fi împărțit.

Funcția "find_k" primește un număr "a" și calculează cel mai mare exponent "k", astfel încât numărul să poată fi scris ca un produs de numere prime ridicate la puterea "k". Pentru fiecare factor prim al numărului "a", se calculează câte apariții are în lista de factori ai lui "a". Apoi, se caută cel mai mare "k" astfel încât "a" să fie divizibil cu puterea a "p" la "k". Valoarea maximă a "k" este returnată.

La sfârșitul programului, utilizând condiția "if name == 'main'", se verifică dacă codul este rulat direct sau importat ca modul într-un alt program. În cazul în care programul este rulat direct, se citește numărul de cazuri de testare și se verifică dacă se încadrează în intervalul specificat, precum și pentru fiecare valoare a lui "a". Dacă nu se îndeplinesc restricțiile, se afișează un mesaj de eroare și programul se termină. În caz contrar, se rezolvă fiecare caz de testare și se afișează răspunsul.

2037 - Dec 2 Ord

2023-04-29T09:42:30Z

Sinn Erich: /* Cerinţa */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Vrăjitorul Arpsod are foarte multă treabă, așa că s-a gândit să vă ocupe timpul cu o problemă foarte grea, astfel încât acesta să poată lucra liniștit la proiectele sale despre stăpânirea lumii.

Acesta vă dă '''N''' numere naturale. Pentru fiecare număr '''A''' trebuie să găsiți cel mai mare '''K''' cu proprietatea că există un șir '''B''' de numere naturale nenule, nu neapărat distincte, astfel încât: '''(B1 + 1)(B2 + 1)...(BK + 1) = A'''

Arătați-i vrăjitorului că problema nu e suficient de grea pentru voi, găsind numărul '''K''' cerut într-un timp cât mai scurt, pentru fiecare din cele '''T''' numere.

== Date de intrare ==
Programul va conţine pe prima linie numărul natural '''T''', reprezentând numărul de valori date. Urmează apoi '''T''' linii. Pe fiecare linie va exista un număr '''A''', numărul dat de Arpsod.

== Date de ieșire ==
Programul va conţine '''T''' linii. Pe fiecare linie va exista un număr '''K''', reprezentând numărul maxim de termeni pe care îi poate avea șirul, astfel încât să respecte proprietatea cerută. Prima linie reprezintă raspunsul pentru primul număr, a doua penrtu cel de-al doilea … şamd.

Dacă datele sunt introduse corect, programul va rula.

Î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 ≤ '''T''' ≤ 500

2 ≤ '''A''' ≤ 2.000.000.000

== Exemplul 1 ==
; Datele de intrare
: 1
: 4
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

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

# function for factorizing a number into prime factors
def factorize(n):
factors = []
while n % 2 == 0:
factors.append(2)
n //= 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
factors.append(i)
n //= i
if n > 2:
factors.append(n)
return factors

# function for finding the maximum value of k
def find_k(a):
factors = factorize(a)
max_k = 1
for p in set(factors):
k = factors.count(p)
while a % (p ** k) == 0:
k += 1
max_k = max(max_k, k - 1)
return max_k
def validate_input(t: int, a: int) -> bool:
if not (1 <= t <= 500):
print("Numărul de teste nu respectă restricțiile impuse.")
return False
if not (2 <= a <= 2000000000):
print("Numărul a nu respectă restricțiile impuse.")
return False
return True

if __name__ == '__main__':
t = int(input("t:"))
a = int(input("a:"))
if validate_input(t, a):
for i in range(t):
k = find_k(a)
print(k)
print("Datele sunt introduse corect.")

</syntaxhighlight>

'''Explicatie cod:'''

Importul "math" este o bibliotecă standard în Python, care oferă o serie de funcții matematice. În acest cod, este utilizată funcția "sqrt" pentru a găsi rădăcina pătrată a unui număr în funcția "factorize".

Funcția "factorize" primește un număr "n" și returnează o listă cu factorii primi ai numărului. Algoritmul utilizat este metoda divizării repetate a numerelor la 2 și apoi testarea divizorilor impari de la 3 la radicalul pătrat al numărului "n". Pentru fiecare divizor găsit, se adaugă la lista "factors" și se împarte numărul "n" la acel divizor, până când acesta nu mai poate fi împărțit.

Funcția "find_k" primește un număr "a" și calculează cel mai mare exponent "k", astfel încât numărul să poată fi scris ca un produs de numere prime ridicate la puterea "k". Pentru fiecare factor prim al numărului "a", se calculează câte apariții are în lista de factori ai lui "a". Apoi, se caută cel mai mare "k" astfel încât "a" să fie divizibil cu puterea a "p" la "k". Valoarea maximă a "k" este returnată.

La sfârșitul programului, utilizând condiția "if name == 'main'", se verifică dacă codul este rulat direct sau importat ca modul într-un alt program. În cazul în care programul este rulat direct, se citește numărul de cazuri de testare și se verifică dacă se încadrează în intervalul specificat, precum și pentru fiecare valoare a lui "a". Dacă nu se îndeplinesc restricțiile, se afișează un mesaj de eroare și programul se termină. În caz contrar, se rezolvă fiecare caz de testare și se afișează răspunsul.

1910 - Numar Minim 0

2023-04-29T09:37:37Z

Sinn Erich: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Georgiana a mai primit o problemă de la doamna profesor. Se dau '''n''' triplete de forma '''primul_nr, al_doilea_nr, rest,''' iar pentru fiecare triplet Georgiana trebuie să afle care este cel mai mic număr natural format cu '''primul_nr''' , care împărţit la '''al_doilea_nr''' dă restul '''rest'''.

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

== Date de ieșire ==
Programul va afișa pe ecran, pe '''linii separate''', cele '''n''' numere cerute.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează care este cel mai mic număr natural format cu n_cifre , care împărţit la m_cifre dă restul rest.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 10

1 ≤ '''primul_nr''' ≤ 100.000

2 ≤ '''al_doilea_nr''' ≤ 10

0 ≤ '''rest''' < b

== Exemplul 1 ==
; Datele de intrare
: Introduceti numarul de triplete:
: 3
: Introduceti tripletul {} de forma: primul_nr, al_doilea_nr si restul
: 2 3 1
: 3 5 4
: 4 6 0
; Datele de ieșire
: Datele sunt introduse corect.
: 10
: 104
: 1002
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1910
def gaseste_numar(m_cifre, n_cifre, rest):
for j in range(10**(m_cifre-1), 10**m_cifre):
if j % n_cifre == rest:
return j

def validate_input(m_cifre, n_cifre, rest):
if not (1 <= m_cifre <= 100000) or not (2 <= n_cifre <= 10) or not (0 <= rest < n_cifre):
return False
return True

if __name__ == '__main__':
n = int(input("Introduceti numarul de triplete: "))
for i in range(n):
m_cifre, n_cifre, rest = map(int, input("Introduceti tripletul {} de forma m_cifre n_cifre rest: ".format(i+1)).split())
if not validate_input(m_cifre, n_cifre, rest):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print(gaseste_numar(m_cifre, n_cifre, rest))

</syntaxhighlight>

'''Explicatie cod:'''

Acest program primește de la utilizator un număr n, care reprezintă numărul de triplete de forma m, b, r ce urmează să fie introduse.

Apoi, într-un for loop, pentru fiecare triplet introdus, este apelată funcția de validare validate_input care verifică dacă m respectă restricțiile de la 1 la 100000, b respectă restricțiile de la 2 la 10 și r respectă restricția de la 0 la b-1. Dacă tripletul introdus nu respectă aceste restricții, se afișează un mesaj de eroare.

Dacă tripletul este valid, atunci este apelată funcția gaseste_numar, care găsește cel mai mic număr natural cu m cifre, care împărțit la b dă restul r și îl afișează pe ecran.

Funcția gaseste_numar lucrează în felul următor: pentru fiecare număr j din intervalul [10**(m-1), 10**m), verifică dacă j împărțit la b dă restul r. Dacă da, atunci acesta este cel mai mic număr cu m cifre care împărțit la b dă restul r și îl returnează. Dacă nu, continuă cu următorul număr până găsește unul care să satisfacă condiția dată.

1910 - Numar Minim 0

2023-04-29T09:37:11Z

Sinn Erich: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Georgiana a mai primit o problemă de la doamna profesor. Se dau '''n''' triplete de forma '''primul_nr, al_doilea_nr, rest,''' iar pentru fiecare triplet Georgiana trebuie să afle care este cel mai mic număr natural format cu '''primul_nr''' , care împărţit la '''al_doilea_nr''' dă restul '''rest'''.

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

== Date de ieșire ==
Programul va afișa pe ecran, pe '''linii separate''', cele '''n''' numere cerute.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează care este cel mai mic număr natural format cu n_cifre , care împărţit la m_cifre dă restul rest.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 10

1 ≤ '''primul_nr''' ≤ 100.000

2 ≤ '''al_doilea_nr''' ≤ 10

0 ≤ '''rest''' < b

== Exemplul 1 ==
; Datele de intrare
: Introduceti numarul de triplete:
: 3
: Introduceti tripletul {} de forma primul_nr, al_doilea_nr si restul:
: 2 3 1
: 3 5 4
: 4 6 0
; Datele de ieșire
: Datele sunt introduse corect.
: 10
: 104
: 1002
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1910
def gaseste_numar(m_cifre, n_cifre, rest):
for j in range(10**(m_cifre-1), 10**m_cifre):
if j % n_cifre == rest:
return j

def validate_input(m_cifre, n_cifre, rest):
if not (1 <= m_cifre <= 100000) or not (2 <= n_cifre <= 10) or not (0 <= rest < n_cifre):
return False
return True

if __name__ == '__main__':
n = int(input("Introduceti numarul de triplete: "))
for i in range(n):
m_cifre, n_cifre, rest = map(int, input("Introduceti tripletul {} de forma m_cifre n_cifre rest: ".format(i+1)).split())
if not validate_input(m_cifre, n_cifre, rest):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print(gaseste_numar(m_cifre, n_cifre, rest))

</syntaxhighlight>

'''Explicatie cod:'''

Acest program primește de la utilizator un număr n, care reprezintă numărul de triplete de forma m, b, r ce urmează să fie introduse.

Apoi, într-un for loop, pentru fiecare triplet introdus, este apelată funcția de validare validate_input care verifică dacă m respectă restricțiile de la 1 la 100000, b respectă restricțiile de la 2 la 10 și r respectă restricția de la 0 la b-1. Dacă tripletul introdus nu respectă aceste restricții, se afișează un mesaj de eroare.

Dacă tripletul este valid, atunci este apelată funcția gaseste_numar, care găsește cel mai mic număr natural cu m cifre, care împărțit la b dă restul r și îl afișează pe ecran.

Funcția gaseste_numar lucrează în felul următor: pentru fiecare număr j din intervalul [10**(m-1), 10**m), verifică dacă j împărțit la b dă restul r. Dacă da, atunci acesta este cel mai mic număr cu m cifre care împărțit la b dă restul r și îl returnează. Dacă nu, continuă cu următorul număr până găsește unul care să satisfacă condiția dată.

1910 - Numar Minim 0

2023-04-29T09:35:51Z

Sinn Erich: /* Restricţii şi precizări */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Georgiana a mai primit o problemă de la doamna profesor. Se dau '''n''' triplete de forma '''primul_nr, al_doilea_nr, rest,''' iar pentru fiecare triplet Georgiana trebuie să afle care este cel mai mic număr natural format cu '''primul_nr''' , care împărţit la '''al_doilea_nr''' dă restul '''rest'''.

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

== Date de ieșire ==
Programul va afișa pe ecran, pe '''linii separate''', cele '''n''' numere cerute.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează care este cel mai mic număr natural format cu n_cifre , care împărţit la m_cifre dă restul rest.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 10

1 ≤ '''primul_nr''' ≤ 100.000

2 ≤ '''al_doilea_nr''' ≤ 10

0 ≤ '''rest''' < b

== Exemplul 1 ==
; Datele de intrare
: Introduceti numarul de triplete:
: 3
: Introduceti tripletul {} de forma n_cifre m_cifre rest: "
: 2 3 1
: 3 5 4
: 4 6 0
; Datele de ieșire
: Datele sunt introduse corect.
: 10
: 104
: 1002
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1910
def gaseste_numar(m_cifre, n_cifre, rest):
for j in range(10**(m_cifre-1), 10**m_cifre):
if j % n_cifre == rest:
return j

def validate_input(m_cifre, n_cifre, rest):
if not (1 <= m_cifre <= 100000) or not (2 <= n_cifre <= 10) or not (0 <= rest < n_cifre):
return False
return True

if __name__ == '__main__':
n = int(input("Introduceti numarul de triplete: "))
for i in range(n):
m_cifre, n_cifre, rest = map(int, input("Introduceti tripletul {} de forma m_cifre n_cifre rest: ".format(i+1)).split())
if not validate_input(m_cifre, n_cifre, rest):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print(gaseste_numar(m_cifre, n_cifre, rest))

</syntaxhighlight>

'''Explicatie cod:'''

Acest program primește de la utilizator un număr n, care reprezintă numărul de triplete de forma m, b, r ce urmează să fie introduse.

Apoi, într-un for loop, pentru fiecare triplet introdus, este apelată funcția de validare validate_input care verifică dacă m respectă restricțiile de la 1 la 100000, b respectă restricțiile de la 2 la 10 și r respectă restricția de la 0 la b-1. Dacă tripletul introdus nu respectă aceste restricții, se afișează un mesaj de eroare.

Dacă tripletul este valid, atunci este apelată funcția gaseste_numar, care găsește cel mai mic număr natural cu m cifre, care împărțit la b dă restul r și îl afișează pe ecran.

Funcția gaseste_numar lucrează în felul următor: pentru fiecare număr j din intervalul [10**(m-1), 10**m), verifică dacă j împărțit la b dă restul r. Dacă da, atunci acesta este cel mai mic număr cu m cifre care împărțit la b dă restul r și îl returnează. Dacă nu, continuă cu următorul număr până găsește unul care să satisfacă condiția dată.

1910 - Numar Minim 0

2023-04-29T09:35:11Z

Sinn Erich: /* Cerinţa */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Georgiana a mai primit o problemă de la doamna profesor. Se dau '''n''' triplete de forma '''primul_nr, al_doilea_nr, rest,''' iar pentru fiecare triplet Georgiana trebuie să afle care este cel mai mic număr natural format cu '''primul_nr''' , care împărţit la '''al_doilea_nr''' dă restul '''rest'''.

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

== Date de ieșire ==
Programul va afișa pe ecran, pe '''linii separate''', cele '''n''' numere cerute.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează care este cel mai mic număr natural format cu n_cifre , care împărţit la m_cifre dă restul rest.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 10

1 ≤ '''n_cifre''' ≤ 100.000

2 ≤ '''m_cifre''' ≤ 10

0 ≤ '''rest''' < b

== Exemplul 1 ==
; Datele de intrare
: Introduceti numarul de triplete:
: 3
: Introduceti tripletul {} de forma n_cifre m_cifre rest: "
: 2 3 1
: 3 5 4
: 4 6 0
; Datele de ieșire
: Datele sunt introduse corect.
: 10
: 104
: 1002
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1910
def gaseste_numar(m_cifre, n_cifre, rest):
for j in range(10**(m_cifre-1), 10**m_cifre):
if j % n_cifre == rest:
return j

def validate_input(m_cifre, n_cifre, rest):
if not (1 <= m_cifre <= 100000) or not (2 <= n_cifre <= 10) or not (0 <= rest < n_cifre):
return False
return True

if __name__ == '__main__':
n = int(input("Introduceti numarul de triplete: "))
for i in range(n):
m_cifre, n_cifre, rest = map(int, input("Introduceti tripletul {} de forma m_cifre n_cifre rest: ".format(i+1)).split())
if not validate_input(m_cifre, n_cifre, rest):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print(gaseste_numar(m_cifre, n_cifre, rest))

</syntaxhighlight>

'''Explicatie cod:'''

Acest program primește de la utilizator un număr n, care reprezintă numărul de triplete de forma m, b, r ce urmează să fie introduse.

Apoi, într-un for loop, pentru fiecare triplet introdus, este apelată funcția de validare validate_input care verifică dacă m respectă restricțiile de la 1 la 100000, b respectă restricțiile de la 2 la 10 și r respectă restricția de la 0 la b-1. Dacă tripletul introdus nu respectă aceste restricții, se afișează un mesaj de eroare.

Dacă tripletul este valid, atunci este apelată funcția gaseste_numar, care găsește cel mai mic număr natural cu m cifre, care împărțit la b dă restul r și îl afișează pe ecran.

Funcția gaseste_numar lucrează în felul următor: pentru fiecare număr j din intervalul [10**(m-1), 10**m), verifică dacă j împărțit la b dă restul r. Dacă da, atunci acesta este cel mai mic număr cu m cifre care împărțit la b dă restul r și îl returnează. Dacă nu, continuă cu următorul număr până găsește unul care să satisfacă condiția dată.

3166 - Vas 1

2023-04-29T09:33:03Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Într-un vas sunt '''apa_initiala''' litri de apă '''(apa_initiala>0)'''. După fiecare '''t''' minute, '''apa_initiala\rata_evaporare''' din cantitatea de apă rămasă se evaporă. Să se determine după câte minute vor rămâne în vas cel mult '''apa_minima''' litri de apă.

== Date de intrare ==
Programul citește de la tastatură patru numere naturale '''apa_initiala,timp_evaporare,apa_minima,rata_evaporare'''.

== Date de ieșire ==
Programul va afișa pe ecran numărul de minute necesare astfel încât in vas sa rămână cel mult '''apa_minima''' litri de apa.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează după câte minute vor rămâne în vas cel mult '''apa_minima''' litri de apă.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''apa_initiala,timp_evaporare,apa_minima''' ≤ 1.000.000.000

2 ≤ '''rata_evaporare''' ≤ 100

== Exemplul 1 ==
; Datele de intrare
: Apa initiala este:
: 100
:Timpul de evaporare este:
:15
:Apa minima este:
:20
:Rata de evaporare este:
:5
; Datele de ieșire
: Datele sunt introduse corect.
: Dupa 120 minute vor ramane in vas cel mult 20 litri de apa.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3166
def calculate_remaining_water_time(apa_initiala, timp_evaporare, apa_minima, rata_evaporare):
remaining_water = apa_initiala
elapsed_time = 0
while remaining_water>rata_evaporare:
evaporated_water = remaining_water / rata_evaporare
remaining_water -= evaporated_water
elapsed_time += timp_evaporare
return elapsed_time

def validate_input(apa_initiala, timp_evaporare, apa_minima, rata_evaporare):
if not (1 <= apa_initiala <= 1000000000 and 1 <= timp_evaporare <= 1000000000 and 1 <= apa_minima <= 1000000000 and 2 <= rata_evaporare <= 100):
return False
return True

if __name__ == '__main__':
apa_initiala, timp_evaporare, apa_minima, rata_evaporare = map(int, input("Introduceti X T Y I, separate prin spatiu: ").split())
if not validate_input(apa_initiala, timp_evaporare, apa_minima, rata_evaporare):
print("Datele introduse nu corespund restrictiilor impuse.")
else:
elapsed_time = calculate_remaining_water_time(apa_initiala, timp_evaporare, apa_minima, rata_evaporare)
print("Datele sunt introduse corect.")
print("Dupa", elapsed_time, "minute, vor ramane in vas cel mult", apa_minima, "litri de apa")
</syntaxhighlight>

'''Explicatie cod:'''

Acest cod are rolul de a calcula timpul necesar pentru ca cantitatea de apa dintr-un vas sa ajunga la o cantitate minima dupa evaporare, pe baza datelor de intrare: cantitatea initiala de apa din vas, timpul de evaporare pentru fiecare unitate de apa, cantitatea minima de apa pe care dorim sa o lasam in vas si rata de evaporare.

Funcția calculate_remaining_water_time primește ca parametri cantitatea inițială de apă, timpul de evaporare pentru fiecare unitate de apă, cantitatea minimă de apă pe care dorim să o lăsăm în vas și rata de evaporare. Ea calculează timpul necesar pentru ca cantitatea de apă din vas să ajungă la cantitatea minimă prin scăderea continuă a cantității de apă evaporată de rata de evaporare.

Funcția validate_input primește ca parametri datele de intrare și returnează True dacă acestea respectă restricțiile impuse (cantitățile de apă trebuie să fie între 1 și 1.000.000.000, timpul de evaporare între 1 și 1.000.000.000, cantitatea minimă de apă între 1 și 1.000.000.000 și rata de evaporare între 2 și 100), altfel returnează False.

În secțiunea principală, se cere utilizatorului să introducă cantitatea inițială de apă din vas, timpul de evaporare pentru fiecare unitate de apă, cantitatea minimă de apă pe care dorim să o lăsăm în vas și rata de evaporare. Se validează datele de intrare cu ajutorul funcției validate_input, iar dacă acestea sunt valide, se calculează timpul necesar pentru evaporare cu ajutorul funcției calculate_remaining_water_time și se afișează rezultatul. În caz contrar, se afișează un mesaj de eroare.

3166 - Vas 1

2023-04-29T09:31:57Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Într-un vas sunt '''apa_initiala''' litri de apă '''(apa_initiala>0)'''. După fiecare '''t''' minute, '''apa_initiala\rata_evaporare''' din cantitatea de apă rămasă se evaporă. Să se determine după câte minute vor rămâne în vas cel mult '''apa_minima''' litri de apă.

== Date de intrare ==
Programul citește de la tastatură patru numere naturale '''apa_initiala,timp_evaporare,apa_minima,rata_evaporare'''.

== Date de ieșire ==
Programul va afișa pe ecran numărul de minute necesare astfel încât in vas sa rămână cel mult '''apa_minima''' litri de apa.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează după câte minute vor rămâne în vas cel mult '''apa_minima''' litri de apă.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''apa_initiala,timp_evaporare,apa_minima''' ≤ 1.000.000.000

2 ≤ '''rata_evaporare''' ≤ 100

== Exemplul 1 ==
; Datele de intrare
: Apa initiala este:
: 100
:Timpul de evaporare este:
:15
:Apa minima este:
:20
:Rata de evaporare este:
:5
; Datele de ieșire
: Datele sunt introduse corect.
: Dupa 120 minute vor ramane in vas cel mult 20 litri de apa.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3166
def calculate_remaining_water_time(apa_initiala, timp_evaporare, apa_minima, rata_evaporare):
remaining_water = apa_initiala
elapsed_time = 0
while remaining_water>rata_evaporare:
evaporated_water = remaining_water / rata_evaporare
remaining_water -= evaporated_water
elapsed_time += timp_evaporare
return elapsed_time

def validate_input(apa_initiala, timp_evaporare, apa_minima, rata_evaporare):
if not (1 <= apa_initiala <= 1000000000 and 1 <= timp_evaporare <= 1000000000 and 1 <= apa_minima <= 1000000000 and 2 <= rata_evaporare <= 100):
return False
return True

if __name__ == '__main__':
apa_initiala, timp_evaporare, apa_minima, rata_evaporare = map(int, input("Introduceti X T Y I, separate prin spatiu: ").split())
if not validate_input(apa_initiala, timp_evaporare, apa_minima, rata_evaporare):
print("Datele introduse nu corespund restrictiilor impuse.")
else:
elapsed_time = calculate_remaining_water_time(apa_initiala, timp_evaporare, apa_minima, rata_evaporare)
print("Datele sunt introduse corect.")
print("Dupa", elapsed_time, "minute, vor ramane in vas cel mult", apa_minima, "liapa_initiala")
</syntaxhighlight>

'''Explicatie cod:'''

Acest cod are rolul de a calcula timpul necesar pentru ca cantitatea de apa dintr-un vas sa ajunga la o cantitate minima dupa evaporare, pe baza datelor de intrare: cantitatea initiala de apa din vas, timpul de evaporare pentru fiecare unitate de apa, cantitatea minima de apa pe care dorim sa o lasam in vas si rata de evaporare.

Funcția calculate_remaining_water_time primește ca parametri cantitatea inițială de apă, timpul de evaporare pentru fiecare unitate de apă, cantitatea minimă de apă pe care dorim să o lăsăm în vas și rata de evaporare. Ea calculează timpul necesar pentru ca cantitatea de apă din vas să ajungă la cantitatea minimă prin scăderea continuă a cantității de apă evaporată de rata de evaporare.

Funcția validate_input primește ca parametri datele de intrare și returnează True dacă acestea respectă restricțiile impuse (cantitățile de apă trebuie să fie între 1 și 1.000.000.000, timpul de evaporare între 1 și 1.000.000.000, cantitatea minimă de apă între 1 și 1.000.000.000 și rata de evaporare între 2 și 100), altfel returnează False.

În secțiunea principală, se cere utilizatorului să introducă cantitatea inițială de apă din vas, timpul de evaporare pentru fiecare unitate de apă, cantitatea minimă de apă pe care dorim să o lăsăm în vas și rata de evaporare. Se validează datele de intrare cu ajutorul funcției validate_input, iar dacă acestea sunt valide, se calculează timpul necesar pentru evaporare cu ajutorul funcției calculate_remaining_water_time și se afișează rezultatul. În caz contrar, se afișează un mesaj de eroare.

3166 - Vas 1

2023-04-29T09:27:52Z

Sinn Erich: /* Restricţii şi precizări */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Într-un vas sunt '''apa_initiala''' litri de apă '''(apa_initiala>0)'''. După fiecare '''t''' minute, '''apa_initiala\rata_evaporare''' din cantitatea de apă rămasă se evaporă. Să se determine după câte minute vor rămâne în vas cel mult '''apa_minima''' litri de apă.

== Date de intrare ==
Programul citește de la tastatură patru numere naturale '''apa_initiala,timp_evaporare,apa_minima,rata_evaporare'''.

== Date de ieșire ==
Programul va afișa pe ecran numărul de minute necesare astfel încât in vas sa rămână cel mult '''apa_minima''' litri de apa.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează după câte minute vor rămâne în vas cel mult '''apa_minima''' litri de apă.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''apa_initiala,timp_evaporare,apa_minima''' ≤ 1.000.000.000

2 ≤ '''rata_evaporare''' ≤ 100

== Exemplul 1 ==
; Datele de intrare
: Apa initiala este:
: 100
:Timpul de evaporare este:
:15
:Apa minima este:
:20
:Rata de evaporare este:
:5
; Datele de ieșire
: Datele sunt introduse corect.
: Dupa 120 minute vor ramane in vas cel mult 20 litri de apa.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3166
def calculate_remaining_water_time(initial_water, evaporation_time, minimum_water, evaporation_rate):
remaining_water = initial_water
elapsed_time = 0
while remaining_water > minimum_water:
evaporated_water = remaining_water / evaporation_rate
remaining_water -= evaporated_water
elapsed_time += evaporation_time
return elapsed_time

def validate_input(initial_water, evaporation_time, minimum_water, evaporation_rate):
if not (1 <= initial_water <= 1000000000 and 1 <= evaporation_time <= 1000000000 and 1 <= minimum_water <= 1000000000 and 2 <= evaporation_rate <= 100):
return False
return True

if __name__ == '__main__':
initial_water, evaporation_time, minimum_water, evaporation_rate = map(int, input("Introduceti X T Y I, separate prin spatiu: ").split())
if not validate_input(initial_water, evaporation_time, minimum_water, evaporation_rate):
print("Datele introduse nu sunt valide.")
else:
elapsed_time = calculate_remaining_water_time(initial_water, evaporation_time, minimum_water, evaporation_rate)
print("Datele introduse sunt valide.")
print("Dupa", elapsed_time, "minute, vor ramane in vas cel mult", minimum_water, "litri de apa.")

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod este un program Python care calculează timpul rămas până când va rămâne o anumită cantitate minimă de apă într-un vas, ținând cont de timpul de evaporare și de rata de evaporare a apei din vas.

Funcția calculate_remaining_water_time() primește patru argumente: initial_water (cantitatea inițială de apă din vas), evaporation_time (timpul necesar evaporării unei unități de apă), minimum_water (cantitatea minimă de apă care trebuie să rămână în vas) și evaporation_rate (rata de evaporare a apei din vas).

Funcția utilizează o buclă while pentru a calcula timpul rămas până când cantitatea de apă din vas ajunge la valoarea minimă specificată. În fiecare iterație a buclei, se calculează cantitatea de apă care s-a evaporat într-un interval de timp și se actualizează cantitatea rămasă în vas. Variabila elapsed_time este folosită pentru a calcula timpul total de evaporare.

Funcția validate_input() este utilizată pentru a verifica dacă argumentele primite de calculate_remaining_water_time() sunt valide. Dacă nu sunt valide, funcția returnează False, altfel returnează True.

Blocul if __name__ == '__main__': este folosit pentru a verifica dacă acest script este rulat direct sau importat ca modul într-un alt script Python. Dacă este rulat direct, utilizatorul va fi rugat să introducă valorile pentru initial_water, evaporation_time, minimum_water și evaporation_rate. Aceste valori sunt separate prin spațiu și sunt convertite la integer folosind funcția map(). Dacă valorile introduse sunt invalide, este afișat un mesaj corespunzător. Altfel, timpul rămas până când va rămâne cantitatea minimă de apă este calculat folosind funcția calculate_remaining_water_time(), iar rezultatul este afișat.

3166 - Vas 1

2023-04-29T09:27:43Z

Sinn Erich: /* Date de intrare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Într-un vas sunt '''apa_initiala''' litri de apă '''(apa_initiala>0)'''. După fiecare '''t''' minute, '''apa_initiala\rata_evaporare''' din cantitatea de apă rămasă se evaporă. Să se determine după câte minute vor rămâne în vas cel mult '''apa_minima''' litri de apă.

== Date de intrare ==
Programul citește de la tastatură patru numere naturale '''apa_initiala,timp_evaporare,apa_minima,rata_evaporare'''.

== Date de ieșire ==
Programul va afișa pe ecran numărul de minute necesare astfel încât in vas sa rămână cel mult '''apa_minima''' litri de apa.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează după câte minute vor rămâne în vas cel mult '''apa_minima''' litri de apă.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''apa_initiala,timpul_evaporare,apa_minima''' ≤ 1.000.000.000

2 ≤ '''rata_evaporare''' ≤ 100

== Exemplul 1 ==
; Datele de intrare
: Apa initiala este:
: 100
:Timpul de evaporare este:
:15
:Apa minima este:
:20
:Rata de evaporare este:
:5
; Datele de ieșire
: Datele sunt introduse corect.
: Dupa 120 minute vor ramane in vas cel mult 20 litri de apa.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3166
def calculate_remaining_water_time(initial_water, evaporation_time, minimum_water, evaporation_rate):
remaining_water = initial_water
elapsed_time = 0
while remaining_water > minimum_water:
evaporated_water = remaining_water / evaporation_rate
remaining_water -= evaporated_water
elapsed_time += evaporation_time
return elapsed_time

def validate_input(initial_water, evaporation_time, minimum_water, evaporation_rate):
if not (1 <= initial_water <= 1000000000 and 1 <= evaporation_time <= 1000000000 and 1 <= minimum_water <= 1000000000 and 2 <= evaporation_rate <= 100):
return False
return True

if __name__ == '__main__':
initial_water, evaporation_time, minimum_water, evaporation_rate = map(int, input("Introduceti X T Y I, separate prin spatiu: ").split())
if not validate_input(initial_water, evaporation_time, minimum_water, evaporation_rate):
print("Datele introduse nu sunt valide.")
else:
elapsed_time = calculate_remaining_water_time(initial_water, evaporation_time, minimum_water, evaporation_rate)
print("Datele introduse sunt valide.")
print("Dupa", elapsed_time, "minute, vor ramane in vas cel mult", minimum_water, "litri de apa.")

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod este un program Python care calculează timpul rămas până când va rămâne o anumită cantitate minimă de apă într-un vas, ținând cont de timpul de evaporare și de rata de evaporare a apei din vas.

Funcția calculate_remaining_water_time() primește patru argumente: initial_water (cantitatea inițială de apă din vas), evaporation_time (timpul necesar evaporării unei unități de apă), minimum_water (cantitatea minimă de apă care trebuie să rămână în vas) și evaporation_rate (rata de evaporare a apei din vas).

Funcția utilizează o buclă while pentru a calcula timpul rămas până când cantitatea de apă din vas ajunge la valoarea minimă specificată. În fiecare iterație a buclei, se calculează cantitatea de apă care s-a evaporat într-un interval de timp și se actualizează cantitatea rămasă în vas. Variabila elapsed_time este folosită pentru a calcula timpul total de evaporare.

Funcția validate_input() este utilizată pentru a verifica dacă argumentele primite de calculate_remaining_water_time() sunt valide. Dacă nu sunt valide, funcția returnează False, altfel returnează True.

Blocul if __name__ == '__main__': este folosit pentru a verifica dacă acest script este rulat direct sau importat ca modul într-un alt script Python. Dacă este rulat direct, utilizatorul va fi rugat să introducă valorile pentru initial_water, evaporation_time, minimum_water și evaporation_rate. Aceste valori sunt separate prin spațiu și sunt convertite la integer folosind funcția map(). Dacă valorile introduse sunt invalide, este afișat un mesaj corespunzător. Altfel, timpul rămas până când va rămâne cantitatea minimă de apă este calculat folosind funcția calculate_remaining_water_time(), iar rezultatul este afișat.

1565 - N Zero

2023-04-29T09:25:35Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Se dă un număr '''n'''. Afișați numărul '''n * 10a'''.

== Date de intrare ==
Programul citește de la tastatură numărul '''n''', apoi numărul '''a'''.

== Date de ieșire ==
Programul va afișa pe ecran numărul '''p''', acesta fiind '''n * 10a'''.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează numărul n * 10a.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 1000

0 ≤ '''a''' ≤ 5

== Exemplul 1 ==
; Datele de intrare
:Introduceti n:
: 5
:Introduceti a:
: 4
; Datele de ieșire
: Datele sunt introduse corect.
: 50000
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1565
def validate_input(n, a):
if 1 <= n <= 1000 and 0 <= a <= 5:
return True
else:
return False

def calculate_p(n, a):
return n * (10 ** a)

def display_result(p):
if p is not None:
print("Datele sunt introduse corect.")
print(p)
else:
print("Datele nu corespund restricțiilor impuse.")

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

if validate_input(n, a):
p = calculate_p(n, a)
display_result(p)
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod implementează o funcție care primește un număr întreg `n` și un număr întreg `a` și calculează și afișează un număr întreg `p` dat de produsul dintre `n` și 10 ridicat la puterea `a`.

Funcția `validate_input(n, a)` verifică dacă `n` este între 1 și 1000 și dacă `a` este între 0 și 5 și returnează `True` dacă aceste condiții sunt îndeplinite, în caz contrar, returnează `False`.

Funcția `calculate_p(n, a)` primește două argumente `n` și `a` și returnează produsul dintre `n` și 10 ridicat la puterea `a`.

Funcția `display_result(p)` afișează mesajul "Datele sunt introduse corect." urmat de valoarea `p` dacă `p` este diferit de `None`. Dacă `p` este `None`, funcția afișează mesajul "Datele nu corespund restricțiilor impuse.".

În funcția principală (`main`), se citesc valorile `n` și `a` de la utilizator, se validează aceste date folosind funcția `validate_input` și, dacă datele sunt corecte, se calculează `p` folosind funcția `calculate_p` și se afișează rezultatul utilizând funcția `display_result`. Dacă datele nu sunt corecte, se afișează mesajul "Datele nu corespund restricțiilor impuse.".

Acest cod pare să fie simplu și nu implică nicio logică complexă sau operații costisitoare.

0350 - Produs Cartezian

2023-04-29T09:24:33Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Se dau două numere naturale nenule '''n și m'''. Pentru mulțimile '''A={1,2,..,n} și B={1,2,...,m}''', să se afișeze mulțimea '''A×B={(a,b) | a∈A, b∈B}''' – '''produsul cartezian''' al mulțimilor '''A și B'''.

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

== Date de ieșire ==
Programul afișează pe ecran mulțimea cerută astfel:

elementele mulțimii vor fi scrise între acolade și separate prin virgule fiecare element este o pereche de numere, care va fi scrisă între paranteze rotunde, numerele din pereche fiind separate prin virgulă mai întâi se vor scrie perechile '''(a,b)''' pentru care '''a=1''', cu b în ordine crescătoare, apoi perechile pentru care '''a=2''' cu '''b''' în ordine crescătoare, etc, ca în exemplu.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează mulțimea A×B={(a,b) | a∈A, b∈B} – produsul cartezian al mulțimilor A și B.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n,m''' ≤ 10

== Exemplul 1 ==
; Datele de intrare
:Introduceti numarul n:
: 3
:Introduceti numarul m:
: 2
; Datele de ieșire
: Datele sunt introduse corect.
: {(1,1),(1,2),(2,1),(2,2),(3,1),(3,2)}
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0350
def build_cartesian_product(n, m):
produs_cartezian = "{"
for a in range(1, n+1):
for b in range(1, m+1):
produs_cartezian += f"({a},{b}),"
produs_cartezian = produs_cartezian[:-1] + "}"
return produs_cartezian

def validate_input(n, m):
if not (1 <= n <= 10 and 1 <= m <= 10):
return False
return True

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

if not validate_input(n, m):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
produs_cartezian = build_cartesian_product(n, m)
print(produs_cartezian)

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod definește o funcție care construiește produsul cartezian dintre două seturi de numere, și o funcție care validează datele de intrare.

Funcția `build_cartesian_product(n, m)` primește două numere `n` și `m` și construiește produsul cartezian dintre seturile `{1,2,3,...,n}` și `{1,2,3,...,m}`. Produsul cartezian este o mulțime de perechi ordonate formate din elemente din fiecare set. În acest caz, perechile sunt construite astfel: `({1,2,...,n},{1,2,...,m})`. Produsul cartezian este returnat sub forma unui șir de caractere care conține toate perechile ordonate separate prin virgulă și încadrate între acolade: `{(1,1),(1,2),...,(n,m)}`.

Funcția `validate_input(n, m)` primește două numere întregi și validează dacă acestea respectă restricțiile impuse. În cazul de față, acestea trebuie să fie între 1 și 10 inclusiv. Funcția returnează `False` dacă datele de intrare nu sunt valide și `True` în caz contrar.

În secțiunea `if __name__ == '__main__':`, utilizatorul este întrebat să introducă două numere întregi `n` și `m`. Dacă acestea nu respectă restricțiile, se va afișa un mesaj corespunzător și programul se va încheia. În caz contrar, se va afișa un mesaj de confirmare și se va apela funcția `build_cartesian_product(n, m)` pentru a construi produsul cartezian, care va fi apoi afișat pe ecran.

0339 - Numere

2023-04-29T09:23:06Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Se dau '''n''' numere naturale. Determinaţi primul număr par dintre cele '''n''' numere.

== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii.

== Date de ieșire ==
Programul afișează pe ecran numărul '''P''', reprezentând primul număr par dintre cele '''n''' numere.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează primul număr par dintre cele n numere.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
*1 ≤ '''n''' ≤ 100

cele n numere citite vor avea cel mult 9 cifre

== Exemplul 1 ==
; Datele de intrare
: N este:
: 5
:Numerele n sunt:
: 7 4 2 5 8
; Datele de ieșire
: Datele sunt introduse corect.
: 4
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0339
def validate_input(n, numere):
if not (1 <= n <= 100):
return False
for nr in numere:
if len(nr) > 9:
return False
return True

def gaseste_primul_numar_par(numere):
for nr in numere:
if int(nr) % 2 == 0:
return nr
return "IMPOSIBIL"

if __name__ == '__main__':
n = int(input("N este:"))
numere = input("Numerele n sunt:").split()
if not validate_input(n, numere):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print(gaseste_primul_numar_par(numere))

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod primește un număr `n` și o listă de `n` numere și verifică dacă datele de intrare sunt valide, adică `n` trebuie să fie între 1 și 100 și fiecare număr din lista `numere` trebuie să aibă cel mult 9 cifre.

Funcția `validate_input(n, numere)` primește doi parametri, `n` și `numere`, și începe prin a verifica dacă `n` se află în intervalul permis, adică între 1 și 100, utilizând expresia booleană `1 <= n <= 100`. Dacă această condiție nu este îndeplinită, funcția returnează `False`, indicând faptul că datele de intrare nu sunt valide.

În caz contrar, pentru fiecare număr din lista `numere`, funcția verifică dacă numărul are cel mult 9 cifre, utilizând expresia booleană `len(nr) > 9`. Dacă un număr depășește această limită, funcția returnează `False`, indicând din nou faptul că datele de intrare nu sunt valide.

În cele din urmă, dacă toate verificările sunt trecute cu succes, funcția returnează `True`, indicând că datele de intrare sunt valide.

Funcția `gaseste_primul_numar_par(numere)` primește lista `numere` și caută primul număr par din listă. Pentru fiecare număr din listă, funcția verifică dacă numărul este par sau nu, utilizând expresia booleană `int(nr) % 2 == 0`. Dacă numărul este par, funcția returnează numărul respectiv. Dacă nu există niciun număr par în listă, funcția returnează string-ul "IMPOSIBIL".

În funcția `main()`, întâi se solicită utilizatorului să introducă `n` și `numere`. Dacă datele de intrare nu sunt valide, se afișează mesajul "Datele nu corespund restricțiilor impuse." În caz contrar, se afișează mesajul "Datele sunt introduse corect.", iar funcția `gaseste_primul_numar_par(numere)` este apelată cu argumentul `numere`. Rezultatul este afișat apoi în consolă.

3431 - Cartonase 3

2023-04-29T09:20:43Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Ionel are '''N''' cartonașe. Fiecare cartonaș are înscrise două numere (un număr, '''nr_cartonas_stanga''', în partea stângă, și celălalt număr, '''nr_cartonas_dreapta''', în partea dreaptă). El a așezat cartonașele într-un șir, lipite unul de celălalt, astfel încât numărul din partea dreaptă a primului cartonaș este lipit de numărul din partea stângă a celui de-al doilea cartonaș, numărul din partea dreaptă a celui de al doilea cartonaș este lipit de numărul din partea stângă a celui de-al treilea cartonaș etc. Spunem că două cartonașe alăturate “se potrivesc” dacă numărul din dreapta al primului cartonaș este egal cu numărul din stânga al celui de al doilea cartonaș.

Ionel observă că sunt perechi de cartonașe alăturate care “se potrivesc” și chiar secvențe de mai multe cartonașe alăturate, în care primul “se potrivește” cu al doilea, al doilea “se potrivește” cu al treilea etc.

Scrieți un program care să citească numărul '''N''' de cartonașe, numerele înscrise pe fiecare cartonaș și determină:

1) Numărul de perechi de cartonașe care “se potrivesc”.
2) Numărul de cartonașe din cea mai lungă secvență în care fiecare două cartonașe alăturate “se potrivesc”.
3) Numărul de secvențe cu număr maxim de cartonașe care “se potrivesc”.

== Date de intrare ==
Programul conține doar numere naturale nenule:

pe prima linie se găsește numărul '''C''' care poate avea doar valorile '''1, 2 sau 3''' și reprezintă cerința
care urmează a fi rezolvată. Pe a doua linie a programului se găsește numărul natural '''N''', cu semnificația din enunț.

pe fiecare dintre următoarele '''N''' linii se află, în acestă ordine, câte două numere naturale '''nr_cartonas_stanga și nr_cartonas_dreapta''', separate printr-un spațiu, cu semnificația din enunț pentru un cartonaș. Perechile de numere sunt date în ordinea în care cartonașele corespunzătoare lor apar în șirul lui Ionel.

== Date de ieșire ==
Programul va conține pe prima linie un număr natural reprezentând răspunsul la cerința specificată.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''N''' ≤ 500;

1 ≤ '''nr_cartonas_stanga''' ≤ 10.000;

1 ≤ '''nr_cartonas_dreapta''' ≤ 10.000

În concurs, pentru rezolvarea fiecărei cerințe se obțin câte 30 de puncte. Pe site se acordă 10 puncte pentru exemple.

== Exemplul 1 ==
; Datele de intrare
:Introduceti cerinta (1, 2 sau 3): 1
:Introduceti numarul de cartonase: 5
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:10 5
:Introduceti cartonasul stanga si cartonasul dreapta:10 2
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:37 5
; Datele de ieșire
: Datele sunt introduse corect.
: 3
 

== Exemplul 2 ==
; Datele de intrare
:Introduceti cerinta (1, 2 sau 3): 2
:Introduceti numarul de cartonase: 5
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:10 5
:Introduceti cartonasul stanga si cartonasul dreapta:10 2
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:37 5
; Datele de ieșire
: Datele sunt introduse corect.
: 4
 

== Exemplul 3 ==
; Datele de intrare
:Introduceti cerinta (1, 2 sau 3): 3
:Introduceti numarul de cartonase: 5
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:10 5
:Introduceti cartonasul stanga si cartonasul dreapta:10 2
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:37 5
; Datele de ieșire
: Datele sunt introduse corect.
: 3
:2

 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3431
def validate_input(n, cards):
if n != len(cards):
return False
for card in cards:
if len(card) != 2:
return False
if not all(1 <= x <= 10000 for x in card):
return False
return True

def find_matching_pairs(cards):
matching_pairs = 0
max_sequence = 1
current_sequence = 1
for i in range(len(cards) - 1):
if cards[i][1] == cards[i + 1][0]:
matching_pairs += 1
current_sequence += 1
max_sequence = max(max_sequence, current_sequence)
else:
current_sequence = 1
return (matching_pairs, max_sequence)

def find_max_sequences(cards):
max_sequence_length = 1
sequence_lengths = {}
current_sequence_length = 1
for i in range(len(cards) - 1):
if cards[i][1] == cards[i + 1][0]:
current_sequence_length += 1
else:
if current_sequence_length in sequence_lengths:
sequence_lengths[current_sequence_length] += 1
else:
sequence_lengths[current_sequence_length] = 1
max_sequence_length = max(max_sequence_length, current_sequence_length)
current_sequence_length = 1
if current_sequence_length in sequence_lengths:
sequence_lengths[current_sequence_length] += 1
else:
sequence_lengths[current_sequence_length] = 1
max_sequence_count = sequence_lengths[max_sequence_length]
return max_sequence_count

if __name__ == '__main__':
c = int(input("Introduceti cerinta (1, 2 sau 3): "))
n = int(input("Introduceti numarul de cartonase: "))
cards = [list(map(int, input("Introduceti cartonasul stanga si cartonasul dreapta:").split())) for _ in range(n)]

if not validate_input(n, cards):
print("Datele nu corespund restrictiilor impuse.")
else:
print("Datele sunt introduse corect.")
if c == 1:
matching_pairs, max_sequence = find_matching_pairs(cards)
print(matching_pairs + 1)
elif c == 2:
matching_pairs, max_sequence = find_matching_pairs(cards)
print(max_sequence)
elif c == 3:
max_sequence_count = find_max_sequences(cards)
print(max_sequence_count)

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod reprezintă o soluție pentru o problemă care are trei cerințe diferite.

Funcția `validate_input` verifică dacă datele introduse corespund unor anumite restricții. Mai precis, verifică dacă numărul de cartonașe introduse corespunde valorii `n` și dacă fiecare cartonaș este format din două numere întregi cuprinse între 1 și 10000.

Funcția `find_matching_pairs` primește o listă de cartonașe și calculează numărul de perechi de cartonașe care se potrivesc și lungimea cea mai mare a unei secvențe de cartonașe consecutive care se potrivesc.

Funcția `find_max_sequences` primește o listă de cartonașe și calculează numărul de secvențe maximale de cartonașe consecutive care se potrivesc.

În `main`, utilizatorul trebuie să introducă numărul cerinței (`c`) și numărul de cartonașe (`n`) și apoi cartonașele propriu-zise. Dacă datele introduse sunt valide, se apelează funcția corespunzătoare cerinței și se afișează rezultatul. Pentru cerința 1, se afișează numărul de perechi de cartonașe care se potrivesc plus 1. Pentru cerința 2, se afișează lungimea cea mai mare a unei secvențe de cartonașe consecutive care se potrivesc. Pentru cerința 3, se afișează numărul de secvențe maximale de cartonașe consecutive care se potrivesc.

3431 - Cartonase 3

2023-04-29T09:19:51Z

Sinn Erich: /* Exemplul 3 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Ionel are '''N''' cartonașe. Fiecare cartonaș are înscrise două numere (un număr, '''nr_cartonas_stanga''', în partea stângă, și celălalt număr, '''nr_cartonas_dreapta''', în partea dreaptă). El a așezat cartonașele într-un șir, lipite unul de celălalt, astfel încât numărul din partea dreaptă a primului cartonaș este lipit de numărul din partea stângă a celui de-al doilea cartonaș, numărul din partea dreaptă a celui de al doilea cartonaș este lipit de numărul din partea stângă a celui de-al treilea cartonaș etc. Spunem că două cartonașe alăturate “se potrivesc” dacă numărul din dreapta al primului cartonaș este egal cu numărul din stânga al celui de al doilea cartonaș.

Ionel observă că sunt perechi de cartonașe alăturate care “se potrivesc” și chiar secvențe de mai multe cartonașe alăturate, în care primul “se potrivește” cu al doilea, al doilea “se potrivește” cu al treilea etc.

Scrieți un program care să citească numărul '''N''' de cartonașe, numerele înscrise pe fiecare cartonaș și determină:

1) Numărul de perechi de cartonașe care “se potrivesc”.
2) Numărul de cartonașe din cea mai lungă secvență în care fiecare două cartonașe alăturate “se potrivesc”.
3) Numărul de secvențe cu număr maxim de cartonașe care “se potrivesc”.

== Date de intrare ==
Programul conține doar numere naturale nenule:

pe prima linie se găsește numărul '''C''' care poate avea doar valorile '''1, 2 sau 3''' și reprezintă cerința
care urmează a fi rezolvată. Pe a doua linie a programului se găsește numărul natural '''N''', cu semnificația din enunț.

pe fiecare dintre următoarele '''N''' linii se află, în acestă ordine, câte două numere naturale '''nr_cartonas_stanga și nr_cartonas_dreapta''', separate printr-un spațiu, cu semnificația din enunț pentru un cartonaș. Perechile de numere sunt date în ordinea în care cartonașele corespunzătoare lor apar în șirul lui Ionel.

== Date de ieșire ==
Programul va conține pe prima linie un număr natural reprezentând răspunsul la cerința specificată.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''N''' ≤ 500;

1 ≤ '''nr_cartonas_stanga''' ≤ 10.000;

1 ≤ '''nr_cartonas_dreapta''' ≤ 10.000

În concurs, pentru rezolvarea fiecărei cerințe se obțin câte 30 de puncte. Pe site se acordă 10 puncte pentru exemple.

== Exemplul 1 ==
; Datele de intrare
:Introduceti cerinta (1, 2 sau 3): 1
:Introduceti numarul de cartonase: 5
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:10 5
:Introduceti cartonasul stanga si cartonasul dreapta:10 2
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:37 5
; Datele de ieșire
: Datele sunt introduse corect.
: 3
 

== Exemplul 2 ==
; Datele de intrare
:Introduceti cerinta (1, 2 sau 3): 2
:Introduceti numarul de cartonase: 5
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:10 5
:Introduceti cartonasul stanga si cartonasul dreapta:10 2
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:37 5
; Datele de ieșire
: Datele sunt introduse corect.
: 4
 

== Exemplul 3 ==
; Datele de intrare
:Introduceti cerinta (1, 2 sau 3): 3
:Introduceti numarul de cartonase: 5
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:10 5
:Introduceti cartonasul stanga si cartonasul dreapta:10 2
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:37 5
; Datele de ieșire
: Datele sunt introduse corect.
: 3
:2

 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3431
def num_pairs(cards):
num_pairs = 0
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
num_pairs += 1
return num_pairs

def longest_sequence(cards):
max_len = 1
curr_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
else:
curr_len = 1
return max_len

def num_max_sequences(cards):
max_len = 1
curr_len = 1
num_max_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
num_max_len = 1
elif curr_len == max_len:
num_max_len += 1
return num_max_len

if __name__ == '__main__':
C = int(input())
N = int(input())
if not 1 <= N <= 500:
print("Datele nu corespund restricțiilor impuse.")
exit()
cards = []
for i in range(N):
stanga, dreapta = map(int, input().split())
if not (1 <= s <= 10000 and 1 <= d <= 10000):
print("Datele nu corespund restricțiilor impuse.")
exit()
cards.append((stanga, dreapta))

if C == 1:
print("Datele sunt introduse corect.")
print(num_pairs(cards))
elif C == 2:
print("Datele sunt introduse corect.")
print(longest_sequence(cards))
else:
print("Datele sunt introduse corect.")
print(num_max_sequences(cards))

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod este o soluție la o problemă matematică care presupune determinarea unor perechi de cărți într-un șir de cărți, în funcție de o regulă. Scopul este să se scrie un program care primește ca input o valoare C (1, 2 sau 3), un număr N (numărul de cărți din șir), și N perechi de numere s și d, reprezentând cărțile. Dacă C este 1, programul trebuie să afișeze numărul de perechi de cărți în care valoarea de pe cartea dreaptă a primei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 2, programul trebuie să afișeze lungimea celei mai lungi secvențe de cărți în care valoarea de pe cartea dreaptă a unei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 3, programul trebuie să afișeze numărul de secvențe de cărți de lungime maximă care respectă regula dată.

Funcțiile num_pairs, longest_sequence și num_max_sequences implementează cele trei cerințe ale problemei. Ele iau ca argument șirul de cărți și returnează valoarea corespunzătoare.

În blocul if name == 'main': se face validarea datelor de intrare. Se primește valoarea C și N, iar apoi se creează o listă de perechi de cărți folosind funcția map(). Dacă N nu este între 1 și 500, se afișează un mesaj de eroare și programul se termină. În plus, dacă oricare dintre valorile s sau d este mai mică decât 1 sau mai mare decât 10000, programul va afișa un alt mesaj de eroare și se va termina. În cele din urmă, se apelează funcțiile corespunzătoare în funcție de valoarea C și se afișează rezultatul.

3431 - Cartonase 3

2023-04-29T09:19:08Z

Sinn Erich: /* Exemplul 2 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Ionel are '''N''' cartonașe. Fiecare cartonaș are înscrise două numere (un număr, '''nr_cartonas_stanga''', în partea stângă, și celălalt număr, '''nr_cartonas_dreapta''', în partea dreaptă). El a așezat cartonașele într-un șir, lipite unul de celălalt, astfel încât numărul din partea dreaptă a primului cartonaș este lipit de numărul din partea stângă a celui de-al doilea cartonaș, numărul din partea dreaptă a celui de al doilea cartonaș este lipit de numărul din partea stângă a celui de-al treilea cartonaș etc. Spunem că două cartonașe alăturate “se potrivesc” dacă numărul din dreapta al primului cartonaș este egal cu numărul din stânga al celui de al doilea cartonaș.

Ionel observă că sunt perechi de cartonașe alăturate care “se potrivesc” și chiar secvențe de mai multe cartonașe alăturate, în care primul “se potrivește” cu al doilea, al doilea “se potrivește” cu al treilea etc.

Scrieți un program care să citească numărul '''N''' de cartonașe, numerele înscrise pe fiecare cartonaș și determină:

1) Numărul de perechi de cartonașe care “se potrivesc”.
2) Numărul de cartonașe din cea mai lungă secvență în care fiecare două cartonașe alăturate “se potrivesc”.
3) Numărul de secvențe cu număr maxim de cartonașe care “se potrivesc”.

== Date de intrare ==
Programul conține doar numere naturale nenule:

pe prima linie se găsește numărul '''C''' care poate avea doar valorile '''1, 2 sau 3''' și reprezintă cerința
care urmează a fi rezolvată. Pe a doua linie a programului se găsește numărul natural '''N''', cu semnificația din enunț.

pe fiecare dintre următoarele '''N''' linii se află, în acestă ordine, câte două numere naturale '''nr_cartonas_stanga și nr_cartonas_dreapta''', separate printr-un spațiu, cu semnificația din enunț pentru un cartonaș. Perechile de numere sunt date în ordinea în care cartonașele corespunzătoare lor apar în șirul lui Ionel.

== Date de ieșire ==
Programul va conține pe prima linie un număr natural reprezentând răspunsul la cerința specificată.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''N''' ≤ 500;

1 ≤ '''nr_cartonas_stanga''' ≤ 10.000;

1 ≤ '''nr_cartonas_dreapta''' ≤ 10.000

În concurs, pentru rezolvarea fiecărei cerințe se obțin câte 30 de puncte. Pe site se acordă 10 puncte pentru exemple.

== Exemplul 1 ==
; Datele de intrare
:Introduceti cerinta (1, 2 sau 3): 1
:Introduceti numarul de cartonase: 5
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:10 5
:Introduceti cartonasul stanga si cartonasul dreapta:10 2
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:37 5
; Datele de ieșire
: Datele sunt introduse corect.
: 3
 

== Exemplul 2 ==
; Datele de intrare
:Introduceti cerinta (1, 2 sau 3): 2
:Introduceti numarul de cartonase: 5
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:10 5
:Introduceti cartonasul stanga si cartonasul dreapta:10 2
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:37 5
; Datele de ieșire
: Datele sunt introduse corect.
: 4
 

== Exemplul 3 ==
; Datele de intrare
: C este:
: 3
: N este:
: 6
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 2 8
:STANGA,DREAPTA sunt:
: 6 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3431
def num_pairs(cards):
num_pairs = 0
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
num_pairs += 1
return num_pairs

def longest_sequence(cards):
max_len = 1
curr_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
else:
curr_len = 1
return max_len

def num_max_sequences(cards):
max_len = 1
curr_len = 1
num_max_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
num_max_len = 1
elif curr_len == max_len:
num_max_len += 1
return num_max_len

if __name__ == '__main__':
C = int(input())
N = int(input())
if not 1 <= N <= 500:
print("Datele nu corespund restricțiilor impuse.")
exit()
cards = []
for i in range(N):
stanga, dreapta = map(int, input().split())
if not (1 <= s <= 10000 and 1 <= d <= 10000):
print("Datele nu corespund restricțiilor impuse.")
exit()
cards.append((stanga, dreapta))

if C == 1:
print("Datele sunt introduse corect.")
print(num_pairs(cards))
elif C == 2:
print("Datele sunt introduse corect.")
print(longest_sequence(cards))
else:
print("Datele sunt introduse corect.")
print(num_max_sequences(cards))

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod este o soluție la o problemă matematică care presupune determinarea unor perechi de cărți într-un șir de cărți, în funcție de o regulă. Scopul este să se scrie un program care primește ca input o valoare C (1, 2 sau 3), un număr N (numărul de cărți din șir), și N perechi de numere s și d, reprezentând cărțile. Dacă C este 1, programul trebuie să afișeze numărul de perechi de cărți în care valoarea de pe cartea dreaptă a primei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 2, programul trebuie să afișeze lungimea celei mai lungi secvențe de cărți în care valoarea de pe cartea dreaptă a unei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 3, programul trebuie să afișeze numărul de secvențe de cărți de lungime maximă care respectă regula dată.

Funcțiile num_pairs, longest_sequence și num_max_sequences implementează cele trei cerințe ale problemei. Ele iau ca argument șirul de cărți și returnează valoarea corespunzătoare.

În blocul if name == 'main': se face validarea datelor de intrare. Se primește valoarea C și N, iar apoi se creează o listă de perechi de cărți folosind funcția map(). Dacă N nu este între 1 și 500, se afișează un mesaj de eroare și programul se termină. În plus, dacă oricare dintre valorile s sau d este mai mică decât 1 sau mai mare decât 10000, programul va afișa un alt mesaj de eroare și se va termina. În cele din urmă, se apelează funcțiile corespunzătoare în funcție de valoarea C și se afișează rezultatul.

3431 - Cartonase 3

2023-04-29T09:15:41Z

Sinn Erich: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Ionel are '''N''' cartonașe. Fiecare cartonaș are înscrise două numere (un număr, '''nr_cartonas_stanga''', în partea stângă, și celălalt număr, '''nr_cartonas_dreapta''', în partea dreaptă). El a așezat cartonașele într-un șir, lipite unul de celălalt, astfel încât numărul din partea dreaptă a primului cartonaș este lipit de numărul din partea stângă a celui de-al doilea cartonaș, numărul din partea dreaptă a celui de al doilea cartonaș este lipit de numărul din partea stângă a celui de-al treilea cartonaș etc. Spunem că două cartonașe alăturate “se potrivesc” dacă numărul din dreapta al primului cartonaș este egal cu numărul din stânga al celui de al doilea cartonaș.

Ionel observă că sunt perechi de cartonașe alăturate care “se potrivesc” și chiar secvențe de mai multe cartonașe alăturate, în care primul “se potrivește” cu al doilea, al doilea “se potrivește” cu al treilea etc.

Scrieți un program care să citească numărul '''N''' de cartonașe, numerele înscrise pe fiecare cartonaș și determină:

1) Numărul de perechi de cartonașe care “se potrivesc”.
2) Numărul de cartonașe din cea mai lungă secvență în care fiecare două cartonașe alăturate “se potrivesc”.
3) Numărul de secvențe cu număr maxim de cartonașe care “se potrivesc”.

== Date de intrare ==
Programul conține doar numere naturale nenule:

pe prima linie se găsește numărul '''C''' care poate avea doar valorile '''1, 2 sau 3''' și reprezintă cerința
care urmează a fi rezolvată. Pe a doua linie a programului se găsește numărul natural '''N''', cu semnificația din enunț.

pe fiecare dintre următoarele '''N''' linii se află, în acestă ordine, câte două numere naturale '''nr_cartonas_stanga și nr_cartonas_dreapta''', separate printr-un spațiu, cu semnificația din enunț pentru un cartonaș. Perechile de numere sunt date în ordinea în care cartonașele corespunzătoare lor apar în șirul lui Ionel.

== Date de ieșire ==
Programul va conține pe prima linie un număr natural reprezentând răspunsul la cerința specificată.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''N''' ≤ 500;

1 ≤ '''nr_cartonas_stanga''' ≤ 10.000;

1 ≤ '''nr_cartonas_dreapta''' ≤ 10.000

În concurs, pentru rezolvarea fiecărei cerințe se obțin câte 30 de puncte. Pe site se acordă 10 puncte pentru exemple.

== Exemplul 1 ==
; Datele de intrare
:Introduceti cerinta (1, 2 sau 3): 1
:Introduceti numarul de cartonase: 5
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:10 5
:Introduceti cartonasul stanga si cartonasul dreapta:10 2
:Introduceti cartonasul stanga si cartonasul dreapta:2 10
:Introduceti cartonasul stanga si cartonasul dreapta:37 5
; Datele de ieșire
: Datele sunt introduse corect.
: 3
 

== Exemplul 2 ==
; Datele de intrare
: C este:
: 2
:N este:
: 5
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 5 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 4
 

== Exemplul 3 ==
; Datele de intrare
: C este:
: 3
: N este:
: 6
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 2 8
:STANGA,DREAPTA sunt:
: 6 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3431
def num_pairs(cards):
num_pairs = 0
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
num_pairs += 1
return num_pairs

def longest_sequence(cards):
max_len = 1
curr_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
else:
curr_len = 1
return max_len

def num_max_sequences(cards):
max_len = 1
curr_len = 1
num_max_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
num_max_len = 1
elif curr_len == max_len:
num_max_len += 1
return num_max_len

if __name__ == '__main__':
C = int(input())
N = int(input())
if not 1 <= N <= 500:
print("Datele nu corespund restricțiilor impuse.")
exit()
cards = []
for i in range(N):
stanga, dreapta = map(int, input().split())
if not (1 <= s <= 10000 and 1 <= d <= 10000):
print("Datele nu corespund restricțiilor impuse.")
exit()
cards.append((stanga, dreapta))

if C == 1:
print("Datele sunt introduse corect.")
print(num_pairs(cards))
elif C == 2:
print("Datele sunt introduse corect.")
print(longest_sequence(cards))
else:
print("Datele sunt introduse corect.")
print(num_max_sequences(cards))

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod este o soluție la o problemă matematică care presupune determinarea unor perechi de cărți într-un șir de cărți, în funcție de o regulă. Scopul este să se scrie un program care primește ca input o valoare C (1, 2 sau 3), un număr N (numărul de cărți din șir), și N perechi de numere s și d, reprezentând cărțile. Dacă C este 1, programul trebuie să afișeze numărul de perechi de cărți în care valoarea de pe cartea dreaptă a primei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 2, programul trebuie să afișeze lungimea celei mai lungi secvențe de cărți în care valoarea de pe cartea dreaptă a unei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 3, programul trebuie să afișeze numărul de secvențe de cărți de lungime maximă care respectă regula dată.

Funcțiile num_pairs, longest_sequence și num_max_sequences implementează cele trei cerințe ale problemei. Ele iau ca argument șirul de cărți și returnează valoarea corespunzătoare.

În blocul if name == 'main': se face validarea datelor de intrare. Se primește valoarea C și N, iar apoi se creează o listă de perechi de cărți folosind funcția map(). Dacă N nu este între 1 și 500, se afișează un mesaj de eroare și programul se termină. În plus, dacă oricare dintre valorile s sau d este mai mică decât 1 sau mai mare decât 10000, programul va afișa un alt mesaj de eroare și se va termina. În cele din urmă, se apelează funcțiile corespunzătoare în funcție de valoarea C și se afișează rezultatul.

3431 - Cartonase 3

2023-04-29T09:08:23Z

Sinn Erich: /* Restricţii şi precizări */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Ionel are '''N''' cartonașe. Fiecare cartonaș are înscrise două numere (un număr, '''nr_cartonas_stanga''', în partea stângă, și celălalt număr, '''nr_cartonas_dreapta''', în partea dreaptă). El a așezat cartonașele într-un șir, lipite unul de celălalt, astfel încât numărul din partea dreaptă a primului cartonaș este lipit de numărul din partea stângă a celui de-al doilea cartonaș, numărul din partea dreaptă a celui de al doilea cartonaș este lipit de numărul din partea stângă a celui de-al treilea cartonaș etc. Spunem că două cartonașe alăturate “se potrivesc” dacă numărul din dreapta al primului cartonaș este egal cu numărul din stânga al celui de al doilea cartonaș.

Ionel observă că sunt perechi de cartonașe alăturate care “se potrivesc” și chiar secvențe de mai multe cartonașe alăturate, în care primul “se potrivește” cu al doilea, al doilea “se potrivește” cu al treilea etc.

Scrieți un program care să citească numărul '''N''' de cartonașe, numerele înscrise pe fiecare cartonaș și determină:

1) Numărul de perechi de cartonașe care “se potrivesc”.
2) Numărul de cartonașe din cea mai lungă secvență în care fiecare două cartonașe alăturate “se potrivesc”.
3) Numărul de secvențe cu număr maxim de cartonașe care “se potrivesc”.

== Date de intrare ==
Programul conține doar numere naturale nenule:

pe prima linie se găsește numărul '''C''' care poate avea doar valorile '''1, 2 sau 3''' și reprezintă cerința
care urmează a fi rezolvată. Pe a doua linie a programului se găsește numărul natural '''N''', cu semnificația din enunț.

pe fiecare dintre următoarele '''N''' linii se află, în acestă ordine, câte două numere naturale '''nr_cartonas_stanga și nr_cartonas_dreapta''', separate printr-un spațiu, cu semnificația din enunț pentru un cartonaș. Perechile de numere sunt date în ordinea în care cartonașele corespunzătoare lor apar în șirul lui Ionel.

== Date de ieșire ==
Programul va conține pe prima linie un număr natural reprezentând răspunsul la cerința specificată.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''N''' ≤ 500;

1 ≤ '''nr_cartonas_stanga''' ≤ 10.000;

1 ≤ '''nr_cartonas_dreapta''' ≤ 10.000

În concurs, pentru rezolvarea fiecărei cerințe se obțin câte 30 de puncte. Pe site se acordă 10 puncte pentru exemple.

== Exemplul 1 ==
; Datele de intrare
: C este:
: 1
: N este:
: 5
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 10 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

== Exemplul 2 ==
; Datele de intrare
: C este:
: 2
:N este:
: 5
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 5 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 4
 

== Exemplul 3 ==
; Datele de intrare
: C este:
: 3
: N este:
: 6
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 2 8
:STANGA,DREAPTA sunt:
: 6 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3431
def num_pairs(cards):
num_pairs = 0
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
num_pairs += 1
return num_pairs

def longest_sequence(cards):
max_len = 1
curr_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
else:
curr_len = 1
return max_len

def num_max_sequences(cards):
max_len = 1
curr_len = 1
num_max_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
num_max_len = 1
elif curr_len == max_len:
num_max_len += 1
return num_max_len

if __name__ == '__main__':
C = int(input())
N = int(input())
if not 1 <= N <= 500:
print("Datele nu corespund restricțiilor impuse.")
exit()
cards = []
for i in range(N):
stanga, dreapta = map(int, input().split())
if not (1 <= s <= 10000 and 1 <= d <= 10000):
print("Datele nu corespund restricțiilor impuse.")
exit()
cards.append((stanga, dreapta))

if C == 1:
print("Datele sunt introduse corect.")
print(num_pairs(cards))
elif C == 2:
print("Datele sunt introduse corect.")
print(longest_sequence(cards))
else:
print("Datele sunt introduse corect.")
print(num_max_sequences(cards))

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod este o soluție la o problemă matematică care presupune determinarea unor perechi de cărți într-un șir de cărți, în funcție de o regulă. Scopul este să se scrie un program care primește ca input o valoare C (1, 2 sau 3), un număr N (numărul de cărți din șir), și N perechi de numere s și d, reprezentând cărțile. Dacă C este 1, programul trebuie să afișeze numărul de perechi de cărți în care valoarea de pe cartea dreaptă a primei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 2, programul trebuie să afișeze lungimea celei mai lungi secvențe de cărți în care valoarea de pe cartea dreaptă a unei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 3, programul trebuie să afișeze numărul de secvențe de cărți de lungime maximă care respectă regula dată.

Funcțiile num_pairs, longest_sequence și num_max_sequences implementează cele trei cerințe ale problemei. Ele iau ca argument șirul de cărți și returnează valoarea corespunzătoare.

În blocul if name == 'main': se face validarea datelor de intrare. Se primește valoarea C și N, iar apoi se creează o listă de perechi de cărți folosind funcția map(). Dacă N nu este între 1 și 500, se afișează un mesaj de eroare și programul se termină. În plus, dacă oricare dintre valorile s sau d este mai mică decât 1 sau mai mare decât 10000, programul va afișa un alt mesaj de eroare și se va termina. În cele din urmă, se apelează funcțiile corespunzătoare în funcție de valoarea C și se afișează rezultatul.

3431 - Cartonase 3

2023-04-29T09:07:57Z

Sinn Erich: /* Date de intrare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Ionel are '''N''' cartonașe. Fiecare cartonaș are înscrise două numere (un număr, '''nr_cartonas_stanga''', în partea stângă, și celălalt număr, '''nr_cartonas_dreapta''', în partea dreaptă). El a așezat cartonașele într-un șir, lipite unul de celălalt, astfel încât numărul din partea dreaptă a primului cartonaș este lipit de numărul din partea stângă a celui de-al doilea cartonaș, numărul din partea dreaptă a celui de al doilea cartonaș este lipit de numărul din partea stângă a celui de-al treilea cartonaș etc. Spunem că două cartonașe alăturate “se potrivesc” dacă numărul din dreapta al primului cartonaș este egal cu numărul din stânga al celui de al doilea cartonaș.

Ionel observă că sunt perechi de cartonașe alăturate care “se potrivesc” și chiar secvențe de mai multe cartonașe alăturate, în care primul “se potrivește” cu al doilea, al doilea “se potrivește” cu al treilea etc.

Scrieți un program care să citească numărul '''N''' de cartonașe, numerele înscrise pe fiecare cartonaș și determină:

1) Numărul de perechi de cartonașe care “se potrivesc”.
2) Numărul de cartonașe din cea mai lungă secvență în care fiecare două cartonașe alăturate “se potrivesc”.
3) Numărul de secvențe cu număr maxim de cartonașe care “se potrivesc”.

== Date de intrare ==
Programul conține doar numere naturale nenule:

pe prima linie se găsește numărul '''C''' care poate avea doar valorile '''1, 2 sau 3''' și reprezintă cerința
care urmează a fi rezolvată. Pe a doua linie a programului se găsește numărul natural '''N''', cu semnificația din enunț.

pe fiecare dintre următoarele '''N''' linii se află, în acestă ordine, câte două numere naturale '''nr_cartonas_stanga și nr_cartonas_dreapta''', separate printr-un spațiu, cu semnificația din enunț pentru un cartonaș. Perechile de numere sunt date în ordinea în care cartonașele corespunzătoare lor apar în șirul lui Ionel.

== Date de ieșire ==
Programul va conține pe prima linie un număr natural reprezentând răspunsul la cerința specificată.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''N''' ≤ 500;

1 ≤ '''stanga''' ≤ 10.000;

1 ≤ '''dreapta''' ≤ 10.000

În concurs, pentru rezolvarea fiecărei cerințe se obțin câte 30 de puncte. Pe site se acordă 10 puncte pentru exemple.

== Exemplul 1 ==
; Datele de intrare
: C este:
: 1
: N este:
: 5
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 10 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

== Exemplul 2 ==
; Datele de intrare
: C este:
: 2
:N este:
: 5
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 5 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 4
 

== Exemplul 3 ==
; Datele de intrare
: C este:
: 3
: N este:
: 6
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 2 8
:STANGA,DREAPTA sunt:
: 6 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3431
def num_pairs(cards):
num_pairs = 0
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
num_pairs += 1
return num_pairs

def longest_sequence(cards):
max_len = 1
curr_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
else:
curr_len = 1
return max_len

def num_max_sequences(cards):
max_len = 1
curr_len = 1
num_max_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
num_max_len = 1
elif curr_len == max_len:
num_max_len += 1
return num_max_len

if __name__ == '__main__':
C = int(input())
N = int(input())
if not 1 <= N <= 500:
print("Datele nu corespund restricțiilor impuse.")
exit()
cards = []
for i in range(N):
stanga, dreapta = map(int, input().split())
if not (1 <= s <= 10000 and 1 <= d <= 10000):
print("Datele nu corespund restricțiilor impuse.")
exit()
cards.append((stanga, dreapta))

if C == 1:
print("Datele sunt introduse corect.")
print(num_pairs(cards))
elif C == 2:
print("Datele sunt introduse corect.")
print(longest_sequence(cards))
else:
print("Datele sunt introduse corect.")
print(num_max_sequences(cards))

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod este o soluție la o problemă matematică care presupune determinarea unor perechi de cărți într-un șir de cărți, în funcție de o regulă. Scopul este să se scrie un program care primește ca input o valoare C (1, 2 sau 3), un număr N (numărul de cărți din șir), și N perechi de numere s și d, reprezentând cărțile. Dacă C este 1, programul trebuie să afișeze numărul de perechi de cărți în care valoarea de pe cartea dreaptă a primei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 2, programul trebuie să afișeze lungimea celei mai lungi secvențe de cărți în care valoarea de pe cartea dreaptă a unei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 3, programul trebuie să afișeze numărul de secvențe de cărți de lungime maximă care respectă regula dată.

Funcțiile num_pairs, longest_sequence și num_max_sequences implementează cele trei cerințe ale problemei. Ele iau ca argument șirul de cărți și returnează valoarea corespunzătoare.

În blocul if name == 'main': se face validarea datelor de intrare. Se primește valoarea C și N, iar apoi se creează o listă de perechi de cărți folosind funcția map(). Dacă N nu este între 1 și 500, se afișează un mesaj de eroare și programul se termină. În plus, dacă oricare dintre valorile s sau d este mai mică decât 1 sau mai mare decât 10000, programul va afișa un alt mesaj de eroare și se va termina. În cele din urmă, se apelează funcțiile corespunzătoare în funcție de valoarea C și se afișează rezultatul.

3431 - Cartonase 3

2023-04-29T09:07:22Z

Sinn Erich: /* Cerinţa */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Ionel are '''N''' cartonașe. Fiecare cartonaș are înscrise două numere (un număr, '''nr_cartonas_stanga''', în partea stângă, și celălalt număr, '''nr_cartonas_dreapta''', în partea dreaptă). El a așezat cartonașele într-un șir, lipite unul de celălalt, astfel încât numărul din partea dreaptă a primului cartonaș este lipit de numărul din partea stângă a celui de-al doilea cartonaș, numărul din partea dreaptă a celui de al doilea cartonaș este lipit de numărul din partea stângă a celui de-al treilea cartonaș etc. Spunem că două cartonașe alăturate “se potrivesc” dacă numărul din dreapta al primului cartonaș este egal cu numărul din stânga al celui de al doilea cartonaș.

Ionel observă că sunt perechi de cartonașe alăturate care “se potrivesc” și chiar secvențe de mai multe cartonașe alăturate, în care primul “se potrivește” cu al doilea, al doilea “se potrivește” cu al treilea etc.

Scrieți un program care să citească numărul '''N''' de cartonașe, numerele înscrise pe fiecare cartonaș și determină:

1) Numărul de perechi de cartonașe care “se potrivesc”.
2) Numărul de cartonașe din cea mai lungă secvență în care fiecare două cartonașe alăturate “se potrivesc”.
3) Numărul de secvențe cu număr maxim de cartonașe care “se potrivesc”.

== Date de intrare ==
Programul conține doar numere naturale nenule:

pe prima linie se găsește numărul '''C''' care poate avea doar valorile '''1, 2 sau 3''' și reprezintă cerința
care urmează a fi rezolvată. Pe a doua linie a programului se găsește numărul natural '''N''', cu semnificația din enunț.

pe fiecare dintre următoarele '''N''' linii se află, în acestă ordine, câte două numere naturale '''stanga și dreapta''', separate printr-un spațiu, cu semnificația din enunț pentru un cartonaș. Perechile de numere sunt date în ordinea în care cartonașele corespunzătoare lor apar în șirul lui Ionel.

== Date de ieșire ==
Programul va conține pe prima linie un număr natural reprezentând răspunsul la cerința specificată.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''N''' ≤ 500;

1 ≤ '''stanga''' ≤ 10.000;

1 ≤ '''dreapta''' ≤ 10.000

În concurs, pentru rezolvarea fiecărei cerințe se obțin câte 30 de puncte. Pe site se acordă 10 puncte pentru exemple.

== Exemplul 1 ==
; Datele de intrare
: C este:
: 1
: N este:
: 5
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 10 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

== Exemplul 2 ==
; Datele de intrare
: C este:
: 2
:N este:
: 5
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 5 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 4
 

== Exemplul 3 ==
; Datele de intrare
: C este:
: 3
: N este:
: 6
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 2 8
:STANGA,DREAPTA sunt:
: 6 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3431
def num_pairs(cards):
num_pairs = 0
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
num_pairs += 1
return num_pairs

def longest_sequence(cards):
max_len = 1
curr_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
else:
curr_len = 1
return max_len

def num_max_sequences(cards):
max_len = 1
curr_len = 1
num_max_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
num_max_len = 1
elif curr_len == max_len:
num_max_len += 1
return num_max_len

if __name__ == '__main__':
C = int(input())
N = int(input())
if not 1 <= N <= 500:
print("Datele nu corespund restricțiilor impuse.")
exit()
cards = []
for i in range(N):
stanga, dreapta = map(int, input().split())
if not (1 <= s <= 10000 and 1 <= d <= 10000):
print("Datele nu corespund restricțiilor impuse.")
exit()
cards.append((stanga, dreapta))

if C == 1:
print("Datele sunt introduse corect.")
print(num_pairs(cards))
elif C == 2:
print("Datele sunt introduse corect.")
print(longest_sequence(cards))
else:
print("Datele sunt introduse corect.")
print(num_max_sequences(cards))

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod este o soluție la o problemă matematică care presupune determinarea unor perechi de cărți într-un șir de cărți, în funcție de o regulă. Scopul este să se scrie un program care primește ca input o valoare C (1, 2 sau 3), un număr N (numărul de cărți din șir), și N perechi de numere s și d, reprezentând cărțile. Dacă C este 1, programul trebuie să afișeze numărul de perechi de cărți în care valoarea de pe cartea dreaptă a primei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 2, programul trebuie să afișeze lungimea celei mai lungi secvențe de cărți în care valoarea de pe cartea dreaptă a unei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 3, programul trebuie să afișeze numărul de secvențe de cărți de lungime maximă care respectă regula dată.

Funcțiile num_pairs, longest_sequence și num_max_sequences implementează cele trei cerințe ale problemei. Ele iau ca argument șirul de cărți și returnează valoarea corespunzătoare.

În blocul if name == 'main': se face validarea datelor de intrare. Se primește valoarea C și N, iar apoi se creează o listă de perechi de cărți folosind funcția map(). Dacă N nu este între 1 și 500, se afișează un mesaj de eroare și programul se termină. În plus, dacă oricare dintre valorile s sau d este mai mică decât 1 sau mai mare decât 10000, programul va afișa un alt mesaj de eroare și se va termina. În cele din urmă, se apelează funcțiile corespunzătoare în funcție de valoarea C și se afișează rezultatul.

3431 - Cartonase 3

2023-04-29T09:06:53Z

Sinn Erich: /* Cerinţa */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Ionel are '''N''' cartonașe. Fiecare cartonaș are înscrise două numere (un număr, '''cartonas_stanga''', în partea stângă, și celălalt număr, '''cartonas_dreapta''', în partea dreaptă). El a așezat cartonașele într-un șir, lipite unul de celălalt, astfel încât numărul din partea dreaptă a primului cartonaș este lipit de numărul din partea stângă a celui de-al doilea cartonaș, numărul din partea dreaptă a celui de al doilea cartonaș este lipit de numărul din partea stângă a celui de-al treilea cartonaș etc. Spunem că două cartonașe alăturate “se potrivesc” dacă numărul din dreapta al primului cartonaș este egal cu numărul din stânga al celui de al doilea cartonaș.

Ionel observă că sunt perechi de cartonașe alăturate care “se potrivesc” și chiar secvențe de mai multe cartonașe alăturate, în care primul “se potrivește” cu al doilea, al doilea “se potrivește” cu al treilea etc.

Scrieți un program care să citească numărul '''N''' de cartonașe, numerele înscrise pe fiecare cartonaș și determină:

1) Numărul de perechi de cartonașe care “se potrivesc”.
2) Numărul de cartonașe din cea mai lungă secvență în care fiecare două cartonașe alăturate “se potrivesc”.
3) Numărul de secvențe cu număr maxim de cartonașe care “se potrivesc”.

== Date de intrare ==
Programul conține doar numere naturale nenule:

pe prima linie se găsește numărul '''C''' care poate avea doar valorile '''1, 2 sau 3''' și reprezintă cerința
care urmează a fi rezolvată. Pe a doua linie a programului se găsește numărul natural '''N''', cu semnificația din enunț.

pe fiecare dintre următoarele '''N''' linii se află, în acestă ordine, câte două numere naturale '''stanga și dreapta''', separate printr-un spațiu, cu semnificația din enunț pentru un cartonaș. Perechile de numere sunt date în ordinea în care cartonașele corespunzătoare lor apar în șirul lui Ionel.

== Date de ieșire ==
Programul va conține pe prima linie un număr natural reprezentând răspunsul la cerința specificată.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''N''' ≤ 500;

1 ≤ '''stanga''' ≤ 10.000;

1 ≤ '''dreapta''' ≤ 10.000

În concurs, pentru rezolvarea fiecărei cerințe se obțin câte 30 de puncte. Pe site se acordă 10 puncte pentru exemple.

== Exemplul 1 ==
; Datele de intrare
: C este:
: 1
: N este:
: 5
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 10 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

== Exemplul 2 ==
; Datele de intrare
: C este:
: 2
:N este:
: 5
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 5 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 4
 

== Exemplul 3 ==
; Datele de intrare
: C este:
: 3
: N este:
: 6
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 10 5
:STANGA,DREAPTA sunt:
: 2 8
:STANGA,DREAPTA sunt:
: 6 2
:STANGA,DREAPTA sunt:
: 2 10
:STANGA,DREAPTA sunt:
: 37 5
: Datele sunt introduse corect.
; Datele de ieșire
: 2
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3431
def num_pairs(cards):
num_pairs = 0
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
num_pairs += 1
return num_pairs

def longest_sequence(cards):
max_len = 1
curr_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
else:
curr_len = 1
return max_len

def num_max_sequences(cards):
max_len = 1
curr_len = 1
num_max_len = 1
for i in range(len(cards)-1):
if cards[i][1] == cards[i+1][0]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
num_max_len = 1
elif curr_len == max_len:
num_max_len += 1
return num_max_len

if __name__ == '__main__':
C = int(input())
N = int(input())
if not 1 <= N <= 500:
print("Datele nu corespund restricțiilor impuse.")
exit()
cards = []
for i in range(N):
stanga, dreapta = map(int, input().split())
if not (1 <= s <= 10000 and 1 <= d <= 10000):
print("Datele nu corespund restricțiilor impuse.")
exit()
cards.append((stanga, dreapta))

if C == 1:
print("Datele sunt introduse corect.")
print(num_pairs(cards))
elif C == 2:
print("Datele sunt introduse corect.")
print(longest_sequence(cards))
else:
print("Datele sunt introduse corect.")
print(num_max_sequences(cards))

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod este o soluție la o problemă matematică care presupune determinarea unor perechi de cărți într-un șir de cărți, în funcție de o regulă. Scopul este să se scrie un program care primește ca input o valoare C (1, 2 sau 3), un număr N (numărul de cărți din șir), și N perechi de numere s și d, reprezentând cărțile. Dacă C este 1, programul trebuie să afișeze numărul de perechi de cărți în care valoarea de pe cartea dreaptă a primei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 2, programul trebuie să afișeze lungimea celei mai lungi secvențe de cărți în care valoarea de pe cartea dreaptă a unei cărți este egală cu valoarea de pe cartea stângă a celei de-a doua cărți. Dacă C este 3, programul trebuie să afișeze numărul de secvențe de cărți de lungime maximă care respectă regula dată.

Funcțiile num_pairs, longest_sequence și num_max_sequences implementează cele trei cerințe ale problemei. Ele iau ca argument șirul de cărți și returnează valoarea corespunzătoare.

În blocul if name == 'main': se face validarea datelor de intrare. Se primește valoarea C și N, iar apoi se creează o listă de perechi de cărți folosind funcția map(). Dacă N nu este între 1 și 500, se afișează un mesaj de eroare și programul se termină. În plus, dacă oricare dintre valorile s sau d este mai mică decât 1 sau mai mare decât 10000, programul va afișa un alt mesaj de eroare și se va termina. În cele din urmă, se apelează funcțiile corespunzătoare în funcție de valoarea C și se afișează rezultatul.

2950 - Adun

2023-04-29T09:03:32Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==

Ionel a primit la ora de matematica o problema interesantă. El are doua numere naturale '''X''' și '''Y''' și trebuie să determine un număr natural '''K''' astfel încât cel mai mic multiplu comun al numerelor '''X + K''' și '''Y + K''' să fie minim

Determinați valoarea lui '''K''' astfel încât cel mai mic multiplu comun al numerelor '''X + K''' și '''Y + K''' să fie minim.

== Date de intrare ==
Programul citește de la tastatură numerele naturale '''X și Y''' separate cu un spațiu.

== Date de ieșire ==
Programul va afișa pe ecran valoarea '''K'''.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează valoarea lui K astfel încât cel mai mic multiplu comun al numerelor X + K și Y + K să fie minim.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
'''X și Y''' sunt numere naturale mai mici decât 1.000.000.001.

Dacă sunt mai multe valori K pentru care cel mai mic multiplu comun al numerelor '''X + K și Y + K''' este minim, se va afișa valoarea '''K minimă'''.

== Exemplul 1 ==
; Datele de intrare
: Introduceti cele doua numere:
: 6 14
; Datele de ieșire
: Datele sunt introduse corect.
: 2
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2950
def validate_input(x, y):
if x < 1 or x >= 1000000001:
return False
if y < 1 or y >= 1000000001:
return False
return True

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

def solve(x, y):
gcd_xy = gcd(x, y)
lcm_xy = x * y // gcd_xy

# iteram prin toate numerele intre 1 si gcd(X, Y)
min_lcm = lcm_xy
min_k = 0

for k in range(1, gcd_xy + 1):
lcm_k = (x + k) * (y + k) // gcd(x + k, y + k)
if lcm_k < min_lcm:
min_lcm = lcm_k
min_k = k

# afisam valoarea lui K
print(min_k)

if __name__ == '__main__':
x, y = map(int, input("Introduceti cele doua numere:").split())

if not validate_input(x, y):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
solve(x, y)

</syntaxhighlight>

'''Explicatie cod:'''

Această implementare calculează cel mai mic multiplu comun al două numere naturale x și y, în care sunt adăugate valori constante diferite k la fiecare număr și se determină valoarea minimă a lui k astfel încât LCM(x+k, y+k) să fie minim.

Funcția `validate_input(x, y)` verifică dacă cele două numere introduse sunt numere naturale și se încadrează în intervalul [1, 1000000000]. Dacă una dintre condiții nu este îndeplinită, funcția returnează `False`.

Funcția `gcd(a, b)` calculează cel mai mare divizor comun al două numere a și b folosind algoritmul lui Euclid.

Funcția `solve(x, y)` calculează cel mai mic multiplu comun al lui x și y folosind gcd și apoi calculează pentru fiecare valoare k între 1 și gcd(x, y) valoarea LCM(x+k, y+k) și determină valoarea minimă a lui k astfel încât LCM(x+k, y+k) să fie minim. Valoarea minimă a lui k și LCM(x+k, y+k) sunt stocate în variabilele `min_k` și `min_lcm`. La sfârșit, funcția afișează valoarea lui `min_k`.

În `main()`, se citește cele două numere de la tastatură folosind `map()` și apoi se verifică dacă datele de intrare sunt corecte folosind funcția `validate_input(x, y)`. Dacă datele de intrare sunt incorecte, se afișează un mesaj corespunzător. În caz contrar, se afișează un mesaj de confirmare și se apelează funcția `solve(x, y)`.

2308 - Fractzii

2023-04-29T08:59:04Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
O proprietate interesanta a fracțiilor ireductibile este ca orice fracție se poate obține după următoarele reguli:
- pe primul nivel se afla fracția 1/1;
- pe al doilea nivel, în stânga fracției 1/1 de pe primul nivel, plasam fracția 1/2 iar în dreapta ei fracția 2/1;

nivelul 1: 1/1
nivelul 2: 1/2 2/1

- pe fiecare nivel k se plasează sub fiecare fracție i / j de pe nivelul de deasupra, fracția i / (i + j) în stânga, iar fracția (i + j) / j în dreapta.

nivelul 1: 1/1
nivelul 2: 1/2 2/1
nivelul 3: 1/3 3/2 2/3 3/1

Dându-se o fracție oarecare prin numărătorul și numitorul său, determinați numărul nivelului pe care se află fracția sau o fracție echivalentă (având aceeași valoare) cu aceasta.

== Date de intrare ==
Programul conține pe prima linie două numere naturale nenule '''N M''', separate printr-un spațiu, reprezentând '''numărătorul și respectiv numitorul''' unei fracții.

== Date de ieșire ==
Programul va conţine o ingură linie, pe care va fi scris număr natural nenul, reprezentând numărul nivelului care corespunde fracţiei."

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează numărul nivelului pe care se află fracția sau o fracție echivalentă (având aceeași valoare) cu aceasta.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''N, M''' ≤ 2 000 000 000

== Exemplul 1 ==
; Datele de intrare
: Introduceti doua numere naturale:
: 13 8
; Datele de ieșire
: Datele sunt introduse corect.
: 6
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2308
def nivel_fracție(n, m):
nivel = 1
fracții = [[1, 1]]

while True:
fracții_nivel = []
for fracție in fracții:
fracții_nivel.append([fracție[0], fracție[0] + fracție[1]])
fracții_nivel.append([fracție[0] + fracție[1], fracție[1]])

if [n, m] in fracții_nivel:
return nivel + 1
elif nivel == 100: # pentru a evita o buclă infinită
return -1

fracții = fracții_nivel
nivel += 1
def validare_input(n, m):
"""
Verifică dacă datele de intrare sunt valide.
"""
if n < 1 or n > 2000000000 or m < 1 or m > 2000000000:
return False
return True

if __name__ == '__main__':
n, m = map(int, input("Introduceti doua numere naturale: ").split())

if n >= 1 and n <= 2000000000 and m >= 1 and m <= 2000000000:
print("Datele sunt introduse corect.")
print(nivel_fracție(n, m))
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

'''Explicatie cod:'''

Codul dat începe cu o funcție nivel_fracție care primește două numere întregi pozitive n și m. Scopul funcției este de a determina nivelul la care fracția n/m apare în șirul de fracții în ordine crescătoare generat astfel:

nivelul 1: 1/1

nivelul 2: 1/2, 2/1

nivelul 3: 1/3, 2/3, 3/2, 3/1

nivelul 4: 1/4, 2/4, 3/4, 4/3, 4/2, 4/1
și așa mai departe.

Pentru a face acest lucru, se pornește de la fracția 1/1 și se generează toate fracțiile posibile la nivelul curent, folosindu-se de fracțiile de la nivelul anterior. De exemplu, pentru a genera fracțiile nivelului 2, se iau fracțiile de la nivelul 1 și se adaugă la ele fracțiile de forma k/1 și 1/k, unde k este un număr întreg pozitiv mai mare decât 1. În cazul de față, se folosește o listă fracții pentru a ține evidența fracțiilor de la nivelul anterior, iar la fiecare iterație se creează o listă nouă fracții_nivel care conține toate fracțiile la nivelul curent, generându-se astfel toate fracțiile pentru nivelurile următoare.

Funcția se oprește când fracția n/m apare la un anumit nivel nivel și returnează nivel + 1, adică nivelul la care apare această fracție. Dacă fracția nu apare în primele 100 de niveluri, se consideră că nu apare deloc și se returnează -1.

Funcția validare_input este o funcție auxiliară care verifică dacă datele de intrare sunt valide, adică dacă n și m sunt numere întregi pozitive între 1 și 2 miliarde.

În blocul principal, se citește de la tastatură două numere întregi pozitive n și m. Se verifică dacă datele de intrare sunt valide, apelându-se funcția validare_input, și se afișează un mesaj corespunzător. Dacă datele de intrare sunt valide, se apelează funcția nivel_fracție și se afișează rezultatul.

2308 - Fractzii

2023-04-29T08:58:38Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
O proprietate interesanta a fracțiilor ireductibile este ca orice fracție se poate obține după următoarele reguli:
- pe primul nivel se afla fracția 1/1;
- pe al doilea nivel, în stânga fracției 1/1 de pe primul nivel, plasam fracția 1/2 iar în dreapta ei fracția 2/1;

nivelul 1: 1/1
nivelul 2: 1/2 2/1

- pe fiecare nivel k se plasează sub fiecare fracție i / j de pe nivelul de deasupra, fracția i / (i + j) în stânga, iar fracția (i + j) / j în dreapta.

nivelul 1: 1/1
nivelul 2: 1/2 2/1
nivelul 3: 1/3 3/2 2/3 3/1

Dându-se o fracție oarecare prin numărătorul și numitorul său, determinați numărul nivelului pe care se află fracția sau o fracție echivalentă (având aceeași valoare) cu aceasta.

== Date de intrare ==
Programul conține pe prima linie două numere naturale nenule '''N M''', separate printr-un spațiu, reprezentând '''numărătorul și respectiv numitorul''' unei fracții.

== Date de ieșire ==
Programul va conţine o ingură linie, pe care va fi scris număr natural nenul, reprezentând numărul nivelului care corespunde fracţiei."

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează numărul nivelului pe care se află fracția sau o fracție echivalentă (având aceeași valoare) cu aceasta.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''N, M''' ≤ 2 000 000 000

== Exemplul 1 ==
; Datele de intrare
: Introduceti doua numere naturale:
: 13 8
; Datele de ieșire
: Datele sunt introduse corect.
: 6
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2308
def nivel_fracție(n, m):
nivel = 1
fracții = [[1, 1]]

while True:
fracții_nivel = []
for fracție in fracții:
fracții_nivel.append([fracție[0], fracție[0] + fracție[1]])
fracții_nivel.append([fracție[0] + fracție[1], fracție[1]])

if [n, m] in fracții_nivel:
return nivel + 1
elif nivel == 100: # pentru a evita o buclă infinită
return -1

fracții = fracții_nivel
nivel += 1
def validare_input(n, m):
"""
Verifică dacă datele de intrare sunt valide.
"""
if n < 1 or n > 2000000000 or m < 1 or m > 2000000000:
return False
return True

if __name__ == '__main__':
n, m = map(int, input("Introduceti doua numere naturale: ").split())

if n >= 1 and n <= 2000000000 and m >= 1 and m <= 2000000000:
print("Datele sunt introduse corect.")
print(nivel_fracție(n, m))
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

'''Explicatie cod:'''

Codul dat începe cu o funcție nivel_fracție care primește două numere întregi pozitive n și m. Scopul funcției este de a determina nivelul la care fracția n/m apare în șirul de fracții în ordine crescătoare generat astfel:

nivelul 1: 1/1
nivelul 2: 1/2, 2/1
nivelul 3: 1/3, 2/3, 3/2, 3/1
nivelul 4: 1/4, 2/4, 3/4, 4/3, 4/2, 4/1
și așa mai departe.
Pentru a face acest lucru, se pornește de la fracția 1/1 și se generează toate fracțiile posibile la nivelul curent, folosindu-se de fracțiile de la nivelul anterior. De exemplu, pentru a genera fracțiile nivelului 2, se iau fracțiile de la nivelul 1 și se adaugă la ele fracțiile de forma k/1 și 1/k, unde k este un număr întreg pozitiv mai mare decât 1. În cazul de față, se folosește o listă fracții pentru a ține evidența fracțiilor de la nivelul anterior, iar la fiecare iterație se creează o listă nouă fracții_nivel care conține toate fracțiile la nivelul curent, generându-se astfel toate fracțiile pentru nivelurile următoare.

Funcția se oprește când fracția n/m apare la un anumit nivel nivel și returnează nivel + 1, adică nivelul la care apare această fracție. Dacă fracția nu apare în primele 100 de niveluri, se consideră că nu apare deloc și se returnează -1.

Funcția validare_input este o funcție auxiliară care verifică dacă datele de intrare sunt valide, adică dacă n și m sunt numere întregi pozitive între 1 și 2 miliarde.

În blocul principal, se citește de la tastatură două numere întregi pozitive n și m. Se verifică dacă datele de intrare sunt valide, apelându-se funcția validare_input, și se afișează un mesaj corespunzător. Dacă datele de intrare sunt valide, se apelează funcția nivel_fracție și se afișează rezultatul.

1529 - Pesti

2023-04-29T08:54:59Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Andrei îşi doreşte un acvariu cu peşti. Găseşte în oraş un singur magazin ZOO unde se vând doar peştişori ciudaţi. Fiecare peştişor se îngraşă în fiecare zi cu câte un număr de grame. Cu fiecare săptămâna ce trece, peştişorii vor lua în greutate acelaşi număr de grame ca şi săptămâna precedentă, la care se adaugă greutatea pe care o luau în prima săptămână. Nu toţi peştişorii sunt de acelaşi tip, deci nu au neapărat aceeaşi greutate şi nici nu se îngraşă neapărat cu acelaşi număr de grame.

Andrei se hotărăşte totuşi să cumpere n peştişori, pe care-i numeşte A,B,C,D,… în ordinea în care îi pune în acvariu. Vrând să ştie în permanenţă ce greutate are fiecare, îşi notează câţi peşti a pus în acvariu, litera atribuită fiecărui peşte, câte grame are fiecare peşte când a fost pus în acvariu şi cu câte grame se îngraşă în ziua în care este pus în acvariu.

Scrieţi un program care afişează, în ordine alfabetică, toţi peştii care au cel puțin greutatea '''greutate_peste''', dată în grame, după ce au trecut '''nr_zile''' zile. Pentru fiecare peşte se va afişa greutatea în grame şi litera ce i-a fost atribuită.

== Date de intrare ==
Programul conţine pe prima linie, separate prin spațiu, valorile '''n, greutate_peste şi nr_zile'''.

Urmează '''n''' linii, pe fiecare linie fiind scrise separate prin spaţiu: o literă mare, greutatea peştelui în grame şi numărul de grame cu care se îngraşă în ziua în care este pus în acvariu.

== Date de ieșire ==
Programul va afișa pe ecran, mesajul "Datele introduse corespund cerințelor" și pe o linie nouă numărul '''P''' , reprezentând produsul primelor '''n''' pătrate perfecte nenule, în caz contrar programul va afișa pe o linie noua mesajul "Datele introduse nu corespund cerintelor."

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează, în ordine alfabetică, toţi peştii care au cel puțin greutatea G, dată în grame, după ce au trecut z zile.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
'''0<n<27'''; '''G – număr natural;''' '''0<z<365'''

Pentru fiecare peşte: greutatea iniţială în grame şi numărul de grame cu care se îngraşă '''nu depăşesc valoarea 10.'''
Andrei codifică peştii în ordine, cu litere mari consecutive.

La scrierea programul Andrei respectă ordinea alfabetică.

== Exemplul 1 ==
; Datele de intrare:
: 2 500 25
: A 5 2
: B 4 3
; Datele de ieșire:
: Datele sunt introduse corect.
: 0
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1529
def validare_input(n, greutate_peste, nr_zile, fish_list):
"""
Verifică dacă datele de intrare sunt valide.
"""
if not (0 < n < 27 and 0 < greutate_peste < 100000 and 0 < nr_zile < 365):
return False
for fish in fish_list:
if fish[1] > 10 or fish[2] > 10:
return False
return True

def compute_weight(fish, nr_zile):
"""
Calculează greutatea unui peste în funcție de coeficientul z.
"""
return fish[1] + fish[2] * nr_zile

def solve(n, greutate_peste, nr_zile, fish_list):
"""
Rezolvă problema și returnează o listă de tuple de forma (greutate, denumire) pentru fiecare peste care
are greutatea suficientă, sau o listă goală dacă niciun peste nu are greutatea necesară.
"""
valid = validare_input(n, greutate_peste, nr_zile, fish_list)
if not valid:
return None
results = []
for fish in fish_list:
weight = compute_weight(fish, nr_zile)
if weight >= greutate_peste:
results.append((weight, fish[0]))
return results

def print_results(results):
"""
Afiseaza greutatea si denumirea pestilor cu greutatea suficienta,
sau mesajul "0" daca niciun peste nu are greutatea necesara.
"""
if results:
for weight, name in sorted(results):
print(weight, name)
else:
print("0")

def main():
n, greutate_peste, nr_zile = map(int, input().split())
fish_list = []
for i in range(n):
letter, weight, gain = input().split()
fish_list.append([letter, int(weight), int(gain)])
results = solve(n, greutate_peste, nr_zile, fish_list)
if results is None:
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print_results(results)

if __name__ == '__main__':
main()

</syntaxhighlight>

'''Explcatie cod:'''

Acest cod rezolvă o problemă referitoare la calcularea greutății unor pești în funcție de coeficientul lor z, numărul de zile, și verifică dacă greutatea obținută este suficient de mare. În detaliu, codul include următoarele funcții:

- `validare_input(n, greutate_peste, nr_zile, fish_list)`: verifică dacă datele de intrare sunt valide și returnează True dacă sunt valide, False în caz contrar.
- `compute_weight(fish, nr_zile)`: calculează greutatea unui peste în funcție de coeficientul z și numărul de zile.

- `solve(n, greutate_peste, nr_zile, fish_list)`: rezolvă problema și returnează o listă de tuple de forma (greutate, denumire) pentru fiecare peste care are greutatea suficientă, sau o listă goală dacă niciun peste nu are greutatea necesară.

- `print_results(results)`: afișează greutatea și denumirea pestilor cu greutatea suficienta sau mesajul "0" daca niciun peste nu are greutatea necesara.

- `main()`: primește datele de intrare, apelează funcția `solve()` pentru a rezolva problema și afișează rezultatele apelând funcția `print_results()`.

În general, codul începe prin a verifica datele de intrare utilizând funcția `validare_input()`. Dacă datele sunt valide, funcția `solve()` calculează greutatea fiecărui pește și adaugă într-o listă tuple de forma (greutate, denumire) pentru fiecare peste care are greutatea suficientă.

Apoi, funcția `print_results()` afișează greutatea și denumirea pestilor cu greutatea suficienta, sau mesajul "0" dacă niciun peste nu are greutatea necesara.

1529 - Pesti

2023-04-29T08:53:43Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Andrei îşi doreşte un acvariu cu peşti. Găseşte în oraş un singur magazin ZOO unde se vând doar peştişori ciudaţi. Fiecare peştişor se îngraşă în fiecare zi cu câte un număr de grame. Cu fiecare săptămâna ce trece, peştişorii vor lua în greutate acelaşi număr de grame ca şi săptămâna precedentă, la care se adaugă greutatea pe care o luau în prima săptămână. Nu toţi peştişorii sunt de acelaşi tip, deci nu au neapărat aceeaşi greutate şi nici nu se îngraşă neapărat cu acelaşi număr de grame.

Andrei se hotărăşte totuşi să cumpere n peştişori, pe care-i numeşte A,B,C,D,… în ordinea în care îi pune în acvariu. Vrând să ştie în permanenţă ce greutate are fiecare, îşi notează câţi peşti a pus în acvariu, litera atribuită fiecărui peşte, câte grame are fiecare peşte când a fost pus în acvariu şi cu câte grame se îngraşă în ziua în care este pus în acvariu.

Scrieţi un program care afişează, în ordine alfabetică, toţi peştii care au cel puțin greutatea '''greutate_peste''', dată în grame, după ce au trecut '''nr_zile''' zile. Pentru fiecare peşte se va afişa greutatea în grame şi litera ce i-a fost atribuită.

== Date de intrare ==
Programul conţine pe prima linie, separate prin spațiu, valorile '''n, greutate_peste şi nr_zile'''.

Urmează '''n''' linii, pe fiecare linie fiind scrise separate prin spaţiu: o literă mare, greutatea peştelui în grame şi numărul de grame cu care se îngraşă în ziua în care este pus în acvariu.

== Date de ieșire ==
Programul va afișa pe ecran, mesajul "Datele introduse corespund cerințelor" și pe o linie nouă numărul '''P''' , reprezentând produsul primelor '''n''' pătrate perfecte nenule, în caz contrar programul va afișa pe o linie noua mesajul "Datele introduse nu corespund cerintelor."

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează, în ordine alfabetică, toţi peştii care au cel puțin greutatea G, dată în grame, după ce au trecut z zile.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
'''0<n<27'''; '''G – număr natural;''' '''0<z<365'''

Pentru fiecare peşte: greutatea iniţială în grame şi numărul de grame cu care se îngraşă '''nu depăşesc valoarea 10.'''
Andrei codifică peştii în ordine, cu litere mari consecutive.

La scrierea programul Andrei respectă ordinea alfabetică.

== Exemplul 1 ==
; Datele de intrare:
: 2 500 25
: A 5 2
: B 4 3
; Datele de ieșire:
: Datele sunt introduse corect.
: 0
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1529
def validare_input(n, greutate_peste, nr_zile, fish_list):
"""
Verifică dacă datele de intrare sunt valide.
"""
if not (0 < n < 27 and 0 < greutate_peste < 100000 and 0 < nr_zile < 365):
return False
for fish in fish_list:
if fish[1] > 10 or fish[2] > 10:
return False
return True

def compute_weight(fish, nr_zile):
"""
Calculează greutatea unui peste în funcție de coeficientul z.
"""
return fish[1] + fish[2] * nr_zile

def solve(n, greutate_peste, nr_zile, fish_list):
"""
Rezolvă problema și returnează o listă de tuple de forma (greutate, denumire) pentru fiecare peste care
are greutatea suficientă, sau o listă goală dacă niciun peste nu are greutatea necesară.
"""
valid = validare_input(n, greutate_peste, nr_zile, fish_list)
if not valid:
return None
results = []
for fish in fish_list:
weight = compute_weight(fish, nr_zile)
if weight >= greutate_peste:
results.append((weight, fish[0]))
return results

def print_results(results):
"""
Afiseaza greutatea si denumirea pestilor cu greutatea suficienta,
sau mesajul "0" daca niciun peste nu are greutatea necesara.
"""
if results:
for weight, name in sorted(results):
print(weight, name)
else:
print("0")

def main():
n, greutate_peste, nr_zile = map(int, input().split())
fish_list = []
for i in range(n):
letter, weight, gain = input().split()
fish_list.append([letter, int(weight), int(gain)])
results = solve(n, greutate_peste, nr_zile, fish_list)
if results is None:
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print_results(results)

if __name__ == '__main__':
main()

</syntaxhighlight>

'''Explcatie cod:'''

Acest cod rezolvă o problemă referitoare la calcularea greutății unor pești în funcție de coeficientul lor z, numărul de zile, și verifică dacă greutatea obținută este suficient de mare. În detaliu, codul include următoarele funcții:

- `validare_input(n, greutate_peste, nr_zile, fish_list)`: verifică dacă datele de intrare sunt valide și returnează True dacă sunt valide, False în caz contrar.
- `compute_weight(fish, nr_zile)`: calculează greutatea unui peste în funcție de coeficientul z și numărul de zile.
- `solve(n, greutate_peste, nr_zile, fish_list)`: rezolvă problema și returnează o listă de tuple de forma (greutate, denumire) pentru fiecare peste care are greutatea suficientă, sau o listă goală dacă niciun peste nu are greutatea necesară.
- `print_results(results)`: afișează greutatea și denumirea pestilor cu greutatea suficienta sau mesajul "0" daca niciun peste nu are greutatea necesara.
- `main()`: primește datele de intrare, apelează funcția `solve()` pentru a rezolva problema și afișează rezultatele apelând funcția `print_results()`.

În general, codul începe prin a verifica datele de intrare utilizând funcția `validare_input()`. Dacă datele sunt valide, funcția `solve()` calculează greutatea fiecărui pește și adaugă într-o listă tuple de forma (greutate, denumire) pentru fiecare peste care are greutatea suficientă. Apoi, funcția `print_results()` afișează greutatea și denumirea pestilor cu greutatea suficienta, sau mesajul "0" dacă niciun peste nu are greutatea necesara.

1529 - Pesti

2023-04-29T08:52:02Z

Sinn Erich: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Andrei îşi doreşte un acvariu cu peşti. Găseşte în oraş un singur magazin ZOO unde se vând doar peştişori ciudaţi. Fiecare peştişor se îngraşă în fiecare zi cu câte un număr de grame. Cu fiecare săptămâna ce trece, peştişorii vor lua în greutate acelaşi număr de grame ca şi săptămâna precedentă, la care se adaugă greutatea pe care o luau în prima săptămână. Nu toţi peştişorii sunt de acelaşi tip, deci nu au neapărat aceeaşi greutate şi nici nu se îngraşă neapărat cu acelaşi număr de grame.

Andrei se hotărăşte totuşi să cumpere n peştişori, pe care-i numeşte A,B,C,D,… în ordinea în care îi pune în acvariu. Vrând să ştie în permanenţă ce greutate are fiecare, îşi notează câţi peşti a pus în acvariu, litera atribuită fiecărui peşte, câte grame are fiecare peşte când a fost pus în acvariu şi cu câte grame se îngraşă în ziua în care este pus în acvariu.

Scrieţi un program care afişează, în ordine alfabetică, toţi peştii care au cel puțin greutatea '''greutate_peste''', dată în grame, după ce au trecut '''nr_zile''' zile. Pentru fiecare peşte se va afişa greutatea în grame şi litera ce i-a fost atribuită.

== Date de intrare ==
Programul conţine pe prima linie, separate prin spațiu, valorile '''n, greutate_peste şi nr_zile'''.

Urmează '''n''' linii, pe fiecare linie fiind scrise separate prin spaţiu: o literă mare, greutatea peştelui în grame şi numărul de grame cu care se îngraşă în ziua în care este pus în acvariu.

== Date de ieșire ==
Programul va afișa pe ecran, mesajul "Datele introduse corespund cerințelor" și pe o linie nouă numărul '''P''' , reprezentând produsul primelor '''n''' pătrate perfecte nenule, în caz contrar programul va afișa pe o linie noua mesajul "Datele introduse nu corespund cerintelor."

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează, în ordine alfabetică, toţi peştii care au cel puțin greutatea G, dată în grame, după ce au trecut z zile.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
'''0<n<27'''; '''G – număr natural;''' '''0<z<365'''

Pentru fiecare peşte: greutatea iniţială în grame şi numărul de grame cu care se îngraşă '''nu depăşesc valoarea 10.'''
Andrei codifică peştii în ordine, cu litere mari consecutive.

La scrierea programul Andrei respectă ordinea alfabetică.

== Exemplul 1 ==
; Datele de intrare:
: 2 500 25
: A 5 2
: B 4 3
; Datele de ieșire:
: Datele sunt introduse corect.
: 0
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1529
def validare_input(n, greutate_peste, nr_zile, fish_list):
"""
Verifică dacă datele de intrare sunt valide.
"""
if not (0 < n < 27 and 0 < greutate_peste < 100000 and 0 < nr_zile < 365):
return False
for fish in fish_list:
if fish[1] > 10 or fish[2] > 10:
return False
return True

def compute_weight(fish, nr_zile):
"""
Calculează greutatea unui peste în funcție de coeficientul z.
"""
return fish[1] + fish[2] * nr_zile

def solve(n, greutate_peste, nr_zile, fish_list):
"""
Rezolvă problema și returnează o listă de tuple de forma (greutate, denumire) pentru fiecare peste care
are greutatea suficientă, sau o listă goală dacă niciun peste nu are greutatea necesară.
"""
valid = validare_input(n, greutate_peste, nr_zile, fish_list)
if not valid:
return None
results = []
for fish in fish_list:
weight = compute_weight(fish, nr_zile)
if weight >= greutate_peste:
results.append((weight, fish[0]))
return results

def print_results(results):
"""
Afiseaza greutatea si denumirea pestilor cu greutatea suficienta,
sau mesajul "0" daca niciun peste nu are greutatea necesara.
"""
if results:
for weight, name in sorted(results):
print(weight, name)
else:
print("0")

def main():
n, greutate_peste, nr_zile = map(int, input().split())
fish_list = []
for i in range(n):
letter, weight, gain = input().split()
fish_list.append([letter, int(weight), int(gain)])
results = solve(n, greutate_peste, nr_zile, fish_list)
if results is None:
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print_results(results)

if __name__ == '__main__':
main()

</syntaxhighlight>

'''Explcatie cod:'''

Funcția read_input() citește valorile n, G, z și lista de n pești, formată din tripletele litera, greutate și crestere. Aceste valori sunt returnate ca tuplu.

Funcția compute_weight(fish, z) primește un peste sub formă de tripletă și coeficientul z, și calculează greutatea acestuia adăugând la greutatea inițială produsul dintre coeficientul z și rata de creștere a peștelui. Funcția returnează greutatea calculată.

Funcția print_results(fish_list, G) primește lista de pești și greutatea minimă G și afișează greutatea și denumirea tuturor peștilor care au greutatea minimă sau mai mare. Peștii sunt sortați în ordine alfabetică înainte de a fi procesați. Dacă niciun peste nu îndeplinește condiția, funcția afișează mesajul "0".

În funcția principală se apelează funcția read_input() pentru a obține datele de intrare și se stochează fiecare valoare într-o variabilă separată. Apoi, se apelează funcția print_results(fish_list, G) cu lista de pești și greutatea minimă G.

1528 - Operatii Matematice

2023-04-29T08:51:19Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Maria, Cristi şi Alex au găsit o modalitate de a-şi îmbunătăţi viteza de efectuare a operaţiilor matematice printr-un joc care să corespundă nivelului de vârsta al fiecăruia. Maria ştie doar operaţiile de adunare şi scădere, Cristi a învăţat înmulţirile iar Alex fiind în clasa a 5-a studiază divizibilitatea numerelor.

Jocul se desfăşoară în felul următor: Maria alege o cifra – cifra de start (întotdeauna este nenulă). Cristi o înmulţeşte cu 3. La numărul obţinut de Cristi, Maria adaugă o nouă cifră şi îi spune lui Cristi suma obţinută. Cristi caută cel mai mare multiplu a lui 7 mai mic decât numărul obţinut de Maria şi îl spune Mariei. Aceasta scade din numărul ei multiplul spus de Cristi şi obţine un număr nou. Din acest moment jocul se reia, Cristi înmulţeşte cu 3, Maria alege o cifră şi o adaugă la numărul obţinut de Cristi s.a.m.d…

Între timp Alex este atent la cifrele pe care Maria le-a introdus în joc şi caută să vadă dacă numărul format din aceste cifre este divizibil cu '''7'''.

1) Aflaţi care este numărul obţinut de Maria după adăugarea ultimei cifre.

2) Ajutaţi-l pe Alex să verifice dacă numărul format din cifrele alese de Maria este divizibil cu '''7'''.

== Date de intrare ==
Programul va contine pe prima linie numărul de cifre alese de Maria iar pe următoarea linie separate prin spaţiu cifrele în ordinea alegerii acestora.

== Date de ieșire ==
Programul va conține pe prima linie numărul obţinut la cerința 1 şi pe a doua linie răspunsul '''DA''' în cazul în care răspunsul lui Alex '''trebuie să fie afirmativ''', '''respectiv NU în caz contrar'''.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
Numărul de cifre alese de Maria este maxim 100.

Pentru rezolvarea corectă a primei cerinţe se obţine 50% din punctajul unui test.

== Exemplul 1 ==
; Datele de intrare:
: Introduceti numarul de cifre:
: 4
: Introduceti cifrele:
:2 3 4 5
; Datele de ieșire:
: Datele sunt introduse corect.
: Numarul obtinut de Maria este: 14
: DA, este divizibil cu 7.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1528
def play_game(cifre):
"""
Returneaza numarul obtinut de Maria dupa joc.
"""
cristi_nr = cifre[0] * 3
maria_suma = cifre[0]
for cifra in cifre[1:]:
cristi_nr = cristi_nr * 3
maria_suma = maria_suma + cifra
maxim_7 = (maria_suma // 7) * 7
maria_nr_nou = maria_suma - maxim_7
cristi_nr = cristi_nr + maria_nr_nou
return maria_suma

def print_result(maria_suma):
"""
Afiseaza numarul obtinut de Maria si daca acesta este divizibil cu 7.
"""
print("Datele sunt corecte.")
print("Numarul obtinut de Maria este:", maria_suma)
if maria_suma % 7 == 0:
print("DA, este divizibil cu 7.")
else:
print("NU, nu este divizibil cu 7.")

if __name__ == '__main__':
n = int(input("Introduceti numarul de cifre: "))
cifre = list(map(int, input("Introduceti cifrele: ").split()))

if n <= 0 or n > 100:
print("Datele nu corespund restricțiilor impuse.")
elif len(cifre) != n:
print("Datele nu corespund restricțiilor impuse.")
else:
maria_suma = play_game(cifre)
print_result(maria_suma)

</syntaxhighlight>
'''Explicatie cod:'''

Funcția play_game primește ca argument o listă de cifre și returnează numărul obținut de Maria după jocul descris în enunțul problemei.

În prima linie, se inițializează variabila cristi_nr cu valoarea primei cifre din listă, înmulțită cu 3. Aceasta reprezintă numărul obținut de Cristi la prima etapă a jocului. Variabila maria_suma este inițializată cu aceeași valoare, reprezentând suma cifrelor alese de Maria la primele două etape ale jocului.

Apoi, pentru fiecare cifră din lista de cifre, se efectuează următoarele operații:

se înmulțește numărul lui Cristi cu 3
se adună cifra curentă la suma cifrelor alese de Maria
se determină cel mai mare multiplu de 7 care este mai mic sau egal cu suma cifrelor alese de Maria
se calculează o nouă valoare pentru suma cifrelor alese de Maria, scăzând din suma curentă cel mai mare multiplu de 7 găsit la pasul anterior
se adaugă noua valoare calculată pentru suma cifrelor alese de Maria la numărul lui Cristi
La final, funcția returnează valoarea finală a sumei cifrelor alese de Maria.

Funcția print_result primește ca argument valoarea returnată de funcția play_game și afișează numărul obținut de Maria, precum și faptul că acesta este sau nu divizibil cu 7.

În blocul if __name__ == '__main__':, se citește numărul de cifre și lista de cifre de la tastatură. Dacă numărul de cifre nu respectă restricțiile impuse în enunțul problemei, se afișează un mesaj corespunzător. Dacă lungimea listei de cifre nu corespunde cu numărul de cifre specificat, se afișează de asemenea un mesaj corespunzător. În caz contrar, se apelează funcția play_game cu lista de cifre și se afișează rezultatul apelului funcției print_result.

1060 - Porumb

2023-04-29T08:46:55Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Locuitorii planetei Agria, numiţi agri, au hotărât ca în celebrul an 2012 să le explice pământenilor cum trebuie cules „eficient” un rând cu '''n''' porumbi, numerotaţi, în ordine, cu '''1, 2, 3,..., n'''.

Cei '''n''' porumbi sunt culeşi de mai mulţi agri. Primul agri merge de-a lungul rândului, plecând de la primul porumb şi culege primul porumb întâlnit, al treilea, al cincilea şi aşa mai departe până la capătul rândului.

Atunci când ajunge la capătul rândului, porneşte al doilea agri şi culege porumbi respectând aceeaşi regulă ca şi primul agri.

Metoda se repetă până când toţi porumbii sunt culeşi.

Pământeanul Ionel încearcă să descopere ce ascunde această metodă şi se gândeşte câţi porumbi culege primul agri, câţi agri culeg un rând cu '''n''' porumbi, la a câta trecere este cules porumbul cu numărul '''x''' şi care este numărul ultimului porumb cules.

Exemplu: Dacă pe un rând sunt n=14 porumbi atunci sunt 4 agri care culeg porumbii:
primul agri culege porumbii 1,3,5,7,9,11,13;
al doilea agri culege porumbii 2,6,10,14;
al treilea agri culege porumbii 4 şi 12;
ultimul agri culege porumbul 8.

Pentru a-l ajuta pe Ionel să descopere secretul acestei metode, scrieţi un program care citeşte cele două numere naturale '''n''' şi '''x''' şi care determină:

a) numărul de porumbi culeşi de primul agri;
b) numărul de agri care culeg şirul de n porumbi;
c) numărul trecerii la care este cules porumbul cu numărul x;
d) numărul ultimului porumb cules.

== Date de intrare ==
Programul conține pe prima linie, separate printr-un spaţiu, cele două numere naturale '''n''' şi '''x''' cu semnificația din enunţ.

== Date de ieșire ==
Programul va conține patru linii:

pe prima linie se va scrie un număr natural reprezentând numărul de porumbi culeşi de primul agri;

pe a doua linie se va scrie un număr natural reprezentând numărul de agri care culeg cei n porumbi;

pe a treia linie se va scrie un număr natural, reprezentând numărul trecerii la care este cules porumbul x;

pe a patra linie se va scrie un număr natural, reprezentând numărul ultimului porumb cules.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse".

== Restricţii şi precizări ==

1 ≤ '''x''' ≤ '''n''' ≤ 1.000.000.000

Trecerile se numerotează în ordine, începând cu valoarea '''1'''.

Pentru rezolvarea corectă a cerinţei a) se acordă '''10%''' din punctaj.

Pentru rezolvarea corectă a cerinţelor a) şi b) se acordă '''40%''' din punctaj.

Pentru rezolvarea corectă a cerinţelor a), b) şi c) se acordă '''70%''' din punctaj.

Pentru rezolvarea corectă a celor patru cerinţe se acordă '''100%''' din punctaj.

== Exemplul 1 ==
; Datele de intrare:
: Introduceti numarul de porumbi:
:14
: Introduceti numarul porumbului cautat:
: 4
; Datele de ieșire:
: Datele sunt introduse corect.
: Numarul de porumbi culesi de primul agri:
: 7
: Numarul de agri care culeg sirul de n porumbi:
: 7
: Porumbul cu numarul 4 este cules la trecerea
: 1
: Numarul ultimului porumb cules: 2
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1060
def porumbi_primul_agricultor(n):
return (n + 1) // 2

def numar_agricultori(n):
return (n + 1) // 2

def trecere_porumb_cautat(n, x):
agri = numar_agricultori(n)
pozitie_x = (x - 1) % n + 1
trecere_x = (pozitie_x - 1) // agri + 1
return trecere_x

def validate_input(n, x):
if not isinstance(n, int) or not isinstance(x, int):
print("Datele nu corespund restricțiilor impuse.")
return False
elif n < x:
print("Datele nu corespund restricțiilor impuse.")
return False
elif n < 1 or n > 1000000000 or x < 1 or x > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
return False
else:
print("Datele sunt introduse corect.")
return True

if __name__ == '__main__':
n = int(input("Introduceti numarul de porumbi: "))
x = int(input("Introduceti numarul porumbului cautat: "))

if validate_input(n, x):
primul_agri = porumbi_primul_agricultor(n)
agri = numar_agricultori(n)
ultimul_porumb = n - (n // agri) * (agri - 1)
trecere_x = trecere_porumb_cautat(n, x)

print("Numarul de porumbi culesi de primul agri: ", primul_agri)
print("Numarul de agri care culeg sirul de n porumbi: ", agri)
print("Porumbul cu numarul ", x, "este cules la trecerea ", trecere_x)
print("Numarul ultimului porumb cules: ", ultimul_porumb)

</syntaxhighlight>

'''Explicația codului:'''

Acesta este un program care calculează informații despre culegerea porumbului de către agricultori, date fiind numărul total de porumbi și poziția porumbului căutat.

Funcția `porumbi_primul_agricultor(n)` returnează numărul de porumbi culeși de primul agricultor, calculat prin împărțirea numărului total de porumbi la doi și apoi rotunjit în sus cu ajutorul operatorului de divizare întreagă `//`.

Funcția `numar_agricultori(n)` returnează numărul de agricultori care culeg porumbul, calculat în același mod ca mai sus.

Funcția `trecere_porumb_cautat(n, x)` calculează numărul de treceri ale șirului de agricultori necesare pentru a ajunge la poziția porumbului căutat. Variabila `agri` este numărul de agricultori calculat anterior, iar variabila `pozitie_x` reprezintă poziția porumbului căutat pe șirul circular de porumbi. Variabila `trecere_x` reprezintă numărul de treceri necesare pentru ca porumbul cu numărul `x` să fie cules de unul dintre agricultori.

Funcția `validate_input(n, x)` verifică dacă numerele introduse de utilizator sunt întregi și îndeplinesc alte restricții impuse. În caz contrar, afișează un mesaj de eroare și returnează `False`. Dacă numerele sunt valide, afișează un mesaj de confirmare și returnează `True`.

În funcția principală `main`, utilizatorul este întâi invitat să introducă numărul total de porumbi și poziția porumbului căutat. Apoi se verifică dacă acestea sunt valori valide cu ajutorul funcției `validate_input`. Dacă valorile sunt valide, se calculează informațiile cerute și se afișează.

1073 - Numerus

2023-04-29T08:45:44Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
La ora de matematică distractivă, domnul profesor Numerus propune elevilor săi să completeze cu numere naturale o grilă cu 6 coloane numerotate cu literele A, B, C, D, E şi F şi cu un număr infinit de linii. Grila va fi completată cu numere naturale, începând cu numărul 1. Pe liniile impare completarea se va face de la stânga la dreapta, iar pe cele pare de la dreapta la stânga. Ultimul număr de pe o linie va fi identic cu penultimul număr (în sensul completării) de pe aceeaşi linie.
Deoarece pe tablă sau pe o foaie de hârtie numărul de linii este limitat, deci grila poate fi efectiv completată doar pentru un număr mic de linii, domnul profesor Numerus doreşte ca elevii săi să determine, cu ajutorul calculatorului, imaginea unei anumite linii a grilei şi locul sau locurile pe care se poate afla un număr natural dat.

Deduceţi regula după care se completează linia '''k''' a grilei şi scrieţi un program care să citească numerele naturale '''k''' şi '''n''' şi care să determine:

a) numerele naturale de pe linia '''k''', vizualizate de la stânga la dreapta;
b) linia pe care se află în grilă numărul natural '''n''';
c) coloana sau coloanele pe care se află în grilă numărul natural '''n'''.

== Date de intrare ==
Programul conține o singură linie pe care sunt scrise două numere naturale '''k''' şi '''n''', separate printr-un spaţiu.

== Date de ieșire ==
Programul va conține 3 linii:
a) pe prima linie, se vor scrie numerele de pe linia '''k''' a grilei;
b) pe a doua linie, se va scrie un număr natural reprezentând linia pe care se află în grilă numărul natural '''n''';
c) pe a treia linie, se va scrie litera sau literele care reprezintă coloana, respectiv coloanele pe care se află în grilă numărul natural '''n'''; în situaţia în care avem de afişat două litere acestea se vor afişa cu un spaţiu între ele.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.

== Restricţii şi precizări ==
Numerele '''k''' şi '''n'''sunt naturale nenule

5 ≤ '''k''' < 200000000

1 ≤ '''n''' ≤ 999999999

== Exemplul 1 ==
; Datele de intrare:
: Introduceti numerele naturale:
: 10 40
; Datele de ieșire:
: Datele sunt introduse corect.
: 50 50 49 48 47 46
:8
:A B
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1073
def completare_linie(k):
if k % 2 == 1: # linie impară
start = (k - 1) * 5 + 1
return list(range(start, start + 5)) + [start + 4]
else: # linie pară
start = k * 5
return [start] + list(range(start - 1, start - 6, -1))

def determina_linia_si_coloanele(n):
for k in range(1, n + 1):
linie = completare_linie(k)
if n in linie:
linia = k
coloane = [chr(ord('A') + linie.index(n))]
if linie[-1] == linie[-2]: # numărul de pe linie este duplicat
coloane.append(chr(ord('A') + linie.index(n, 0, -1)))
return linia, ' '.join(coloane)

def validate_input(k, n):
if not isinstance(k, int) or not isinstance(n, int):
print("Datele nu corespund restricțiilor impuse.")
return False
elif k <= 0 or n <= 0:
print("Datele nu corespund restricțiilor impuse.")
return False
else:
print("Datele sunt introduse corect")
return True

if __name__ == '__main__':
k, n = map(int, input("Introduceti numerele naturale:").split())

if not validate_input(k, n):
quit()

# a) completarea liniei k
linie_k = completare_linie(k)
print(*linie_k)

# b) determinarea liniei și coloanei/coloanelor pe care se află n
linia_n, coloane_n = determina_linia_si_coloanele(n)
print(linia_n)
print(coloane_n)

</syntaxhighlight>
'''Explicatie cod:'''

Acest cod are urmatoarele functii:

1. `completare_linie(k)`: Aceasta functie primeste un numar natural `k` ca argument si returneaza o lista cu primele cinci numere naturale aflate pe linia `k` si numarul de pe coloana a cincea a acelei linii, daca `k` este impar, sau o lista cu numarul de pe prima coloana a liniei `k` si celelalte patru numere naturale de pe acea linie, daca `k` este par.

2. `determina_linia_si_coloanele(n)`: Aceasta functie primeste un numar natural `n` ca argument si determina linia si coloana/coloanele pe care se afla acel numar in matricea formata prin unirea liniilor calculate de functia `completare_linie()`. Daca numarul de pe linia respectiva are o singura aparitie, functia returneaza numarul liniei si litera corespunzatoare coloanei respective. Daca numarul de pe linie este duplicat, functia returneaza numarul liniei si literele corespunzatoare ambelor aparitii ale numarului respectiv.

3. `validate_input(k, n)`: Aceasta functie primeste doua numere naturale `k` si `n` ca argument si verifica daca acestea sunt indeplinesc restrictiile impuse: trebuie sa fie numere naturale pozitive. Daca acestea nu sunt valide, functia afiseaza un mesaj de eroare si returneaza `False`, altfel afiseaza un mesaj de confirmare si returneaza `True`.

La final, se citesc doua numere naturale `k` si `n` de la tastatura, se valideaza input-ul, apoi se apeleaza cele trei functii definite mai sus in urmatoarea ordine:

1. Se afiseaza completarea liniei `k`.
2. Se determina linia si coloana/coloanele pe care se afla `n` si se afiseaza aceste valori.

1723 - Culegere 1

2023-04-29T08:44:31Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==

O culegere de probleme are '''P''' pagini, numerotate de la '''1 la P'''. Problemele din culegere sunt numerotate cu 1,2,3,...,etc, în ordinea apariţiei lor în culegere. Pe prima pagină a culegerii este scrisă o singură problemă (cea cu numărul 1). Pe a doua pagină sunt scrise exact două probleme (cele cu numerele 2 şi 3, în această ordine). Pe cea de-a treia pagină sunt scrise exact trei probleme (cele cu numerele 4, 5 şi 6, în această ordine),…, pe cea de a P-a pagină sunt scrise exact '''P''' probleme.

Scrieţi un program care citeşte numerele naturale '''P şi N''' şi determină valorile:
a) '''T''', numărul total de cifre care au fost utilizate în numerotarea tuturor problemelor din culegere;
b) '''M''', numărul minim de pagini pe care ar trebui să le aibă culegerea, astfel încât aceasta să conţină şi problema numerotată cu '''N'''.

== Date de intrare ==
Programul conţine pe prima linie cele două numere naturale '''P şi N''', separate printr-un spaţiu, cu semnificaţia din enunţ.

== Date de ieșire ==
Programul conţine:
pe prima linie numărul natural '''T''', cu semnificaţia din enunţ;
pe a doua linie numărul natural '''M''', cu semnificaţia din enunţ.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

Î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 ≤ '''P''' ≤ 16000
1 ≤ '''N''' ≤ 2112600000

== Exemplul 1 ==
; Datele de intrare
: 5 9
; Datele de ieșire
: Datele sunt introduse corect.
: 21
: 4
 

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

def validate_input(p, n):
if not 1 <= p <= 16000 or not 1 <= n <= 2112600000:
return False
return True

def solve(p, n):
# calculate the total number of problems in the first P pages
total_problems = sum(range(1, p+1))

# calculate the number of pages needed to include problem N
n_page = ((3 + 8 * (n - 1)) ** 0.5 - 1) // 2 + 1

# calculate the total number of digits used to number all the problems in the collection
total_digits = sum(len(str(i)) for i in range(1, total_problems + 1))

# print the values of T and M
print(total_digits)
print(int(n_page))

if __name__ == '__main__':
# read input values
p, n = map(int, input().split())

# validate input values
if not validate_input(p, n):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
solve(p, n)

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod implementează un algoritm care calculează numărul total de cifre folosite pentru a numerota toate problemele dintr-o carte de probleme și numărul de pagini necesare pentru a include o problemă dată, în funcție de numărul de probleme pe pagină și numărul problemei. Inputul constă din două numere întregi p și n, unde p reprezintă numărul de probleme pe pagină și n este numărul problemei căutate.

Funcția `validate_input` verifică dacă valorile p și n îndeplinesc restricțiile impuse. Dacă acestea nu sunt îndeplinite, se va returna `False`. Dacă valorile sunt corecte, se va returna `True`.

Funcția `solve` primește valorile validate și calculează numărul total de probleme în primele p pagini, numărul de pagini necesare pentru a include problema n și numărul total de cifre folosite pentru a numerota toate problemele din carte. Apoi, afișează numărul total de cifre și numărul de pagini necesare.

În secțiunea `__name__ == '__main__'`, se vor citi valorile de la intrare, apoi se vor valida și, dacă valorile sunt corecte, se va apela `solve` pentru a rezolva problema și a afișa rezultatele. Dacă valorile nu sunt corecte, se va afișa mesajul "Datele nu corespund restricțiilor impuse."

2427 - Sir 10

2023-04-29T08:43:02Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Gigel se distrează construind şiruri crescătoare de numere din mulţimea '''{1,2,…,n}'''. La un moment dat observă că unele şiruri, de cel puţin k '''nr_termeni''' '''(k ≥ 3)''', au o proprietate mai aparte: diferența dintre doi termeni consecutivi este constantă. Iată câteva exemple de astfel de şiruri pentru '''n ≥ 22''':

2, 3, 4

1, 5, 9, 13

7, 10, 13, 16, 19, 22

Dându-se numărul natural '''n''' ajutați-l pe Gigel să numere câte astfel de șiruri poate să construiască.

== Date de intrare ==
Programul conține pe prima linie numărul '''n'''.

== Date de ieșire ==
Programul va conține pe prima linie numărul cerut.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează câte astfel de șiruri poate să construiască poate să construiască Gigel.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
3 ≤ '''n''' ≤ 20000

3 ≤ '''nr_termeni''' ≤ n

== Exemplul 1 ==
; Datele de intrare
: N este:
: 3
; Datele de ieșire
: Datele sunt introduse corect.
: 1
 

== Exemplul 2 ==
; Datele de intrare
: N este:
: 4
; Datele de ieșire
: Datele sunt introduse corect.
: 3
 

== Exemplul 3 ==
; Datele de intrare
: N este:
: 5
; Datele de ieșire
: Datele sunt introduse corect.
: 7
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2427
def has_valid_input(n, nr_termeni):
if not (3 <= n <= 20000):
print("Datele nu corespund restricțiilor impuse.")
return False
if not (3 <= nr_termeni <= n):
print("Datele nu corespund restricțiilor impuse.")
return False
return True

def has_property(sir):
d = sir[1] - sir[0]
for i in range(2, len(sir)):
if sir[i] - sir[i - 1] != d:
return False
return True

def backtracking(sir, pozitie):
global nr_siruri
if len(sir) >= nr_termeni:
if has_property(sir):
nr_siruri += 1
for i in range(pozitie + 1, n + 1):
sir.append(i)
backtracking(sir, i)
sir.pop()

if __name__ == '__main__':
n = int(input("N este:"))
nr_termeni = 3
nr_siruri = 0

if not has_valid_input(n, nr_termeni):
exit()

backtracking([], 0)
print("Datele sunt introduse corect.")
print(nr_siruri)

</syntaxhighlight>

'''Explicatie cod:'''

Acest program calculează numărul de șiruri aritmetice de lungime fixă și dimensiune n, care încep cu un element oarecare și au cel puțin trei elemente și diferența constantă între oricare două elemente consecutive. Programul utilizează un algoritm de backtracking pentru a genera toate șirurile posibile, verificând dacă acestea au proprietatea cerută.

Funcția has_valid_input(n, nr_termeni) verifică dacă inputul dat este valid, adică dacă n și nr_termeni se încadrează într-un interval specificat. În caz contrar, se afișează un mesaj de eroare și se returnează False.

Funcția has_property(sir) verifică dacă un șir dat are proprietatea cerută (adică diferența dintre oricare două elemente consecutive este constantă). Dacă această proprietate este îndeplinită, funcția returnează True. Dacă nu, funcția returnează False.

Funcția backtracking(sir, pozitie) utilizează un algoritm de backtracking pentru a genera toate șirurile posibile care îndeplinesc cerințele. Aceasta primește ca argumente sir, care reprezintă șirul curent, și pozitie, care reprezintă poziția curentă în șirul n. Dacă șirul sir are cel puțin nr_termeni elemente și îndeplinește proprietatea cerută, se incrementează nr_siruri. Altfel, se explorează toate combinațiile posibile ale elementelor următoare în șirul n cu ajutorul unei bucle for. În continuare, se adaugă elementul curent în sir, se apelează recursiv funcția backtracking() pentru a explora toate posibilitățile ulterioare, se scoate ultimul element adăugat din sir și se continuă cu următoarea iterație a buclei.

În blocul if __name__ == '__main__': se citesc datele de intrare n și se inițializează variabilele nr_termeni și nr_siruri. Apoi, se verifică dacă datele introduse sunt valide, utilizând funcția has_valid_input(). Dacă inputul este valid, se apelează funcția backtracking() pentru a calcula numărul de șiruri cerute și se afișează rezultatul.

0359 - Gard

2023-04-29T08:39:36Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Parcul orașului este înconjurat cu un gard format din '''n''' stâlpi formați din blocuri de piatră suprapuse. La început, toți stâlpii aveau aceeași înălțime, dar în timp s-au deteriorat, pierzându-se de la unii stâlpi unele blocuri de piatră.

Primarul orașului dorește să renoveze gardul. Pentru aceasta, s-a determinat înălțimea curentă a fiecărui stâlp și se vor completa cu blocuri de piatră noi stâlpii deteriorați, astfel încât toți stâlpii să aibă aceeași înălțime.

Determinați numărul de blocuri de piatră necesare pentru renovarea gardului.

== Date de intrare ==
Programul citește de la tastatură numărul de stâlpi '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând înălțimea curentă a fiecărui stâlp.

== Date de ieșire ==
Programul afișează pe ecran numărul '''T''', reprezentând numărul de blocuri de piatră noi necesare pentru renovarea gardului.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează numărul de blocuri de piatră necesare pentru renovarea gardului.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 1000

fiecare stâlp va avea înălțimea între 0 și 100

== Exemplul 1 ==
; Date de intrare:
: Introdu numarul de stalpi:
: 5
: 7 5 6 8 2
; Date de ieșire:
:Datele sunt introduse corect.
: 12
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0359
def validate(n, heights):
if n < 1 or n > 1000:
raise ValueError("Datele nu corespund restricțiilor impuse.")
if len(heights) != n:
raise ValueError("Datele nu corespund restricțiilor impuse.")
for h in heights:
if h < 0 or h > 100:
raise ValueError("Datele nu corespund restricțiilor impuse.")
print("Datele sunt introduse corect.")

def calculate_needed_blocks(heights):
max_height = max(heights)
return sum(max_height - h for h in heights)

if __name__ == '__main__':
n = int(input("Introdu numărul de stâlpi: "))
heights = list(map(int, input("Introdu înălțimile stâlpilor, separate prin spații: ").split()))
try:
validate(n, heights)
except ValueError as e:
print(e)
exit()
needed_blocks = calculate_needed_blocks(heights)
print("Numărul de blocuri necesare este:", needed_blocks)

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod implementează o funcție de validare a datelor de intrare, care primește un număr întreg n și o listă de întregi heights. Dacă n nu se află în intervalul [1, 1000] sau lungimea listei heights nu este egală cu n, sau oricare dintre valorile din heights se află în afara intervalului [0, 100], funcția aruncă o excepție ValueError cu un mesaj corespunzător. Dacă datele de intrare sunt validate cu succes, funcția afișează un mesaj de confirmare.

Funcția calculate_needed_blocks primește lista heights și calculează numărul total de blocuri necesare pentru a egala înălțimea stâlpilor. Se determină înălțimea maximă a stâlpilor și se scade înălțimea fiecărui stâlp din această valoare maximă. Rezultatul reprezintă numărul de blocuri necesare.

În blocul if __name__ == '__main__':, se citesc datele de intrare utilizând funcția input(), apoi se încearcă validarea lor folosind funcția validate. Dacă datele sunt validate cu succes, se calculează numărul de blocuri necesare utilizând funcția calculate_needed_blocks, apoi se afișează rezultatul. Dacă se aruncă o excepție ValueError în timpul validării, se afișează mesajul de eroare corespunzător și se oprește programul.

0482 - Auto

2023-04-29T08:31:47Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Gigel se plimbă cu mașina. El parcurge '''n''' etape, despre fiecare etapă cunoscându-se durata și viteza constantă de deplasare. Să se determine distanța totală parcursă și viteza medie de deplasare.

== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' perechi de numere naturale '''t v''', reprezentând durata și viteza pentru fiecare etapă.

== Date de ieșire ==
Programul afișează pe ecran numerele '''D VM''', reprezentând distanța totală parcursă și viteza medie de deplasare.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează distanța totală parcursă și viteza medie de deplasare .

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 100

pentru fiecare etapă, durata și viteza sunt numere naturale mai mici sau egale cu 100

durata se exprimă în ore, distanța în kilometri, iar viteza în km/h

== Exemplul 1 ==
; Datele de intrare:
: Introdu numărul de măsurători de viteză:
: 3
: 2 65
: 3 70
: 1 55
; Datele de ieșire:
: Datele sunt introduse corect.
: 395 65.83
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0482
def read_number():
while True:
try:
n = int(input("Introdu numărul de măsurători de viteză: "))
if n < 1 or n > 100:
print("Datele nu corespund restricțiilor impuse.")
else:
return n
except ValueError:
print("Introduceti un număr valid.")

def validate_input(t, v):
if t < 1 or t > 100 or v < 1 or v > 100:
raise ValueError("Datele nu corespund restricțiilor impuse.")
else:
return True

def calc_total_distance_and_time(n):
distance = 0
time = 0
for i in range(n):
t, v = map(int, input().split())
if not validate_input(t, v):
exit()
distance += t * v
time += t
print("Datele sunt introduse corect.")
return distance, time

def calc_avg_speed(distance, time):
return distance / time

if __name__ == '__main__':
n = read_number()
distance, time = calc_total_distance_and_time(n)
avg_speed = calc_avg_speed(distance, time)
print(distance, avg_speed)

</syntaxhighlight>

'''Explicatie cod:'''
Acest cod are rolul de a calcula distanta totala parcursa si viteza medie a unui vehicul in functie de numarul de masuratori de viteza efectuate.

Functia `read_number()` citeste de la tastatura numarul de masuratori de viteza si il returneaza. In timp ce utilizatorul introduce un numar nevalid (mai mic de 1 sau mai mare de 100), functia va afisa un mesaj de eroare.

Functia `validate_input(t, v)` primeste ca argumente doua variabile `t` si `v` reprezentand timpul si viteza pentru o masuratoare. Aceasta verifica daca timpul si viteza sunt valide (mai mici de 1 sau mai mari de 100), iar daca nu sunt, arunca o exceptie. In caz contrar, functia returneaza `True`.

Functia `calc_total_distance_and_time(n)` primeste ca argument numarul de masuratori de viteza si calculeaza distanta totala parcursa si timpul total de parcurs. In timp ce se citesc valorile pentru fiecare masuratoare, functia verifica daca valorile citite sunt valide prin apelarea functiei `validate_input(t, v)`. Daca una dintre valorile nu este valida, functia se opreste prin apelarea functiei `exit()`. Dupa ce s-au citit toate masuratorile, functia afiseaza un mesaj de confirmare a introducerii datelor si returneaza distanta totala si timpul total.

Functia `calc_avg_speed(distance, time)` calculeaza viteza medie prin impartirea distantei totale la timpul total.

In blocul `if __name__ == '__main__':`, programul citeste numarul de masuratori de viteza prin apelarea functiei `read_number()`. Apoi, functia `calc_total_distance_and_time(n)` este apelata pentru a calcula distanta totala si timpul total, care sunt stocate in variabilele `distance` si `time`. In cele din urma, viteza medie este calculata prin apelarea functiei `calc_avg_speed(distance, time)` si afisata impreuna cu distanta totala.

1284 - Carte 1

2023-04-29T08:29:39Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Pentru a se numerota paginile unei cărți s-au folosit '''n''' cifre. Câte pagini are cartea?

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

Programul afișează pe ecran numărul '''p''', reprezentând numărul de pagini ale carții.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cate pagini are cartea.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 1.000.000

pentru fiecare test exista soluție.

numerotarea paginilor se face de la 1.

== Exemplul 1 ==
; Datele de intrare:
: Introduceti numarul de cifre folosite pentru numerotarea paginilor:
: 1791
; Datele de ieșire:
: Datele sunt introduse corect.
: Numarul de pagini al cartii este:
: 633
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1284
def validate_input(n):
if not isinstance(n, int):
print("Datele nu corespund restricțiilor impuse.")
return False
elif n < 1:
print("Datele nu corespund restricțiilor impuse.")
return False
else:
return True

def calculate_pages(n):
pagini = 0
cifre = 0

while cifre <= n:
pagini += 1
cifre += len(str(pagini))

return pagini-1

def display_pages(total_pages):
print("Numarul de pagini al cartii este:", total_pages)

if __name__ == '__main__':
while True:
try:
n = int(input("Introduceti numarul de cifre folosite pentru numerotarea paginilor: "))
if n < 1:
print("Datele nu corespund restricțiilor impuse.")
else:
if not validate_input(n):
exit()

total_pages = calculate_pages(n)
if total_pages < 1:
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
display_pages(total_pages)

break
except ValueError:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
'''Explicatie cod:'''

Acest cod implementează un program care calculează numărul total de pagini al unei cărți, în funcție de numărul de cifre folosite pentru numerotarea paginilor.

Funcția `validate_input(n)` verifică dacă datele de intrare sunt valide, respectiv dacă numărul introdus este un întreg și este mai mare decât zero. Dacă datele nu sunt valide, se afișează un mesaj de eroare și se returnează `False`, altfel se returnează `True`.

Funcția `calculate_pages(n)` calculează numărul total de pagini al cărții în funcție de numărul de cifre folosite pentru numerotarea paginilor. Algoritmul folosit este să se calculeze numărul de cifre necesare pentru a numerota fiecare pagină până la ultima pagină, astfel încât atunci când numărul de cifre necesare depășește numărul de cifre date, se știe că s-au numerotat toate paginile.

Funcția `display_pages(total_pages)` afișează numărul total de pagini al cărții.

În `if __name__ == '__main__':` se pornește programul. Programul citeste numărul de cifre folosite pentru numerotarea paginilor și verifică dacă datele sunt valide folosind funcția `validate_input(n)`. Dacă datele sunt valide, se calculează numărul total de pagini folosind funcția `calculate_pages(n)`. Dacă numărul total de pagini este mai mic decât 1, se afișează un mesaj de eroare, altfel se afișează un mesaj de confirmare și numărul total de pagini al cărții folosind funcția `display_pages(total_pages)`.

1255 - Lipsa

2023-04-29T08:11:03Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Se dau '''n - 1''' numere naturale distincte de la '''1''' la '''n'''. Să se gaseasca numărul lipsă.

== Date de intrare ==
Programul conține pe prima linie numărul '''n''', iar pe a doua linie '''n - 1''' numere naturale separate prin spații.

== Date de ieșire ==
Programul va conține pe prima linie numărul căutat.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează numărul lipsă .

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
2 ≤ '''n''' ≤ 1.000.000

== Exemplul 1 ==
; Datele de intrare:
: Introdu un nr. N urmat de N numere:
: 5
:Numelere N sunt:
: 5 3 1 2
; Datele de ieșire:
: Datele sunt introduse corect.
: 4
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1255
def calculate_missing_number(n, nums):
sum_given = sum(nums)
sum_n = (n * (n+1)) // 2
missing_num = sum_n - sum_given
return missing_num

def display_missing_number(missing_num):
print(missing_num)

def validate_input(n, nums):
if not isinstance(n, int):
print("Datele nu corespund restricțiilor impuse.")
return False
elif len(nums) != n-1:
print("Datele nu corespund restricțiilor impuse.")
return False
elif any(num < 1 or num > n for num in nums):
print("Datele nu corespund restricțiilor impuse.")
return False
elif len(set(nums)) != n-1:
print("Datele nu corespund restricțiilor impuse.")
return False
else:
return True

if __name__ == '__main__':
n = int(input("Introdu un nr. N urmat de N numere:"))
nums = list(map(int, input("Numerele N sunt:").split()))

if validate_input(n, nums):
missing_num = calculate_missing_number(n, nums)
display_missing_number(missing_num)
print("Datele sunt introduse corect.")
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
'''Explicatie cod:'''

Această cod rezolvă problema de găsire a unui număr lipsă într-o secvență de numere de la 1 la N.

Funcția `calculate_missing_number` primește două argumente: `n` și `nums`. `n` reprezintă lungimea secvenței, iar `nums` este o listă de numere întregi care reprezintă secvența. Funcția calculează suma secvenței prin apelarea funcției `sum(nums)` și calculează suma secvenței de la 1 la `n` prin utilizarea formulei `(n * (n+1)) // 2`. Numărul lipsă este apoi calculat prin scăderea sumei secvenței date de la suma secvenței de la 1 la `n`. Numărul lipsă este returnat de funcție.

Funcția `display_missing_number` primește un argument, `missing_num`, care este numărul lipsă calculat de funcția `calculate_missing_number`. Funcția afișează numărul lipsă.

Funcția `validate_input` primește două argumente, `n` și `nums`, și verifică dacă intrarea este validă. Funcția returnează `False` dacă intrarea nu respectă constrângerile necesare și returnează `True` altfel. Constrângerile sunt că `n` trebuie să fie un număr întreg, `nums` trebuie să fie o listă de lungime `n-1`, toate numerele din listă trebuie să fie între 1 și `n`, iar toate numerele din listă trebuie să fie distincte.

În blocul principal, utilizatorul introduce `n` și `nums`. Intrarea este validată apelând funcția `validate_input`. Dacă intrarea este validă, numărul lipsă este calculat prin apelarea funcției `calculate_missing_number` și afișat prin apelarea funcției `display_missing_number`. Dacă intrarea nu este validă, este afișat un mesaj de eroare. Dacă intrarea este validă, este afișat un mesaj de succes.

1255 - Lipsa

2023-04-29T08:09:02Z

Sinn Erich: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Se dau '''n - 1''' numere naturale distincte de la '''1''' la '''n'''. Să se gaseasca numărul lipsă.

== Date de intrare ==
Programul conține pe prima linie numărul '''n''', iar pe a doua linie '''n - 1''' numere naturale separate prin spații.

== Date de ieșire ==
Programul va conține pe prima linie numărul căutat.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează numărul lipsă .

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
2 ≤ '''n''' ≤ 1.000.000

== Exemplul 1 ==
; Datele de intrare:
: Introdu un nr. N urmat de N numere:
: 5
:Numelere N sunt:
: 5 3 1 2
; Datele de ieșire:
: Datele sunt introduse corect.
: 4
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1255
def calculate_missing_number(n, nums):
sum_given = sum(nums)
sum_n = (n * (n+1)) // 2
missing_num = sum_n - sum_given
return missing_num

def display_missing_number(missing_num):
print(missing_num)

def validate_input(n, nums):
if not isinstance(n, int):
print("Datele nu corespund restricțiilor impuse.")
return False
elif len(nums) != n:
print("Datele nu corespund restricțiilor impuse.")
return False
elif any(num < 1 or num > n for num in nums):
print("Datele nu corespund restricțiilor impuse.")
return False
else:
return True

if __name__ == '__main__':
n = int(input("Introdu un nr. N urmat de N numere:"))
nums = list(map(int, input().split()))

if validate_input(n, nums):
missing_num = calculate_missing_number(n, nums)
display_missing_number(missing_num)
print("Datele sunt introduse corect")

</syntaxhighlight>
'''Explicatie cod:'''

Acest cod rezolvă problema găsirii unui număr lipsă într-o secvență de numere de la 1 la N.

Funcția `calculate_missing_number` primește două argumente, `n` și `nums`, unde `n` este un întreg care reprezintă lungimea secvenței și `nums` este o listă de întregi care reprezintă secvența. Funcția calculează suma secvenței apelând `sum(nums)` și calculează suma secvenței de la 1 la `n` utilizând formula `(n * (n+1)) // 2`. Numărul lipsă este apoi calculat prin scăderea sumei secvenței date din suma secvenței de la 1 la `n`. Numărul lipsă este returnat de funcție.

Funcția `display_missing_number` primește un singur argument, `missing_num`, care reprezintă numărul lipsă calculat de funcția `calculate_missing_number`. Funcția afișează numărul lipsă.

Funcția `validate_input` primește doi argumente, `n` și `nums`, și verifică dacă introducerea este validă. Funcția returnează `False` dacă introducerea nu respectă restricțiile necesare și returnează `True` în caz contrar. Restricțiile sunt că `n` trebuie să fie un întreg, `nums` trebuie să fie o listă de lungime `n`, iar toate numerele din listă trebuie să fie între 1 și `n`.

În blocul principal, utilizatorul este invitat să introducă `n` și `nums`. Introducerea este validată apelând funcția `validate_input`. Dacă introducerea este validă, numărul lipsă este calculat prin apelarea funcției `calculate_missing_number` și afișat prin apelarea funcției `display_missing_number`. Dacă introducerea este invalidă, se afișează un mesaj de eroare. Dacă introducerea este validă, se afișează un mesaj de succes.

1255 - Lipsa

2023-04-29T08:02:27Z

Sinn Erich: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Se dau '''n - 1''' numere naturale distincte de la '''1''' la '''n'''. Să se gaseasca numărul lipsă.

== Date de intrare ==
Programul conține pe prima linie numărul '''n''', iar pe a doua linie '''n - 1''' numere naturale separate prin spații.

== Date de ieșire ==
Programul va conține pe prima linie numărul căutat.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează numărul lipsă .

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
2 ≤ '''n''' ≤ 1.000.000

== Exemplul 1 ==
; Datele de intrare:
: Introdu un nr. N urmat de N numere:
: 5
: 5 3 1 2
; Datele de ieșire:
: Datele sunt introduse corect.
: 4
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1255
def calculate_missing_number(n, nums):
sum_given = sum(nums)
sum_n = (n * (n+1)) // 2
missing_num = sum_n - sum_given
return missing_num

def display_missing_number(missing_num):
print(missing_num)

def validate_input(n, nums):
if not isinstance(n, int):
print("Datele nu corespund restricțiilor impuse.")
return False
elif len(nums) != n:
print("Datele nu corespund restricțiilor impuse.")
return False
elif any(num < 1 or num > n for num in nums):
print("Datele nu corespund restricțiilor impuse.")
return False
else:
return True

if __name__ == '__main__':
n = int(input("Introdu un nr. N urmat de N numere:"))
nums = list(map(int, input().split()))

if validate_input(n, nums):
missing_num = calculate_missing_number(n, nums)
display_missing_number(missing_num)
print("Datele sunt introduse corect")

</syntaxhighlight>
'''Explicatie cod:'''

Acest cod rezolvă problema găsirii unui număr lipsă într-o secvență de numere de la 1 la N.

Funcția `calculate_missing_number` primește două argumente, `n` și `nums`, unde `n` este un întreg care reprezintă lungimea secvenței și `nums` este o listă de întregi care reprezintă secvența. Funcția calculează suma secvenței apelând `sum(nums)` și calculează suma secvenței de la 1 la `n` utilizând formula `(n * (n+1)) // 2`. Numărul lipsă este apoi calculat prin scăderea sumei secvenței date din suma secvenței de la 1 la `n`. Numărul lipsă este returnat de funcție.

Funcția `display_missing_number` primește un singur argument, `missing_num`, care reprezintă numărul lipsă calculat de funcția `calculate_missing_number`. Funcția afișează numărul lipsă.

Funcția `validate_input` primește doi argumente, `n` și `nums`, și verifică dacă introducerea este validă. Funcția returnează `False` dacă introducerea nu respectă restricțiile necesare și returnează `True` în caz contrar. Restricțiile sunt că `n` trebuie să fie un întreg, `nums` trebuie să fie o listă de lungime `n`, iar toate numerele din listă trebuie să fie între 1 și `n`.

În blocul principal, utilizatorul este invitat să introducă `n` și `nums`. Introducerea este validată apelând funcția `validate_input`. Dacă introducerea este validă, numărul lipsă este calculat prin apelarea funcției `calculate_missing_number` și afișat prin apelarea funcției `display_missing_number`. Dacă introducerea este invalidă, se afișează un mesaj de eroare. Dacă introducerea este validă, se afișează un mesaj de succes.

1581 - Max Suma

2023-04-29T07:38:51Z

Sinn Erich: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/4273/prodpp]
== Cerinţa ==
Se dau '''n''' şiruri, fiecare şir fiind format din '''m''' numere naturale '''mai mici decat 500'''. Să se determine cel mai mare număr din fiecare şir. Să se determine '''suma''' numerelor fiecărui şir.

== Date de intrare ==
Programul citeste pe rând '''n, m şi restul numerelor'''.

== Date de ieșire ==
Se vor scrie pe fiecare rând pentru fiecare şir '''cel mai mare număr''' din şir şi '''suma'''.

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cel mai mare număr din fiecare şir. Să se determine suma numerelor fiecărui şir.

În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."

== Restricţii şi precizări ==
1 ≤ '''n''' ≤ 100

1 ≤ '''m''' ≤ 50

== Exemplul 1 ==
; Datele de intrare:
: Introduceti numarul de siruri:
: 3
: Introduceti numarul maxim de numere dintr-un sir:
: 5
: Introduceti sirul de numere separate prin spatiu:
:15 25 44 66 87
: Introduceti sirul de numere separate prin spatiu:
:25 11 44 78 32
: Introduceti sirul de numere separate prin spatiu:
:20 59 87 45 99
; Datele de ieșire:
:Datele sunt introduse corect.
:Sirul 0:
:Cel mai mare numar: 87
:Suma numerelor: 237
:Sirul 1:
:Cel mai mare numar: 78
:Suma numerelor: 190
:Sirul 2:
:Cel mai mare numar: 99
:Suma numerelor: 310
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1581
def validate_input(n, m):
"""
Verifica daca valorile introduse pentru n si m respecta
restricțiile impuse.
"""
if not (1 <= n <= 100):
print("Datele nu corespund restricțiilor impuse.")
return False
if not (1 <= m <= 50):
print("Datele nu corespund restricțiilor impuse.")
return False
return True

def max_and_sum(sir):
"""
Gaseste cel mai mare numar din sir si suma tuturor numerelor.
"""
max_numar = max(sir)
suma = sum(sir)
return max_numar, suma

def print_result(max_numar, suma, i):
"""
Afiseaza rezultatele pentru sirul cu indicele i.
"""
print(f"Sirul {i}:")
print(f"Cel mai mare numar: {max_numar}")
print(f"Suma numerelor: {suma}")
print()

def solution_function(n, m, siruri_numere):
"""
Functia de rezolvare a problemei.
"""
for i, sir in enumerate(siruri_numere):
max_numar, suma = max_and_sum(sir)
print_result(max_numar, suma, i)

if __name__ == '__main__':
n = int(input("Introduceti numarul de siruri: "))
m = int(input("Introduceti numarul maxim de numere dintr-un sir: "))
print("Datele sunt corecte.")
if not validate_input(n, m):
exit()

siruri_numere = []
for i in range(n):
sir = input("Introduceti sirul de numere separate prin spatiu: ")
numere = sir.split()
numere_int = [int(x) for x in numere]
if len(numere_int) > m:
print("Datele nu corespund restricțiilor impuse.")
exit()
siruri_numere.append(numere_int)

solution_function(n, m, siruri_numere)

</syntaxhighlight>

'''Explicatie cod:'''

Acest cod citeste n siruri de numere separate prin spatiu, apoi pentru fiecare sir de numere calculeaza cel mai mare numar si suma tuturor numerelor din sir.

Functia read_input() citeste numarul de siruri de numere, iar apoi citeste fiecare sir de numere, il transforma intr-o lista de intregi si adauga lista la o lista generala siruri_numere. Aceasta lista este returnata la final.

Functia max_and_sum(sir) primeste un sir de numere si calculeaza cel mai mare numar din sir si suma tuturor numerelor din sir. Pentru aceasta, initializeaza max_numar cu 0 si suma cu 0, apoi parcurge fiecare numar din sir, actualizand valorile max_numar si suma corespunzator. La final, functia returneaza cele doua valori.

Functia print_result(max_numar, suma, index) primeste cel mai mare numar si suma numerelor dintr-un sir, impreuna cu numarul sirului, si le afiseaza.

In main, se citesc sirurile de numere folosind read_input(), apoi se parcurg sirurile folosind enumerate(siruri_numere) pentru a retine si indexul fiecarui sir. Pentru fiecare sir, se calculeaza cel mai mare numar si suma numerelor folosind max_and_sum(sir), iar apoi se afiseaza aceste valori folosind print_result(max_numar, suma, i), unde i este indexul sirului.