Bitnami MediaWiki - User contributions [en]

Gazeta Matematică

2024-01-16T15:35:29Z

Csula Beatrice:

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

Gazeta Matematică

2024-01-16T15:32:24Z

Csula Beatrice:

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

28163

2024-01-16T15:30:03Z

Csula Beatrice: Pagină nouă: '''28163 (Dana Heuberger)''' ''Aflați șirul de numere naturale nenule <math>(a_n)_{n\geq1}</math> pentru care <math>\frac{1}{{(1+a_1) \cdot a_{a_1}}} + \frac{1}{{(1+a_2) \cdot a_{a_2}}} + \ldots + \frac{1}{{(1+a_n) \cdot a_{a_n}}} = \frac{n}{{n+1}}</math>, pentru orice <math>n \geq 1</math>.'' '''Soluție:''' Dacă <math>n = 1</math>, egalitatea din enunț devine <math>(1+a_1) \cdot a_{a_1} = 2</math>, de unde obținem <math>a_1 = 1</math>. </b...

'''28163 (Dana Heuberger)'''
 
 
''Aflați șirul de numere naturale nenule <math>(a_n)_{n\geq1}</math> pentru care
<math>\frac{1}{{(1+a_1) \cdot a_{a_1}}} + \frac{1}{{(1+a_2) \cdot a_{a_2}}} + \ldots + \frac{1}{{(1+a_n) \cdot a_{a_n}}} = \frac{n}{{n+1}}</math>, pentru orice <math>n \geq 1</math>.''
 
 
'''Soluție:'''

Dacă <math>n = 1</math>, egalitatea din enunț devine <math>(1+a_1) \cdot a_{a_1} = 2</math>, de unde obținem <math>a_1 = 1</math>.


Dacă <math>n \geq 2</math>, scriind egalitatea din enunț pentru <math>n-1</math> și scăzând-o din relația inițială, obținem


<math>\frac{1}{{(1+a_n) \cdot a_{a_n}}} = \frac{n}{{n+1}} - \frac{n-1}{n} = \frac{1}{{n(n+1)}}</math>, deci 
<math>(1+a_n) \cdot a_{a_n} = n(n+1)</math> pentru orice <math>n \in \mathbb{N}</math>, <math>n \geq 2</math>. (1)

Demonstrăm, folosind inducția ''tare'', că <math>a_n = n</math>, pentru orice număr natural nenul <math>n</math>. Etapa de verificare este evidentă.
 
Fie <math>k \in \mathbb{N}</math>, <math>k \geq 2</math>. Presupunem că <math>a_t = t</math>, pentru orice număr natural <math>t</math> cu <math>t \in \{1,2,...,k-1\}</math> și arătăm că <math>a_k = k</math>.
 
'''I.''' Dacă <math>a_k = s < k</math>, din ipoteza de inducție rezultă <math>a_{a_k} = a_s = s < k</math>. Din relația (1) obținem <math>k(k+1) = (1+a_k) \cdot a_{a_k} = s(s+1) < k(k+1)</math>, fals.


'''II.''' Dacă <math>a_k = s > k</math>, din (1) deducem:

<math>
a_s = a_{a_k} = \frac{k(k+1)}{1+a_k} = \frac{k(k+1)}{s+1},
</math>
deci <math>a_s = k \cdot \frac{k+1}{s+1} < k</math>. (2)
 

Din ipoteza de inducție rezultă că <math>a_{a_s} = a_s = \frac{k(k+1)}{s+1}</math>.

Din relația (1) obținem că <math>a_{a_s} = \frac{s(s+1)}{a_s+1}</math>, deci <math>\frac{k(k+1)}{s+1} = \frac{s(s+1)}{1+a_s}</math>.

Așadar, <math>1+a_s = \frac{s(s+1)}{k(k+1)} \cdot (s+1) > s+1</math>, adică <math>a_s > s > k</math>, contradicție cu inegalitatea (2).
 
Din '''I''' și '''II''' deducem că <math>a_k = k</math>. Conform principiului inducției, rezultă că <math>a_n = n</math>, pentru orice număr natural <math>n</math>. Pentru acest șir, egalitatea din enunț devine o identitate, așadar soluția problemei este șirul cu termenul general <math>a_n = n</math>.

14440

2024-01-08T23:03:03Z

Csula Beatrice: Pagină nouă: '''14440 (Vasile Ienuțaș și Radu Pop)''' ''Se consideră numărul natural <math> A=a_1^2+a_2^2+a_3^2+.....+a_{2012}^2 </math> unde <math>a_1,a_2,a_3,.....,a_{2012}</math> sunt numere prime, mai mari sau egale cu 5. Arătați că <math>B=2 \cdot A + 2013 </math> nu este pătrat perfect.'' '''Soluție:''' Dacă <math>a_i</math>, cu <math>i \in \{1,2,3,\ldots,2012\}</math>, este număr prim mai mare decât 5, atunci <math>a_i^2 \equiv M8 + 1</math...

'''14440 (Vasile Ienuțaș și Radu Pop)'''
 
 
''Se consideră numărul natural <math> A=a_1^2+a_2^2+a_3^2+.....+a_{2012}^2 </math> unde <math>a_1,a_2,a_3,.....,a_{2012}</math> sunt numere prime, mai mari sau egale cu 5.
Arătați că <math>B=2 \cdot A + 2013 </math> nu este pătrat perfect.''
 
 
'''Soluție:'''
Dacă <math>a_i</math>, cu <math>i \in \{1,2,3,\ldots,2012\}</math>, este număr prim mai mare decât 5, atunci <math>a_i^2 \equiv M8 + 1</math>, pentru orice <math>i \in \{1,2,3,\ldots,2012\}</math>. Prin urmare, <math>B = 2 \cdot (M8 + 2012) + 2013 = M8 + 6037 = M8 + 5</math>, care nu este pătrat perfect.

26713

2024-01-08T03:07:37Z

Csula Beatrice:

'''26713 (Radu Pop și Vasile Ienuțaș)'''
 
'' Se consideră șirul de numere reale <math>(x_n)_{n \geq 0}</math> și <math>(y_n)_{n \geq 0}</math> cu <math>x_n \geq 1</math>, <math>y_n \geq 1</math>, pentru orice <math>n \in \mathbb{N}</math>, și <math>\lim_{{n \to \infty}} (x_n^2 + y_n^2) = 2</math>. Să se calculeze <math>\lim_{{n \to \infty}} x_n</math> și <math>\lim_{{n \to \infty}} y_n</math>.''
 
'''Soluție:'''
 
 
Avem <math> 2 \leq x_n - y_n \leq \sqrt{2(x_n^2 + y_n^2)} </math> și cum <math> \lim_{{n \to \infty}} \sqrt{2(x_n^2 + y_n^2)} = 2 </math>, rezultă că <math> \lim_{{n \to \infty}} (x_n + y_n) = 2 </math>. Cum <math> 1 \leq x_n \leq x_n + y_n - 1 </math> și <math> \lim_{{n \to \infty}} (x_n + y_n - 1) = 1 </math>, obținem <math> \lim_{{n \to \infty}} x_n = 1 </math>. Analog, <math> \lim_{{n \to \infty}} y_n = 1 </math>.

26713

2024-01-08T03:05:57Z

Csula Beatrice: Pagină nouă: '''28354 (Radu Pop și Vasile Ienuțaș)''' '' Se consideră șirul de numere reale <math>(x_n)_{n \geq 0}</math> și <math>(y_n)_{n \geq 0}</math> cu <math>x_n \geq 1</math>, <math>y_n \geq 1</math>, pentru orice <math>n \in \mathbb{N}</math>, și <math>\lim_{{n \to \infty}} (x_n^2 + y_n^2) = 2</math>. Să se calculeze <math>\lim_{{n \to \infty}} x_n</math> și <math>\lim_{{n \to \infty}} y_n</math>.'' '''Soluție:''' Avem <math> 2 \leq x_n...

'''28354 (Radu Pop și Vasile Ienuțaș)'''
 
'' Se consideră șirul de numere reale <math>(x_n)_{n \geq 0}</math> și <math>(y_n)_{n \geq 0}</math> cu <math>x_n \geq 1</math>, <math>y_n \geq 1</math>, pentru orice <math>n \in \mathbb{N}</math>, și <math>\lim_{{n \to \infty}} (x_n^2 + y_n^2) = 2</math>. Să se calculeze <math>\lim_{{n \to \infty}} x_n</math> și <math>\lim_{{n \to \infty}} y_n</math>.''
 
'''Soluție:'''
 
 
Avem <math> 2 \leq x_n - y_n \leq \sqrt{2(x_n^2 + y_n^2)} </math> și cum <math> \lim_{{n \to \infty}} \sqrt{2(x_n^2 + y_n^2)} = 2 </math>, rezultă că <math> \lim_{{n \to \infty}} (x_n + y_n) = 2 </math>. Cum <math> 1 \leq x_n \leq x_n + y_n - 1 </math> și <math> \lim_{{n \to \infty}} (x_n + y_n - 1) = 1 </math>, obținem <math> \lim_{{n \to \infty}} x_n = 1 </math>. Analog, <math> \lim_{{n \to \infty}} y_n = 1 </math>.

1892 - S Norocos

2023-05-14T19:37:31Z

Csula Beatrice: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/1892/snorocos]
== Cerinţa ==
Se dă un număr natural '''n'''. Dacă numărul este norocos afișați cele '''n''' numere consecutive care adunate dau pătratul acestuia.

== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Daca '''n''' este norocos, programul va afișa pe ecran cele '''n''' numere consecutive care adunate dau '''n * n''', separate prin spații și mesajul "Datele introduse corespund cerintelor." În caz contrar, programul va afișa mesajele '''NU ESTE NOROCOS''' și "Datele introduse nu corespund cerintelor."

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 1000

== Exemplul 1 ==
; Intrare
: 7
; Ieșire
: Datele introduse corespund cerintelor.
: 4 5 6 7 8 9 10
 

== Exemplul 2 ==
; Intrare
: 8
; Ieșire
: Datele introduse corespund cerintelor.
: NU ESTE NOROCOS
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1892
def validate_n(n):
if isinstance(n, int) and 1 <= n <= 1000:
return True
else:
return False

if __name__ == '__main__':
n = int(input("n: "))
if not validate_n(n):
print("Datele introduse nu corespund cerințelor.")
exit()

else:
print("Datele introduse corespund cerintelor.")

if n % 2 == 1:
k = (n+1)//2
while n > 0:
print(k, end=' ')
k += 1
n -= 1
else:
print("NU ESTE NOROCOS")

</syntaxhighlight>

== Explicatie rezolvare ==
Acest program primește un număr întreg n de la utilizator și verifică dacă numărul se încadrează între '''1 și 1000'''.
Dacă '''n''' este un număr impar, programul va imprima primele '''n''' numere naturale impare consecutive începând cu '''(n+1)//2'''.
În caz contrar, programul va afișa '''NU ESTE NOROCOS'''.
Funcția '''validate_n''' este folosită pentru a verifica dacă '''n-ul''' introdus este un număr întreg între '''1''' și '''1000'''.

1754 - Munți

2023-05-14T19:27:43Z

Csula Beatrice: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/1754/munti]
== Cerinţa ==
Vrăjitorul vă cere să determinați numărul maxim de munți ce pot fi aduși la o înălțime egală.

== Date de intrare ==
Pe prima linie a fișierului '''munti.in''' se va afla numărul natural '''N''', reprezentând numărul de munți existenți. Pe cea de-a doua linie se vor afla '''N''' valori naturale separate prin spațiu, reprezentând înălțimea inițială a fiecărui munte.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse corespund cerintelor.", apoi fișierul de ieșire munti.out va conține, pe prima și singura linie a fișierului, numărul maxim de munți ce pot fi aduși la o înălțime egală. În cazul în care datele nu respectă restricțiile, se va doar afișa pe ecran: "Datele introduse nu corespund cerintelor."

== Restricţii şi precizări ==
* 1 &les; '''N''' &les; 1.000.000
* 1 &les; '''înalțimea inițială''' &les; 1.000.000.000

== Exemplul 1 ==
; Intrare
: ''munti.in''
: 4
: 2 6 2 2
; Ieșire
: Datele introduse corespund cerintelor.
: ''munti.out''
: 4
 

== Exemplul 2 ==
; Intrare
: ''munti.in''
: 8
: 2 6 2 2
; Ieșire
: Datele introduse corespund cerintelor.
: ''munti.out''
: 7

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1754
def validate_input(n, x_list):
print("Datele introduse corespund cerintelor.")
if not 1 <= n <= 1000000:
print("Datele introduse nu corespund cerintelor.")
exit()
if not all(1 <= x <= 1000000000 for x in x_list):
print("Datele introduse nu corespund cerintelor.")
exit()

if __name__ == "__main__":
with open("munti.in", "r") as f_in, open("munti.out", "w") as f_out:
n = int(f_in.readline())
x_list = list(map(int, f_in.readline().split()))
validate_input(n, x_list)
s = sum(x_list)
if s % n == 0:
f_out.write(str(n))
else:
f_out.write(str(n - 1))

</syntaxhighlight>

== Explicatie rezolvare ==
Acest program este o soluție pentru o problemă de programare care citește date de intrare dintr-un fișier numit "munti.in", verifică dacă aceste date îndeplinesc anumite cerințe și apoi calculează un rezultat bazat pe datele de intrare și îl scrie într-un fișier numit "munti.out".

Funcția "validate_input" verifică dacă numărul "n" și lista "x_list" de numere întregi citite din fișierul de intrare îndeplinesc cerințele problemei. Dacă datele nu îndeplinesc cerințele, programul afișează un mesaj de eroare și se încheie prin apelul funcției "exit()".

După validarea datelor de intrare, programul calculează suma numerelor din lista "x_list" și determină dacă această sumă este divizibilă cu "n" sau nu. Dacă suma este divizibilă cu "n", atunci programul scrie în fișierul de ieșire numărul "n", altfel scrie "n - 1".

În esență, acest program încearcă să găsească numărul de munți (sau vârfuri) care pot fi formați prin gruparea unui anumit număr de înălțimi ale munților citite din fișierul de intrare.

3622 - Perechi Pare

2023-05-14T19:15:16Z

Csula Beatrice: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3622/perechipare]
== Cerinţa ==
Se dă un interval '''[l,r]'''. Aflaţi câte perechi de numere pare se pot forma alegând două numere din interval.

== Date de intrare ==
Programul citește de la tastatură numerele '''l''' şi '''r'''.

== Date de ieșire ==
Dacă datele introduse sunt corecte și respectă formatul așteptat, programul va afișa în continuare, pe un rând nou, perechile de numere pare care se pot forma alegând două numere din interval și mesajul "Datele introduse corespund cerințelor".

În cazul în care datele de intrare nu respectă restricțiile impuse programul va afișa pe ecran mesajul "Datele introduse nu corespund cerințelor" și nu va continua cu restul execuției programului.

== Restricţii şi precizări ==
* 1 &les; '''l''' &les; '''r''' &les; 1.000.000

== Exemplul 1 ==
; Intrare
: Introdu l: 5
: Introdu r: 10
; Ieșire
: Datele introduse corespund cerintelor.
: 9
 

== Exemplul 2 ==
; Intrare
: Introdu l: 5
: Introdu r: 1000000000000000000000000000000
; Ieșire
: Datele introduse nu corespund cerintelor.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3622
def validate_input(l, r):
if not (1 <= l <= r <= 1000000):
print("Datele introduse nu corespund cerintelor.")
exit()

def numarare_numere_pare(l, r):
validate_input(l, r)
contor = 0
for i in range(l, r+1):
if i % 2 == 0:
contor += 1
return contor

if __name__ == '__main__':
l = int(input("Introdu l: "))
r = int(input("Introdu r: "))

contor = numarare_numere_pare(l, r)
print(f"Datele introduse corespund cerintelor.\n{contor * contor}")

</syntaxhighlight>

== Explicatie rezolvare ==
Acest program numara numerele pare dintre doua numere l si r date de utilizator si afiseaza patratul numarului de numere pare gasite.

Mai intai, functia `validate_input` verifica daca cele doua numere introduse sunt intre 1 si 1000000 si afiseaza un mesaj de eroare si opreste programul daca acestea nu sunt indeplinite. Aceasta functie este apelata in functia `numarare_numere_pare` pentru a asigura ca datele introduse sunt valide.

Functia `numarare_numere_pare` utilizeaza un contor pentru a numara numerele pare intre l si r, inclusiv. Daca un numar este divizibil cu 2, se incrementeaza contorul cu 1. La sfarsit, functia returneaza valoarea contorului.

In programul principal, utilizatorul este intrebat sa introduca valorile l si r. Apoi, functia `numarare_numere_pare` este apelata si rezultatul este afisat, alaturi de un mesaj care confirma ca datele introduse sunt valide.

3664 - Cif Par Cif Imp

2023-05-14T19:07:45Z

Csula Beatrice: /* Date de ieşire */

Sursă: [https://www.pbinfo.ro/probleme/3664/cifparcifimp]

== Cerinţa ==
Se dau '''n''' numere naturale. Determinaţi câte cifre pare şi câte cifre impare se află în total în 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 ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse corespund cerintelor.", apoi pe un rând nou va afișa numărul de cifre pare și impare separate printr-un spațiu. În caz contrar, se va afișa mesajul:" Datele introduse nu corespund cerintelor."

== Restricții și precizări ==
* 1 &les; '''n''' &les; 10
* cele '''n''' numere citite vor fi mai mici decât '''1.000.000.000'''.

== Exemplul 1 ==
; Intrare
: Introduceți numărul de numere: 3
: Introduceți numărul 1: 11
: Introduceți numărul 2: 30
: Introduceți numărul 3: 3
; Ieșire
: Datele de intrare corespund cerintelor.
: 1 4

== Exemplul 2 ==
; Intrare
: Introduceți numărul de numere: 0
; Iesire
: Datele de intrare nu corespund cerintelor.

== Rezolvare ==

<syntaxhighlight lang="python" line>
#3664
def validate_input(n):
if not 1 <= n <= 10:
print("Datele introduse nu corespund cerintelor.")
return False
return True

def count_parity_digits(n):
pare = 0
impare = 0
while n > 0:
cifra = n % 10
if cifra % 2 == 0:
pare += 1
else:
impare += 1
n //= 10
return pare, impare

if __name__ == '__main__':
numere = int(input("Introduceți numărul de numere: "))
if not validate_input(numere):
exit()
pare_total = 0
impare_total = 0
for i in range(numere):
n = int(input(f"Introduceți numărul {i + 1}: "))
if n >= 1000000000:
print("Datele de intrare nu corespund cerintelor")
continue
pare, impare = count_parity_digits(n)
pare_total += pare
impare_total += impare

print(f"Datele de intrare corespund cerintelor\n{pare_total} {impare_total}")

</syntaxhighlight>

==Explicatie rezolvare==
Acest program este o soluție la o problemă care prelucrează un număr dat de numere și calculează numărul total de cifre pare și impare în toate numerele introduse.

Mai întâi, programul folosește funcția `validate_input(n)` pentru a verifica dacă numărul de numere introduse este între 1 și 10. Dacă nu, se afișează un mesaj de eroare și se returnează valoarea `False`.

Apoi, funcția `count_parity_digits(n)` primește un număr `n` și numără cifrele pare și impare în acel număr, utilizând o buclă `while` și operatorul modulo `%`. Rezultatul este returnat sub formă de tuplu.

În blocul principal, utilizatorul este întâi întrebat să introducă numărul de numere pe care le va introduce. Dacă numărul nu este validat cu ajutorul funcției `validate_input()`, programul se încheie. În caz contrar, programul trece printr-o buclă `for` și cere utilizatorului să introducă fiecare număr. Dacă numărul introdus este mai mare sau egal cu 1 miliard, se afișează un mesaj de eroare și se trece la următorul număr. Altfel, se apelează funcția `count_parity_digits()` pentru a număra cifrele pare și impare în numărul introdus și se adaugă la numerele totale de cifre pare și impare.

La sfârșit, programul afișează un mesaj de confirmare și numărul total de cifre pare și impare numărate.

2021 - Sumă Gauss2

2023-05-14T18:58:38Z

Csula Beatrice: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/2021/sumagauss2]
== Cerinţa ==
Ana a calculat suma numerelor naturale mai mici sau egale cu '''n''', iar Andreea suma numerelor naturale mai mici sau egale cu '''m'''. Doamna de mate a calculat apoi diferenţa celor două sume şi a obţinut rezultatul '''S'''.

Pentru o valoare '''S''' dată, aflaţi toate perechile '''(n,m)''', cu '''n>m''', scriindu-le în ordine descrescătoare după '''n''' astfel încât doamna de mate să obţină rezultatul '''S'''.

== Date de intrare ==
Fișierul de intrare '''sumagauss2.in''' conține pe prima linie numărul '''S'''.

== Date de ieșire ==
Dacă datele introduse sunt corecte și respectă formatul așteptat, programul va afișa în continuare, pe un rând nou, perechile '''(n,m)''', cu '''n''' > '''m''', în ordine descrescătoare după '''n'''.

În cazul în care datele din fișierul de intrare nu respectă restricțiile impuse programul va afișa pe ecran mesajul "Datele introduse nu corespund cerințelor." și nu va continua cu restul execuției programului.

== Restricţii şi precizări ==
* 1 &les; '''S''' &les; 2.000.000.000

== Exemplul 1 ==
; Intrare
: ''sumagauss2.in''
: 10
; Ieșire
: Datele corespund cerintelor.
: ''sumagauss2.out''
: 10 9
: 4 0
 

== Exemplul 2 ==
; Intrare
: ''sumagauss2.in''
: 10000000000
; Ieșire
: Datele introduse nu corespund cerințelor.
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
#2021
def validate_input(s):
if not 1 <= s <= 2000000000:
print("Datele introduse nu corespund cerințelor.")
exit()

def read_input_file(input_file):
with open(input_file, 'r') as f:
s = int(f.readline().strip())
validate_input(s)
print("Datele corespund cerințelor.")
return s

def write_output_file(output_file, solutions):
with open(output_file, 'w') as f:
for p in solutions:
f.write(f"{p[0]} {p[1]}\n")

def find_solutions(s):
solutions = []
for n in range(s, 0, -1):
sn = n * (n + 1) // 2
for m in range(n):
sm = m * (m + 1) // 2
d = sn - sm
if d == s and n > m:
solutions.append((n, m))
solutions.sort(reverse=True)
return solutions

if __name__ == '__main__':
# Citim numărul S din fișierul de intrare
input_file = 'sumagauss2.in'
s = read_input_file(input_file)

# Găsim toate perechile (n, m) cu diferența dată S
solutions = find_solutions(s)

# Scriem perechile în ordine descrescătoare după n în fișierul de ieșire
output_file = 'sumagauss2.out'
write_output_file(output_file, solutions)

</syntaxhighlight>

== Explicatie rezolvare ==
Acest program are rolul de a găsi toate perechile de numere naturale (n, m) astfel încât diferența dintre suma primelor n numere naturale și suma primelor m numere naturale să fie egală cu un anumit număr S dat.

Funcția "read_input_file" primește ca parametru numele fișierului de intrare și returnează numărul S citit din fișierul respectiv.

Funcția "write_output_file" primește ca parametri numele fișierului de ieșire și o listă de perechi (n, m) și scrie aceste perechi în fișierul de ieșire, fiecare pe o linie separată. Funcția "find_solutions" primește ca parametru numărul S și returnează o listă cu toate perechile (n, m) care îndeplinesc condiția dată, sortate descrescător după n.

În funcția "find_solutions", se parcurg toate numerele naturale de la s până la 1 și se calculează suma primelor n numere naturale pentru fiecare n, apoi se parcurg toate numerele naturale de la 0 până la n-1 și se calculează suma primelor m numere naturale pentru fiecare m.
Se calculează diferența dintre aceste sume și se verifică dacă este egală cu numărul S dat.
Dacă este, perechea (n, m) este adăugată la lista de soluții. La final, lista de soluții este sortată descrescător după n și returnată.

În blocul "if name == 'main'", se citește numărul S din fișierul de intrare, se găsesc toate perechile (n, m) cu diferența dată S folosind funcția "find_solutions", iar apoi se scriu perechile în ordine descrescătoare după n în fișierul de ieșire folosind funcția "write_output_file".
Numele fișierelor de intrare și de ieșire sunt specificate în variabilele "input_file" și, respectiv, "output_file".

2021 - Sumă Gauss2

2023-05-14T18:57:54Z

Csula Beatrice: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/2021/sumagauss2]
== Cerinţa ==
Ana a calculat suma numerelor naturale mai mici sau egale cu '''n''', iar Andreea suma numerelor naturale mai mici sau egale cu '''m'''. Doamna de mate a calculat apoi diferenţa celor două sume şi a obţinut rezultatul '''S'''.

Pentru o valoare '''S''' dată, aflaţi toate perechile '''(n,m)''', cu '''n>m''', scriindu-le în ordine descrescătoare după '''n''' astfel încât doamna de mate să obţină rezultatul '''S'''.

== Date de intrare ==
Fișierul de intrare '''sumagauss2.in''' conține pe prima linie numărul '''S'''.

== Date de ieșire ==
Dacă datele introduse sunt corecte și respectă formatul așteptat, programul va afișa în continuare, pe un rând nou, perechile '''(n,m)''', cu '''n''' > '''m''', în ordine descrescătoare după '''n'''.

În cazul în care datele din fișierul de intrare nu respectă restricțiile impuse programul va afișa pe ecran mesajul "Datele introduse nu corespund cerințelor." și nu va continua cu restul execuției programului.

== Restricţii şi precizări ==
* 1 &les; '''S''' &les; 2.000.000.000

== Exemplul 1 ==
; Intrare
: ''sumagauss2.in''
: 10
; Ieșire
: Datele corespund cerintelor.
: ''sumagauss2.out''
: 10 9
: 4 0
 

== Exemplul 2 ==
; Intrare
: ''sumagauss2.in''
: 10000000000
; Ieșire
: Datele introduse nu corespund cerințelor.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2021
def validate_input(s):
if not 1 <= s <= 2000000000:
print("Datele nu corespund cerintelor.")
exit()

def read_input_file(input_file):
with open(input_file, 'r') as f:
s = int(f.readline().strip())
validate_input(s)
print("Datele corespund cerințelor.")
return s

def write_output_file(output_file, solutions):
with open(output_file, 'w') as f:
for p in solutions:
f.write(f"{p[0]} {p[1]}\n")

def find_solutions(s):
solutions = []
for n in range(s, 0, -1):
sn = n * (n + 1) // 2
for m in range(n):
sm = m * (m + 1) // 2
d = sn - sm
if d == s and n > m:
solutions.append((n, m))
solutions.sort(reverse=True)
return solutions

if __name__ == '__main__':
# Citim numărul S din fișierul de intrare
input_file = 'sumagauss2.in'
s = read_input_file(input_file)

# Găsim toate perechile (n, m) cu diferența dată S
solutions = find_solutions(s)

# Scriem perechile în ordine descrescătoare după n în fișierul de ieșire
output_file = 'sumagauss2.out'
write_output_file(output_file, solutions)

</syntaxhighlight>

== Explicatie rezolvare ==
Acest program are rolul de a găsi toate perechile de numere naturale (n, m) astfel încât diferența dintre suma primelor n numere naturale și suma primelor m numere naturale să fie egală cu un anumit număr S dat.

Funcția "read_input_file" primește ca parametru numele fișierului de intrare și returnează numărul S citit din fișierul respectiv.

Funcția "write_output_file" primește ca parametri numele fișierului de ieșire și o listă de perechi (n, m) și scrie aceste perechi în fișierul de ieșire, fiecare pe o linie separată. Funcția "find_solutions" primește ca parametru numărul S și returnează o listă cu toate perechile (n, m) care îndeplinesc condiția dată, sortate descrescător după n.

În funcția "find_solutions", se parcurg toate numerele naturale de la s până la 1 și se calculează suma primelor n numere naturale pentru fiecare n, apoi se parcurg toate numerele naturale de la 0 până la n-1 și se calculează suma primelor m numere naturale pentru fiecare m.
Se calculează diferența dintre aceste sume și se verifică dacă este egală cu numărul S dat.
Dacă este, perechea (n, m) este adăugată la lista de soluții. La final, lista de soluții este sortată descrescător după n și returnată.

În blocul "if name == 'main'", se citește numărul S din fișierul de intrare, se găsesc toate perechile (n, m) cu diferența dată S folosind funcția "find_solutions", iar apoi se scriu perechile în ordine descrescătoare după n în fișierul de ieșire folosind funcția "write_output_file".
Numele fișierelor de intrare și de ieșire sunt specificate în variabilele "input_file" și, respectiv, "output_file".

2021 - Sumă Gauss2

2023-05-14T18:00:24Z

Csula Beatrice: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/2021/sumagauss2]
== Cerinţa ==
Ana a calculat suma numerelor naturale mai mici sau egale cu '''n''', iar Andreea suma numerelor naturale mai mici sau egale cu '''m'''. Doamna de mate a calculat apoi diferenţa celor două sume şi a obţinut rezultatul '''S'''.

Pentru o valoare '''S''' dată, aflaţi toate perechile '''(n,m)''', cu '''n>m''', scriindu-le în ordine descrescătoare după '''n''' astfel încât doamna de mate să obţină rezultatul '''S'''.

== Date de intrare ==
Fișierul de intrare '''sumagauss2.in''' conține pe prima linie numărul '''S'''.

== Date de ieșire ==
Dacă datele introduse sunt corecte și respectă formatul așteptat, programul va afișa în continuare, pe un rând nou, perechile '''(n,m)''', cu '''n''' > '''m''', în ordine descrescătoare după '''n'''.

În cazul în care datele din fișierul de intrare nu respectă restricțiile impuse programul va afișa pe ecran mesajul "Datele nu corespund restricțiilor impuse." și nu va continua cu restul execuției programului.

== Restricţii şi precizări ==
* 1 &les; '''S''' &les; 2.000.000.000

== Exemplul 1 ==
; Intrare
: ''sumagauss2.in''
: 10
; Ieșire
: Datele corespund cerintelor.
: ''sumagauss2.out''
: 10 9
: 4 0
 

== Exemplul 2 ==
; Intrare
: ''sumagauss2.in''
: 10000000000
; Ieșire
: Datele introduse nu corespund cerințelor.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2021
def validate_input(s):
if not 1 <= s <= 2000000000:
print("Datele nu corespund cerintelor.")
exit()

def read_input_file(input_file):
with open(input_file, 'r') as f:
s = int(f.readline().strip())
validate_input(s)
print("Datele corespund cerințelor.")
return s

def write_output_file(output_file, solutions):
with open(output_file, 'w') as f:
for p in solutions:
f.write(f"{p[0]} {p[1]}\n")

def find_solutions(s):
solutions = []
for n in range(s, 0, -1):
sn = n * (n + 1) // 2
for m in range(n):
sm = m * (m + 1) // 2
d = sn - sm
if d == s and n > m:
solutions.append((n, m))
solutions.sort(reverse=True)
return solutions

if __name__ == '__main__':
# Citim numărul S din fișierul de intrare
input_file = 'sumagauss2.in'
s = read_input_file(input_file)

# Găsim toate perechile (n, m) cu diferența dată S
solutions = find_solutions(s)

# Scriem perechile în ordine descrescătoare după n în fișierul de ieșire
output_file = 'sumagauss2.out'
write_output_file(output_file, solutions)

</syntaxhighlight>

== Explicatie rezolvare ==
Acest program are rolul de a găsi toate perechile de numere naturale (n, m) astfel încât diferența dintre suma primelor n numere naturale și suma primelor m numere naturale să fie egală cu un anumit număr S dat.

Funcția "read_input_file" primește ca parametru numele fișierului de intrare și returnează numărul S citit din fișierul respectiv.

Funcția "write_output_file" primește ca parametri numele fișierului de ieșire și o listă de perechi (n, m) și scrie aceste perechi în fișierul de ieșire, fiecare pe o linie separată. Funcția "find_solutions" primește ca parametru numărul S și returnează o listă cu toate perechile (n, m) care îndeplinesc condiția dată, sortate descrescător după n.

În funcția "find_solutions", se parcurg toate numerele naturale de la s până la 1 și se calculează suma primelor n numere naturale pentru fiecare n, apoi se parcurg toate numerele naturale de la 0 până la n-1 și se calculează suma primelor m numere naturale pentru fiecare m.
Se calculează diferența dintre aceste sume și se verifică dacă este egală cu numărul S dat.
Dacă este, perechea (n, m) este adăugată la lista de soluții. La final, lista de soluții este sortată descrescător după n și returnată.

În blocul "if name == 'main'", se citește numărul S din fișierul de intrare, se găsesc toate perechile (n, m) cu diferența dată S folosind funcția "find_solutions", iar apoi se scriu perechile în ordine descrescătoare după n în fișierul de ieșire folosind funcția "write_output_file".
Numele fișierelor de intrare și de ieșire sunt specificate în variabilele "input_file" și, respectiv, "output_file".

4272 - Prod Pare

2023-05-14T17:56:07Z

Csula Beatrice: /* Exemplul 2 */

Sursa: [https://www.pbinfo.ro/probleme/4272/prodpare]
== Cerinţa ==
Se dă numărul natural nenul '''n'''. Să se determine produsul primelor n numere pare nenule.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de iesire ==
Dacă datele sunt introduse corect, în consolă se va afișa mesajul "Datele introduse corespund cerintelor." și pe rând nou se va afișa produsul rezultat din inmultirea primelor '''n''' numere pare. În caz contrar, se va afișa pe ecran: "Datele introduse nu corespund cerintelor.".

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 10

== Exemplu ==
=== Exemplul 1 ===
; Intrare
: 4
; Ieșire
: Datele introduse corespund cerintelor.
: 384

=== Exemplul 2 ===
; Intrare
: 11
; Ieșire
: Datele introduse nu corespund cerintelor.

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

#4272
def produs_numere_pare(n):
produs = 1

for i in range(2, 2 * n + 1, 2):
produs *= i

print(produs)

def validare_numar(n):
if n < 1 or n > 10:
print("Datele introduse nu corespund cerintelor.")
return False
return True

if __name__ == "__main__":
numar = int(input("Introduceți un număr: "))
if validare_numar(numar):
print("Datele introduse corespund cerintelor.")
produs_numere_pare(numar)

</syntaxhighlight>

== Explicatie rezolvare ==
Acest program calculează produsul numerelor pare de la 2 la 2n, unde n este un număr întreg introdus de utilizator.

Funcția validare_numar(n) verifică dacă numărul introdus de utilizator respectă cerințele, adică să fie între 1 și 10 inclusiv. Dacă numărul nu respectă aceste cerințe, funcția va afișa un mesaj de eroare și va returna False. Dacă numărul este valid, funcția va returna True.

Funcția produs_numere_pare(n) calculează produsul numerelor pare de la 2 la 2n, prin intermediul unui ciclu for. Ciclul pornește de la 2 și se oprește la 2n inclusiv, în pași de 2. La fiecare iterație, valoarea curentă a produsului este înmulțită cu valoarea curentă a variabilei i.

În if __name__ == "__main__": se verifică dacă programul rulează ca script (adică nu a fost importat ca modul). Utilizatorul este invitat să introducă un număr întreg. Dacă numărul respectă cerințele, se afișează un mesaj de confirmare și se calculează produsul numerelor pare de la 2 la 2n prin apelul funcției produs_numere_pare(n).

4272 - Prod Pare

2023-05-14T17:55:22Z

Csula Beatrice: /* Date de iesire */

Sursa: [https://www.pbinfo.ro/probleme/4272/prodpare]
== Cerinţa ==
Se dă numărul natural nenul '''n'''. Să se determine produsul primelor n numere pare nenule.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de iesire ==
Dacă datele sunt introduse corect, în consolă se va afișa mesajul "Datele introduse corespund cerintelor." și pe rând nou se va afișa produsul rezultat din inmultirea primelor '''n''' numere pare. În caz contrar, se va afișa pe ecran: "Datele introduse nu corespund cerintelor.".

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 10

== Exemplu ==
=== Exemplul 1 ===
; Intrare
: 4
; Ieșire
: Datele introduse corespund cerintelor.
: 384

=== Exemplul 2 ===
; Intrare
: 11
; Ieșire
: Datele nu corespund cerintelor.

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

#4272
def produs_numere_pare(n):
produs = 1

for i in range(2, 2 * n + 1, 2):
produs *= i

print(produs)

def validare_numar(n):
if n < 1 or n > 10:
print("Datele introduse nu corespund cerintelor.")
return False
return True

if __name__ == "__main__":
numar = int(input("Introduceți un număr: "))
if validare_numar(numar):
print("Datele introduse corespund cerintelor.")
produs_numere_pare(numar)

</syntaxhighlight>

== Explicatie rezolvare ==
Acest program calculează produsul numerelor pare de la 2 la 2n, unde n este un număr întreg introdus de utilizator.

Funcția validare_numar(n) verifică dacă numărul introdus de utilizator respectă cerințele, adică să fie între 1 și 10 inclusiv. Dacă numărul nu respectă aceste cerințe, funcția va afișa un mesaj de eroare și va returna False. Dacă numărul este valid, funcția va returna True.

Funcția produs_numere_pare(n) calculează produsul numerelor pare de la 2 la 2n, prin intermediul unui ciclu for. Ciclul pornește de la 2 și se oprește la 2n inclusiv, în pași de 2. La fiecare iterație, valoarea curentă a produsului este înmulțită cu valoarea curentă a variabilei i.

În if __name__ == "__main__": se verifică dacă programul rulează ca script (adică nu a fost importat ca modul). Utilizatorul este invitat să introducă un număr întreg. Dacă numărul respectă cerințele, se afișează un mesaj de confirmare și se calculează produsul numerelor pare de la 2 la 2n prin apelul funcției produs_numere_pare(n).

3976 - Prod Impare

2023-05-14T17:52:08Z

Csula Beatrice: /* Exemplul 1 */

Sursa: [https://www.pbinfo.ro/probleme/3976/prodimpare]
== Cerinţa ==
Se dă numărul natural nenul '''n'''. Să se determine produsul primelor '''n''' numere impare.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de iesire ==
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''' numere impare, în caz contrar programul va afișa pe o linie nouă "Datele introduse nu corespund cerințelor".

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 15
== Exemplu ==
=== Exemplul 1 ===
; Intrare
: 4
; Ieșire
: Datele introduse corespund cerințelor.
: 105

=== Exemplul 2 ===
; Intrare
: 0
; Ieșire
: Datele introduse nu corespund cerințelor.
=== Exemplul 3 ===
; Intrare
: 7
; Ieșire
: Datele introduse corespund cerințelor.
: 135135

=== Rezolvare ===
<syntaxhighlight lang="python" line>
#3976
def validare_numar_intreg_pozitiv(mesaj):
while True:
try:
numar = int(input(mesaj))
if numar <= 0:
print("Datele introduse nu corespund cerintelor.")

elif numar > 15:
print("Datele introduse nu corespund cerintelor.")

else:
return numar

except ValueError:
print("Introduceti un numar intreg pozitiv.")

def produs_primelor_n_numere_impare(n):
produs = 1
for i in range(1, 2*n, 2):
produs *= i
return produs

if __name__ == '__main__':
n = validare_numar_intreg_pozitiv("Introduceti un numar natural nenul: ")
produs = produs_primelor_n_numere_impare(n)
print("Datele introduse corespund cerintelor.\n",produs)
</syntaxhighlight>

== Explicatie rezolvare ==
Acest program calculează produsul primelor n numere impare, unde n este un număr natural dat de utilizator. Funcția "validare_numar_intreg_pozitiv(mesaj)" primește un argument "mesaj" care este afișat pentru a îndruma utilizatorul să introducă un număr natural nenul. În cadrul acestei funcții, programul verifică dacă numărul introdus este mai mic sau egal cu 0 sau mai mare decât 15, afișând un mesaj de eroare în caz contrar. Dacă numărul este un număr natural între 1 și 15, acesta este returnat și funcția se termină. În caz contrar, utilizatorul este rugat să introducă un alt număr.

Funcția "produs_primelor_n_numere_impare(n)" primește un argument "n" și calculează produsul primelor n numere impare. Produsul este inițializat cu 1 și apoi, folosind un ciclu for, se calculează produsul valorilor impare din intervalul [1, 2n], adică valorile 1, 3, 5, ..., 2n-1.

În programul principal, utilizatorul este întâi rugat să introducă un număr natural nenul, care este verificat pentru a se asigura că corespunde cerințelor prin intermediul funcției "validare_numar_intreg_pozitiv(mesaj)". Dacă numărul este valid, programul calculează produsul și îl afișează împreună cu un mesaj de confirmare că datele introduse sunt valabile.

2330 - prim023

2023-04-30T15:04:10Z

Csula Beatrice: /* Explicaţie cod */

Sursa: [https://www.pbinfo.ro/probleme/2330/prim023 - prim023]
----
== Cerinţa ==
Dorel a scris un şir format din '''n''' numere naturale nenule. Apoi a luat fiecare subşir şi a calculat produsul termenilor săi. Aflaţi câte dintre produsele efectuate sunt numere prime.
== Date de intrare ==
Fișierul de intrare '''prim023.in''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale nenule separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fișierul de ieșire '''prim023.out''' va conține pe prima linie numărul produselor care sunt numere prime. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''n''' ≤ 5.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1.000.000.000'''
* un subşir conţine cel puţin un termen şi se formează alegând o parte din termenii şirului
== Exemple ==
===Exemplul 1===
; prim023.in
: 3
: 1 2 3
; Ieșire
: Datele sunt corecte.
; prim023.out
: 4
===Exemplul 2===
; prim023.in
: 4
: 13 3123 414 41241
; Ieșire
: Datele sunt corecte.
; prim023.out
: 1
===Exemplul 3===
; prim023.in
: 2
: 314441 41241241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2330 prim023

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

def prim023(vector, n):
with open("prim023.out", "w") as f:
count = 0
for i in range(1 << n):
product = 1
for j in range(n):
if i & (1 << j):
product *= vector[j]
if este_prim(product):
count += 1
f.write(str(count))

def conform_restrictiilor():
with open('prim023.in') as f:
n = int(f.readline())
vector = list(map(int, f.read().split()))
if n > 5000:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
for x in vector:
if x > 1000000000:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return n, vector

if __name__ == '__main__':
n, vector = conform_restrictiilor()
prim023(vector,n)

</syntaxhighlight>

==Explicaţie cod==

Acesta este un program care primește un fișier de intrare și calculează numărul de produse prime ale elementelor din fișierul de intrare.

Funcția '''este_prim''' primește un număr și returnează True dacă numărul este prim și False altfel. Verifică dacă numărul este mai mic sau egal cu 1 și, în caz afirmativ, returnează False. Pentru ceilalți întregi pozitivi, se iterază prin toate numerele de la 2 până la rădăcina pătrată a numărului și se verifică dacă numărul este divizibil cu vreunul dintre acestea. Dacă da, returnează False. În caz contrar, returnează True.

Funcția '''prim023''' primește o listă de numere și numărul de elemente din această listă. Se deschide un fișier de ieșire '''prim023.out'''. Funcția apoi iterează prin toate combinațiile posibile ale elementelor din lista dată și înmulțește elementele care apar în acea combinație. Dacă produsul este prim, numără acest lucru. La sfârșit, numărul de produse prime este scris în fișierul de ieșire.

Funcția '''conform_restrictiilor''' deschide fișierul de intrare '''prim023.in'''. Citeste numărul de elemente din listă și lista de numere din fișier. Verifică dacă numărul de elemente din listă este mai mic sau egal cu 5000 și dacă toate elementele listei sunt mai mici sau egale cu 1000000000. În caz contrar, afișează un mesaj de eroare și iese din program. Dacă datele sunt corecte, funcția returnează numărul de elemente și lista de numere.

În '''main''', se apelează funcția conform_restrictiilor pentru a obține datele din fișierul de intrare și apoi se apelează funcția '''prim023''' pentru a calcula numărul de produse prime și a le scrie în fișierul de ieșire '''prim023.out'''.

2327 - prim997

2023-04-30T15:02:35Z

Csula Beatrice: /* Explicaţie cod */

Sursa: [https://www.pbinfo.ro/probleme/2327/prim997 - prim997]
----
== Cerinţa ==
Se dau '''n''' numere naturale. Pentru fiecare număr '''k''' dat, să se afle cea mai lungă secvenţă de numere naturale consecutive din şirul '''1,2,3,...,k''', astfel încât orice număr din secvenţă să nu fie prim.
== Date de intrare ==
Fișierul de intrare '''prim997.in''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fișierul de ieșire '''prim997.out''' va conține pe linia '''i''', primul număr din secvenţă şi lungimea secvenţei, pentru cel de-al '''i'''-lea număr de pe linia a doua a fişierului de intrare. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''n''' ≤ 100.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''10.000.000'''
* dacă sunt mai multe secvenţe de lungime maximă cu numere consecutive neprime, se va afişa cea cu primul număr din secvenţă minim
== Exemple ==
===Exemplul 1===
; prim997.in
: 3
: 4 11 30
; Ieșire
: Datele sunt corecte.
; prim997.out
: 1 1
: 8 3
: 24 5
===Exemplul 2===
; prim997.in
: 4
: 19 23 410 421
; Ieșire
: Datele sunt corecte.
; prim997.out
: 8 3
: 8 3
: 114 3
: 114 3
===Exemplul 3===
; prim997.in
: 2
: 314441 41241241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2327 prim997

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

def prim997(nums, n):
with open("prim997.out", "w") as f:
for k in nums:
max_len = 0
start_num = 1
current_len = 0
for i in range(1, k+1):
if not este_prim(i):
current_len += 1
else:
if current_len > max_len:
max_len = current_len
start_num = i - current_len
current_len = 0
if current_len > max_len:
max_len = current_len
start_num = k - current_len + 1
f.write(f"{start_num} {max_len}\n")

def conform_restrictiilor():
with open('prim997.in') as f:
n = int(f.readline())
vector = list(map(int, f.read().split()))
if n > 100000:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
for x in vector:
if x > 10000000:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return n, vector

if __name__ == '__main__':
n, vector = conform_restrictiilor()
prim997(vector,n)

</syntaxhighlight>

==Explicaţie cod==

Funcția '''este_prim(n)''' primește un număr întreg '''n''' și returnează True dacă '''n''' este un număr prim, iar False altfel. Algoritmul de verificare a numărului prim verifică dacă '''n''' este mai mic decât 2 și dacă este divizibil cu oricare dintre numerele din intervalul '''[2, sqrt(n)]'''.
Funcția '''prim997(nums, n)''' primește o listă de numere întregi nums și un număr întreg '''n''' și determină pentru fiecare număr din lista '''nums''' cel mai lung subșir format din numere non-prime consecutive. Pentru fiecare număr din listă, se parcurge intervalul '''[1, k]''' și se actualizează variabilele '''max_len''' (lungimea maximă a unui subșir de numere non-prime consecutive), '''start_num''' (primul număr din cel mai lung subșir de numere non-prime consecutive) și '''current_len''' (lungimea curentă a unui subșir de numere non-prime consecutive) în funcție de starea curentă a numărului verificat. La final, se scriu în fișierul '''prim997.out''' valorile găsite pentru fiecare număr din lista '''nums'''.
Funcția '''conform_restrictiilor()''' citește din fișierul '''prim997.in''' un număr întreg '''n''' și o listă de numere întregi vector și verifică dacă acestea respectă restricțiile impuse (n ≤ 10^5, valoarea fiecărui element din vector ≤ 10^7). Dacă datele sunt conforme, funcția returnează cele două variabile citite din fișier.

2325 - prim003

2023-04-30T15:00:45Z

Csula Beatrice: /* Explicaţie cod */

Sursa: [https://www.pbinfo.ro/probleme/2325/prim003 - prim003]
----
== Cerinţa ==
Anul '''2017''' tocmai s-a încheiat, suntem trişti deoarece era număr prim, însă avem şi o veste bună, anul 2018 este produs de două numere prime, '''2''' şi '''1009'''. Dorel, un adevărat colecţionar de numere prime, şi-a pus întrebarea: “Câte numere dintr-un interval [a,b] se pot scrie ca produs de două numere prime? “.
== Date de intrare ==
Programul citește de la tastatură numărul natural '''t''', iar apoi '''t''' perechi de numere naturale '''a,b''' cu '''a≤b''', separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi va afișa pe ecran, pentru fiecare pereche '''a,b''', numărul numerelor din intervalul '''[a,b]''' care se pot scrie ca produs de două numere prime. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''t''' ≤ 100.000
* 1 ≤ '''a, b''' ≤ 1.000.000
== Exemple ==
===Exemplul 1===
; Intrare
: 3
: 1 7
: 10 30
: 88 100
; Ieșire
: Datele sunt corecte.
: 2 7 4
===Exemplul 2===
; Intrare
: 5
: 1 10
: 26 40
: 15 90
: 90 111
: 1431 1530
; Ieșire
: Datele sunt corecte.
: 4 6 25 6 24
===Exemplul 3===
; Intrare
: 2
: 314515341535441 412351541241
: 29 49
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2325 prim003

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

def conform_restrictiilor(vector,t):
for i in range(0, t*2,2):
a = vector[i]
b = vector[i+1]
if a <= 0 or b <= 0 or a > 1000000 or b > 1000000 or a > b or t > 100000 or t < 1:
print("Datele nu sunt conform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
t = int (input())
vector = list()
for _ in range(t):
a , b = map(int,input().split())
vector.append(a)
vector.append(b)
if conform_restrictiilor(vector,t) is True:
for i in range(0, t*2,2):
a = vector[i]
b = vector[i+1]
contor = 0
for numere in range(a, b+1):
for i in range(2, numere):
if este_prim(i) and numere % i == 0 and este_prim(numere // i):
contor += 1
break
print(contor,end=' ')

</syntaxhighlight>

==Explicaţie cod==

Acest cod implementează un program care primește ca intrare un număr întreg '''t''' și apoi '''t''' perechi de numere întregi '''a''' și '''b'''. Programul numără câte perechi de numere primesc un număr compus din produsul a două numere prime. Programul verifică dacă datele de intrare sunt conforme cu restricțiile impuse și afișează un mesaj corespunzător dacă nu sunt. Pentru a verifica dacă un număr este prim, programul utilizează funcția '''este_prim'''.

Funcția '''conform_restrictiilor''' verifică dacă valorile '''a''' și '''b''' din fiecare pereche de numere întregi sunt cuprinse în intervalul [1, 1 000 000], iar dacă '''t''' se află în intervalul [1, 100 000]. Dacă valorile dintr-o pereche de numere sunt în afara intervalului sau '''a''' este mai mare decât '''b''', funcția va returna False și va afișa un mesaj corespunzător.

În funcția '''main''', programul primește datele de intrare sub forma unui număr întreg '''t''' și a unei liste de perechi de numere întregi. Dacă datele sunt conforme cu restricțiile impuse, programul va număra câte perechi de numere primesc un număr compus din produsul a două numere prime folosind un contor și afișează numărul la ieșire.

2533 - SecventaIncadrata

2023-04-30T14:57:50Z

Csula Beatrice: /* Explicaţie cod */

Sursa: [https://www.pbinfo.ro/probleme/2533/secventaincadrata - SecventaIncadrata]
----
== Cerinţa ==
Numim '''secvență încadrată''' a unui șir de numere naturale un subșir al acestuia, format din termeni aflați pe poziții consecutive în șirul dat, subșir care începe și se termină cu aceeași valoare. Lungimea secvenței este egală cu numărul de termeni ai acesteia.

Să se determine secvențele încadrate dintr-un șir, care au lungimea maximă.
== Date de intrare ==
Fișierul de intrare '''secventaincadrata.in''' conține cel puțin '''două''' și cel mult '''106''' numere naturale din intervalul '''[0,9]''', separate printr-un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fișierul de ieșire '''secventaincadrata.out''' va conține pe prima linie numărul '''L''', reprezentând lungimea maximă a secvențelor încadrate, iar pe a doua linie a fișierului valoarea primului termen al fiecărei secvențe încadrate de lungime maximă, în ordine crescătoare și separate printr-un spațiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* în șir există ce puțin doi termeni egali
* proiectați un algoritm eficient din punctul de vedere al timpului de executare și a memoriei utilizate
* se recomandă o soluție care să evite stocarea tuturor valorilor citite într-un tablou sau într-o altă structură de date similară
== Exemple ==
===Exemplul 1===
; secventaincadrata.in
: 3 1 5 2 4 5 5 2 5 9 5 7 4 6 8 0 8
; Ieșire
: Datele sunt corecte.
; secventaincadrata.out
: 9
: 4 5
===Exemplul 2===
; secventaincadrata.in
: 9 0 1 3 4 7 1 8 9 1 3 1 2 3 4 6
; Ieșire
: Datele sunt corecte.
; secventaincadrata.out
: 11
: 3 4
===Exemplul 3===
; secventaincadrata.in
: 314441 41241241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2533 secventaincadrata

def secventaincadrata(vector):
with open("secventaincadrata.out","w") as f:
A = [float('inf')] * 10
lmax = [0] * 10
L = 0
i = 1

for x in vector:
lmax[x] = max(i - A[x] + 1, lmax[x])
if A[x] == float('inf'):
A[x] = i
L = max(lmax[x], L)
i += 1

f.write(str(L) + '\n')
for i in range(10):
if lmax[i] == L:
f.write(str(i) + ' ')
f.write('\n')

def conform_restrictiilor():
with open('secventaincadrata.in') as f:
vector = list(map(int, f.read().split()))
if len(vector) < 2 or len(vector) > 106:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
for x in vector:
if x > 9:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector

if __name__ == '__main__':
vector= conform_restrictiilor()
secventaincadrata(vector)

</syntaxhighlight>

==Explicaţie cod==

cest cod implementează o funcție '''secventaincadrata''' care primește un '''vector''' de numere întregi și calculează lungimea celei mai lungi subsecvențe a vectorului care conține cel puțin două elemente și în care toate elementele sunt identice sau difera cel mult cu o unitate.

De asemenea, programul verifică dacă datele de intrare sunt valide (două sau mai multe elemente, fiecare element să fie un număr întreg între 0 și 9), iar apoi apelează funcția '''secventaincadrata''' cu vectorul de intrare dat.

Funcția '''secventaincadrata''' folosește o listă '''A''' și o listă '''lmax'''. Listele au dimensiunea 10 și reprezintă valori auxiliare folosite în calcularea lungimii subsecvenței cerute.

Pe parcursul parcurgerii vectorului, pentru fiecare element, se calculează lungimea maximă a subsecvenței în care toate elementele sunt identice sau difera cel mult cu o unitate și care se termină cu elementul curent. Aceasta se face folosind formula '''max(i - A[x] + 1, lmax[x])''', unde '''i''' este indicele curent al elementului, '''x''' este valoarea elementului și '''A[x]''' este poziția celui mai recent element cu valoarea '''x'''. De asemenea, se actualizează lista '''A''', astfel încât '''A[x]''' să conțină poziția curentă '''i'''.

La final, programul scrie în fișierul '''secventaincadrata.out''' lungimea celei mai lungi subsecvențe găsite și afișează subsecvențele cu această lungime.

2328 - prim013

2023-04-30T14:56:21Z

Csula Beatrice: /* Explicaţie cod */

Sursa: [https://www.pbinfo.ro/probleme/2328/prim013 - prim013]
----
== Cerinţa ==
Dorel este pasionat de feng shui. Astfel, pentru a-şi crea un cadru adecvat meditaţiei, s-a hotărât să scrie pe pereţii casei numere care au un număr prim de divizori. El a găsit n numere, însă nu ştie să le aleagă pe cele potrivite.
Se dau '''n''' numere naturale. Aflaţi câte dintre acestea au un număr prim de divizori.
== Date de intrare ==
Fișierul de intrare '''prim013.in''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale nenule separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fișierul de ieșire '''prim013.out''' va conține pe prima linie numărul de numere care au un număr prim de divizori. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''n''' ≤ 1.000.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''10.000.000'''
== Exemple ==
===Exemplul 1===
; prim013.in
: 5
: 1 3 6 9 625
; Ieșire
: Datele sunt corecte.
; prim013.out
: 3
===Exemplul 2===
; prim013.in
: 5
: 1 10 12 15 19999
; Ieșire
: Datele sunt corecte.
; prim013.out
: 0
===Exemplul 3===
; prim013.in
: 2
: 314441 41241241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2328 prim013

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

def prim013(n,vector):
numere_cu_divizori_primi = 0
for num in vector:
num_divizori = 0
for i in range(1, num + 1):
if num % i == 0:
num_divizori += 1
if este_prim(num_divizori):
numere_cu_divizori_primi += 1
with open('prim013.out','w') as f:
f.write(str(numere_cu_divizori_primi))

def conform_restrictiilor():
with open('prim013.in') as f:
n = int(f.readline())
vector = list(map(int, f.read().split()))
if n > 1000000:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
for x in vector:
if x > 10000000:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return n , vector

if __name__ == '__main__':
n , vector= conform_restrictiilor()
prim013(n , vector)

</syntaxhighlight>

==Explicaţie cod==

Acest cod implementează o funcție numită '''prim013''', care primește un număr întreg '''n''' și un vector de '''n''' numere întregi '''vector''', și își propune să determine numărul de elemente din vector care au un număr prim de divizori.

Funcția '''este_prim''' este o funcție ajutătoare care primește un număr întreg și returnează adevărat dacă numărul este prim, iar fals în caz contrar.

Funcția '''conform_restrictiilor''' citește datele de intrare din fișierul '''prim013.in''' și verifică dacă acestea respectă restricțiile impuse. În cazul în care datele nu sunt conforme, programul se încheie prin apelarea funcției '''exit()''', iar în cazul în care datele sunt conforme, funcția returnează cele două variabile '''n''' și '''vector'''.

Funcția '''prim013''' parcurge fiecare element din '''vector''' și numără numărul de divizori ai fiecărui element. Dacă numărul de divizori este prim, acesta este adăugat la numărul total de elemente cu număr prim de divizori. Rezultatul este scris în fișierul '''prim013.out'''.

3499 - Secv011

2023-04-30T14:50:39Z

Csula Beatrice: /* Explicaţie cod */

Sursa: [https://www.pbinfo.ro/probleme/3499/secv011 - Secv011]
----
== Cerinţa ==
Se dă un șir '''A''' format din '''n''' elemente din mulțimea '''{0,1}'''. Numim secvență a șirului '''A''' orice succesiune de elemente situate pe poziții consecutive în șir. Numim secvență a șirului '''A''' orice succesiune de elemente situate pe poziții consecutive în șir.
Să se determine numărul de secvențe ale șirului '''A''' ce conțin de două ori mai mulți de '''1''' decât de '''0'''.
== Date de intrare ==
Pe prima linie a fișierului '''secv011.in''' se află numărul '''n'''. Pe următoarea linie se află cele '''n''' elemente ale șirului , separate prin câte un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fișierul de ieșire '''secv011.out''' va conține pe prima linie numărul cerut. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''n''' ≤ 1.000.000
== Exemple ==
===Exemplul 1===
; secv011.in
: 6
: 1 0 1 1 1 0
; Ieșire
: Datele sunt corecte.
; secv011.out
: 4
===Exemplul 2===
; secv011.in
: 10
: 1 0 0 0 1 1 1 0 0 0
; Ieșire
: Datele sunt corecte.
; secv011.out
: 2
===Exemplul 3===
; secv011.in
: 2
: 314441 41241241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0302 Secv011

def secv011(vector,n):
f = open("secv011.out","w")
contor = 0
zero = 0
unu = 0
for i in range(n):
for j in range(i,n):
if vector[j] == 0:
zero += 1
else:
unu +=1
if unu > 1 and unu == 2 * zero:
contor += 1
zero = 0
unu = 0
f.write(str(contor))

def conform_restrictiilor():
with open('secv011.in') as f:
n = int(f.readline().strip())
vector = list(map(int, f.read().split()))
if not 1 <= n <= 100000:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
for x in vector:
if x > 1:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return n, vector

if __name__ == '__main__':
n, vector= conform_restrictiilor()
secv011(vector,n)

</syntaxhighlight>

==Explicaţie cod==

Acesta este un program care citeste un vector de numere intregi din fisierul '''secv011.in''', verifica daca exista secvente de cel putin doua cifre '''1''' consecutive, separate de o secventa de cifre '''0''' si afiseaza numarul total de astfel de secvente in fisierul '''secv011.out'''.

Functia '''conform_restrictiilor()''' citeste datele de intrare din fisierul '''secv011.in''' si verifica daca sunt conforme cu restrictiile impuse. In cazul in care acestea nu sunt conforme, se afiseaza un mesaj de eroare si programul se termina. Daca datele sunt conforme, functia returneaza vectorul '''vector''' si lungimea acestuia '''n'''.

Functia '''secv011(vector, n)''' calculeaza numarul de secvente valide din '''vector'''. Pentru fiecare subsecventa a vectorului, numara cate cifre '''0''' si cate cifre '''1''' sunt prezente si verifica daca exista o secventa de cel putin doua cifre '''1''' consecutive, separate de o secventa de cifre '''0'''. Daca exista, incrementarea contorului '''contor'''. La final, functia afiseaza valoarea contorului in fisierul '''secv011.out'''.

2906 - Potrivire

2023-04-30T14:48:14Z

Csula Beatrice: /* Explicaţie cod */

Sursa: [https://www.pbinfo.ro/probleme/2906/potrivire - Potrivire]
----
== Cerinţa ==
Gigel a găsit un șir de '''n''' cifre minunate. A adormit cu ele în brațe și a visat '''m''' numere naturale. Nedumerit, a cerut părerea vrăjitoarei Ghiocica. Acesta i-a spus:

* - Gigele, ești norocos. Suma numerelor distincte visate care sunt scrise cu cifre consecutive în șirul de cifre minunate este suma pe care o vei câștiga la Loto.

Nerăbdător, Gigel vă roagă să scrieți un program care să citească cele '''n''' cifre și cele '''m''' numere și să determine suma pe care o va câștiga la Loto.
== Date de intrare ==
Fișierul de intrare '''potrivire.in''' conține pe prima linie numărul '''n'''; a doua linie conține șirul de '''n''' cifre. A treia linie conține numărul '''m''', iar a patra linie conține cele '''m''' numere.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fișierul de ieșire '''potrivire.out''' va conține pe prima linie numărul '''S''', reprezentând suma pe care o va câștiga Gigel. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''n, m''' ≤ 100.000
* pentru 50% din teste, 1 ≤ '''n, m''' ≤ 1000
* cele '''m''' numere visate sunt numere naturale și au cel mult cinci cifre
== Exemple ==
===Exemplul 1===
; potrivire.in
: 10
: 4 5 6 2 6 0 7 1 9 7
: 6
: 456 662 2607 2607 97 975
; Ieșire
: Datele sunt corecte.
; potrivire.out
: 3160
===Exemplul 2===
; potrivire.in
: 6
: 1 0 3 1 4 5
: 8
: 111 1231 4124 5741 4124 22 21 12
; Ieșire
: Datele sunt corecte.
; potrivire.out
: 0
===Exemplul 3===
; potrivire.in
: 10
: 4 5 6 2 6 0 7 1 9 7
: 2
: 12414124215 1251251512
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2906 - Potrivire

def potrivire(n, cifre, m, numere_visate):
f = open("potrivire.out", "w")
frecventa = {}
s = 0
for i in range(n):
num = 0
for j in range(i, min(i + 4, n)):
num = num * 10 + cifre[j]
if num not in frecventa:
frecventa[num] = 0
frecventa[num] += 1
for i in range(m):
if numere_visate[i] in frecventa and frecventa[numere_visate[i]] != 0 and frecventa[numere_visate[i]] != -1:
s += numere_visate[i]
frecventa[numere_visate[i]] = -1
f.write(str(s))
f.close()

def conform_restrictiilor():
with open("potrivire.in", "r") as f:
n = int(f.readline())
cifre = list(map(int, f.readline().split()))
m = int(f.readline())
numere_visate = list(map(int, f.readline().split()))
if not (1 <= m <= 100000) and not (1 <= n <= 100000):
print("Datele nu sunt conform restricțiilor impuse.")
exit()
for x in numere_visate:
if x > 100000:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
for x in cifre:
if x >= 10:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return n, cifre, m, numere_visate

if __name__ == '__main__':
n, cifre, m, numere_visate = conform_restrictiilor()
potrivire(n, cifre, m, numere_visate)
</syntaxhighlight>

==Explicaţie cod==

Funcția '''conform_restrictiilor()''' verifică dacă datele de intrare sunt conforme cu restricțiile impuse în problemă, respectiv: '''n''' și '''m''' trebuie să fie între 1 și 100.000, inclusiv, cifre și numere_visate trebuie să conțină numere între 0 și 100.000, inclusiv, iar cifrele din cifre trebuie să fie mai mici decât 10.

Funcția '''potrivire()''' primește ca argumente '''n''', '''cifre''', '''m''' și '''numere_visate''', determină toate numerele care pot fi formate prin combinarea unui subset de cifre consecutive din cifre, și calculează suma tuturor numerelor din numere_visate care se regăsesc printre numerele calculate. Aceasta se realizează prin parcurgerea tuturor subset-urilor de cifre consecutive și adăugarea numerelor rezultate într-un dicționar care memorează frecvența aparițiilor acestora. Apoi, pentru fiecare număr din numere_visate, se verifică dacă acesta se regăsește în dicționar și dacă apare cel puțin o dată și nu a fost deja adăugat la sumă.

La final, suma calculată este scrisă în fișierul '''potrivire.out'''.

3298 - fmi orase2

2023-04-30T14:46:26Z

Csula Beatrice: /* Explicaţie cod */

Sursa: [https://www.pbinfo.ro/probleme/3298/fmi-orase2 - fmi_orase2]
----
== Cerinţa ==
Suntem în anul 2050. Resursele de apă de pe planeta noastră sunt limitate din cauza schimbărilor climatice. Pentru ca toți locuitorii unui oraș să supraviețuiască în cazul unei catastrofe, orașul trebuie să aibă o rezervă de cel puțin '''1 km^3''' de apă. Pentru a face față mai ușor unor catastrofe, orașele pot forma alianțe în care se pot împrumuta reciproc cu apă. Astfel, într-o alianță formată din '''h''' orașe, fiecare oraș trebuie să aibă o rezervă de cel puțin '''h km^3''' de apă (pentru a putea supraviețui toți locuitorii săi și a putea să împrumute cu câte '''1 km^3''' de apă fiecare dintre celelalte '''h - 1''' orașe aliate).

Fiind dat numărul '''m''' de orașe și un șir de '''m''' numere naturale strict pozitive, notate cu '''c[1] c[2] ... c[m]''', unde fiecare număr '''c[i]''' reprezintă capacitatea maximă de stocare a orașului '''i''', să se determine numărul maxim de orașe '''h''' care pot forma o alianță, adică există cel puțin '''h''' orașe care pot reține fiecare o cantitate de apă cel puțin egală cu '''h km^3'''.
== Date de intrare ==
Fișierul de intrare '''fmi_orase2.in''' conține pe prima linie numărul '''m''', iar pe a doua linie '''m''' numere naturale separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fișierul de ieșire '''fmi_orase2.out''' va conține pe prima linie numărul '''h''', reprezentând cel mai mare număr de orașe care se pot alia. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''m''' ≤ 100
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1.000'''
== Exemple ==
===Exemplul 1===
; fmi_orase2.in
: 5
: 3 1 6 1 5
; Ieșire
: Datele sunt corecte.
; fmi_orase2.out
: 3
===Exemplul 2===
; fmi_orase2.in
: 5
: 7 81 2 3 4
; Ieșire
: Datele sunt corecte.
; fmi_orase2.out
: 4
===Exemplul 3===
; fmi_orase2.in
: 2
: 314441 41241241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3298 - fmi orase2

def orase(vector,m):
f = open("fmi_orase2.out", "w")
vector.sort(reverse=True)
h = 0
for i in range(m):
h += 1
if h >= vector[i]:
break
f.write(str(h))

def conform_restrictiilor():
with open("fmi_orase2.in", "r") as f:
m = int(f.readline())
vector = list(map(int, f.readline().split()))
if not (1 <= m <= 100):
print("Datele nu sunt conform restricțiilor impuse.")
exit()
for x in vector:
if x >= 1000:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector, m

if __name__ == '__main__':
vector , m = conform_restrictiilor()
orase(vector , m)

</syntaxhighlight>

==Explicaţie cod==

Acesta este un cod care citeste date dintr-un fisier de intrare '''fmi_orase2.in''' si afiseaza rezultatul in alt fisier '''fmi_orase2.out'''. Codul verifica daca datele citite sunt in limitele permise si daca sunt corecte.

Functia '''conform_restrictiilor''' citeste datele din fisier si verifica daca sunt in limitele permise. Daca datele sunt in limitele permise, aceasta returneaza o lista cu numerele citite si numarul de orase '''m'''.

Functia '''orase''' sorteaza lista cu numerele citite in ordine descrescatoare, calculeaza suma tuturor oraselor incepand cu orasul cu populatia maxima, si scrie aceasta suma in fisierul de iesire '''fmi_orase2.out'''.

In final, programul principala citeste datele, verifica daca sunt in limitele permise, si daca acestea sunt corecte, calculeaza si scrie rezultatul in fisierul de iesire.

3790 - subsets

2023-04-30T14:43:41Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/3790/subsets - subsets]
----
== Cerinţa ==
Se dă șirul '''a1, a2, …, an''' de numere naturale nenule distincte. Vrem să alegem trei submulțimi '''X, Y și Z''' cu proprietățile:

* submulțimile sunt nevide
* orice element din șir aparține cel mult unei submulțimi
* cele trei submulțimi au suma elementelor identică

De exemplu, dacă '''a = (1,2,3,4,5,6)''', atunci putem alege submulțimile: '''X={1,4}, Y={2,3}, Z={5}'''. Se observă că au toate suma elementelor egală cu 5 și că 6 nu apare în niciuna din submulțimi. O altă alegere este '''X={1,6}, Y={2,5}, Z={3,4}''' și în acest caz toate submulțimile au suma 7 și toate elementele șirului aparțin uneia dintre submulțimi.

Reținem faptul că ordinea elementelor într-o submulțime nu contează, deci '''X={1,4}''' este totuna cu '''X={4,1}'''. De asemenea, ordinea celor trei submulțimi nu contează, adică de exemplu '''X={1,4}, Y={2,3}, Z={5}''' înseamnă același triplet cu '''X={2,3}, Y={1,4}, Z={5}'''.

Să se determine numărul tripletelor de submulțimi care îndeplinesc proprietățile.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' cele numere naturale '''a1, a2, …, an''', separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi va afișa pe ecran numărul tripletelor de submulțimi. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 3 ≤ '''n''' ≤ 10
* cele n numere din șir vor fi nenule, distincte două câte două și mai mici decât '''100'''
== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 1 2 3 4 5 6
; Ieșire
: Datele sunt corecte.
: 3
===Exemplul 2===
; Intrare
: 5
: 1 2 3 4 7
; Ieșire
: Datele sunt corecte.
: 0
===Exemplul 3===
; Intrare
: 2
: 314515341535441 412351541241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3790 - subsets

def numara_tripleturi(n, vector):
def verifica_suma_egala(submultimi):
sume = []
for submultime in submultimi:
sume.append(sum(submultime))
return len(set(sume)) == 1

def backtracking(index, submultimi):
nonlocal numar
if index == n:
if len(submultimi[0]) > 0 and len(submultimi[1]) > 0 and len(submultimi[2]) > 0 and verifica_suma_egala(submultimi):
numar += 1
return
for i in range(3):
submultimi[i].append(vector[index])
backtracking(index + 1, submultimi)
submultimi[i].pop()

numar = 0
submultimi = [[], [], []]
backtracking(0, submultimi)
return numar // 2

def conform_restrictiilor(n,vector):
if not 3 <= n <= 10:
print("Datele nu sunt conform restricțiilor impuse.")
return False
for x in vector:
if x > 100 or x == 0:
print("Datele nu sunt conform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
if conform_restrictiilor(n,vector) is True:
rezultat = numara_tripleturi(n,vector)
print(rezultat)

</syntaxhighlight>

==Explicaţie cod==

Funcția '''verifica_suma_egala''' primește o listă de submulțimi și verifică dacă suma elementelor din fiecare submulțime este aceeași. Pentru a face acest lucru, se calculează suma elementelor din fiecare submulțime, aceste sume fiind stocate într-o listă. Dacă această listă conține un singur element, înseamnă că suma elementelor din toate cele trei submulțimi este egală.

Funcția '''backtracking''' primește un index și o listă de submulțimi și generează toate tripleturile posibile de submulțimi care îndeplinesc criteriile impuse. Algoritmul de '''backtracking''' adaugă elemente în submulțimi în mod recursiv, începând cu primul element din '''vector''', și verifică dacă suma elementelor din fiecare submulțime este egală. Dacă această condiție este îndeplinită pentru toate cele trei submulțimi, se incrementează numărul de tripleturi găsite.

Funcția '''numara_tripleturi''' inițializează o listă vidă pentru fiecare submulțime și apelează funcția '''backtracking''' pentru a genera toate tripleturile de submulțimi. Numărul de tripleturi găsite este returnat împărțit la 2 pentru a elimina duplicatele, deoarece un triplet de submulțimi poate fi reprezentat într-un mod diferit (fiecare submulțime poate fi permutată).

Funcția '''conform_restrictiilor''' verifică dacă datele de intrare sunt conforme cu restricțiile impuse și returnează True dacă acest lucru este adevărat. Datele de intrare trebuie să aibă o dimensiune cuprinsă între 3 și 10, inclusiv, iar fiecare element din vector trebuie să fie mai mic sau egal cu 100 și diferit de 0.

2329 - prim007

2023-04-30T14:41:01Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/2329/prim007 - prim007]
----
== Cerinţa ==
Se dă un șir '''a1, a2, …, an''' format din '''n''' numere naturale. Determinați numărul de perechi de elemente din șir '''(ai,aj)''' cu '''i < j''', care au suma număr prim.
== 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 ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi va afișa pe ecran numărul rezultatelor care sunt numere prime. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 2 ≤ '''n''' ≤ 100.000
* elementele șirului vor fi mai mici decât '''10.000'''
== Exemple ==
===Exemplul 1===
; Intrare
: 3
: 2 5 9
; Ieșire
: Datele sunt corecte.
: 2
===Exemplul 2===
; Intrare
: 5
: 16 7 90 19 82
; Ieșire
: Datele sunt corecte.
: 5
===Exemplul 3===
; Intrare
: 2
: 314515341535441 412351541241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2329 prim007

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

def prim007(n,vector):
count = 0
for i in range(n):
for j in range(i+1, n):
if este_prim(vector[i] + vector[j]):
count += 1
print(count)

def conform_restrictiilor(n,vctor):
if not 2 <= n <= 100000:
print("Datele nu sunt conform restricțiilor impuse.")
return False
for x in vector:
if x > 10000:
print("Datele nu sunt conform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
if conform_restrictiilor(n,vector) is True:
prim007(n,vector)

</syntaxhighlight>

==Explicaţie cod==

Functia '''este_prim(n)''' - Verifica daca un numar este prim sau nu. Daca numarul este mai mic decat 2, functia va returna False, altfel, va verifica daca numarul are un divizor in intervalul '''[2, sqrt(n)]'''. Daca il gaseste, functia va returna False, altfel, va returna True.

Functia '''prim007(n, vector)''' - Primeste un numar '''n''' si un vector de numere '''vector'''. Functia itereaza prin toate perechile de numere din '''vector''', calculeaza suma lor si verifica daca suma este un numar prim prin apelarea functiei '''este_prim(n)'''. Daca suma este un numar prim, va incrementa un contor. La final, functia va afisa valoarea contorului.

Functia '''conform_restrictiilor(n, vector)''' - Verifica daca valorile primite ca input respecta restrictiile impuse de problema. Verifica daca '''n''' este intre 2 si 100000, iar valorile din vector sunt mai mici sau egale cu 10000. Daca valorile respecta restrictiile, functia va returna True, altfel, va afisa un mesaj de eroare si va returna False.

In functia '''main''', programul primeste input-ul, verifica daca acesta respecta restrictiile impuse prin apelarea functiei '''conform_restrictiilor(n, vector)''' si, daca este cazul, calculeaza si afiseaza numarul de perechi de numere din '''vector''' a caror suma este un numar prim prin apelarea functiei '''prim007(n, vector)'''.

3278 - AproapePrime

2023-04-30T14:37:00Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/3278/aproapeprime - AproapePrime]
----
== Cerinţa ==
Spunem că un număr natural este '''aproape prim''' dacă el poate fi scris ca produs de două numere prime. De exemplu 6 și 25 sunt aproape prime pentru că 6 = 2 * 3, iar 25 = 5 * 5. Considerăm șirul crescător al numerelor naturale aproape prime: 4, 6, 9, 10, 14, 15, 21, … Acestora li se asociază câte un număr de ordine, numerotarea începând cu '''1'''. Deci 4 este primul număr aproape prim, 6 este al doilea număr, 9 este al treilea etc.
Dat un număr natural '''N''', să se determine al '''N'''-lea număr aproape prim.
== Date de intrare ==
Programul citește de la tastatură numărul '''N'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa pe ecran un singur număr natural, reprezentând al '''N'''-lea număr aproape prim. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''N''' ≤ 23.378
== Exemple ==
===Exemplul 1===
; Intrare
: 4
; Ieșire
: Datele sunt corecte.
: 10
===Exemplul 2===
; Intrare
: 5
; Ieșire
: Datele sunt corecte.
: 14
===Exemplul 3===
; Intrare
: 314515341535441
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3278 AproapePrim

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

def aproape_prim(N):
contor = 0
i = 2
while True:
if contor == N:
return i-1
if este_prim(i):
i += 1
continue
for j in range(2, int(i ** 0.5) + 1):
if i % j == 0 and este_prim(j) and este_prim(i // j):
contor += 1
break
i += 1

def conform_restrictiilor():
if not 1 <= N <= 23378:
print("Datele nu sunt conform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
N = int(input())
if conform_restrictiilor(N) is True:
print(aproape_prim(N))

</syntaxhighlight>

==Explicaţie cod==
Funcția '''este_prim(n)''' primește un număr întreg '''n''' și returnează '''True''' dacă acesta este prim și '''False''' altfel. Ea verifică dacă numărul este mai mic decât 2 (în acest caz, nu este prim) și apoi verifică dacă există vreun divizor între 2 și radicalul pătrat al lui '''n''' (inclusiv) care îl divide pe '''n'''. Dacă există, numărul nu este prim.

Funcția '''aproape_prim(N)''' primește un număr întreg '''N''' și returnează al '''N'''-lea număr aproape prim din șirul de numere aproape prime. Ea inițializează un contor de indexare cu 0 și i cu 2. Apoi, începe să itereze prin numerele naturale, verificând dacă fiecare număr este aproape prim. Dacă un număr este prim, continuă iterația cu următorul număr, astfel încât numai numerele compuse sunt testate pentru a fi aproape prime. Pentru a verifica dacă un număr este aproape prim, programul încearcă să îl descompună în factori primi și să verifice dacă ambele sunt prime. Dacă da, crește contorul cu 1 și trece la următorul număr. Când contorul ajunge la '''N''', programul returnează ultimul număr testat minus 1, deoarece ultimul număr a fost al '''N'''-lea număr aproape prim.

Funcția '''conform_restrictiilor(N)''' primește noul număr întreg '''N''' ca si parametru și verifică dacă este între 1 și 23378, conform restricțiilor impuse. Dacă nu este, afișează un mesaj de eroare și se returneaza False. Dacă este corect, afișează un mesaj de confirmare și returnează True.

În funcția principală, programul citește '''N''' iar daca functia '''conform_restrictiilor(N)''' este True atunci se apelează funcția '''aproape_prim(N)''' și afișează rezultatul returnat.

3460 - FirstPrime

2023-04-30T14:33:43Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/3460/firstprime - FirstPrime]
----
== Cerinţa ==
Se dau '''n''' numere naturale. Definim '''FP(x)''' cel mai mic număr prim care îl divide pe '''x'''. Aflați suma '''FP'''-urilor celor '''n''' numere.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi va afișa pe ecran numărul '''S'''. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 2 ≤ '''n''' ≤ 1.000.000
* cele '''n''' numere citite vor fi mai mici decât '''100.000.000'''
== Exemple ==
===Exemplul 1===
; Intrare
: 4
: 2 13 9 25
; Ieșire
: Datele sunt corecte.
: 23
===Exemplul 2===
; Intrare
: 5
: 16 7 90 19 82
; Ieșire
: Datele sunt corecte.
: 32
===Exemplul 3===
; Intrare
: 2
: 314515341535441 412351541241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3460 FirstPrime

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

def fp(x):
if x < 2:
return 0
for i in range(2, int(x ** 0.5) + 1):
if x % i == 0:
return i if este_prim(i) else 0
return x

def conform_restrictiilor(vector , n):
if not 2 <= n <= 1000000:
print("Datele nu sunt conform restricțiilor impuse.")
return False
for x in vector:
if x > 100000000:
print("Datele nu sunt conform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
if conform_restrictiilor(vector , n) is True:
suma_fp = sum(fp(x) for x in vector)
print(suma_fp)

</syntaxhighlight>

==Explicaţie cod==
Funcția '''este_prim(n)''' primește un număr întreg pozitiv '''n''' și returnează '''True''' dacă '''n''' este prim și '''False''' în caz contrar. Implementarea folosește o metodă eficientă de verificare a primalității care verifică toți divizorii numărului '''n''' până la radicalul pătrat din '''n'''.

Funcția '''fp(x)''' primește un număr întreg pozitiv '''x''' și returnează cel mai mic număr prim care îl divide pe '''x''' sau '''0''' dacă '''x''' este mai mic decât '''2''' sau nu are divizori primi.

Funcția '''conform_restrictiilor(vector , n)''' primește două argumente, un vector de numere întregi și un număr întreg n. Mai întâi, funcția verifică dacă n este între 2 și 1.000.000, iar dacă nu, afișează un mesaj de eroare și returnează False. Apoi, pentru fiecare element din vector, funcția verifică dacă este mai mic sau egal cu 100.000.000. Dacă se găsește un element care depășește această limită, funcția afișează un mesaj de eroare și returnează False.

Dacă toate verificările sunt trecute cu succes, funcția afișează un mesaj de confirmare și returnează True.

În programul principal, citim numărul '''n''' și cele '''n''' numere naturale de la tastatură, stocate în lista numere. Se apeleaza apoi functia '''conform_restrictiilor(vector , n)''' iar daca se returneaza True, se continua.
Pentru a calcula suma '''FP'''-urilor celor '''n''' numere, iterăm prin lista numere și pentru fiecare element apelăm funcția '''fp(x)''' pentru a determina cel mai mic număr prim care îl divide pe '''x'''. Suma acestor valori este stocată în variabila '''suma_fp'''.
La final, afișăm valoarea variabilei '''suma_fp'''.

2576 - Ciurul Lui Eratosthenes

2023-04-30T14:27:06Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/2576/ciurul-lui-eratosthenes - Ciurul Lui Eratosthenes]
----
== Cerinţa ==
Să se afișeze numerele prime de la '''1''' la '''n'''.
== Date de intrare ==
Se citește numărul '''n'''.
== Date de ieșire ==
Se vor afișa numerele prime de la '''1''' la '''n''', în ordine crescătoare,separate printr-un spațiu iar pe ecran se va afisa "Datele sunt corecte.". Daca n = 1 se va afisa pe un rand nou "Nu exista numere prime mai mici decat 2.". In caz contrar, se va afisa "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''n''' ≤ 1.000.000
== Exemple ==
===Exemplul 1===
; Intrare
: 30
; Ieșire
: Datele sunt corecte.
: 2 3 5 7 11 13 17 19 23 29
===Exemplul 2===
; Intrare
: 1
; Ieșire
: Datele sunt corecte.
;Explicație
: Nu exista numere prime mai mici decat 1.
===Exemplul 3===
; Intrare
: 154242352352
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2576 Ciurul Lui Eratosthenes
def ciur(n):
if n < 2:
print("Nu exista numere prime mai mici decat 2.")
else:
prime = []
for i in range(2, n+1):
e_prim = True
for j in range(2, int(i ** 0.5) + 1):
if i % j == 0:
e_prim = False
break
if e_prim:
prime.append(i)
print(*prime)

def conform_restrictiilor(n):
if n > 1000000 or n < 1:
print("Datele nu sunt comform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
n = int(input())
if conform_restrictiilor(n) is True:
ciur(n)

</syntaxhighlight>

==Explicaţie cod==
Funcția '''conform_restrictiilor()''' primeste ca si parametru un numar intreg '''n''' și verifică dacă acesta respectă restricțiile impuse: trebuie să fie între '''1''' și '''1.000.000'''. Dacă datele sunt conforme, se afiseaza mesajul de confrimare si se returneaza True.

Funcția '''ciur(n)''' primește ca argument un număr întreg '''n'''. Această funcție determină toate numerele prime mai mici sau egale cu '''n''', utilizând algoritmul '''Ciurul lui Eratostene'''. În această implementare, se initializează o listă vidă prime pentru a stoca numerele prime. Se iterează prin fiecare număr întreg de la 2 până la '''n''' și pentru fiecare număr se verifică dacă este prim sau nu, utilizând un al doilea for care merge de la 2 până la radicalul pătrat din i (care este cel mai mare divizor posibil). Dacă numărul i este divizibil cu un alt număr întreg în intervalul [2, radicalul pătrat din i], atunci nu este prim și se trece la următorul număr. Dacă numărul i trece prin această verificare, atunci este adăugat în lista prime. La final, funcția afișează lista prime, folosind * pentru a extrage toate elementele acesteia.

În secțiunea '''if __name__ == '__main__':''', se citeste mai întâi numarul '''n''' iar apoi se verifica daca funcția '''conform_restrictiilor(n)''' este conforma restricțiilor. Apoi, se apelează funcția '''ciur(n)''' pentru a determina și afișa toate numerele prime mai mici sau egale cu '''n'''.

3737 - SecvEgale1 v2

2023-04-30T14:24:50Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/3737/secvegale1-v2 - SecvEgale1 v2]
----
== Cerinţa ==
Se dă un vector cu '''n''' elemente, numere naturale. Determinați cea mai lungă secvență de elemente din vector care începe și se termină cu aceeași valoare. Dacă în vector există mai multe secvențe corecte de lungime maximă se va determina cea mai din stânga.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi va afișa pe ecran indicii '''st dr''' ai capetelor secvenței determinate, separați printr-un spațiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''n''' ≤ 1.000.000
* cele '''n''' numere citite vor fi mai mici decât '''1.000.000'''
* indexarea elementelor vectorului începe de la 1.
== Exemple ==
===Exemplul 1===
; Intrare
: 12
: 6 6 8 3 6 6 3 8 4 3 3 4
; Ieșire
: Datele sunt corecte.
: 4 11
===Exemplul 2===
; Intrare
: 7
: 1 2 3 4 1 7 8
; Ieșire
: Datele sunt corecte.
: 1 5
===Exemplul 3===
; Intrare
: 2
: 314441 41241241
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3737

def secvente(vector, n):
lungime_maxima=0
st = 0
dr = 0
for i in range(n):
for j in range(i+1 , n+1):
if vector[i] == vector [j-1] and j - i > lungime_maxima:
lungime_maxima = j-i
st = i
dr = j-1
print(st+1, dr+1)

def conform_restrictiilor(n, vector):
if n > 1000000 or n < 1:
print("Datele nu sunt comform restricțiilor impuse.")
return False
for x in vector:
if x > 1000000 or x < 0:
print("Datele nu sunt comform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
n=int(input())
vector = list(map(int,input().split()))
if conform_restrictiilor(n, vector) is True:
secvente(vector, n)

</syntaxhighlight>

==Explicaţie cod==

Funcția '''secvente()''' primește vectorul '''vector''' și numărul de elemente din vector '''n'''. Acestă funcție calculează cea mai lungă secvență de elemente din '''vector''' care începe și se termină cu aceeași valoare. Inițial, variabilele '''lungime_maxima''', '''st''' și '''dr''' sunt inițializate cu 0. Două bucle for sunt utilizate pentru a itera prin toate elementele vectorului și pentru a găsi secvențele de lungime maximă. Când sunt găsite două elemente consecutive egale, se calculează lungimea secvenței, iar dacă aceasta este mai mare decât '''lungimea maximă''' găsită anterior, atunci variabilele '''st''' și '''dr''' sunt actualizate cu indicii elementelor de început și de sfârșit ai secvenței. Indicii afișați sunt incrementați cu 1 pentru a corespunde indexării elementelor în program, care începe de la 1, nu de la 0.
Funcția '''conform_restrictiilor''' primește un numar '''n''' și o listă '''vector''' și verifică dacă sunt respectate restricțiile problemei (0 < '''n''' < 1000000, 0 ≤ '''vector[i]''' ≤ 1000000 pentru fiecare '''i''' în [0, n)). Dacă restricțiile nu sunt respectate, funcția afișează un mesaj de eroare și returnează False; în caz contrar, afișează un mesaj de confirmare și returnează True.

În blocul '''__name__ == '__main__'''', programul citește dimensiunea și secvența de la intrare folosind '''input()''' și '''map()'''. Apoi verifică dacă restricțiile sunt respectate utilizând funcția '''conform_restrictiilor'''. Dacă restricțiile sunt respectate, funcția secvente este apelată cu '''vector''' și '''n''' ca argumente.

3324 - Eratostene0

2023-04-30T14:18:52Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/3324/eratostene0 - Eratostene0]
----
== Cerinţa ==
Se dau '''n''' perechi de numere naturale '''(i, j)''', cu '''i ≤ j'''. Pentru fiecare pereche trebuie să aflați '''suma''' divizorilor tuturor numerelor din șirul i, i + 1, ..., j.
== Date de intrare ==
Fișierul de intrare '''eratostene0.in''' conține pe prima linie numărul '''n''', iar pe următoarele n linii câte două numere naturale i(1) j(1), i(2) j(2), …, i(n) j(n).
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieșire '''eratostene0.out''' va conține '''n''' linii, pe fiecare linie L, L = 1..n, aflându-se un singur număr natural reprezentând suma divizorilor tuturor numerelor corespunzătoare perechii '''i(L) j(L)'''. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''n''' ≤ 200.000
* 1 ≤ '''i''' ≤ '''j''' ≤ 1.000.000
== Exemple ==
===Exemplul 1===
; eratostene0.in
: 4
: 1 6
: 3 7
: 2 5
: 8 8
; Ieșire
: Datele sunt corecte.
; eratostene0.out
: 33
: 37
: 20
: 15
===Exemplul 2===
; eratostene0.in
: 3
: 2 4
: 10 20
: 40 90
; Ieșire
: Datele sunt corecte.
; eratostene0.out
: 14
: 270
: 5481
===Exemplul 3===
; eratostene0.in
: 2
: 191824719471 19991
: 120 200
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3324 Eratostene0

def eratostene(vector, n):
suma = 0
f = open("eratostene0.out", "w")
for k in range(0, n * 2, +2):
suma = 0
i = vector[k]
j = vector[k + 1]
for numar in range(i, j + 1):
divizor = 1
while divizor <= numar:
if numar % divizor == 0:
suma += divizor
divizor += 1
f.write(str(suma) + "\n")

def conform_restrictiilor():
vector = list()
with open('eratostene0.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() == True:
vector.append(int(c))
n = vector[0]
vector = vector[1:]
if n > 200000 and n < 1:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector, n

if __name__ == '__main__':
vector, n = conform_restrictiilor()
eratostene(vector, n)

</syntaxhighlight>
==Explicaţie cod==

Acest cod calculează suma divizorilor pentru intervale de numere date în fișierul '''eratostene0.in''' și scrie sumele corespunzătoare în fișierul '''eratostene0.out'''.

Funcția '''conform_restrictiilor()''' citeste datele din fișier și verifică dacă sunt în limitele impuse de restricțiile problemei. Apoi, returnează numerele citite din fișier într-un vector și numărul de intervale de numere.

Funcția '''eratostene()''' primește vectorul și numărul de intervale de numere ca parametri. Apoi, pentru fiecare interval de numere, calculează suma divizorilor pentru fiecare număr în interval și o scrie în fișierul de ieșire.

Spre deosebire de numărul prim, suma divizorilor unui număr nu poate fi determinată cu un algoritm eficient. De aceea, se verifică fiecare divizor de la 1 la numărul în cauză și se adaugă la suma dacă divizează numărul.

0303 - Eratostene

2023-04-30T14:17:06Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/303/eratostene - Eratostene]
----
== Cerinţa ==
Se dau '''n''' numere naturale mai mici decât '''1.000.000'''. Determinaţi câte dintre ele sunt prime.
== Date de intrare ==
Fişierul de intrare '''eratostene.in''' conţine pe prima linie numărul '''n'''; urmează cele '''n''' numere, dispuse pe mai multe linii şi separate prin spaţii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieşire '''eratostene.out''' va conţine pe prima linie numărul '''C''', reprezentând numărul valorilor citite care erau numere prime. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ n ≤ 1.000.000
== Exemple ==
===Exemplul 1===
; eratostene.in
: 6
: 12 18 19 25 29 7
; Ieșire
: Datele sunt corecte.
; eratostene.out
: 3
===Exemplul 2===
; eratostene.in
: 3
: 100 102 104
; Ieșire
: Datele sunt corecte.
; eratostene.out
: 0
===Exemplul 3===
; eratostene.in
: 3
: 191824719471 19991 19724174
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0303 Eratostene

def eratostene(vector, n):
C = 0
for i in range(n):
numar = vector[i]
if numar == 2:
C += 1
divizor = 3
while divizor * divizor <= numar:
if numar % divizor == 0 or numar%2==0:
break
divizor += 2
if divizor ** 2 > numar:
C += 1
f = open("eratostene.out", "w")
f.write(str(C))

def conform_restrictiilor():
vector = list()
with open('eratostene.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() == True:
vector.append(int(c))
n = vector[0]
vector = vector[1:]
if n > 1000000 and n < 1:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector, n

if __name__ == '__main__':
vector, n = conform_restrictiilor()
eratostene(vector, n)

</syntaxhighlight>
==Explicaţie cod==

Acest cod implementează Ciurul lui Eratostene, un algoritm folosit pentru a găsi toate numerele prime până la un anumit număr dat '''n'''.

Funcția '''conform_restrictiilor''' verifică dacă datele de intrare respectă condițiile impuse și returnează vectorul de numere și '''n'''.

Funcția '''eratostene''' primește vectorul de numere și '''n''', parcurge vectorul și pentru fiecare număr verifică dacă este prim folosind Ciurul lui Eratostene. Se verifică dacă numărul este 2, în caz contrar se începe căutarea divizorilor de la 3. Dacă numărul este divizibil cu un număr impar sau cu 2, se trece la următorul număr. În caz contrar, se continuă căutarea divizorilor până la radicalul numărului. Dacă numărul este prim, se adaugă 1 la variabila '''C'''. La final se scrie rezultatul în fișierul '''eratostene.out'''.

În general, este important să se verifice condițiile impuse înainte de procesarea datelor pentru a preveni erori și pentru a se asigura că datele sunt valide.

0607 - Asfalt

2023-04-30T14:14:37Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/?pagina=probleme&id=607 - Asfalt]
----
== Cerinţa ==
S-a hotărât asfaltarea șoselei care unește orașul '''A''' de orașul '''B'''. Lungimea acestei șosele este de '''n''' kilometri. De-a lungul șoselei sunt instalate borne, distanța dintre ele fiind de un kilometru; prima bornă este numerotată cu 0, iar ultima cu n. La asfaltarea șoselei participă '''m''' firme, fiecare firmă dorind să asfalteze o porțiune de șosea cuprinsă între doua borne date.

Gigel, conducătorul operațiunilor de asfaltare, dorește să afle dacă cele '''m''' firme vor asfalta toată șoseaua și dacă există părți ale șoselei care ar urma să fie asfaltate de mai multe firme.
== Date de intrare ==
Fișierul de intrare '''asfalt.in''' conține pe prima linie numerele '''n m''', reprezentând lungimea șoselei și numărul de firme participante. Următoarele '''m''' linii conțin câte două numere '''x y''' – firma curentă dorește să asfalteze șoseaua între borna numerotată cu '''x''' și cea numerotată cu '''y'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieșire '''asfalt.out''' va conține pe prima linie două numere '''A B''', separate prin exact un spațiu, reprezentând numărul de kilometri de șosea care ar rămâne neasfaltați și numărul de kilometri de șosea care ar fi asfaltați de mai multe firme. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ n ≤ 10000
* 1 ≤ m ≤ 1000
* 1 ≤ x < y ≤ n
== Exemple ==
===Exemplul 1===
; asfalt.in
: 10 4
: 5 8
: 0 3
: 1 4
: 6 10
; Ieșire
: Datele sunt corecte.
; asfalt.out
: 1 4
===Exemplul 2===
; asfalt.in
: 10 5
: 1 2
: 3 8
: 9 10
: 8 9
: 2 6
; Ieșire
: Datele sunt corecte.
; asfalt.out
: 2 3
===Exemplul 3===
; asfalt.in
: 10 3
: 1 21
: 3 831
: 9 130
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0607 Asfalt

def asfalt(vector, n):
vector_verificare = [0] * n
for i in range(0, len(vector), +2):
x = vector[i]
y = vector[i + 1]
for j in range(x, y):
vector_verificare[j] += 1
A = 0
B = 0
for valoare in vector_verificare:
if valoare == 0:
A += 1
elif valoare > 1:
B += 1
f = open("asfalt.out", "w")
line = [str(A), " ", str(B)]
f.writelines(line)

def conform_restrictiilor():
vector = list()
with open('asfalt.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() == True:
vector.append(int(c))
n = vector[0]
m = vector[1]
vector = vector[2:]
if n > 10000 and n < 1 or m > 1000 and m < 1:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > n:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector, n

if __name__ == '__main__':
vector, n = conform_restrictiilor()
asfalt(vector, n)

</syntaxhighlight>
==Explicaţie cod==

Acesta este un program care primește datele dintr-un fișier de intrare, verifică dacă respectă restricțiile impuse și apoi procesează acele date și scrie rezultatul într-un fișier de ieșire.

Funcția '''conform_restrictiilor''' citește datele din fișierul de intrare și verifică dacă valorile introduse sunt valide, respectând restricțiile impuse. Aceasta întoarce un vector și lungimea acestuia.

Funcția '''asfalt''' primește ca parametri vectorul și lungimea acestuia și numără câte elemente din '''vector''' se află în intervalul '''[x, y)''' pentru fiecare pereche de valori '''x''' și '''y'''. Pe baza acestei numărători, funcția determină câte elemente din vector nu se află în niciun interval, respectiv câte elemente apar în cel puțin două intervale diferite. Aceste valori sunt scrise într-un fișier de ieșire.

Funcția '''main''' apelează funcția '''conform_restrictiilor''' pentru a verifica datele de intrare și, dacă acestea sunt corecte, apelează funcția '''asfalt''' pentru a procesa datele și a scrie rezultatul în fișierul de ieșire.

1010 - produs

2023-04-30T14:12:06Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/1010/produs - produs]
----
== Cerinţa ==
Se dau două șiruri cu câte '''n''', respectiv '''m''' elemente. Dacă înmulțim fiecare element din primul șir cu fiecare element din al doilea șir, să se afle câte produse sunt mai mici decât '''p'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' și '''p''', iar apoi '''n''' numere naturale, separate prin spații, reprezentând elementele primului șir, după care citește numărul '''m''' urmat de '''m''' numere naturale, reprezentând elementele celui de-al doilea șir.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi se va afișa pe ecran numărul '''nr''', reprezentând numărul produselor mai mici decât '''p'''. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''p''' ≤ 200.000
* 1 ≤ '''n , m''' ≤ 50.000
* elementele celor două șiruri sunt numere naturale mai mici decât '''10.000'''
== Exemple ==
===Exemplul 1===
; Intrare
: 5 99
: 1 2 3 4 5
: 2
: 25 34
; Ieșire
: Datele sunt corecte.
: 5
===Exemplul 2===
; Intrare
: 4 10
: 10 2 6341 46541242
: 2
: 2541412 341212
; Ieșire
: Datele nu corespund restricțiilor impuse.
===Exemplul 3===
; Intrare
: 4 10
: 10 2 63 465
: 2
: 25 3
; Ieșire
: Datele sunt corecte.
: 1
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1010 produs

def numere(vector, n, vector_2, m, p):
nr = 0
for i in vector:
for j in vector_2:
if i * j < p:
nr += 1
print(nr)

def conform_restrictiilor(vector, n, vector_2, m, p):
if n < 1 or n > 50000:
print("Datele nu sunt comform restricțiilor impuse.")
return False
for x in vector:
if x > 10000 or x < 0:
print("Datele nu sunt comform restricțiilor impuse.")
return False
if m < 1 or m > 50000:
print("Datele nu sunt comform restricțiilor impuse.")
return False
for x in vector_2:
if x > 10000 or x < 0:
print("Datele nu sunt comform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
n, p = map(int, input().split())
vector = list(map(int, input().split()))
m = int(input())
vector_2 = list(map(int, input().split()))
if conform_restrictiilor(vector, n, vector_2, m, p) is True:
numere(vector, n, vector_2, m, p)

</syntaxhighlight>
==Explicaţie cod==

Acesta este un program care primește ca input 2 vectori și un număr întreg, apoi verifică dacă datele de intrare sunt conforme cu restricțiile impuse, după care calculează numărul de perechi de elemente din cele două vectori ale căror produs este mai mic decât numărul întreg dat.

Funcția '''conform_restrictiilor''' verifică dacă valorile date ca input sunt conforme cu următoarele restricții:
'''n''' și '''m''' trebuie să fie între 1 și 50000
valorile vectorilor trebuie să fie între 0 și 10000
Dacă valorile de intrare sunt conforme cu restricțiile, se afișează "Datele sunt corecte." și se returnează True, altfel se afișează "Datele nu sunt conforme restricțiilor impuse." și se returnează False.

Funcția '''numere''' primește cei doi vectori, lungimile lor și numărul întreg '''p'''. Folosind o buclă for dublă, calculează numărul de perechi ale căror produs este mai mic decât '''p'''.

În funcția '''main''', se citesc cele patru valori de intrare, apoi se apelează funcția '''conform_restrictiilor''' pentru a verifica dacă datele sunt conforme. Dacă sunt conforme, se apelează funcția numere pentru a calcula numărul de perechi ale căror produs este mai mic decât '''p'''.

0301 - Frecventa1

2023-04-30T14:08:21Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/301/frecventa1 -Frecventa1]
----
== Cerinţa ==
Se dau '''n''' numere naturale cu cel mult două cifre fiecare. Afişaţi valorile distincte în ordinea descrescătoare a numărului de apariţii.
== Date de intrare ==
Fișierul de intrare '''frecventa1.in''' conţine pe prima linie numărul '''n'''; urmează cele '''n''' numere, dispuse pe mai multe linii şi separate prin spaţii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieşire '''frecventa1.out''' va conţine pe prima linie valorile distincte dintre cele '''n''', în ordinea descrescătoare a numărului de apariţii. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ '''n''' ≤ 100.000
* dacă două valori apar de acelaşi număr de ori, se va afişa mai întâi valoarea mai mică
== Exemple ==
===Exemplul 1===
; frecventa1.in
: 8
: 3 19 3 65 3 19 14 3
; Ieșire
: Datele sunt corecte.
; frecventa1.out
: 3 19 14 65
===Exemplul 2===
; frecventa1.in
: 4
: 10 10 1 12
; Ieșire
: Datele sunt corecte.
; frecventa1.out
: 10 1 12
===Exemplul 3===
; frecventa1.in
: 5
: 22241 12 1234 12 236
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0301 Frecventa1

def frecventa(vector):
f = open("frecventa1.out", "w")
aparitii = [(i, vector[i]) for i in range(100) if vector[i] > 0]
aparitii.sort(key=lambda x: x[1], reverse=True)
for i in range(len(aparitii)):
f.write(str(aparitii[i][0]) + " ")

def conform_restrictiilor():
vector = list()
with open('frecventa1.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() is True:
vector.append(int(c))
n = vector[0]
vector_aparitii = [0] * 100
if n < 1 or n > 100000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
vector = vector[1:]
for x in vector:
if x < 0 or x >= 100:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
vector_aparitii[x] += 1
print("Datele sunt corecte.")
return vector_aparitii

if __name__ == '__main__':
vector = conform_restrictiilor()
frecventa(vector)

</syntaxhighlight>
==Explicaţie cod==

Acest cod are ca scop determinarea frecvenței fiecărui element dintr-un vector de numere naturale citit din fișierul '''frecventa1.in''' și scrierea acestor frecvențe în ordine descrescătoare în fișierul '''frecventa1.out'''.

Funcția '''conform_restrictiilor()''' se ocupă de citirea datelor din fișier, verificarea restricțiilor impuse (numărul de elemente din vector și valorile elementelor trebuie să se încadreze în anumite limite) și crearea unui nou vector '''vector_aparitii''' inițializat cu 0 pentru fiecare element posibil (de la 0 la 99, deoarece elementele vectorului trebuie să fie numere între 0 și 99). Dacă datele nu sunt conforme cu restricțiile impuse, programul se oprește cu ajutorul funcției '''exit()'''. Funcția returnează vectorul '''vector_aparitii''' cu frecvențele.

Funcția '''frecventa(vector)''' primește ca parametru vectorul cu frecvențele obținut anterior și realizează sortarea acestor frecvențe în ordine descrescătoare prin crearea unei liste de tupluri '''(i, vector[i])''' pentru fiecare element '''i''' și frecvența sa '''vector[i]''', apoi sortarea acestei liste după a doua valoare din fiecare tuplu și scrierea în fișierul '''frecventa1.out''' a primului element din fiecare tuplu (adica a valorilor elementelor cu frecvență cea mai mare).

În funcția principală, se citește numărul de elemente ale vectorului '''n''' și elementele vectorului vector cu ajutorul funcției '''input()''', apoi se apelează funcția '''conform_restrictiilor(vector)''' pentru a verifica dacă datele citite din fișier sunt valide. Dacă datele sunt conforme, se afișează mesajul "Datele sunt corecte." și se apelează funcția '''frecventa(vector)''' pentru a sorta și afișa frecvențele elementelor în ordine descrescătoare.

1927 - Bitsort

2023-04-30T14:04:31Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/1927/bitsort - Bitsort]
----
== Cerinţa ==
Se dă un vector cu '''n''' elemente, numere naturale nenule. Afișați termenii în ordine crescătoare.

'''Termenii care apar de mai multe ori se vor afișa o singură dată.'''
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi ''n''' numere naturale nenule, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi se afișează elementele vectorului, în ordine crescătoare, separate prin spații, respectând cerința cerută. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 1.000.000
* cele '''n''' numere citite vor fi mai mici decât 300.000
== Exemple ==
===Exemplul 1===
; Intrare
: 7
: 9 8 8 8 1 2 8
; Ieșire
: Datele sunt corecte.
: 1 2 8 9
===Exemplul 2===
; Intrare
: 4
: 1000001 214141251521 20 20
; Ieșire
: Datele nu corespund restricțiilor impuse.
===Exemplul 3===
; Intrare
: 5
: 11 11 20 31 31 39
; Ieșire
: Datele sunt corecte.
: 11 20 31 39
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1927 Bitsort

def bitsort(vector):
vector.sort()
for i in range(len(vector) - 1):
if vector[i] != vector[i + 1]:
print(vector[i], end=" ")
if vector[len(vector) - 1] != vector[len(vector) - 2]:
print(vector[len(vector) - 1])

def conform_restrictiilor(n, vector):
if n < 1 or n > 1000000:
print("Datele nu sunt comform restricțiilor impuse.")
return False
for x in vector:
if x > 300000 or x < 1:
print("Datele nu sunt comform restricțiilor impuse.")
return False
return True

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
if conform_restrictiilor(n, vector) is True:
print("Datele sunt corecte.")
bitsort(vector)

</syntaxhighlight>
==Explicaţie cod==

Funcția '''bitsort''' primește ca parametru un '''vector''' și sortează elementele sale. Apoi, pentru a elimina elementele duplicate, compară fiecare element cu elementul următor și îl afișează dacă este diferit de acesta. La final, verifică și ultimul element din '''vector'''.

Funcția '''conform_restrictiilor''' primește ca parametri un număr întreg '''n''' și un '''vector''' de numere întregi '''vector'''. Verifică dacă '''n''' respectă restricțiile impuse, respectiv dacă este între 1 și 1.000.000, iar fiecare element al vectorului este între 1 și 300.000. Dacă datele de intrare respectă aceste restricții, funcția returnează True, altfel returnează False.

În funcția '''main''', se citește numărul '''n''' și vectorul de la intrare și se apelează funcția '''conform_restrictiilor''' pentru a verifica restricțiile. Dacă acestea sunt respectate, se afișează mesajul '''Datele sunt corecte.''' și se apelează funcția '''bitsort''' pentru a sorta și afișa elementele unice din '''vector'''.

0276 - PareImpare

2023-04-30T14:02:37Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/276/pareimpare -PareImpare]
----
== Cerinţa ==
Se dau cel mult '''100.000''' de numere naturale, cu cel mult 2 cifre fiecare. Afişaţi în ordine strict crescătoare valorile impare care se regăsesc printre valorile date, şi în ordine strict descrescătoare valorile pare care se regăsesc printre valorile date.
== Date de intrare ==
Fişierul de intrare '''pareimpare.in''' conţine cel mult '''100.000''' de numere naturale, cu cel mult 2 cifre fiecare, dispuse pe mai multe linii şi separate prin spaţii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieşire '''pareimpare.out''' va conţine pe prima linie şirul valorilor impare, separate printr-un spaţiu, iar pe a doua linie şirul valorilor pare, separate printr-un spaţiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* în fişierul de intrare se află cel puţin un număr par şi cel puţin un număr impar
== Exemple ==
===Exemplul 1===
; pareimpare.in
: 75 12 3 3 18 75 1 3
; Ieșire
: Datele sunt corecte.
; pareimpare.out
: 1 3 75
: 18 12
===Exemplul 2===
; pareimpare.in
: 10 11 42 45 79
; Ieșire
: Datele sunt corecte.
; pareimpare.out
: 11 45 79
: 42 10
===Exemplul 3===
; pareimpare.in
: 75 77 71 99
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0276 PareImpare

def pareimpare(vector_pare, vector_impare):
f = open("pareimpare.out", "w")
vector_impare.sort()
vector_pare.sort(reverse=True)
vector_impare.append(0)
vector_pare.append(1)
for i in range(len(vector_impare) - 1):
if vector_impare[i] != vector_impare[i + 1]:
f.write(str(vector_impare[i]))
f.write(" ")
f.write("\n")
for i in range(len(vector_pare) - 1):
if vector_impare[i] != vector_pare[i + 1]:
f.write(str(vector_pare[i]))
f.write(" ")

def conform_restrictiilor():
vector = list()
vector_pare = list()
vector_impare = list()
with open('pareimpare.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() == True:
vector.append(int(c))
if len(vector) > 100000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x >= 100:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
elif x % 2 == 0:
vector_pare.append(x)
else:
vector_impare.append(x)
if len(vector_pare) == 0 or len(vector_impare) == 0:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector_pare, vector_impare

if __name__ == '__main__':
vector_pare, vector_impare = conform_restrictiilor()
pareimpare(vector_pare, vector_impare)

</syntaxhighlight>
==Explicaţie cod==

Acest cod implementează două funcții care citesc datele din fișierul '''pareimpare.in''' și verifică dacă respectă restricțiile impuse. Dacă datele sunt corecte, se apelează funcția "pareimpare" care sortează și afișează în fișierul '''pareimpare.out''' numerele pare și impare distincte din datele citite.

Mai exact, funcția '''conform_restrictiilor''' începe prin a inițializa trei liste: o listă goală numită '''vector''' și două liste numite '''vector_pare''' și '''vector_impare''', inițial, totodată, goale. Funcția deschide fișierul '''pareimpare.in''' și citeste fiecare linie, apoi fiecare caracter din linie și îl adaugă la lista '''vector''' dacă este un număr întreg. Dacă aceasta este lista cu toate datele, funcția verifică dacă aceasta are o lungime mai mică sau egală cu 100.000 și dacă fiecare număr este între 0 și 99. Dacă aceste condiții sunt îndeplinite, funcția adaugă fiecare număr par în lista '''vector_pare''' și fiecare număr impar în lista '''vector_impare'''. Dacă fiecare listă are cel puțin un element, funcția afișează '''Datele sunt corecte.''' și returnează lista '''vector_pare''' și lista '''vector_impare'''.

Funcția '''pareimpare''' primește ca parametrii cele două liste cu numere pare și impare, respectiv. Funcția sortează cele două liste și adaugă 0 la lista '''vector_impare''' și 1 la lista '''vector_pare''' pentru a avea grijă și de cazul în care toate numerele sunt pare sau impare. Apoi, funcția parcurge lista '''vector_impare''' și scrie în fișier toate numerele distincte, cu excepția ultimului element care este întotdeauna 0. Funcția face același lucru și pentru lista '''vector_pare''', cu excepția ultimului element care este întotdeauna 1.

1744 - NrLipsa2

2023-04-30T13:57:30Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/1744/nrlipsa2 - NrLipsa2]
----
== Cerinţa ==
Fișierul de intrare conține cel mult '''1.000.000''' de numere întregi. Se cere să se afișeze în fișierul de ieșire cel mai mic număr din intervalul '''[-100,100]''' care nu apare în fișierul de intrare.

Dacă nu există un astfel de număr se va afișa mesajul '''nu exista'''.
== Date de intrare ==
Fișierul de intrare '''nrlipsa2.in''' conține cel mult '''1.000.000''' de numere întregi, separate prin câte un spațiu, dispuse pe mai multe linii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieșire '''nrlipsa2.out''' va conține pe prima linie valoarea cerută, sau mesajul '''nu exista'''. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* numerele din fișierul de intrare vor fi din intervalul [-1.000.000, 1.000.000]
== Exemple ==
===Exemplul 1===
; nrlipsa2.in
: 80 -190 -149 165 -58 150 -8 -100 -99 65
; Ieșire
: Datele sunt corecte.
; nrlipsa2.out
: -98
===Exemplul 2===
; nrlipsa2.in
: -100 -99 -98 -97 (...) 97 98 99 100 101 102
; Ieșire
: Datele sunt corecte.
; nrlipsa2.out
: nu exista
===Exemplul 3===
; nrlipsa2.in
: 1000001 1000000000 131241 41421 0 131
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1744 NrLipsa2

def nrlipsa(vector_verificare, vector_verificare_negative):
element = 0
for k in range(100, 0, -1):
if vector_verificare_negative[k] == 0:
if element == 0:
element = k * (-1)
else:
break
if element == 0:
for k in range(100, 0, -1):
if vector_verificare[k] == 0:
if element == 0:
element = k
else:
break
f = open("nrlipsa2.out", "w")
if element != 0:
f.write(str(element))
else:
f.write("nu exista")

def readfiles(filename):
with open(filename) as f:
return [[int(num) for num in line.split()] for line in f]

def conform_restrictiilor():
vector = list()
vector_verificare = [0] * 101
vector_verificare_negative = [0] * 101
vector.append(readfiles(filename="nrlipsa2.in"))
if len(vector) > 1000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
vector = vector[0][0]
for x in vector:
x = int(x)
if x * (-1) > 1000000 or x > 1000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
if 0 <= x <= 100:
vector_verificare[x] = 1
elif 0 <= x * (-1) <= 100:
vector_verificare_negative[x * (-1)] = 1
print("Datele sunt corecte.")
return vector_verificare, vector_verificare_negative

if __name__ == '__main__':
vector_verificare, vector_verificare_negative = conform_restrictiilor()
nrlipsa(vector_verificare, vector_verificare_negative)

</syntaxhighlight>

==Explicaţie cod==

Funcția '''nrlipsa''' primește două liste: '''vector_verificare''' și '''vector_verificare_negative''', care reprezintă verificarea dacă un număr se află sau nu în vectorul de intrare. Funcția caută în primul rând un număr negativ care să nu se afle în vectorul de intrare și apoi caută un număr pozitiv care să nu se afle în vectorul de intrare. Dacă găsește un număr care lipsește, îl scrie într-un fișier de ieșire numit '''nrlipsa2.out'''.

Funcția '''conform_restrictiilor''' citește datele de intrare din fișierul '''nrlipsa2.in''' și validează dacă respectă restricțiile impuse, adică numerele din vector trebuie să fie în intervalul [-1000000, 1000000] și trebuie să fie maxim 1.000.000 de numere în '''vector'''. Funcția returnează două vectori: '''vector_verificare''' și '''vector_verificare_negative''', care sunt utilizați mai târziu pentru a găsi numărul lipsă.

Funcția readfiles este o funcție ajutătoare care primește un nume de fișier și citește datele de intrare din fișierul respectiv, pe care le returnează sub forma de listă de liste. Această funcție este utilizată pentru a citi datele de intrare din fișierul '''nrlipsa2.in'''.

În secțiunea principală a programului, se apelează funcția '''conform_restrictiilor''' pentru a obține vectorii de verificare, iar apoi se apelează funcția '''nrlipsa''' pentru a găsi numărul lipsă.

2812 - Progresie3

2023-04-30T13:54:17Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/2812/progresie3 - Progresie3]
----
== Cerinţa ==
Un șir de numere este o '''progresie aritmetică de rație r''' dacă oricare termen al său, cu excepția primului, se obține din cel care îl precede, prin adunarea la acesta a numărului r. '''Exemplu''': șirul 12, 14, 16, 18, 20 este o progresie de rație 2.

Se dă un șir de cel mult 1.000.000 numere naturale din intervalul [0,1.000]. Se cere să se verifice dacă există un număr natural '''r''', astfel încât toate numerele distincte din șir să poată fi rearanjate, pentru a forma o progresie aritmetică de rație '''r'''. Se afișează numărul '''r''', sau mesajul '''NU''', dacă nu există un astfel de număr.
== Date de intrare ==
Fișierul de intrare '''progresie3.in''' conține cel mult 1.000.000 numere naturale din intervalul [0,1.000], separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul e ieșire '''progresie3.out''' va conține pe prima linie numărul '''r''', sau mesajul '''NU''', dacă nu există un astfel de număr. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* în șirul dat există cel puțin două valori distincte
* proiectați un algoritm eficient din punctul de vedere al timpului de executare.
== Exemple ==
===Exemplul 1===
; progresie3.in
: 180 30 80 280 130 330 230 30 30 330 80
; Ieșire
: Datele sunt corecte.
; progresie3.out
: 50
===Exemplul 2===
; progresie3.in
: 1 2 3 4 6
; Ieșire
: Datele sunt corecte.
; progresie3.out
: NU
===Exemplul 3===
; progresie3.in
: 100 100 100
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2812 Progresie3

def progresie(vector):
f = open("progresie3.out", "w")
ratie = int()
vector.sort()
r = int()
for i in range(len(vector) - 1):
if vector[i] != vector[i + 1]:
ratie = vector[i + 1] - vector[i]
r = ratie
break
for i in range(len(vector) - 1):
if vector[i] != vector[i + 1]:
ratie = vector[i + 1] - vector[i]
if ratie != r:
f.write("NU")
exit()
f.write(str(r))

def conform_restrictiilor():
vector = list()
with open('progresie3.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() == True:
vector.append(int(c))
if len(vector) > 1000000 or vector.count(vector[0]) == len(vector):
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector

if __name__ == '__main__':
vector = conform_restrictiilor()
progresie(vector)

</syntaxhighlight>
==Explicaţie cod==

Funcția '''progresie(vector)''' primește un vector ca parametru și începe prin a deschide un fișier '''progresie3.out''' pentru a scrie rezultatul. Apoi, initializează două variabile ratie și '''r''' cu valoarea 0. Vectorul este sortat și apoi se parcurge prin el. Dacă două elemente consecutive sunt diferite, se calculează diferența dintre ele și se stochează în variabila '''ratie'''. De asemenea, valoarea acestei diferențe este stochează și în variabila '''r'''. Programul se oprește din parcurgerea vectorului la primul astfel de caz, deoarece nu mai este nevoie să verifice restul elementelor din vector.

După ce '''r''' a fost calculat, se parcurge din nou vectorul, de data aceasta pentru a verifica dacă toate diferențele dintre elementele consecutive ale vectorului sunt egale cu '''r'''. Dacă acest lucru este adevărat pentru toate diferențele, programul scrie valoarea '''r''' în fișierul de ieșire '''progresie3.out'''. Dacă se găsește o diferență care nu este egală cu '''r''', programul afișează '''NU''' și se oprește prin apelul funcției '''exit()'''.

Funcția '''conform_restrictiilor()''' primește ca input datele din fișierul '''progresie3.in''' și verifică dacă ele corespund restricțiilor impuse. Mai precis, datele din fișier trebuie să conțină între 2 și 1000000 de elemente și fiecare element trebuie să fie între 0 și 1000. De asemenea, toate elementele din '''vector''' trebuie să fie diferite. Dacă restricțiile nu sunt îndeplinite, programul afișează un mesaj corespunzător și se oprește prin apelul funcției '''exit()'''.

În funcția '''main()''', se apelează mai întâi funcția '''conform_restrictiilor()''' pentru a verifica dacă datele din fișier sunt valide și pentru a obține vectorul de numere. Apoi, se apelează funcția '''progresie(vector)''' pentru a determina dacă vectorul este o progresie aritmetică și pentru a afișa diferența în fișierul de ieșire sau '''NU''', după caz.

3287 - cifrazecmax

2023-04-30T13:50:57Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/3287/cifrazecmax -cifrazecmax]
----
== Cerinţa ==
Se consideră un şir '''vector''' de cel puțin 11 şi cel mult 10.000 de numere naturale, despărțite prin câte un spațiu. Fiecare număr are cel puțin două şi cel mult nouă cifre. Primul termen al şirului are numărul de ordine 1, al doilea are numărul de ordine 2 etc. Se citeşte şirul din fişier şi se cere să se determine numărul de ordine al unui termen al şirului care este precedat în fişier de un număr maxim de valori care au cifra zecilor egală cu a sa. Dacă sunt mai mulți termeni cu această proprietate se afişează numărul de ordine al primului.
== Date de intrare ==
Fișierul de intrare '''cifrazecmax.in''' conține pe prima linie cel puțin '''11''' şi cel mult un '''10.000''' de numere naturale, despărțite prin câte un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieșire '''cifrazecmax.out''' va conține pe prima linie numărul de ordine al termenului care este precedat în fişier de un număr maxim de valori care au cifra zecilor egală cu a sa. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* numerele din fișierul de intrare '''cifrazecmax.in''' au cel puțin '''2''' cifre și sunt mai mici decât '''1.000.000.000'''
* în fișier sunt cel mult '''10000''' de numere
== Exemple ==
===Exemplul 1===
; cifrazecmax.in
: 12 36 265 18 139 19 32 34 112 14 68
; Ieșire
: Datele sunt corecte.
; cifrazecmax.out
: 10
===Explicatie===
10 este numărul de ordine al termenului 14. Pe poziția zecilor sunt 5 cifre de 1, 4 cifre de 3 și 2 cifre de 6. Cel mai mare este 5 corespunzător cifrei 1. Ultimul termen al șirului care are cifra zecilor 1 este 14 și are numărul de ordine 10.
===Exemplul 2===
; cifrazecmax.in
: 12 63 265 88 139 19 32 34 68 112 74
; Ieșire
: Datele sunt corecte.
; cifrazecmax.out
: 8
===Explicatie===
8 este numărul de ordine al termenului 34. Pe poziția zecilor sunt 3 cifre de 1, 3 cifre de 3, 3 cifre de 6, o cifră de 8 și una de 7. Contorul cel mai mare este 3 corespunzător cifrelor 1, 3 și 6. Primul termen care este precedat în fişier de un număr maxim de valori care au cifra zecilor egală cu a sa este 34 și are numărul de ordine 8.
===Exemplul 3===
; cifrazecmax.in
: 2 3 4 5 6
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 3287 - cifrazecmax

def cifrazecmax(vector):
f = open("cifrazecmax.out", "w")
cifre = [0] * len(vector)
for i in range(len(vector)):
element = vector[i]
cifre[i] = element % 100 // 10
maxim = 0
pozfinala = int()
for i in range(0, 10):
contor = 0;
poz = int()
for j in range(len(vector)):
if cifre[j] == i:
contor += 1
poz = j
if contor > maxim:
maxim = contor
pozfinala = poz
if contor == maxim and poz < pozfinala:
pozfinala = poz
f.write(str(pozfinala + 1))

def conform_restrictiilor():
vector = list()
with open('cifrazecmax.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() == True:
vector.append(int(c))
if len(vector) > 10000 or len(vector) < 11:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 10 or x > 1000000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector

if __name__ == '__main__':
vector = conform_restrictiilor()
cifrazecmax(vector)

</syntaxhighlight>
==Explicaţie cod==

Funcția '''conform_restrictiilor()''' verifică dacă datele de intrare sunt conforme cu cerințele problemei. Mai precis, programul verifică dacă vectorul are între 11 și 10000 de elemente, iar fiecare element este între 10 și 10^9. Dacă aceste condiții nu sunt îndeplinite, programul va afișa un mesaj de eroare și va ieși din program. Dacă datele sunt conforme, funcția va returna vectorul.

Funcția '''cifrazecmax(vector)''' primește vectorul ca parametru și găsește poziția primei cifre zecimale care apare cel mai des în numerele vectorului. Pentru aceasta, se parcurge fiecare element al vectorului și se extrage cifra zecimală corespunzătoare (adică a doua cifră de la dreapta). Aceste cifre sunt stocate într-un alt vector numit '''cifre'''.

Se parcurg apoi cifrele de la 0 la 9 și se numără câte elemente din cifre au cifra zecimală egală cu cifra rezultata. Dacă numărul de apariții este mai mare decât valoarea maximă găsită până în acel moment, atunci se actualizează valoarea maximă și poziția din '''vector''' corespunzătoare. Dacă numărul de apariții este egal cu valoarea maximă și poziția curentă este mai mică decât poziția anterioară, atunci se actualizează poziția anterioară.

Funcția va scrie poziția primei cifre zecimale care apare cel mai des în fișierul '''cifrazecmax.out'''.

2843 - Puteri6

2023-04-30T13:48:22Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/2843/puteri6 -Puteri6]
----
== Cerinţa ==
Se dă un număr natural '''numar''' (1≤n≤106 ), și un șir cu cel mult 1000000 de elemente, numere naturale de forma 10^p (0≤p≤9). Se cere să se afișeze numărul care ar apărea pe poziția '''numar''' în șirul ordonat crescător. Dacă șirul are mai puțin de '''numar''' termeni, se afișează mesajul Nu exista.
== Date de intrare ==
Fișierul de intrare '''puteri6.in''' conține pe prima linie numărul '''numar''', iar pe a doua linie elementele șirului dat, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieșire '''puteri6.out''' va conține pe prima linie numărul care ar apărea pe poziția '''numar''' în șirul ordonat crescător sau mesajul '''Nu exista''', dacă șirul are mai puțin de '''numar''' termeni. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* Pentru determinarea numărului cerut se utilizează un algoritm eficient din punctul de vedere al timpului de executare. Se recomandă evitarea memorării valorilor elementelor din șir într-un tablou sau în altă structură de date similară.
== Exemple ==
===Exemplul 1===
; puteri6.in
: 5
: 100 100000 1 100000 1000 100 10
; Ieșire
: Datele sunt corecte.
; puteri6.out
: 1000
===Exemplul 2===
; puteri6.in
: 4
: 100 1000 10
; Ieșire
: Datele sunt corecte.
; puteri6.out
: Nu exista
===Exemplul 3===
; puteri6.in
: 5
: 2 3 4 5 6
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0239 Puteri6

def puteri6(vector, numar):
vector_elemente = vector[1:]
vector_elemente.sort()
f = open("puteri6.out", "w")
if len(vector_elemente) < numar:
f.write("nu exista")
else:
f.write(str(vector_elemente[numar - 1]))

def conform_restrictiilor():
vector = list()
puteri10 = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000]
with open('puteri6.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() is True:
vector.append(int(c))
numar = vector[0]
for i in range(1, len(vector)):
element = vector[i]
repetare_element = puteri10.count(element)
if repetare_element == 0:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector, numar

if __name__ == '__main__':
vector, numar = conform_restrictiilor()
puteri6(vector, numar)

</syntaxhighlight>
==Explicaţie cod==

Acest cod citește un fișier de intrare numit '''puteri6.in''' care conține un număr întreg '''N''' și '''N''' numere întregi, și verifică dacă toate numerele din intrare sunt puteri ale lui 10. Dacă datele sunt conforme cu restricțiile impuse, se afișează al '''N'''-lea cel mai mare număr care este o putere a lui 10 din lista numerelor întregi citite din fișierul de intrare. În caz contrar, se afișează un mesaj de eroare.

Mai precis, funcția '''conform_restrictiilor''' citește fișierul de intrare și verifică dacă fiecare număr este o putere a lui 10. Funcția returnează vectorul de numere citite și numar care este primul număr din fișier, reprezentând numărul de elemente din vector. Funcția '''puteri6''' sortează vectorul și verifică dacă există suficiente elemente în '''vector''' pentru a afișa cel de-al '''N'''-lea cel mai mare număr care este o putere a lui 10. Dacă există, afișează acest număr, altfel afișează '''nu exista'''.

0809 - NrLipsa1

2023-04-30T13:44:52Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/809/nrlipsa1 - NrLipsa1]
----
== Cerinţa ==
Fișierul de intrare '''nrlipsa1.in''' conține cel puțin 3 și cel mult 1.000.000 de numere naturale. Se cere să se afișeze în fișierul de ieșire '''nrlipsa1.out''', separate printr-un spaţiu, două numere distincte, anume cel mai mic număr par cu două cifre și cel mai mare număr par cu două cifre care '''NU''' fac parte din şir.

Dacă nu există două astfel de valori, în fișierul de ieșire se afişează mesajul '''nu exista'''.
== Date de intrare ==
Fișierul de intrare '''nrlipsa1.in''' conține cel puțin 3 și cel mult 1.000.000 de numere naturale, separate prin câte un spațiu, dispuse pe mai multe linii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieșire '''nrlipsa1.out''' va conține pe prima linie valorile cerute, separate prin câte un spațiu, sau mesajul '''nu exista'''. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* numerele din fișierul de intrare vor fi din intervalul (0, 1.000.000.000)
== Exemple ==
===Exemplul 1===
; nrlipsa1.in
: 7 2 40 5 10 15 11 12 18 350
; Ieșire
: Datele sunt corecte.
; nrlipsa1.out
: 14 98
===Exemplul 2===
; nrlipsa1.in
: 10 12 14 16 18
: 20 22 24 26 28
: 30 32 34 36 38
: 40 42 44 46 48
: 50 52 54 56 58
: 60 62 64 66 68
: 70 72 74 76 78
: 80 82 84 86 88
: 90 92 94 96 98
; Ieșire
: Datele sunt corecte.
; nrlipsa1.out
: nu exista
===Exemplul 3===
; nrlipsa1.in
: 12614862418561826 121241 14241 191294
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0809 NrLipsa1

def nrlipsa(vector_verificare):
prima_valoare = 0
a_doua_valoare = 0
for k in range(98, 10, -2):
if vector_verificare[k] == 0:
if a_doua_valoare == 0:
a_doua_valoare = k
else:
break
for k in range(10, 98, +2):
if vector_verificare[k] == 0:
if prima_valoare == 0:
prima_valoare = k
else:
break
f = open("nrlipsa1.out", "w")
if prima_valoare != 0 and a_doua_valoare != 0:
line = [str(prima_valoare), " ", str(a_doua_valoare)]
f.writelines(line)
else:
f.write("nu exista")

def conform_restrictiilor():
vector = list()
vector_verificare = [0] * 100
with open('nrlipsa1.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() is True:
vector.append(int(c))
if len(vector) > 1000000 or len(vector) < 3:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x >= 1000000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
if 10 <= x <= 99:
vector_verificare[x] = 1

print("Datele sunt corecte.")
return vector_verificare

if __name__ == '__main__':
vector_verificare = conform_restrictiilor()
nrlipsa(vector_verificare)

</syntaxhighlight>

==Explicaţie cod==

Funcția '''conform_restrictiilor''' verifică dacă datele din fișierul de intrare sunt conforme cu restricțiile impuse și returnează un '''vector''' care conține numerele de la 10 la 99 din fișierul de intrare cu valoarea 1, iar restul elementelor vor avea valoarea 0.

Funcția '''nrlipsa''' primește vectorul de verificare și caută două numere lipsă în lista de numere. În primul '''for''', caută un număr impar lipsă în intervalul [98, 10] în vectorul de verificare. Dacă un astfel de număr este găsit, îl salvează în variabila '''a_doua_valoare'''. Apoi, în al doilea '''for''', caută un număr par lipsă în intervalul [10, 98] în vectorul de verificare. Dacă un astfel de număr este găsit, îl salvează în variabila '''prima_valoare'''. În final, dacă ambele numere lipsă au fost găsite, programul scrie numerele respective într-un fișier de ieșire '''nrlipsa1.out'''. Dacă cel puțin unul dintre aceste numere nu este găsit, programul scrie '''nu exista''' în fișierul de ieșire.

În funcția principală, programul citește numărul de elemente din fișierul de intrare și o listă de numere utilizând '''input()''', apoi verifică dacă datele sunt conforme restricțiilor cu ajutorul funcției conform_restrictiilor și apoi calculează numerele lipsă cu ajutorul funcției '''nrlipsa'''.

4147 - NumarareCifre

2023-04-30T13:41:52Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/4147/numararecifre - NumarareCifre]
----
== Cerinţa ==
Se dă un '''vector''' cu '''numar''' numere naturale. Să se determine câte dintre perechile de elemente din vector au același număr de cifre.
== Date de intrare ==
Programul citește de la tastatură numărul '''numar''', iar apoi '''numar''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi se afișează pe ecran numărul '''c''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 &les; '''numar''' &les; 100.000
* cele '''numar''' numere citite vor fi mai mici decât 1.000.000.000
== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 13 3 8 700 9 25
; Ieșire
: Datele sunt corecte.
: 4
===Exemplul 2===
; Intrare
: 10
: 100 10000 100 20 1 20 30 10 98 999999999999999
; Ieșire
: Datele nu corespund restricțiilor impuse.
===Exemplul 3===
; Intrare
: 5
: 1 11 111 1111 11111
; Ieșire
: Datele sunt corecte.
: 0
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 4147 NumarareCifre

def numarare(vector, numar):
vector.sort()
c = 0
for i in range(numar - 1):
for j in range(i + 1, numar):
element = str(vector[i])
urmatorul_element = str(vector[j])
if len(element) == len(urmatorul_element):
c += 1
print(c)

def conform_restrictiilor(numar, vector):
if numar < 1 or numar > 1000:
print("Datele nu sunt comform restricțiilor impuse.")
return False
for x in vector:
if x > 100000000 or x < 1:
print("Datele nu sunt comform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
numar = int(input())
vector = list(map(int, input().split()))
if conform_restrictiilor(numar, vector) is True:
numarare(vector, numar)

</syntaxhighlight>

==Explicaţie cod==

Funcția '''conform_restrictiilor(numar, vector)''' primește numărul de elemente și lista de elemente și verifică dacă acestea îndeplinesc anumite restricții: numărul de elemente trebuie să fie între 1 și 1000, iar fiecare element trebuie să fie între 1 și 100000000. Dacă datele sunt conforme restricțiilor, funcția returnează True, altfel afișează un mesaj de eroare și returnează False.

Funcția '''numarare(vector, numar)''' sortează lista de elemente primite, apoi parcurge lista și numără numărul de perechi de elemente care au aceeași lungime, adăugându-le la variabila '''c'''. La final, funcția afișează valoarea lui '''c'''.

În funcția principală '''if __name__ == '__main__'''', se citește numărul de elemente și lista de elemente, apoi se verifică dacă datele sunt conforme restricțiilor cu ajutorul funcției conform_restrictiilor. Dacă datele sunt conforme, se apelează funcția '''numarare''' pentru a număra perechile de elemente cu aceeași lungime.

2837 - Intervale5

2023-04-30T13:39:19Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/2837/intervale5 - Intervale5]
----
== Cerinţa ==
Se dă un șir de cel mult '''1.000.000''' de numere naturale din intervalul '''[0,100]'''. Se cere să se determine toate perechile distincte formate din termeni ai șirului dat, x și y (y-x≥2), astfel încât să nu existe niciun termen al șirului care să aparțină intervalului (x,y). Dacă nu există nicio astfel de pereche, se afișează mesajul "nu exista".
== Date de intrare ==
Fișierul de intrare '''intervale5.in''' conține pe prima linie elementele șirului, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieșire '''intervale5.out''' va conține perechile găsite, câte una pe linie, în ordine strict crescătoare, separate printr-un spațiu, iar dacă nu există nicio astfel de pereche, se afișează mesajul '''nu exista'''. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* pentru determinarea numerelor cerute utilizați un algoritm eficient din punctul de vedere al timpului de executare: recomandă evitarea memorării elementelor șirului într-un tablou sau în altă structură de date similară
== Exemple ==
===Exemplul 1===
; intervale5.in
: 5 9 0 8 10 11 12 13 15 14 6 7 40 10 0 0 5 41 95 7
; Ieșire
: Datele sunt corecte.
; intervale5.out
: 0 5
: 15 40
: 41 95
===Exemplul 2===
; intervale5.in
: 1 2 3 4 5 6
; Ieșire
: Datele sunt corecte.
; intervale5.out
: nu exista
===Exemplul 3===
; intervale5.in
: 101 100 102 3000
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2837 Intervale5

def intervale5(vector):
maxi = -1
v = [0] * 101
for x in vector:
v[x] = 1
if x > maxi:
maxi = x
contor = 0
f = open("intervale5.out", "w")
for i in range(0, maxi - 1):
for j in range(i + 2, maxi + 1):
ok = True
for k in range(i + 1, j):
if v[k] == 1:
ok = False
if ok and v[i] == 1 and v[j] == 1:
line = [str(i), " ", str(j), "\n"]
f.writelines(line)
contor += 1
if contor == 0:
f.write("nu exista")

def conform_restrictiilor():
vector = list()
with open('intervale5.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() == True:
vector.append(int(c))
if len(vector) > 1000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 100:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector

if __name__ == '__main__':
vector = conform_restrictiilor()
intervale5(vector)

</syntaxhighlight>

==Explicaţie cod==

Funcția '''conform_restrictiilor()''' citește datele din fișierul '''intervale5.in''' și verifică dacă acestea sunt în concordanță cu cerințele problemei. Dacă datele nu sunt conforme, se afișează un mesaj corespunzător și se oprește execuția programului. Dacă datele sunt conforme, funcția returnează vectorul de valori citite din fișier.

Funcția '''intervale5(vector)''' primește ca parametru vectorul de valori citite din fișier și determină intervalele de lungime minimă 5 care nu conțin alte valori între ele decât cele din vector. Aceste intervale sunt afișate în fișierul '''intervale5.out'''.

Pentru a determina aceste intervale, se construiește un vector '''v''' în care valoarea '''1''' se asociază fiecărei valori din vectorul citit din fișier, iar valoarea '''0''' se asociază celorlalte valori. Se caută apoi toate perechile de indici '''i''' și '''j''', cu proprietatea că între acești indici nu se găsesc alte valori decât cele din vectorul inițial, iar '''j-i''' este cel puțin 4. Pentru a verifica dacă între '''i''' și '''j''' se găsesc alte valori decât cele din vectorul inițial, se parcurge vectorul '''v''' între indicii '''i''' și '''j''' și se verifică dacă toate valorile sunt zero. Dacă condiția este satisfăcută, intervalul '''i'''-'''j''' este afișat în fișierul '''intervale5.out'''.

0797 - SubNumar

2023-04-30T13:35:20Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/797/subnumar - SubNumar]
----
== Explicatie ==
Un număr natural '''x''', format din exact două cifre, este numit '''sub-număr''' al unui număr natural y dacă cifrele lui x apar, în aceeași ordine, pe ranguri consecutive, în numărul y.
Exemplu: 21 este sub-număr al lui 12145, al lui 213, al lui 21, dar nu și al lui 123 sau al lui 231.
== Cerinţa ==
Fișierul de intrare '''subnumar.in''' conține cel mult 1.000.000 de numere naturale. Se cere să se afișeze în fișierul de ieșire '''subnumar.out''', în ordine descrescătoare, sub-numerele care apar de cele mai multe ori în scrierea numerelor date.
== Date de intrare ==
Fișierul de intrare '''subnumar.in''' conține cel mult '''1.000.000''' de numere naturale cu cel puțin '''2''' cifre, separate prin câte un spațiu, dispuse pe mai multe linii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieșire '''subnumar.out''' va conține pe prima linie valorile cerute, separate prin câte un spațiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* numerele din fișierul de intrare vor fi din intervalul '''[10, 1.000.000.000]'''
== Exemple ==
===Exemplul 1===
; subnumar.in
: 393 17775787 72194942 12121774
; Ieșire
: Datele sunt corecte.
; subnumar.out
: 77 21
===Exemplul 2===
; subnumar.in
: 14214 1241 1241 421 514 142312
; Ieșire
: Datele sunt corecte.
; subnumar.out
: 14
===Exemplul 3===
; subnumar.in
: 9 8 7 1
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0797 SubNumar

def subnumar(vector):
subnr = [0] * 100
for i in range(len(vector)):
element = vector[i]
while element > 9:
subnr[element % 100] += 1
element //= 10
max = 0
f = open("subnumar.out", "w")
for i in range(10, 99):
element = subnr[i]
if element > max:
max = element
for i in range(99, 9, -1):
element = subnr[i]
if element == max:
f.write(str(i))
f.write(" ")

def conform_restrictiilor():
vector = list()
vector_verificare = [0] * 1000
with open('subnumar.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() == True:
vector.append(int(c))
if len(vector) > 1000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 10 or x > 1000000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector

if __name__ == '__main__':
vector = conform_restrictiilor()
subnumar(vector)

</syntaxhighlight>

==Explicaţie cod==

In functia '''conform_restrictiilor()''' se citesc datele din fisierul de intrare '''subnumar.in''', se verifica daca sunt conform restricțiilor impuse, apoi se returneaza vectorul de numere.

In functia '''subnumar(vector)''' se parcurge vectorul de numere, iar pentru fiecare numar se calculeaza subsecventele de doua cifre. Aceste subsecvente se adauga la o lista '''subnr''' ce contine numarul de aparitii pentru fiecare subsecventa posibila (10-99). Se cauta apoi cea mai mare valoare din '''subnr''', se afiseaza toate subsecventele care apar de atatea ori si se scriu in fisierul de iesire '''subnumar.out'''.

In cazul in care datele nu sunt conforme, se afiseaza un mesaj de eroare si programul se incheie.

In final, programul afiseaza cele mai frecvente doua cifre din subsecventele de doua cifre din numerele din vector.

1306 - SumChef

2023-04-30T13:31:24Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/1306/sumchef - SumChef]
----
== Cerinţa ==
Fiind dat un şir cu '''numar''' elemente numere naturale, să se calculeze suma '''s''' cuburilor cifrelor tuturor numerelor din şir.
== Date de intrare ==
Programul citește de la tastatură numărul '''numar''', iar apoi '''numar''' numere naturale, separate prin spaţii, reprezentând elementele vectorului '''vector'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi se afișează pe ecran numărul '''s''', reprezentând suma cuburilor cifrelor tuturor numerelor din şir. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 &les; '''numar''' &les; 2.000.000
* numerele din şir au cel mult 4 cifre
== Exemple ==
===Exemplul 1===
; Intrare
: 3
: 24 120 51
; Ieșire
: Datele sunt corecte.
: 207
===Exemplul 2===
; Intrare
: 10
: 100 1000 100 20 1 20 30 10 98 99999
; Ieșire
: Datele nu corespund restricțiilor impuse.
===Exemplul 3===
; Intrare
: 5
: 1 11 111 1111 101
; Ieșire
: Datele sunt corecte.
: 12
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1306 SumChef

def numere(vector, numar):
suma = 0
for i in range(numar):
element = vector[i]
while element != 0:
suma += (element % 10) ** 3
element //= 10
print(suma)

def conform_restrictiilor(numar, vector):
if numar < 1 or numar > 2000000:
print("Datele nu sunt comform restricțiilor impuse.")
return False
for x in vector:
if x > 9999 or x < 1:
print("Datele nu sunt comform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
numar = int(input())
vector = list(map(int, input().split()))
if conform_restrictiilor(numar, vector) is True:
numere(vector, numar)

</syntaxhighlight>

==Explicaţie cod==

Acest cod are rolul de a calcula suma cuburilor cifrelor fiecarui element dintr-un '''vector dat'''.

Funcția '''numere(vector, numar)''':

Parametrii de intrare: '''vector''' este un vector de numere întregi și numar este numărul de elemente din '''vector'''.
Funcționare: Parcurge fiecare element din '''vector''' și calculează suma cuburilor cifrelor fiecărui element. Apoi, adaugă această sumă la '''suma totală''' și o afișează la final.
Rezultatul returnat: Funcția nu returnează nicio valoare, ci afișează direct suma cuburilor cifrelor.
Funcția '''conform_restrictiilor(numar, vector)''':

Parametrii de intrare: '''numar''' este numărul de elemente din '''vector''' și '''vector''' este vectorul de numere întregi.
Funcționare: Verifică dacă datele intră în restricțiile impuse în enunț, adică numar trebuie să fie între 1 și 2.000.000 și fiecare element din vector trebuie să fie între 1 și 9999.
Rezultatul returnat: Dacă datele sunt conforme restricțiilor, funcția afișează "Datele sunt corecte." și returnează True. În caz contrar, afișează "Datele nu sunt conforme restricțiilor impuse." și returnează False.
Blocul principal:

Citim numărul de elemente din '''vector''' și apoi vectorul în sine.
Apelăm funcția '''conform_restrictiilor''' pentru a verifica datele.
Dacă datele sunt corecte, apelăm funcția numere pentru a calcula suma cuburilor cifrelor.

2669 - Count5

2023-04-30T13:27:40Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/2669/count5 - Count5]
----
== Cerinţa ==
Se dă un '''vector''' cu '''numar''' numere naturale. Să se determine câte dintre perechile de elemente din '''vector''' sunt formate din valori cu aceeași sumă a cifrelor.
== Date de intrare ==
Programul citește de la tastatură numărul '''numar''', iar apoi '''numar''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi se afișează pe ecran numărul '''C''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 &les; '''numar''' &les; 100.000
* cele '''numar''' numere citite vor fi mai mici decât 1.000.000.000
== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 51 842 15 28 77 132
; Ieșire
: Datele sunt corecte.
: 4
===Exemplul 2===
; Intrare
: 10
: 100 10000 100 20 1 20 30 10 98 999999999999999
; Ieșire
: Datele nu corespund restricțiilor impuse.
===Exemplul 3===
; Intrare
: 5
: 1 11 111 1111 11111
; Ieșire
: Datele sunt corecte.
: 0
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2669 Count5

def numere(vector, numar):
suma = list()
for i in range(numar):
element = vector[i]
suma_cifre = 0
while element != 0:
suma_cifre += element % 10
element //= 10
suma.append(suma_cifre)
C = 0
for i in range(numar):
for j in range(i + 1, numar):
if suma[i] == suma[j]:
C += 1
print(C)

def conform_restrictiilor(numar, vector):
if numar < 1 or numar > 100000:
print("Datele nu sunt comform restricțiilor impuse.")
return False
for x in vector:
if x > 1000000000 or x < 1:
print("Datele nu sunt comform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
numar = int(input())
vector = list(map(int, input().split()))
if conform_restrictiilor(numar, vector) is True:
numere(vector, numar)

</syntaxhighlight>

==Explicaţie cod==

Acest cod are ca scop determinarea numarului de perechi de numere dintr-un vector care au aceeasi suma a cifrelor.

La inceput, functia '''numere(vector, numar)''' calculeaza suma cifrelor fiecarui element din '''vector''' si salveaza valorile in lista '''suma'''. Apoi, se parcurge lista '''suma''' si se compara fiecare element cu toate elementele din dreapta sa. Daca doua elemente au aceeasi valoare, se incrementeaza un contor '''C'''. La final, functia afiseaza valoarea contorului.

Functia '''conform_restrictiilor(numar, vector)''' verifica daca datele de intrare respecta restrictiile impuse. Aceasta verifica daca numarul de elemente din '''vector''' este cuprins intre 1 si 100000, si daca fiecare element din '''vector''' este cuprins intre 1 si 1000000000. Daca datele sunt in regula, functia returneaza True, altfel returneaza False.

In programul principal, se citeste numarul de elemente din '''vector''' si vectorul de la intrare, iar apoi se verifica daca datele respecta restrictiile. Daca datele sunt in regula, se apeleaza functia '''numere(vector, numar)''' pentru a calcula numarul de perechi cu aceeasi suma a cifrelor.

0247 - CifreOrd1

2023-04-30T13:24:04Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/247/cifreord1 - CifreOrd1]
----
== Cerinţa ==
Se dau mai multe numere naturale, fiecare cu cel mult '''9''' cifre. Să se afişeze, în ordine descrescătoare, toate cifrele care apar în numerele date.
== Date de intrare ==
Fişierul de intrare '''cifreord1.in''' conţine cel mult '''10.000''' numere naturale, dispuse pe mai multe linii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieşire '''cifreord1.out''' va conţine cifrele determinate, ordonate descrescător, câte '''20''' pe o linie, valorile de pe fiecare linie fiind separate prin spaţii. Ultima linie a fişierului poate conţine mai puţin de '''20''' de cifre. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Exemple ==
===Exemplul 1===
; cifreord1.in
: 301941 81912 83392
: 776996 431446
; Ieșire
: Datele sunt corecte.
; cifreord1.out
: 9 9 9 9 9 8 8 7 7 6 6 6 4 4 4 4 3 3 3 3
: 2 2 1 1 1 1 1 0
===Exemplul 2===
; nrlipsa.in
: 100 1001 900
; Ieșire
: Datele sunt corecte.
; nrlipsa.out
: 9 1 1 1 0 0 0 0 0 0
===Exemplul 3===
; nrlipsa.in
: 489127491479 4198749127591 100
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0247 CifreOrd1

def numere(vector):
vector = str(vector)
counter = list()
for i in range(10):
counter.append([vector.count(str(i))])
counter[i].append(i)
f = open("cifreord1.out", "w")
elemente_pe_linie = 0
for i in range(9, -1, -1):
numar_repetitie_cifra = int(counter[i][0])
for j in range(numar_repetitie_cifra):
elemente_pe_linie += 1
if elemente_pe_linie % 20 == 0:
f.write("\n")
else:
f.write(str(counter[i][1]))
f.write(" ")

def conform_restrictiilor():
vector = list()
with open('cifreord1.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() is True:
vector.append(int(c))
if len(vector) > 10000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x >= 1000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return vector

if __name__ == '__main__':
vector = conform_restrictiilor()
numere(vector)

</syntaxhighlight>

==Explicaţie cod==

Funcția '''conform_restrictiilor()''' citește datele din fișierul '''cifreord1.in''' și verifică dacă acestea respectă restricțiile impuse (numărul de elemente din vector trebuie să fie mai mic sau egal cu 10000 și fiecare element trebuie să fie un număr natural mai mic decât 1000000). Dacă datele sunt valide, funcția returnează '''vector'''.

Funcția '''numere()''' primește vectorul ca parametru și numără aparițiile fiecărei cifre în '''vector'''. Apoi, ordonează cifrele descrescător după numărul lor de apariții și le scrie în fișierul '''cifreord1.out''', cu maximum '''20''' de cifre pe linie.

În funcția principală, se apelează cele două funcții pentru a rezolva problema.

0239 - NrLipsa

2023-04-30T13:18:12Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/239/nrlipsa - NrLipsa]
----
== Cerinţa ==
Se dau mai multe numere naturale cu cel mult '''9''' cifre fiecare. Să se determine cele mai mari două numere de '''3''' cifre care nu se găsesc printre numerele date.
== Date de intrare ==
Fişierul de intrare '''nrlipsa.in''' conţine cel mult '''100.000''' de numere, dispuse pe mai multe linii, numerele de pe fiecare linie fiind separate prin unul sau mai multe spaţii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi in fişierul de ieşire '''nrlipsa.out''' va conţine pe prima linie cele mai mari două numere de trei cifre care nu apar în fişierul de intrare, ordonate descrescător, separate prin exact un spaţiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* Dacă nu există două numere de trei cifre care să nu se afle în fişierul de intrare atunci se va afişa mesajul '''NU'''.
== Exemple ==
===Exemplul 1===
; nrlipsa.in
: 12 2345 123 67 989 6 999
: 123 67 989 999
; Ieșire
: Datele sunt corecte.
; nrlipsa.out
: 998 997
===Exemplul 2===
; nrlipsa.in
: 100 101 102 (...) 997 998 999
; Ieșire
: Datele sunt corecte.
; nrlipsa.out
: NU
===Exemplul 3===
; nrlipsa.in
: 1 1 1 1 1 1... (de 100001 ori)
; Ieșire
: Datele nu sunt comform restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0239 NrLipsa

def nrlipsa(vector_verificare):
i = 0;
j = 0
for k in range(999, 100, -1):
if vector_verificare[k] == 0:
if i == 0:
i = k
elif j == 0:
j = k
else:
break
f = open("nrlipsa.out", "w")
if i != 0 and j != 0:
line = [str(i), " ", str(j)]
f.writelines(line)
else:
f.write("NU")

def conform_restrictiilor():
vector = list()
vector_verificare = [0] * 1000
with open('nrlipsa.in') as f:
lines = f.readlines()
for line in lines:
for c in line.split():
if c.isdigit() == True:
vector.append(int(c))
if len(vector) > 100000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x >= 1000000:
print("Datele nu sunt comform restricțiilor impuse.")
exit()
if x >= 100 and x <= 999:
vector_verificare[x] = 1

print("Datele sunt corecte.")
return vector_verificare

if __name__ == '__main__':
vector_verificare = conform_restrictiilor()
nrlipsa(vector_verificare)

</syntaxhighlight>

==Explicaţie cod==

Da, acesta este un program care verifică dacă există două numere lipsă între 100 și 999 într-un vector dat și afișează aceste numere într-un fișier de ieșire.

Iată o explicație detaliată a codului:

- Funcția '''nrlipsa(vector_verificare)''' primește vectorul verificat de conformitate cu restricțiile și verifică dacă există două numere lipsă între 100 și 999 în vector.
- Inițial, variabilele '''i''' și '''j''' sunt setate la 0. Acestea vor fi folosite pentru a stoca numerele lipsă.
- Apoi, un buclă '''for''' rulează invers de la 999 la 100 și verifică dacă elementul de pe acea poziție din vectorul verificat este 0. Dacă este așa, înseamnă că acel număr nu există în vectorul dat și trebuie stocat în '''i''' sau '''j'''.
- Dacă două numere lipsă sunt găsite, funcția va scrie aceste numere în fișierul de ieșire. În caz contrar, va scrie "NU".

- Funcția '''conform_restrictiilor()''' citeste datele din fișierul de intrare și verifica daca sunt conforme cu restricțiile impuse.
- În primul rând, variabilele '''vector''' și '''vector_verificare''' sunt inițializate. '''vector''' va fi folosit pentru a stoca datele din fișierul de intrare și '''vector_verificare''' va fi folosit pentru a verifica daca numerele între 100 și 999 există în vectorul dat.
- Apoi, fișierul de intrare este deschis și datele sunt citite și stocate în variabila '''vector'''.
- Dacă numărul de elemente din '''vector''' depășește 100000, funcția va afișa un mesaj de eroare și se va opri.
- Pentru fiecare element din '''vector''', funcția verifică dacă acesta este negativ, sau dacă depășește valoarea maximă admisă de 1000000. De asemenea, dacă un element este între 100 și 999, variabila '''vector_verificare''' va fi actualizată la poziția respectivă pentru a indica faptul că acel număr există în vectorul dat.
- Dacă datele sunt conforme, funcția va returna vectorul '''vector_verificare''' pentru a fi folosit de funcția '''nrlipsa()'''.

- În blocul principal, mai întâi se apelează funcția '''conform_restrictiilor()''' pentru a verifica datele din fișierul de intrare. Dacă datele sunt conforme, se va apela funcția `nrlipsa()` pentru a căuta două numere lipsă și a le scrie în fișierul de ieșire.

0529 - Cifre4

2023-04-30T13:12:37Z

Csula Beatrice:

Sursa: [https://www.pbinfo.ro/probleme/529/cifre4 - Cifre4]
----
== Cerinţa ==
Se dau '''numar''' numere naturale. Afișați cifrele care apar în scrierea zecimală a acestor numere, în ordinea crescătoare a numărului de apariții. Dacă două cifre au același număr de apariții, se va afișa mai întâi cifra mai mică,
== Date de intrare ==
Programul citește de la tastatură numărul '''numar''', iar apoi '''numar''' numere naturale.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt corecte.", iar apoi se va afișa pe ecran numărul cifrele care apar în scrierea zecimală a numerelor citite, în ordinea cerută, separate prin exact un spațiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 &les; '''numar''' &les; 1000
* cele '''numar''' numere citite vor fi mai mici decât 1.000.000.000
== Exemple ==
===Exemplul 1===
; Intrare
: 5
: 124 229 1322 4 534
; Ieșire
: Datele sunt corecte.
: 5 9 1 3 4 2
===Exemplul 2===
; Intrare
: 4
: 1000001 214141251521 20 20
; Ieșire
: Datele nu corespund restricțiilor impuse.
===Exemplul 3===
; Intrare
: 5
: 11 12 13 14 15
; Ieșire
: Datele sunt corecte.
: 2 3 4 5 1
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0529 Cifre4

def numere(vector, numar):
vector = str(vector)
counter = list()
for i in range(10):
counter.append([vector.count(str(i))])
counter[i].append(i)
counter.sort()
for i in range(10):
if counter[i][0] > 0:
print(counter[i][1], end=" ")

def conform_restrictiilor(numar, vector):
if numar < 1 or numar > 1000:
print("Datele nu sunt comform restricțiilor impuse.")
return False
for x in vector:
if x > 100000000 or x < 1:
print("Datele nu sunt comform restricțiilor impuse.")
return False
print("Datele sunt corecte.")
return True

if __name__ == '__main__':
numar = int(input())
vector = list(map(int, input().split()))
if conform_restrictiilor(numar, vector) is True:
numere(vector, numar)

</syntaxhighlight>

==Explicaţie cod==

Acest cod primește ca input un număr și un vector de numere întregi. Scopul codului este de a număra câte apariții are fiecare cifră în numerele din vector și de a le afișa în ordine crescătoare a numărului de apariții.

Funcția '''numere(vector, numar)''' primește două argumente: '''vector''' - vectorul de numere întregi și '''numar''' - numărul de elemente din vector. Ea transformă vectorul într-un șir de caractere și apoi numără câte apariții are fiecare cifră. Pentru aceasta, se parcurg cifrele de la 0 la 9 și se numără câte apariții are fiecare cifră în șirul de caractere. Aceste valori sunt adăugate într-o listă '''counter''', împreună cu cifra corespunzătoare. Lista este sortată în ordine crescătoare a numărului de apariții și apoi se afișează cifrele în ordine crescătoare a numărului de apariții.

Funcția '''conform_restrictiilor(numar, vector)''' primește două argumente: '''numar''' - numărul de elemente din '''vector''' și '''vector''' - vectorul de numere întregi. Aceasta verifică dacă valorile primite sunt conforme cu restricțiile impuse. Restricțiile impuse sunt următoarele: numărul de elemente din '''vector''' trebuie să fie între 1 și 1000, iar fiecare element din vector trebuie să fie între 1 și 100000000. Dacă datele nu sunt conforme, se afișează un mesaj de eroare și se returnează False. În caz contrar, se afișează un mesaj de confirmare și se returnează True.

În funcția principală '''if __name__ == '__main__':''', se citește numărul numar și vectorul vector din input. Se verifică dacă datele sunt conforme cu restricțiile impuse folosind funcția conform_restrictiilor. Dacă datele sunt conforme, se calculează și se afișează numărul de apariții ale fiecărei cifre în numerele din vector folosind funcția '''numere'''.