Bitnami MediaWiki - User contributions [en]

28203

2023-12-17T12:11:09Z

Tamas Claudia:

'''28203 (Dana Heuberger, Baia Mare)'''

''Fie <math> f: \mathbb{R} \longrightarrow \mathbb{R} </math> o funcție cu proprietatea

<math>\mathcal{P}: f(f(x)-e^x)=e^{f(x)-e^x} + x</math>, pentru orice <math>x\in \mathbb{R}.</math>

<ol type="a"><li> Dați exemplu de funcție cu proprietatea <math> \mathcal{P}</math> care nu este monotonă. </li>
<li> Dați exemplu de funcție cu proprietatea <math> \mathcal{P}</math> care nu este continuă.</li>

<li> Fie f o funcție care admite primitive și are proprietatea <math> \mathcal{P}</math> . Arătați că, dacă <math>f(x)\ge e^x</math>, pentru orice <math>x\ge 0</math>, atunci <math>f</math> este surjectivă.</li></ol>''

'''Soluție:'''
Considerând funcția <math>g: \mathbb{R} \longrightarrow \mathbb{R}, g(x) = f(x) - e^x </math>, relația din enunț are forma echivalentă <math>g(g(x)) = x</math>, pentru orice <math>x\in \mathbb{R}, (1).</math>

a) Alegem <math>g(x)=-x</math> care verifică <math>(1)</math>, și obținem <math>f(x)=e^x-x</math>, care nu este monotonă,, întrucât <math>f'(x)=e^x-1</math> își schimbă semnul pe <math> \mathbb{R}</math>.

b) Alegem <math> g(x) = \begin{cases} x, & x\in \mathbb{Q} \\-x, & x\in \mathbb{R} \backslash \mathbb{Q} \end{cases} </math>, care verifică <math>(1)</math> și obținem

<math>f(x)= e^x + g(x) = \begin{cases} e^x, & x\in \mathbb{Q} \\e^x-x, & x\in \mathbb{R} \backslash \mathbb{Q} \end{cases} </math>. Deoarece <math>f</math> este suma dintre o funcție continuă și alta discontinuă (în orice punct din <math>\mathbb{R}^\ast</math> ), rezultă că <math>f</math> este discontinuă.

c) Pe baza ipotezelor asupra funcției <math>f</math>, rezultă că <math>g(x)\ge 0</math>, pentru orice <math>x\ge 0</math>, iar <math>g</math> admite primitive, deci are proprietatea lui Darboux. Combinând această proprietate cu injectivitatea funcției <math>g</math>, obținută din <math>(1)</math>, rezultă că <math>g</math> este strict monotonă și continuă.

În cazul în care <math>g</math> ar fi strict descrescătoare, pe baza surjectivității funcției <math>g</math>, ce se obține din <math>(1)</math>, am avea că <math>\lim_{x \to \infty}g(x) =-\infty </math>, ceea ce contrazice că <math>g(x)\ge 0</math> pentru orice <math>x\ge 0</math>. Prin urmare, <math>g</math> este strict crescătoare, <math>\lim_{x \to -\infty}g(x) =-\infty </math>, <math>\lim_{x \to \infty}g(x) =\infty </math>, ceea ce conduce la <math>\lim_{x \to -\infty}f(x) =-\infty </math>, <math>\lim_{x \to \infty}f(x) =\infty </math>, iar surjectivitatea funcției <math>f</math> este o consecință a proprietății lui Darboux, în particular a continuității.

28203

2023-12-17T11:59:05Z

Tamas Claudia:

28203

2023-12-17T11:17:21Z

Tamas Claudia:

'''28203 (Dana Heuberger, Baia Mare)'''

''Fie'' <math>
</math>''

''a) Dați exemplu de funcție cu proprietatea <math> P</math> care nu este monotonă.''

''b) Dați exemplu de funcție cu proprietatea <math> P</math> care nu este continuă.''

''c) Fie f o funcție care admite primitive și are proprietatea <math> P</math> . Arătați că, dacă f(x)''

'''Soluție:'''

28203

2023-12-15T06:44:25Z

Tamas Claudia:

'''28203 (Dana Heuberger, Baia Mare)'''

''Fie'' <math>
</math>''

''a) Dați exemplu de funcție cu proprietatea P care nu este monotonă.''

''b) Dați exemplu de funcție cu proprietatea P care nu este continuă.''

''c) Fie f o funcție care admite primitive și are proprietatea P. Arătați că, dacă f(x)''

'''Soluție:'''

28203

2023-12-15T06:44:10Z

Tamas Claudia:

'''28203 (Dana Heuberger, Baia Mare)'''

''Fie'' <math>
</math>''

''a) Dați exemplu de funcție cu proprietatea P care nu este monotonă.''
''b) Dați exemplu de funcție cu proprietatea P care nu este continuă.''
''c) Fie f o funcție care admite primitive și are proprietatea P. Arătați că, dacă f(x)''

'''Soluție:'''

28203

2023-12-15T06:43:00Z

Tamas Claudia: Pagină nouă: '''28203 (Dana Heuberger, Baia Mare)''' ''Fie'' <math> </math>'' a) Dați exemplu de funcție cu proprietatea P care nu este monotonă. b) Dați exemplu de funcție cu proprietatea P care nu este continuă. c) Fie f o funcție care admite primitive și are proprietatea P. Arătați că, dacă f(x) '''Soluție:'''

'''28203 (Dana Heuberger, Baia Mare)'''

''Fie'' <math>
</math>''

a) Dați exemplu de funcție cu proprietatea P care nu este monotonă.
b) Dați exemplu de funcție cu proprietatea P care nu este continuă.
c) Fie f o funcție care admite primitive și are proprietatea P. Arătați că, dacă f(x)

'''Soluție:'''

2221 - Cifre 003

2023-05-15T05:27:28Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2221/cifre003]
== Cerinţa ==
Se dă un număr natural '''n'''. Să se afle câte dintre numerele obținute din '''n''' prin ștergerea unei cifre, sunt divizibile cu 3.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa numărul numerelor obţinute din '''n''' prin ștergerea unei cifre, care sunt divizibile cu 3. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* 1 &les; n &les;2.000.000.000
* dacă '''n''' are o cifră, prin ştergerea unei cifre el devine 0
* dacă prin ştergerea unei cifre numărul rămas începe cu 0, zerourile de la început se elimină
== Exemplu ==
; Intrare
: 23701
; Ieșire
: "Datele introduse sunt corecte."
: 2
== Explicație ==
Prin eliminarea cifrei 1 se obţine numărul 2370 divizibil cu 3, iar prin eliminarea cifrei 7 se obţine 2301 divizibil cu 3.
== Rezolvare ==

<syntaxhighlight lang="python" line>

def este_numar_valid(numar):
if numar.isdigit() and int(numar) >= 1 and int(numar) <= 2000000000:
return True
return False

def numar_divizibile_cu_3(numar):
numere_divizibile_cu_3 = 0
for i in range(len(numar)):
cifra = int(numar[i])
numar_fara_cifra = numar[:i] + numar[i + 1:]
if int(numar_fara_cifra) % 3 == 0:
numere_divizibile_cu_3 += 1
return numere_divizibile_cu_3

if __name__ == '__main__':
numar = int(input("Introduceti numarul: ").strip())
if este_numar_valid(numar):
print("Datele introduse sunt corecte.")
print(numar_divizibile_cu_3(int(numar)))
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''este_numar_valid(numar)''' verifică dacă '''numar''' este un număr natural valid, adică este format doar din cifre și este în intervalul [1, 2000000000]. Dacă numărul este valid, funcția returnează '''True''', altfel returnează '''False'''. Funcția '''numar_divizibile_cu_3(numar)''' primește ca parametru un număr și determină câte dintre numerele obținute prin ștergerea unei cifre sunt divizibile cu 3. Aceasta folosește o buclă for pentru a itera prin fiecare cifră din numar, elimină cifra curentă și verifică dacă numărul obținut este divizibil cu 3. Dacă acesta este divizibil cu 3, funcția incrementează un contor '''numere_divizibile_cu_3'''. Funcția returnează numărul de numere divizibile cu 3. Funcția principală primește un număr de la utilizator folosind funcția input(). Aceasta verifică dacă numărul este valid folosind funcția '''este_numar_valid(numar)'''. Dacă numărul este valid, se afișează un mesaj de confirmare și numărul de numere divizibile cu 3 prin apelul funcției '''numar_divizibile_cu_3(numar)'''. Dacă numărul nu este valid, se afișează un mesaj de eroare.

2661 - Eliminare Cifra Mijloc

2023-05-05T17:52:58Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2661/eliminareciframijloc]

== Cerinţa ==
Se dă un număr natural '''n''' despre care știm că are număr impar de cifre. Să se afișeze valoarea obținută prin eliminarea cifrei din mijloc.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa valoarea obținută prin eliminarea cifrei din mijloc din numarul citit. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 100 &les; n &les; 10.000.000.000.000.000'''
* se garantează că '''n''' are număr impar de cifre.

== Exemplu ==
; Intrare
: 257
; Ieșire
: Datele introduse sunt corecte.
: Numărul obținut prin eliminarea cifrei din mijloc este: 27
== Rezolvare ==

<syntaxhighlight lang="python" line>

def verifica_numar(numar):
if isinstance(numar, str):
numar = int(numar)
if not 100 <= numar < 10**16:
return False
if numar % 2 == 0:
return False
return True

def elimina_cifra_mijloc(numar):
if isinstance(numar, str):
numar = int(numar)
mijloc = len(str(numar)) // 2
nou = str(numar)[:mijloc] + str(numar)[mijloc+1:]
return int(nou)

if __name__ == '__main__':
numar = int(input("Introduceți un număr cu un număr impar de cifre: "))
if verifica_numar(numar):
print("Datele introduse sunt corecte.")
rezultat = elimina_cifra_mijloc(numar)
print("Numărul obținut prin eliminarea cifrei din mijloc este:", rezultat)
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''verifica_numar(numar)''' verifică dacă numărul dat are un număr impar de cifre și se află în intervalul [100, 10^16).
* '''if isinstance(numar, str):''' - dacă numărul este de tipul '''str'', acesta este convertit la '''int''' folosind * int(numar).
* '''if not 100 <= numar < 10**16:''' - verifică dacă numărul este în intervalul '''[100, 10^16)''', altfel returnează '''False'''.
* '''if numar % 2 == 0:''' - verifică dacă numărul are un număr impar de cifre, dacă nu, returnează '''False'''.
* '''return True''' - dacă numărul îndeplinește toate condițiile de validitate, returnează '''True'''.
 

Funcția '''elimina_cifra_mijloc(numar)''' elimină cifra din mijlocul unui număr impar de cifre.
* '''if isinstance(numar, str):''' - dacă numărul este de tipul str, acesta este convertit la int folosind int(numar).
* '''mijloc = len(str(numar)) // 2''' - calculează poziția cifrei din mijloc.
* '''nou = str(numar)[:mijloc] + str(numar)[mijloc+1:]''' - elimină cifra din mijloc și creează un nou număr.
* '''return int(nou)''' - returnează noul număr obținut prin eliminarea cifrei din mijloc, sub forma unui int.
 

În blocul '''if __name__ == '__main__':''', utilizatorul trebuie să introducă un număr cu un număr impar de cifre.
* '''if verifica_numar(numar):''' - verifică dacă numărul introdus este valid.
* '''print("Datele introduse sunt corecte.")''' - afișează un mesaj de confirmare.
* '''rezultat = elimina_cifra_mijloc(numar)''' - elimină cifra din mijloc și obține noul număr.
* '''print("Numărul obținut prin eliminarea cifrei din mijloc este:", rezultat)''' - afișează noul număr obținut prin eliminarea cifrei din mijloc.
* '''else:''' - dacă numărul introdus nu este valid, afișează un mesaj de eroare.

4227 - Cif Tr

2023-05-05T17:52:23Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/4227/cif-tr]

== Cerinţa ==
Când adunăm două cifre '''cifra1''' și '''cifra2''', obținem transport dacă '''cifra1''' + '''cifra2''' ≥ 10. Când adunăm două numere naturale, se poate obține chiar de mai multe ori transport. De exemplu, dacă adunăm 538 și 726, atunci obținem de două ori transport, prima oară când adunăm cifrele unităților, 8 + 6, a doua oară când adunăm cifrele sutelor, 5 + 7. 
Se dau două numere naturale '''n''' și '''m''' care au același număr de cifre. Să se afișeze mesajul NU dacă adunând cele două numere cifră cu cifră nu obținem niciodată transport, sau mesajul DA, dacă obținem măcar o dată transport.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' și '''m'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa mesajul '''NU''' dacă adunând cele două numere cifră cu cifră nu obținem niciodată transport, sau mesajul '''DA''', dacă obținem măcar o dată transport. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n, m &les; 1.000.000.000
* numerele '''n''' și '''m''' au același număr de cifre

== Exemplu ==
; Intrare
: 538 726
; Ieșire
: Datele introduse sunt corecte.
: DA
 
; Intrare
: 1234 8765
; Ieșire
: Datele introduse sunt corecte.
: NU
== Rezolvare ==

<syntaxhighlight lang="python" line>
#4227

def verifica_date(numar1, numar2):
if len(numar1) != len(numar2) or not numar1.isdigit() or not numar2.isdigit():
print("Datele introduse nu sunt corecte.")
return False
print("Datele introduse sunt corecte.")
return True

def are_transport(numar1, numar2):
for i in range(len(numar1)):
suma = int(numar1[i]) + int(numar2[i])
if suma >= 10:
return True
return False

if __name__ == "__main__":
numar1 = int(input("Introduceti primul numar: "))
numar2 = int(input("Introduceti al doilea numar: "))
if verifica_date(numar1, numar2):
if are_transport(numar1, numar2):
print("DA")
else:
print("NU")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''verifica_date''' primește două argumente, '''numar1''' și '''numar2''', și verifică dacă acestea au aceeași lungime și dacă fiecare cifră din cele două numere este un număr întreg. Dacă aceste condiții sunt îndeplinite, funcția afișează "Datele introduse sunt corecte." și returnează valoarea True, în caz contrar, afișează "Datele introduse nu sunt corecte." și returnează valoarea False. Funcția '''are_transport''' primește, de asemenea, două argumente, '''numar1''' și '''numar2''', și verifică dacă există cel puțin un transport atunci când cele două numere sunt adunate cifră cu cifră. Pentru aceasta, funcția parcurge cifră cu cifră cele două numere și calculează suma. Dacă suma este mai mare sau egală cu 10, funcția returnează valoarea '''True''', altfel returnează valoarea '''False'''. În final, funcția '''main''' primește două valori de la utilizator prin intermediul funcției '''input''', apelează funcția '''verifica_date''' pentru a verifica corectitudinea datelor, iar dacă acestea sunt corecte, apelează funcția '''are_transport''' pentru a verifica dacă există un transport în timpul adunării. În funcție de rezultatul obținut, programul afișează '''DA''' dacă există cel puțin un transport și '''NU''' dacă nu există niciun transport.

2221 - Cifre 003

2023-05-05T17:51:40Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2221/cifre003]
== Cerinţa ==
Se dă un număr natural '''n'''. Să se afle câte dintre numerele obținute din '''n''' prin ștergerea unei cifre, sunt divizibile cu 3.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa numărul numerelor obţinute din '''n''' prin ștergerea unei cifre, care sunt divizibile cu 3. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* 1 &les; n &les;2.000.000.000
* dacă '''n''' are o cifră, prin ştergerea unei cifre el devine 0
* dacă prin ştergerea unei cifre numărul rămas începe cu 0, zerourile de la început se elimină
== Exemplu ==
; Intrare
: 23701
; Ieșire
: "Datele introduse sunt corecte."
: 2
== Explicație ==
Prin eliminarea cifrei 1 se obţine numărul 2370 divizibil cu 3, iar prin eliminarea cifrei 7 se obţine 2301 divizibil cu 3.
== Rezolvare ==

<syntaxhighlight lang="python" line>

def este_numar_valid(numar):
if numar.isdigit() and int(numar) >= 1 and int(numar) <= 2000000000:
return True
return False

def numar_divizibile_cu_3(numar):
numere_divizibile_cu_3 = 0
for i in range(len(numar)):
cifra = int(numar[i])
numar_fara_cifra = numar[:i] + numar[i + 1:]
if int(numar_fara_cifra) % 3 == 0:
numere_divizibile_cu_3 += 1
return numere_divizibile_cu_3

if __name__ == '__main__':
numar = input("Introduceti numarul: ").strip()
if este_numar_valid(numar):
print("Datele introduse sunt corecte.")
print(numar_divizibile_cu_3(int(numar)))
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''este_numar_valid(numar)''' verifică dacă '''numar''' este un număr natural valid, adică este format doar din cifre și este în intervalul [1, 2000000000]. Dacă numărul este valid, funcția returnează '''True''', altfel returnează '''False'''. Funcția '''numar_divizibile_cu_3(numar)''' primește ca parametru un număr și determină câte dintre numerele obținute prin ștergerea unei cifre sunt divizibile cu 3. Aceasta folosește o buclă for pentru a itera prin fiecare cifră din numar, elimină cifra curentă și verifică dacă numărul obținut este divizibil cu 3. Dacă acesta este divizibil cu 3, funcția incrementează un contor '''numere_divizibile_cu_3'''. Funcția returnează numărul de numere divizibile cu 3. Funcția principală primește un număr de la utilizator folosind funcția input(). Aceasta verifică dacă numărul este valid folosind funcția '''este_numar_valid(numar)'''. Dacă numărul este valid, se afișează un mesaj de confirmare și numărul de numere divizibile cu 3 prin apelul funcției '''numar_divizibile_cu_3(numar)'''. Dacă numărul nu este valid, se afișează un mesaj de eroare.

2288 - Cifra Impara Maxima

2023-05-05T17:50:06Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2288/cifraimparamaxima]

== Cerinţa ==
Să se scrie un program care să determine cea mai mare cifră impară a unui număr natural citit de la tastatură.
== Date de intrare ==
Programul va citi de la tastatură un număr natural.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi se va afișa cea mai mare cifră impară numărului citit. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* numărul citit va fi mai mic decât 2.000.000.000
* dacă numărul citit nu conține cifre impare se va afișa mesajul '''Numărul citit nu conține cifre impare."'''
== Exemplu ==
; Intrare
: 2785
; Ieșire
: Datele introduse sunt corecte.
: 7

 
; Intrare
: 2064

; Ieșire
: Numărul citit nu conține cifre impare.

== Rezolvare ==

<syntaxhighlight lang="python" line>
#2288

def verificare_numar(numar):
"""
Verifica daca numarul este un numar natural mai mic decat 2.000.000.000.
"""
return isinstance(numar, int) and 0 <= numar < 2000000000

def determina_cifra_maxima_impara(numar):
"""
Determina cea mai mare cifra impara a unui numar.
"""
max_cifra_impara = -1
while numar != 0:
cifra = numar % 10
if cifra % 2 == 1 and cifra > max_cifra_impara:
max_cifra_impara = cifra
numar //= 10
if max_cifra_impara == -1:
return "Nu exista."
else:
return max_cifra_impara

if __name__ == "__main__":
# Citeste un numar de la tastatura
numar = int(input("Introduceti un numar natural: "))
try:
numar = int(numar)
if verificare_numar(numar):
# Afiseaza mesajul "Datele sunt introduse corect." si cea mai mare cifra impara a numarului
print("Datele sunt introduse corect.")
print(determina_cifra_maxima_impara(numar))
else:
# Afiseaza mesajul "Datele nu au fost introduse corect."
print("Datele nu au fost introduse corect.")
except ValueError:
# Afiseaza mesajul "Datele nu au fost introduse corect."
print("Datele nu au fost introduse corect.")

</syntaxhighlight>

1566 - Cif Sort

2023-05-05T09:54:19Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/1566/cifsort]
== Cerinţa ==
Se da numarul natural '''n'''. Afisati numarul, cu prima cifra inversata cu a 2-a, a 3-a cu a 4-a, etc.
== 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 '''"Datele sunt introduse corect."''', apoi se va afișa numarul, cu prima cifra inversata cu a 2-a, a 3-a cu a 4-a, etc. În caz contrar, se va afișa pe ecran. '''"Datele nu au fost introduse corect."'''.
== Restricții și precizări ==
* '''10 &les; n &les; 99.999.999'''
* '''n''' are un numar par de cifre.
== Exemplu ==
; Intrare
: 123456
; Ieșire
: Datele au fost introduse corect.
: 214365
== Explicație ==
1 a fost inversat cu 2, 3 cu 4, iar 5 cu 6.
== Rezolvare ==

<syntaxhighlight lang="python" line>
#1566

def verificare(numar):
if len(numar) % 2 != 0:
return False
try:
int(numar)
return True
except ValueError:
return False

def rezolvare(numar):
invers = ""
for i in range(0, len(numar), 2):
invers += numar[i+1]
invers += numar[i]
return int(invers)

if __name__ == "__main__":
numar = int(input("Introduceti un numar cu un numar par de cifre: "))
if verificare(numar):
print("Datele sunt introduse corect.")
print(rezolvare(numar))
else:
print("Datele nu au fost introduse corect.")

</syntaxhighlight>

== Explicație cod ==
Funcția '''verificare(numar)''' verifică dacă numărul are un număr par de cifre și dacă toate cifrele sunt cifre întregi. Dacă aceste condiții sunt îndeplinite, funcția returnează '''True''', altfel returnează '''False'''. Funcția '''rezolvare(numar)''' primește numărul și creează un șir de caractere în care cifrele inversează poziția. Algoritmul funcției merge prin număr începând cu prima cifră și adăugând în noul șir caracterul de pe poziția impară și apoi caracterul de pe poziția pară, adică inversând poziția acestora. Funcția returnează numărul întors. Instrucțiunea '''if __name__ == "__main__":''' citește numărul de la tastatură, verifică dacă datele sunt introduse corect folosind funcția '''verificare(numar)''' și afișează rezultatul apelând funcția '''rezolvare(numar)''' în cazul în care datele sunt corecte sau afișează mesajul '''"Datele au fost introduse corect."''' în caz contrar, se afișează mesajul '''"Datele nu au fost introduse corect"'''.

2661 - Eliminare Cifra Mijloc

2023-04-29T07:24:17Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2661/eliminareciframijloc]

== Cerinţa ==
Se dă un număr natural '''n''' despre care știm că are număr impar de cifre. Să se afișeze valoarea obținută prin eliminarea cifrei din mijloc.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa valoarea obținută prin eliminarea cifrei din mijloc din numarul citit. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 100 &les; n &les; 10.000.000.000.000.000'''
* se garantează că '''n''' are număr impar de cifre.

== Exemplu ==
; Intrare
: 257
; Ieșire
: Datele introduse sunt corecte.
: Numărul obținut prin eliminarea cifrei din mijloc este: 27
== Rezolvare ==

<syntaxhighlight lang="python" line>

def verifica_numar(numar):
if isinstance(numar, str):
numar = int(numar)
if not 100 <= numar < 10**16:
return False
if numar % 2 == 0:
return False
return True

def elimina_cifra_mijloc(numar):
if isinstance(numar, str):
numar = int(numar)
mijloc = len(str(numar)) // 2
nou = str(numar)[:mijloc] + str(numar)[mijloc+1:]
return int(nou)

if __name__ == '__main__':
numar = input("Introduceți un număr cu un număr impar de cifre: ")
if verifica_numar(numar):
print("Datele introduse sunt corecte.")
rezultat = elimina_cifra_mijloc(numar)
print("Numărul obținut prin eliminarea cifrei din mijloc este:", rezultat)
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''verifica_numar(numar)''' verifică dacă numărul dat are un număr impar de cifre și se află în intervalul [100, 10^16).
* '''if isinstance(numar, str):''' - dacă numărul este de tipul '''str'', acesta este convertit la '''int''' folosind * int(numar).
* '''if not 100 <= numar < 10**16:''' - verifică dacă numărul este în intervalul '''[100, 10^16)''', altfel returnează '''False'''.
* '''if numar % 2 == 0:''' - verifică dacă numărul are un număr impar de cifre, dacă nu, returnează '''False'''.
* '''return True''' - dacă numărul îndeplinește toate condițiile de validitate, returnează '''True'''.
 

Funcția '''elimina_cifra_mijloc(numar)''' elimină cifra din mijlocul unui număr impar de cifre.
* '''if isinstance(numar, str):''' - dacă numărul este de tipul str, acesta este convertit la int folosind int(numar).
* '''mijloc = len(str(numar)) // 2''' - calculează poziția cifrei din mijloc.
* '''nou = str(numar)[:mijloc] + str(numar)[mijloc+1:]''' - elimină cifra din mijloc și creează un nou număr.
* '''return int(nou)''' - returnează noul număr obținut prin eliminarea cifrei din mijloc, sub forma unui int.
 

În blocul '''if __name__ == '__main__':''', utilizatorul trebuie să introducă un număr cu un număr impar de cifre.
* '''if verifica_numar(numar):''' - verifică dacă numărul introdus este valid.
* '''print("Datele introduse sunt corecte.")''' - afișează un mesaj de confirmare.
* '''rezultat = elimina_cifra_mijloc(numar)''' - elimină cifra din mijloc și obține noul număr.
* '''print("Numărul obținut prin eliminarea cifrei din mijloc este:", rezultat)''' - afișează noul număr obținut prin eliminarea cifrei din mijloc.
* '''else:''' - dacă numărul introdus nu este valid, afișează un mesaj de eroare.

2661 - Eliminare Cifra Mijloc

2023-04-29T07:23:50Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2661/eliminareciframijloc]

== Cerinţa ==
Se dă un număr natural '''n''' despre care știm că are număr impar de cifre. Să se afișeze valoarea obținută prin eliminarea cifrei din mijloc.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa valoarea obținută prin eliminarea cifrei din mijloc din numarul citit. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 100 &les; n &les; 10.000.000.000.000.000'''
* se garantează că '''n''' are număr impar de cifre.

== Exemplu ==
; Intrare
: 257
; Ieșire
: Datele introduse sunt corecte.
: Numărul obținut prin eliminarea cifrei din mijloc este: 27
== Rezolvare ==

<syntaxhighlight lang="python" line>

def verifica_numar(numar):
"""
Verifică dacă numărul dat are un număr impar de cifre și se află în intervalul [100, 10^16).
:param numar: int sau str - numărul de verificat
:return: bool - True dacă numărul este valid, False în caz contrar
"""
if isinstance(numar, str):
numar = int(numar)
if not 100 <= numar < 10**16:
return False
if numar % 2 == 0:
return False
return True

def elimina_cifra_mijloc(numar):
"""
Elimină cifra din mijlocul unui număr impar de cifre.
:param numar: int sau str - numărul din care se va elimina cifra din mijloc
:return: int - numărul obținut prin eliminarea cifrei din mijloc
"""
if isinstance(numar, str):
numar = int(numar)
mijloc = len(str(numar)) // 2
nou = str(numar)[:mijloc] + str(numar)[mijloc+1:]
return int(nou)

if __name__ == '__main__':
numar = input("Introduceți un număr cu un număr impar de cifre: ")
if verifica_numar(numar):
print("Datele introduse sunt corecte.")
rezultat = elimina_cifra_mijloc(numar)
print("Numărul obținut prin eliminarea cifrei din mijloc este:", rezultat)
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''verifica_numar(numar)''' verifică dacă numărul dat are un număr impar de cifre și se află în intervalul [100, 10^16).
* '''if isinstance(numar, str):''' - dacă numărul este de tipul '''str'', acesta este convertit la '''int''' folosind * int(numar).
* '''if not 100 <= numar < 10**16:''' - verifică dacă numărul este în intervalul '''[100, 10^16)''', altfel returnează '''False'''.
* '''if numar % 2 == 0:''' - verifică dacă numărul are un număr impar de cifre, dacă nu, returnează '''False'''.
* '''return True''' - dacă numărul îndeplinește toate condițiile de validitate, returnează '''True'''.
 

Funcția '''elimina_cifra_mijloc(numar)''' elimină cifra din mijlocul unui număr impar de cifre.
* '''if isinstance(numar, str):''' - dacă numărul este de tipul str, acesta este convertit la int folosind int(numar).
* '''mijloc = len(str(numar)) // 2''' - calculează poziția cifrei din mijloc.
* '''nou = str(numar)[:mijloc] + str(numar)[mijloc+1:]''' - elimină cifra din mijloc și creează un nou număr.
* '''return int(nou)''' - returnează noul număr obținut prin eliminarea cifrei din mijloc, sub forma unui int.
 

În blocul '''if __name__ == '__main__':''', utilizatorul trebuie să introducă un număr cu un număr impar de cifre.
* '''if verifica_numar(numar):''' - verifică dacă numărul introdus este valid.
* '''print("Datele introduse sunt corecte.")''' - afișează un mesaj de confirmare.
* '''rezultat = elimina_cifra_mijloc(numar)''' - elimină cifra din mijloc și obține noul număr.
* '''print("Numărul obținut prin eliminarea cifrei din mijloc este:", rezultat)''' - afișează noul număr obținut prin eliminarea cifrei din mijloc.
* '''else:''' - dacă numărul introdus nu este valid, afișează un mesaj de eroare.

2661 - Eliminare Cifra Mijloc

2023-04-29T07:23:24Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2661/eliminareciframijloc]

== Cerinţa ==
Se dă un număr natural '''n''' despre care știm că are număr impar de cifre. Să se afișeze valoarea obținută prin eliminarea cifrei din mijloc.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa valoarea obținută prin eliminarea cifrei din mijloc din numarul citit. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 100 &les; n &les; 10.000.000.000.000.000'''
* se garantează că '''n''' are număr impar de cifre.

== Exemplu ==
; Intrare
: 257
; Ieșire
: Datele introduse sunt corecte.
: Numărul obținut prin eliminarea cifrei din mijloc este: 27
== Rezolvare ==

<syntaxhighlight lang="python" line>

def verifica_numar(numar):
"""
Verifică dacă numărul dat are un număr impar de cifre și se află în intervalul [100, 10^16).
:param numar: int sau str - numărul de verificat
:return: bool - True dacă numărul este valid, False în caz contrar
"""
if isinstance(numar, str):
numar = int(numar)
if not 100 <= numar < 10**16:
return False
if numar % 2 == 0:
return False
return True

def elimina_cifra_mijloc(numar):
"""
Elimină cifra din mijlocul unui număr impar de cifre.
:param numar: int sau str - numărul din care se va elimina cifra din mijloc
:return: int - numărul obținut prin eliminarea cifrei din mijloc
"""
if isinstance(numar, str):
numar = int(numar)
mijloc = len(str(numar)) // 2
nou = str(numar)[:mijloc] + str(numar)[mijloc+1:]
return int(nou)

if __name__ == '__main__':
numar = input("Introduceți un număr cu un număr impar de cifre: ")
if verifica_numar(numar):
print("Datele introduse sunt corecte.")
rezultat = elimina_cifra_mijloc(numar)
print("Numărul obținut prin eliminarea cifrei din mijloc este:", rezultat)
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''verifica_numar(numar)''' verifică dacă numărul dat are un număr impar de cifre și se află în intervalul [100, 10^16).
* '''if isinstance(numar, str):''' - dacă numărul este de tipul '''str'', acesta este convertit la '''int''' folosind * int(numar).
* '''if not 100 <= numar < 10**16:''' - verifică dacă numărul este în intervalul '''[100, 10^16)''', altfel returnează '''False'''.
* '''if numar % 2 == 0:''' - verifică dacă numărul are un număr impar de cifre, dacă nu, returnează '''False'''.
* '''return True''' - dacă numărul îndeplinește toate condițiile de validitate, returnează '''True'''.
 
Funcția '''elimina_cifra_mijloc(numar)''' elimină cifra din mijlocul unui număr impar de cifre.
* '''if isinstance(numar, str):''' - dacă numărul este de tipul str, acesta este convertit la int folosind int(numar).
* '''mijloc = len(str(numar)) // 2''' - calculează poziția cifrei din mijloc.
* '''nou = str(numar)[:mijloc] + str(numar)[mijloc+1:]''' - elimină cifra din mijloc și creează un nou număr.
* '''return int(nou)''' - returnează noul număr obținut prin eliminarea cifrei din mijloc, sub forma unui int. În blocul '''if __name__ == '__main__':''', utilizatorul trebuie să introducă un număr cu un număr impar de cifre.
* '''if verifica_numar(numar):''' - verifică dacă numărul introdus este valid.
* '''print("Datele introduse sunt corecte.")''' - afișează un mesaj de confirmare.
* '''rezultat = elimina_cifra_mijloc(numar)''' - elimină cifra din mijloc și obține noul număr.
* '''print("Numărul obținut prin eliminarea cifrei din mijloc este:", rezultat)''' - afișează noul număr obținut prin eliminarea cifrei din mijloc.
* '''else:''' - dacă numărul introdus nu este valid, afișează un mesaj de eroare.

2661 - Eliminare Cifra Mijloc

2023-04-29T07:23:06Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2661/eliminareciframijloc]

== Cerinţa ==
Se dă un număr natural '''n''' despre care știm că are număr impar de cifre. Să se afișeze valoarea obținută prin eliminarea cifrei din mijloc.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa valoarea obținută prin eliminarea cifrei din mijloc din numarul citit. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 100 &les; n &les; 10.000.000.000.000.000'''
* se garantează că '''n''' are număr impar de cifre.

== Exemplu ==
; Intrare
: 257
; Ieșire
: Datele introduse sunt corecte.
: Numărul obținut prin eliminarea cifrei din mijloc este: 27
== Rezolvare ==

<syntaxhighlight lang="python" line>

def verifica_numar(numar):
"""
Verifică dacă numărul dat are un număr impar de cifre și se află în intervalul [100, 10^16).
:param numar: int sau str - numărul de verificat
:return: bool - True dacă numărul este valid, False în caz contrar
"""
if isinstance(numar, str):
numar = int(numar)
if not 100 <= numar < 10**16:
return False
if numar % 2 == 0:
return False
return True

def elimina_cifra_mijloc(numar):
"""
Elimină cifra din mijlocul unui număr impar de cifre.
:param numar: int sau str - numărul din care se va elimina cifra din mijloc
:return: int - numărul obținut prin eliminarea cifrei din mijloc
"""
if isinstance(numar, str):
numar = int(numar)
mijloc = len(str(numar)) // 2
nou = str(numar)[:mijloc] + str(numar)[mijloc+1:]
return int(nou)

if __name__ == '__main__':
numar = input("Introduceți un număr cu un număr impar de cifre: ")
if verifica_numar(numar):
print("Datele introduse sunt corecte.")
rezultat = elimina_cifra_mijloc(numar)
print("Numărul obținut prin eliminarea cifrei din mijloc este:", rezultat)
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''verifica_numar(numar)''' verifică dacă numărul dat are un număr impar de cifre și se află în intervalul [100, 10^16).
* '''if isinstance(numar, str):''' - dacă numărul este de tipul '''str'', acesta este convertit la '''int''' folosind * int(numar).
* '''if not 100 <= numar < 10**16:''' - verifică dacă numărul este în intervalul '''[100, 10^16)''', altfel returnează '''False'''.
* '''if numar % 2 == 0:''' - verifică dacă numărul are un număr impar de cifre, dacă nu, returnează '''False'''.
* '''return True''' - dacă numărul îndeplinește toate condițiile de validitate, returnează '''True'''.
 Funcția '''elimina_cifra_mijloc(numar)''' elimină cifra din mijlocul unui număr impar de cifre.
* '''if isinstance(numar, str):''' - dacă numărul este de tipul str, acesta este convertit la int folosind int(numar).
* '''mijloc = len(str(numar)) // 2''' - calculează poziția cifrei din mijloc.
* '''nou = str(numar)[:mijloc] + str(numar)[mijloc+1:]''' - elimină cifra din mijloc și creează un nou număr.
* '''return int(nou)''' - returnează noul număr obținut prin eliminarea cifrei din mijloc, sub forma unui int. În blocul '''if __name__ == '__main__':''', utilizatorul trebuie să introducă un număr cu un număr impar de cifre.
* '''if verifica_numar(numar):''' - verifică dacă numărul introdus este valid.
* '''print("Datele introduse sunt corecte.")''' - afișează un mesaj de confirmare.
* '''rezultat = elimina_cifra_mijloc(numar)''' - elimină cifra din mijloc și obține noul număr.
* '''print("Numărul obținut prin eliminarea cifrei din mijloc este:", rezultat)''' - afișează noul număr obținut prin eliminarea cifrei din mijloc.
* '''else:''' - dacă numărul introdus nu este valid, afișează un mesaj de eroare.

0665 - Div Cif

2023-04-29T07:13:04Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/665/divcif]

== Cerinţa ==
Se dau două numere naturale '''n''', '''m'''. Determinați câte numere naturale din intervalul '''[n, m]''' se divid cu toate cifrele lor nenule.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''', '''m'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi rogramul va afișa numărul '''nr''', reprezentând numărul de numere naturale din intervalul '''[n, m]''' care se divid cu toate cifrele lor nenule. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n &les; m &les; 1.000.000.000 '''
* ''' n - m &les; 1.000 '''

== Exemplu ==
; Intrare
: 11 25
; Ieșire
: Datele introduse sunt corecte.
: 6
== Explicație ==
Cele '''6''' numere din intervalul '''[11,25]''' care respectă regula sunt:'''11 12 15 20 22 24'''.
== Rezolvare ==

<syntaxhighlight lang="python" line>
#0665

def verificare_date_intrare(n: int, m: int) -> bool:
"""
Verifică dacă datele de intrare sunt corecte conform cerințelor problemei.
"""
if not(1 <= n <= m <= 1000000000) or not(abs(n-m) <= 1000):
return False
return True

def numarare_numere(n: int, m: int) -> int:
"""
Numără câte numere din intervalul [n, m] se divid cu toate cifrele lor nenule.
"""
k = 0
for i in range(n, m+1):
x = i
aux = i
y = i
cate = 0
p = 0
while x != 0:
if x % 10 != 0:
if aux % (x % 10) == 0:
cate += 1
p += 1
if x % 10 == 0:
cate += 1
x = x // 10
if p == cate:
k += 1
return k

if __name__ == '__main__':
# citirea datelor de intrare
n, m = map(int, input("Introduceti numerele cu spatii intre ele: ").split())

# verificarea datelor de intrare
if not verificare_date_intrare(n, m):
print("Datele introduse nu sunt corecte.")
exit()

# afișarea mesajului de confirmare a datelor de intrare
print("Datele introduse sunt corecte.")

# numărarea numerelor care respectă condiția dată și afișarea rezultatului
k = numarare_numere(n, m)
print(k)

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''verificare_date_intrare''' primește doi parametri întregi '''n''' și '''m''' și returnează '''True''' dacă valorile primite sunt valide, altfel returnează '''False'''. Datele de intrare sunt considerate valide dacă '''n''' și '''m''' sunt între 1 și 1.000.000.000, iar diferența dintre '''n''' și '''m''' este mai mică sau egală cu '''1000'''. Funcția '''abs''' este folosită pentru a evita verificarea a două cazuri. Funcția '''numarare_numere''' primește aceiași doi parametri '''n''' și '''m''' și returnează numărul de numere din intervalul [n, m] care se divid cu toate cifrele lor nenule. În main, se citesc datele de intrare de la tastatură, iar apoi se verifică dacă sunt valide folosind funcția '''verificare_date_intrare'''. Dacă acestea sunt invalide, se afișează un mesaj corespunzător și programul se încheie cu ajutorul funcției exit(). În caz contrar, se afișează un mesaj de confirmare și se numără numerele care respectă condiția dată utilizând funcția '''numarare_numere'''. Rezultatul este apoi afișat la consolă.

0372 - Numarare 1

2023-04-28T19:32:03Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/372/numarare1]

== Cerinţa ==
Se citesc '''n''' numere naturale. Determinați în câte perechi citite consecutiv numerele au sumele cifrelor de parități diferite.
== 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 introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul afișează pe ecran numărul '''m''' , reprezentând numărul de perechi care respectă regula. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n &les; 100 '''
* cele '''n''' numere citite vor avea cel mult '''9''' cifre

== Exemplu ==
; Intrare
: 5
: 176 2943 52422 911 1975
; Ieșire
: Datele introduse sunt corecte.
: 2
== Explicație ==
Cele '''2''' perechi sunt: '''2943 52422, 911 1975.'''

== Rezolvare ==

<syntaxhighlight lang="python" line>

def verifica_date_intrare(n: int, numere: list[int]) -> bool:
if n < 1 or n > 100:
return False
for numar in numere:
if numar < 0 or numar > 999999999:
return False
return True

if __name__ == "__main__":
n = int(input("Introduceti numarul de numere: "))
numere_input = input("Introduceti lista de numere separate prin spatii: ").split()
numere = [int(numar) for numar in numere_input]

if verifica_date_intrare(n, numere):
print("Datele introduse sunt corecte.")
numar_perechi = 0
pr = numere[0]
for i in range(1, n):
x = numere[i]
aux = x
a = pr
s1 = 0
s2 = 0
while aux != 0:
s1 = s1 + aux % 10
aux = aux // 10
while a != 0:
s2 = s2 + a % 10
a = a // 10
if s1 % 2 == 0 and s2 % 2 == 1:
numar_perechi += 1
if s1 % 2 == 1 and s2 % 2 == 0:
numar_perechi += 1
pr = x
print(numar_perechi)
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

== Explicație rezolvare ==
Acest cod începe prin definirea unei funcții '''verifica_date_intrare''' care primește doi parametri: '''n''' de tip int și numere de tip '''list[int]'''. Funcția verifică dacă '''n''' este mai mare sau egal cu 1 și mai mic sau egal cu 100, iar fiecare element din lista numere este mai mare sau egal cu 0 și mai mic sau egal cu 999999999. Dacă oricare dintre aceste condiții nu este îndeplinită, funcția va returna '''False''', altfel va returna '''True'''. Următoarea secțiune a codului verifică datele de intrare prin intermediul funcției verifica_date_intrare. Dacă datele sunt corecte, utilizatorul este informat că datele introduse sunt corecte printr-un mesaj specific. Variabila '''numere_input''' primește o listă de numere introduse de utilizator, care este apoi convertită într-o listă de numere întregi folosind o buclă for și o listă de comprimare. Codul continuă prin inițializarea variabilelor și efectuarea unui număr de iterații de calcul al perechilor de numere. În fiecare iterație, se calculează sumele cifrelor fiecărui număr și se verifică dacă acestea sunt impare sau pare. În funcție de rezultat, variabila '''numar_perechi''' este actualizată. La sfârșit, numărul total de perechi este afișat.

0369 - Oglindit 3

2023-04-28T19:22:15Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/369/oglindit3]

== Cerinţa ==
Se dă un număr natural '''n'''. Calculaţi oglinditul sumei cifrelor sale.
== Date de intrare ==
Programul va citi de la tastatură un număr natural '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afişa oglinditul sumei cifrelor lui '''n'''. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* numărul citit va fi mai mic decât <math>2^{31}</math>.

== Exemplu ==
; Intrare
: 2705
; Ieșire
: Datele introduse sunt corecte.
: 41
== Explicație ==
Suma cifrelor lui '''2705''' este '''14''', iar oglinditul lui '''14''' este '''41'''.
== Rezolvare ==

<syntaxhighlight lang="python" line>
#0369

def verifica_numar(numar):
if numar >= 0 and numar < 2**31:
return True
else:
return False

if __name__ == '__main__':
numar = int(input("Introduceti numarul: "))
if verifica_numar(numar):
print("Datele introduse sunt corecte.")
suma_cifre = 0
while numar != 0:
cifra = numar % 10
suma_cifre += cifra
numar //= 10

oglindit = 0
while suma_cifre != 0:
cifra = suma_cifre % 10
oglindit = oglindit * 10 + cifra
suma_cifre //= 10

print(oglindit)
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

== Explicație rezolvare ==
În funcția '''verifica_numar''', se primește un număr și se verifică dacă se află în intervalul [0, 2^31-1]. Dacă numărul este în acest interval, se returnează adevărat (True), altfel se returnează fals (False). În funcția '''main''', se citește numărul de la tastatură folosind funcția '''input()''', care primește un string ce va fi afișat în consolă ca mesaj pentru utilizator. Apoi, se apelează funcția '''verifica_numar''' pentru a verifica dacă numărul introdus este valid. Dacă numărul este valid, se afișează un mesaj corespunzător prin intermediul funcției print(). Se inițializează variabila '''suma_cifre''' cu 0 și se intră într-un '''while''' loop, care va calcula suma cifrelor numărului prin împărțirea repetată a acestuia la 10 și adunarea resturilor. Acest lucru se realizează prin calcularea modulului cu 10 al numărului (cifra unităților) și adăugarea acesteia la variabila suma_cifre. După fiecare iterație, numărul se împarte la 10 pentru a se obține următoarea cifră. Se inițializează variabila '''oglindit''' cu 0 și se intră în alt while loop care va calcula oglinditul sumei cifrelor. Acest lucru se face prin împărțirea repetată a sumei cifrelor la 10 și adăugarea resturilor la variabila oglindit, înmulțind întreaga valoare a lui oglindit cu 10 după fiecare iterație. După fiecare iterație, suma cifrelor se împarte la 10 pentru a se obține următoarea cifră. La final, se afișează valoarea variabilei oglindit.

0362 - Sum Cif 1

2023-04-28T19:15:37Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/362/sumcif1]

== Cerinţa ==
Se citește un număr natural '''n'''. Să se determine suma cifrelor aflate pe poziții pare. Numărarea pozițiilor în numărul dat se face începând de la cifra unităților.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul afișează pe ecran numărul '''s''', reprezentând suma cifrelor aflate pe poziții pare. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n &les; 1.000.000.000'''

== Exemplu ==
; Intrare
: 59712654
; Ieșire
: Datele introduse sunt corecte.
: Suma cifrelor aflate pe pozitii pare este 19.

== Explicație ==
S-au adunat cifrele '''5 2 7 5'''.

== Rezolvare ==

<syntaxhighlight lang="python" line>
#0362

def verificare_date(n: int) -> bool:
if n < 1 or n > 1000000000:
return False
return True

def suma_cifre_pare(n: int) -> int:
suma = 0
pozitie = 1

while n > 0:
cifra = n % 10
if pozitie % 2 == 0:
suma += cifra
pozitie += 1
n //= 10

return suma

if __name__ == "__main__":
n = int(input("Introduceti un numar: "))
if verificare_date(n):
print("Datele introduse sunt corecte.")
print(f"Suma cifrelor aflate pe pozitii pare este {suma_cifre_pare(n)}.")
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>
== Explicație rezolvare ==
Prima funcție, '''verificare_date(n: int) -> bool''', primește ca argument un număr întreg '''n''' și returnează '''True''' dacă numărul este între 1 și 1.000.000.000 și '''False''' în caz contrar. A doua funcție, '''suma_cifre_pare(n: int) -> int''', primește ca argument un număr întreg '''n''' și calculează suma cifrelor aflate pe poziții pare în numărul dat. Aceasta se realizează folosind o buclă while care descompune numărul în cifre și adaugă cifrele aflate pe poziții pare la variabila suma. Funcția principală începe prin citirea unui număr întreg de la tastatură, utilizând funcția input() și transformând rezultatul într-un întreg cu ajutorul funcției int(). Dacă numărul introdus este valid, adică este între 1 și 1.000.000.000, se afișează un mesaj corespunzător și se calculează și afișează suma cifrelor aflate pe poziții pare, utilizând funcția '''suma_cifre_pare(n)'''. În caz contrar, se afișează un mesaj de eroare.

0361 - Cifra 1

2023-04-28T19:10:12Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/361/cifra1]

== Cerinţa ==
Se citește un număr natural '''n'''. Determinați cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul afișează pe ecran numărul cerut '''m''' care se poate obține prin eliminarea unei singure cifre din scrierea numărului '''n'''. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n &les; 1.000.000.000'''

== Exemplu ==
; Intrare
: 423234
; Ieșire
: Datele introduse sunt corecte.
: Cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului 423234 este: 43234
== Rezolvare ==

<syntaxhighlight lang="python" line>
#0361

def verificare_date(n: int) -> bool:
"""Verifică dacă numărul n se află în intervalul [1, 1000000000]."""
return 1 <= n <= 1000000000

def cel_mai_mare_numar_dupa_eliminare(n: int) -> int:
"""Determină cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului n."""
numar_dupa_eliminare = -1 # inițializăm cu o valoare imposibilă
for i in range(len(str(n))): # parcurgem cifrele numărului
cifra_curenta = str(n)[i]
numar_nou = int(str(n)[:i] + str(n)[i+1:]) # eliminăm cifra curentă
if numar_nou > numar_dupa_eliminare:
numar_dupa_eliminare = numar_nou # actualizăm numărul maxim
return numar_dupa_eliminare

if __name__ == "__main__":
"""Funcția principală."""
n = int(input("Introduceți un număr natural: "))
if verificare_date(n):
print("Datele introduse sunt corecte.")
print("Cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului", n, "este:", cel_mai_mare_numar_dupa_eliminare(n))
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

2288 - Cifra Impara Maxima

2023-04-28T19:08:17Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2288/cifraimparamaxima]

== Cerinţa ==
Să se scrie un program care să determine cea mai mare cifră impară a unui număr natural citit de la tastatură.
== Date de intrare ==
Programul va citi de la tastatură un număr natural.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi se va afișa cea mai mare cifră impară numărului citit. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* numărul citit va fi mai mic decât 2.000.000.000
* dacă numărul citit nu conține cifre impare se va afișa mesajul '''Numărul citit nu conține cifre impare."'''
== Exemplu ==
; Intrare
: 2785
; Ieșire
: Datele introduse sunt corecte.
: 7

 
; Intrare
: 2064

; Ieșire
: Numărul citit nu conține cifre impare.

== Rezolvare ==

<syntaxhighlight lang="python" line>
#2288

def verificare_numar(numar):
"""
Verifica daca numarul este un numar natural mai mic decat 2.000.000.000.
"""
return isinstance(numar, int) and 0 <= numar < 2000000000

def determina_cifra_maxima_impara(numar):
"""
Determina cea mai mare cifra impara a unui numar.
"""
max_cifra_impara = -1
while numar != 0:
cifra = numar % 10
if cifra % 2 == 1 and cifra > max_cifra_impara:
max_cifra_impara = cifra
numar //= 10
if max_cifra_impara == -1:
return "Nu exista."
else:
return max_cifra_impara

if __name__ == "__main__":
# Citeste un numar de la tastatura
numar = input("Introduceti un numar natural: ")
try:
numar = int(numar)
if verificare_numar(numar):
# Afiseaza mesajul "Datele sunt introduse corect." si cea mai mare cifra impara a numarului
print("Datele sunt introduse corect.")
print(determina_cifra_maxima_impara(numar))
else:
# Afiseaza mesajul "Datele nu au fost introduse corect."
print("Datele nu au fost introduse corect.")
except ValueError:
# Afiseaza mesajul "Datele nu au fost introduse corect."
print("Datele nu au fost introduse corect.")

</syntaxhighlight>

0361 - Cifra 1

2023-04-28T19:05:10Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/361/cifra1]

== Cerinţa ==
Se citește un număr natural '''n'''. Determinați cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul afișează pe ecran numărul cerut '''m''' care se poate obține prin eliminarea unei singure cifre din scrierea numărului '''n'''. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n &les; 1.000.000.000'''

== Exemplu ==
; Intrare
: 423234
; Ieșire
: Datele introduse sunt corecte.
: Cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului 423234 este: 43234
== Rezolvare ==

<syntaxhighlight lang="python" line>

def verificare_date(n: int) -> bool:
"""Verifică dacă numărul n se află în intervalul [1, 1000000000]."""
return 1 <= n <= 1000000000

def cel_mai_mare_numar_dupa_eliminare(n: int) -> int:
"""Determină cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului n."""
numar_dupa_eliminare = -1 # inițializăm cu o valoare imposibilă
for i in range(len(str(n))): # parcurgem cifrele numărului
cifra_curenta = str(n)[i]
numar_nou = int(str(n)[:i] + str(n)[i+1:]) # eliminăm cifra curentă
if numar_nou > numar_dupa_eliminare:
numar_dupa_eliminare = numar_nou # actualizăm numărul maxim
return numar_dupa_eliminare

if __name__ == "__main__":
"""Funcția principală."""
n = int(input("Introduceți un număr natural: "))
if verificare_date(n):
print("Datele introduse sunt corecte.")
print("Cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului", n, "este:", cel_mai_mare_numar_dupa_eliminare(n))
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

0361 - Cifra 1

2023-04-28T19:04:33Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/361/cifra1]

== Cerinţa ==
Se citește un număr natural '''n'''. Determinați cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul afișează pe ecran numărul cerut '''numar_dupa_eliminare'''. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n &les; 1.000.000.000'''

== Exemplu ==
; Intrare
: 423234
; Ieșire
: Datele introduse sunt corecte.
: Cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului 423234 este: 43234
== Rezolvare ==

<syntaxhighlight lang="python" line>

def verificare_date(n: int) -> bool:
"""Verifică dacă numărul n se află în intervalul [1, 1000000000]."""
return 1 <= n <= 1000000000

def cel_mai_mare_numar_dupa_eliminare(n: int) -> int:
"""Determină cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului n."""
numar_dupa_eliminare = -1 # inițializăm cu o valoare imposibilă
for i in range(len(str(n))): # parcurgem cifrele numărului
cifra_curenta = str(n)[i]
numar_nou = int(str(n)[:i] + str(n)[i+1:]) # eliminăm cifra curentă
if numar_nou > numar_dupa_eliminare:
numar_dupa_eliminare = numar_nou # actualizăm numărul maxim
return numar_dupa_eliminare

if __name__ == "__main__":
"""Funcția principală."""
n = int(input("Introduceți un număr natural: "))
if verificare_date(n):
print("Datele introduse sunt corecte.")
print("Cel mai mare număr care se poate obține prin eliminarea unei singure cifre din scrierea numărului", n, "este:", cel_mai_mare_numar_dupa_eliminare(n))
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

1059 - Schimb Cifre

2023-04-28T18:54:47Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/1059/schimbcifre]

== Cerinţa ==
Se dă un număr natural '''n'''. Asupra lui se efectuează '''s''' serii de transformări, o serie constând în '''t''' transformări de genul: cifra de pe poziția '''i''' se interschimbă cu cifra de pe poziția '''j'''. Să se afişeze numărul obţinut după efectuarea celor '''s''' serii de transformări.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''', '''s''' și '''t''', iar apoi '''t''' perechi de numere naturale, separate prin spații, fiecare pereche reprezentând pozițiile cifrelor care se interschimbă.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa pe ecran numărul obținut în urma efectuării celor '''s''' serii de transformări. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n &les; 1.000.000.000 '''
* ''' 1 &les; s &les; 2.000.000.000'''
* ''' 1 &les; t &les; 10 '''
* prima cifră din scrierea lui '''n''' se află pe poziția 1
* numerele din cele '''t''' perechi reprezentând pozițiile cifrelor care se interschimbă sunt mai mici sau egale cu numărul cifrelor lui '''n'''
* cifra '''0''' nu va ajunge pe prima poziţie în urma unei interschimbări

== Exemplu ==
; Intrare
: 1234 2 2
: 2 4
: 1 4
; Ieșire
: Datele introduse sunt corecte.
: 4132

== Explicație ==
Se efectuează prima serie de transformări: '''1234 → 1432 → 2431'''
A doua serie de transformări: '''2431 → 2134 → 4132'''

== Rezolvare ==

<syntaxhighlight lang="python" line>
#1059

from typing import List, Tuple

# Funcție de verificare a datelor conform restricțiilor
def verificare_date(n: int, s: int, t: int, interschimbari: List[Tuple[int, int]]) -> bool:
# Verificare restricție n
if n < 1 or n > 1000000000:
return False

# Verificare restricție s
if s < 1 or s > 2000000000:
return False

# Verificare restricție t
if t < 1 or t > 10:
return False

# Verificare restricție interschimbari
for i, j in interschimbari:
if i < 1 or i > len(str(n)) or j < 1 or j > len(str(n)):
return False

return True

# Funcție pentru interschimbarea cifrelor la pozițiile i și j într-un număr
def interschimbare_cifre(numar: int, i: int, j: int) -> int:
cifre = [int(cifra) for cifra in str(numar)]
cifre[i-1], cifre[j-1] = cifre[j-1], cifre[i-1]
return int("".join(map(str, cifre)))

# Funcția main
if __name__ == "__main__":
# Citire date de intrare
n, s, t = map(int, input("Introduceti datele separate prin spatii: ").split())

interschimbari = []
for i in range(t):
i, j = map(int, input("Introduceti datele separate prin spatii: ").split())
interschimbari.append((i, j))

# Verificare date de intrare
if not verificare_date(n, s, t, interschimbari):
print("Datele introduse nu sunt corecte.")
exit()

# Efectuare serii de transformări
for k in range(s):
for i, j in interschimbari:
if i > j:
i, j = j, i
n = interschimbare_cifre(n, i, j)

# Afișare rezultat
print("Datele introduse sunt corecte.")
print(n)

</syntaxhighlight>

2310 - Saci

2023-04-28T18:45:22Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2310/saci]

== Cerinţa ==
Pacală şi Tândală mergeau printr-o pădure. Într-un copac, ei au văzut o pasăre.
- Măi, Tândală, uite o pasăre! Hai s-o prindem, s-o frigem şi s-o mâncăm boiereşte, zise Păcală lingându-şi degetele.
- Că bine zici. Dar cum s-o mâncăm fără sare? Stai tu s-o păzeşti ca să nu zboare şi eu dau fuga în sat să aduc nişte sare, zise Tândală.
- Du-te în pivniţa mea şi acolo vei găsi '''n''' saci, pe fiecare sac vezi că e o etichetă pe care scrie un număr; dacă '''numărul are toate cifrele în ordine strict crescătoare, de la stânga la dreapta''', înseamnă că acel sac conţine sare, altfel conţine zahăr. Încarcă în căruţă toţi sacii cu sare şi hai cu ei încoace până păzesc eu pasărea, zise Păcală.
 
Ajutaţi-l pe Tândală să numere câţi saci cu sare trebuie să încarce în căruţă.
== Date de intrare ==
De pe prima linie a fişierului saci.in se citeşte un număr natural '''n''' ce reprezintă numărul sacilor.
De pe următoarele '''n''' linii se citesc valori naturale, câte una de pe fiecare linie, reprezentând numărul scris pe eticheta unui sac.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi în fişierul '''saci.out''' se va afişa, pe prima linie, un număr natural ce reprezintă '''numărul de saci''' cu sare ce trebuie încărcaţi în căruţă. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n &les; 100 '''
* numărul scris pe fiecare sac este un număr natural nenul, cu cel mult '''8 cifre'''
* ''' 1 &les; interschimbari &les; 10 '''
== Exemplu ==
; saci.in
: 5
: 159
: 721
: 18
: 121
: 7
; Ecran
: Datele introduse sunt corecte.
; saci.out
: 3

== Explicație ==
Sunt 5 saci. Dintre numerele cu care sunt etichetaţi saci doar '''159''', '''18''' şi '''7''', au cifrele în ordine strict crescătoare de la stânga la dreapta.
Astfel doar '''3''' saci conţin sare şi trebuie încărcaţi în căruţă.

== Rezolvare ==

<syntaxhighlight lang="python" line>
#2310

def validare_date(numar_saci: int, saci: List[int]) -> bool:
# Verificăm dacă numărul de saci dat este egal cu numărul de saci citiți
if numar_saci != len(saci):
print("Datele introduse nu sunt corecte.")
return False

# Verificăm dacă toți sacii au valori întregi pozitive
for sac in saci:
if not isinstance(sac, int) or sac <= 0:
print("Datele introduse nu sunt corecte.")
return False

return True

def cub(numar_sac: int) -> bool:
ok, p, c, cnt = True, 10, 0, 0
while numar_sac != 0:
if numar_sac % 10 >= p:
ok = False
break
c += 1
cnt += 1
p = numar_sac % 10
numar_sac //= 10

return ok

def rezolva_problema(numar_saci: int, saci: List[int]) -> int:
cnt = 0
for i in range(numar_saci):
if cub(saci[i]):
cnt += 1

return cnt

if __name__ == '__main__':
# Citim datele de intrare din fișier
with open("saci.in", "r") as fin:
numar_saci = int(fin.readline())
saci = []
for i in range(numar_saci):
sac = int(fin.readline())
saci.append(sac)

# Validăm datele de intrare
if not validare_date(numar_saci, saci):
exit()

# Rezolvăm problema
rezultat = rezolva_problema(numar_saci, saci)

# Scriem rezultatul în fișierul de ieșire
with open("saci.out", "w") as fout:
fout.write(str(rezultat))

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''validare_date''' verifică dacă datele de intrare sunt corecte, adică numărul de saci dat trebuie să fie egal cu numărul de saci citiți și dacă toți sacii au valori întregi pozitive. Funcția '''cub''' primește un număr natural și returnează o valoare booleană care indică dacă acest număr respectă restricțiile impuse de cerință. Restricțiile cer că fiecare cifră a numărului trebuie să fie mai mică decât cifra următoare. Funcția '''rezolva_problema''' primește numărul de saci și lista cu sacii și calculează câți dintre acești saci pot fi aranjați într-un șir astfel încât fiecare sac să aibă o greutate mai mică decât sacul următor. Funcția folosește funcția '''cub''' pentru a verifica fiecare sac în parte. În funcția principală '''main''', se citește fișierul de intrare '''saci.in''', se validează datele, se calculează rezultatul și se scrie în fișierul de ieșire '''saci.out'''.

0295 – Vecini

2023-04-28T18:36:19Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/295/vecini]

== Cerinţa ==
Se dă un şir cu '''n''' elemente, numere naturale. Să se verifice dacă există în şir elemente care să aibă ambii vecini de aceeaşi paritate cu el.
== 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 introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul afișează mesajul '''DA''', dacă există în şir elemente care să aibă ambii vecini de aceeaşi paritate cu el, respectiv '''NU''' în caz contrar. Dacă datele introduse nu sunt valide, se afișează mesajul: '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n &les; 100 '''
* elementele şirului vor avea cel mult '''9''' cifre

== Exemplu ==
; Intrare
: 5
: 803 60 102 408 6
; Ieșire
: Datele introduse sunt corecte.
: DA

== Rezolvare ==

<syntaxhighlight lang="python" line>
#0295

def validare_date(n, lista):
if n < 1 or n > 100:
print("Datele introduse nu sunt corecte.")
exit()
for elem in lista:
if elem < 0 or elem > 999999999:
print("Datele introduse nu sunt corecte.")
exit()
print("Datele introduse sunt corecte.")

def verificaVecinii(lista, pozitie):
if (pozitie == 0 or lista[pozitie-1] % 2 == lista[pozitie] % 2) and (pozitie == len(lista)-1 or lista[pozitie+1] % 2 == lista[pozitie] % 2):
return True
else:
return False

if __name__ == "__main__":
n = int(input("Introduceți un numar: "))
lista = list(map(int, input("Introduceți numerele din lista cu spatiu intre ele: ").split()))
validare_date(n, lista)
gasit = False
for i in range(n):
if verificaVecinii(lista, i):
print("DA")
gasit = True
break
if not gasit:
print("NU")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''validare_date(n, lista)''' validează datele introduse de utilizator. Ea primește ca parametri numărul de elemente din șir și lista de elemente, iar în cazul în care numărul de elemente nu se încadrează în intervalul [1, 100] sau cel puțin un element din listă depășește valoarea maximă permisă de 999999999, funcția afișează un mesaj de eroare și se termină executarea programului. În cazul în care toate datele sunt valide, se afișează mesajul '''Datele introduse sunt corecte.'''. Funcția '''verificaVecinii(lista, pozitie)''' primește ca parametri lista de numere și poziția elementului curent din listă și verifică dacă acesta are ambii vecini cu aceeași paritate cu el. Dacă da, returnează '''True''', altfel returnează '''False'''. În funcția principală '''__main__''', se citește numărul de elemente din șir și lista de elemente de la tastatură folosind funcția '''input()'''. Lista de elemente este convertită într-o listă de întregi folosind funcția '''map()''' și metoda '''split()''' pentru a separa elementele citite prin spații. Apoi, funcția '''validare_date(n, lista)''' este apelată pentru a valida datele introduse. În continuare, se parcurge lista cu ajutorul unui for și se verifică pentru fiecare element dacă are ambii vecini cu aceeași paritate cu el folosind funcția '''verificaVecinii(lista, i)'''. Dacă se găsește un astfel de element, se afișează mesajul '''DA''' și se setează variabila gasit pe '''True'''. Dacă nu se găsește niciun element cu această proprietate, se afișează mesajul '''NU'''.

3619 - Gen Nr Patru Cifre

2023-04-28T18:28:49Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/3619/gen-nr-patru-cifre]

== Cerinţa ==
Dându-se cifrele '''c1''' și '''c2''', să se afișeze toate numerele de patru cifre care îndeplinesc următoarele condiții:

Cifra miilor este mai mare sau egală cu '''c1'''. 
Cifra zecilor este mai mică sau egală cu '''c2'''. 
Cifrele sutelor și unităților sunt egale și pare.
== Date de intrare ==
Programul citește de la tastatură cifrele '''c1''' și '''c2'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa pe câte un rând, în ordine crescătoare, numerele de patru cifre care îndeplinesc condițiile. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 0 &les; c1, c2 &les; 9'''

== Exemplu ==
; Intrare
: 8 1
; Ieșire
: Datele introduse sunt corecte.
: 8000
: 8010
: 8202
: 8212
: 8404
: 8414
: 8606
: 8616
: 8808
: 8818
: 9000
: 9010
: 9202
: 9212
: 9404
: 9414
: 9606
: 9616
: 9808
: 9818
== Rezolvare ==

<syntaxhighlight lang="python" line>

def validare_date(c1, c2): # Verificam daca c1 si c2 sunt in intervalul [0,9]
if not (0 <= c1 <= 9) or not (0 <= c2 <= 9):
return False
return True

def afisare_numere(c1, c2):
# Iteram prin cifrele miilor
for m in range(c1, 10):
# Iteram prin cifrele sutelor, care sunt egale cu cifrele unitatilor si trebuie sa fie pare
for s in range(0, 9, 2):
# Iteram prin cifrele zecilor
for z in range(c2+1):
# Formam numarul de patru cifre cu cifra miilor, cifra sutelor, cifra zecilor si cifra unitatilor
num = m*1000 + s*100 + z*10 + s
print(num)

if __name__ == '__main__':
# Citim cifrele c1 si c2 de la tastatura si le convertim la int
cifra1, cifra2 = map(int, input("Introduceti cifrele c1 si c2: ").split())
if not validare_date(cifra1, cifra2):
print("Datele introduse nu sunt corecte.")
return
print("Datele introduse sunt corecte.")
afisare_numere(cifra1, cifra2)

</syntaxhighlight>

0368 - Nr Pal

2023-04-28T18:23:30Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/368/nrpal]

== Cerinţa ==
Se dau două numere naturale '''n''' și '''m'''. Determinati numărul de palindromuri cuprinse în intervalul determinat de cele două numere.
== Date de intrare ==
Programul citește de la tastatură două numere naturale '''n''' și '''m'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul afișează numărul '''p''', reprezentând numărul de palindromuri cuprinse în intervalul determinat de '''n''' și '''m'''. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n, m &les; 1.000.000'''
* nu este obligatoriu ca valorile citite să respecte condiția '''n &les; m'''.

== Exemplu ==
; Intrare
: 130 85
; Ieșire
: Datele introduse sunt corecte.
: 5
== Rezolvare ==

<syntaxhighlight lang="python" line>
#0368

def este_palindrom(n):
oglindit = 0
aux = n
while aux > 0:
oglindit = oglindit * 10 + aux % 10
aux //= 10
return n == oglindit

def numara_palindroame(n, m):
if n > m:
n, m = m, n
contor = 0
for i in range(n, m + 1):
if este_palindrom(i):
contor += 1
return contor

if __name__ == "__main__":
n, m = map(int, input("Introduceti doua numere naturale: ").split())
if n < 1 or m < 1 or n > 1000000 or m > 1000000:
print("Datele introduse nu sunt corecte.")
else:
print("Datele introduse sunt corecte.")
p = numara_palindroame(n, m)
print(p)

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''este_palindrom(n)''' primește un număr întreg '''n''' și returnează '''True''' dacă acesta este un palindrom, respectiv '''False''' în caz contrar. Funcția folosește o buclă '''while''' pentru a inversa cifrele lui '''n''', comparând apoi rezultatul cu '''n'''. Funcția '''numara_palindroame(n, m)''' primește două numere întregi '''n''' și '''m''' și returnează numărul de palindroame din intervalul [n, m]. Această funcție parcurge intervalul și, pentru fiecare număr, apelează funcția este_palindrom pentru a verifica dacă este palindrom, adăugând la un contor contor în caz afirmativ. În blocul '''if __name__ == "__main__":''' se citește de la tastatură două numere întregi '''n''' și '''m''', apoi se verifică dacă valorile introduse respectă restricțiile impuse prin verificarea valorilor lor. Dacă valorile sunt corecte, se afișează un mesaj corespunzător, se calculează numărul de palindroame prin apelul funcției '''numara_palindroame''' și se afișează rezultatul.

0280 - Pal Max

2023-04-28T18:15:48Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/280/palmax]

== Cerinţa ==
Se dau mai multe numere naturale. Determinaţi cel mai mare număr palindrom aflat printre numerele date şi de câte ori apare.
== Date de intrare ==
Programul citește de la tastatură numere naturale, până la apariţia lui zero, care nu se ia în considerare.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul afișează numerele '''p''' şi '''c''', numărul palindrom maxim şi numărul de apariţii, separate printr-un spaţiu, sau mesajul '''NU EXISTA''', dacă printre numerele date nu există nici un număr palindrom. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* fiecare dintre numerele citite va avea cel mult '''9''' cifre;

== Exemplu ==
; Intrare
: 78 56 5665 98789 5665 88 98789 12521 5665 0
; Ieșire
: Datele introduse sunt corecte.
: 98789 2
== Rezolvare ==

<syntaxhighlight lang="python" line>
#0280

def este_palindrom(numar):
invers = 0
copie = numar
while copie > 0:
ultima_cifra = copie % 10
invers = invers * 10 + ultima_cifra
copie //= 10
return numar == invers

def validare_date_intrare(numere, lungime_maxima=9):
if not numere:
return False
for numar in numere:
if not isinstance(numar, int) or numar <= 0 or numar > 10**lungime_maxima - 1:
return False
return True

def rezolva_problema(numere):
palindrom_maxim = None
nr_aparitii = 0
for numar in numere:
if este_palindrom(numar) and (palindrom_maxim is None or numar > palindrom_maxim):
palindrom_maxim = numar
nr_aparitii = 1
elif numar == palindrom_maxim:
nr_aparitii += 1

if palindrom_maxim is not None:
print(palindrom_maxim, nr_aparitii)
else:
print("NU EXISTA")

if __name__ == "__main__":
numere = []
while True:
try:
numar = int(input("Introduceti un numar natural: "))
except ValueError:
print("Datele introduse nu sunt corecte.")
break
if numar == 0:
break
numere.append(numar)

if validare_date_intrare(numere):
print("Datele introduse sunt corecte.")
rezolva_problema(numere)
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''este_palindrom(numar)''' primește un număr și verifică dacă acesta este palindrom. În cadrul funcției, numărul este inversat prin adăugarea cifrelor din număr de la dreapta la stânga, pornind de la cifra unităților și până la cifra cea mai semnificativă. Dacă numărul inițial și cel inversat sunt egale, atunci funcția returnează '''True''', altfel '''False'''. Funcția '''validare_date_intrare(numere, lungime_maxima=9)''' primește o listă de numere și verifică dacă acestea sunt numere naturale cu lungimea maximă admisă specificată (9 cifre în cazul de față). Funcția returnează '''True''' dacă toate numerele din listă respectă condițiile și '''False''' în caz contrar. Funcția '''rezolva_problema(numere)''' primește o listă de numere și găsește cel mai mare palindrom din listă și numărul de apariții ale acestuia în listă. Variabila palindrom_maxim inițial este None. Dacă un număr este palindrom și este mai mare decât '''palindrom_maxim''', acesta devine '''palindrom_maxim''' și variabila '''nr_aparitii''' este resetată la 1. Dacă un alt număr palindrom este egal cu '''palindrom_maxim''', '''nr_aparitii''' este incrementată cu 1. Dacă există cel puțin un palindrom în listă, funcția afișează '''palindrom_maxim''' și '''nr_aparitii'''. În caz contrar, afișează '''NU EXISTA'''. În blocul '''if __name__ == "__main__":''', programul citește numere de la utilizator și încearcă să valideze datele de intrare. Dacă datele sunt valide, apoi se apelează funcția '''rezolva_problema(numere)'''. În caz contrar, se afișează un mesaj corespunzător.

4227 - Cif Tr

2023-04-28T17:55:45Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/4227/cif-tr]

== Cerinţa ==
Când adunăm două cifre '''cifra1''' și '''cifra2''', obținem transport dacă '''cifra1''' + '''cifra2''' ≥ 10. Când adunăm două numere naturale, se poate obține chiar de mai multe ori transport. De exemplu, dacă adunăm 538 și 726, atunci obținem de două ori transport, prima oară când adunăm cifrele unităților, 8 + 6, a doua oară când adunăm cifrele sutelor, 5 + 7. 
Se dau două numere naturale '''n''' și '''m''' care au același număr de cifre. Să se afișeze mesajul NU dacă adunând cele două numere cifră cu cifră nu obținem niciodată transport, sau mesajul DA, dacă obținem măcar o dată transport.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' și '''m'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa mesajul '''NU''' dacă adunând cele două numere cifră cu cifră nu obținem niciodată transport, sau mesajul '''DA''', dacă obținem măcar o dată transport. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n, m &les; 1.000.000.000
* numerele '''n''' și '''m''' au același număr de cifre

== Exemplu ==
; Intrare
: 538 726
; Ieșire
: Datele introduse sunt corecte.
: DA
 
; Intrare
: 1234 8765
; Ieșire
: Datele introduse sunt corecte.
: NU
== Rezolvare ==

<syntaxhighlight lang="python" line>
#4227

def verifica_date(numar1, numar2):
if len(numar1) != len(numar2) or not numar1.isdigit() or not numar2.isdigit():
print("Datele introduse nu sunt corecte.")
return False
print("Datele introduse sunt corecte.")
return True

def are_transport(numar1, numar2):
for i in range(len(numar1)):
suma = int(numar1[i]) + int(numar2[i])
if suma >= 10:
return True
return False

if __name__ == "__main__":
numar1 = input("Introduceti primul numar: ")
numar2 = input("Introduceti al doilea numar: ")
if verifica_date(numar1, numar2):
if are_transport(numar1, numar2):
print("DA")
else:
print("NU")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''verifica_date''' primește două argumente, '''numar1''' și '''numar2''', și verifică dacă acestea au aceeași lungime și dacă fiecare cifră din cele două numere este un număr întreg. Dacă aceste condiții sunt îndeplinite, funcția afișează "Datele introduse sunt corecte." și returnează valoarea True, în caz contrar, afișează "Datele introduse nu sunt corecte." și returnează valoarea False. Funcția '''are_transport''' primește, de asemenea, două argumente, '''numar1''' și '''numar2''', și verifică dacă există cel puțin un transport atunci când cele două numere sunt adunate cifră cu cifră. Pentru aceasta, funcția parcurge cifră cu cifră cele două numere și calculează suma. Dacă suma este mai mare sau egală cu 10, funcția returnează valoarea '''True''', altfel returnează valoarea '''False'''. În final, funcția '''main''' primește două valori de la utilizator prin intermediul funcției '''input''', apelează funcția '''verifica_date''' pentru a verifica corectitudinea datelor, iar dacă acestea sunt corecte, apelează funcția '''are_transport''' pentru a verifica dacă există un transport în timpul adunării. În funcție de rezultatul obținut, programul afișează '''DA''' dacă există cel puțin un transport și '''NU''' dacă nu există niciun transport.

4227 - Cif Tr

2023-04-28T17:55:06Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/4227/cif-tr]

== Cerinţa ==
Când adunăm două cifre '''cifra1''' și '''cifra2''', obținem transport dacă '''cifra1''' + '''cifra2''' ≥ 10. Când adunăm două numere naturale, se poate obține chiar de mai multe ori transport. De exemplu, dacă adunăm 538 și 726, atunci obținem de două ori transport, prima oară când adunăm cifrele unităților, 8 + 6, a doua oară când adunăm cifrele sutelor, 5 + 7. 
Se dau două numere naturale '''cifra1''' și '''cifra2''' care au același număr de cifre. Să se afișeze mesajul NU dacă adunând cele două numere cifră cu cifră nu obținem niciodată transport, sau mesajul DA, dacă obținem măcar o dată transport.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' și '''m'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa mesajul '''NU''' dacă adunând cele două numere cifră cu cifră nu obținem niciodată transport, sau mesajul '''DA''', dacă obținem măcar o dată transport. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* ''' 1 &les; n, m &les; 1.000.000.000
* numerele '''n''' și '''m''' au același număr de cifre

== Exemplu ==
; Intrare
: 538 726
; Ieșire
: Datele introduse sunt corecte.
: DA
 
; Intrare
: 1234 8765
; Ieșire
: Datele introduse sunt corecte.
: NU
== Rezolvare ==

<syntaxhighlight lang="python" line>
#4227

def verifica_date(numar1, numar2):
if len(numar1) != len(numar2) or not numar1.isdigit() or not numar2.isdigit():
print("Datele introduse nu sunt corecte.")
return False
print("Datele introduse sunt corecte.")
return True

def are_transport(numar1, numar2):
for i in range(len(numar1)):
suma = int(numar1[i]) + int(numar2[i])
if suma >= 10:
return True
return False

if __name__ == "__main__":
numar1 = input("Introduceti primul numar: ")
numar2 = input("Introduceti al doilea numar: ")
if verifica_date(numar1, numar2):
if are_transport(numar1, numar2):
print("DA")
else:
print("NU")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția '''verifica_date''' primește două argumente, '''numar1''' și '''numar2''', și verifică dacă acestea au aceeași lungime și dacă fiecare cifră din cele două numere este un număr întreg. Dacă aceste condiții sunt îndeplinite, funcția afișează "Datele introduse sunt corecte." și returnează valoarea True, în caz contrar, afișează "Datele introduse nu sunt corecte." și returnează valoarea False. Funcția '''are_transport''' primește, de asemenea, două argumente, '''numar1''' și '''numar2''', și verifică dacă există cel puțin un transport atunci când cele două numere sunt adunate cifră cu cifră. Pentru aceasta, funcția parcurge cifră cu cifră cele două numere și calculează suma. Dacă suma este mai mare sau egală cu 10, funcția returnează valoarea '''True''', altfel returnează valoarea '''False'''. În final, funcția '''main''' primește două valori de la utilizator prin intermediul funcției '''input''', apelează funcția '''verifica_date''' pentru a verifica corectitudinea datelor, iar dacă acestea sunt corecte, apelează funcția '''are_transport''' pentru a verifica dacă există un transport în timpul adunării. În funcție de rezultatul obținut, programul afișează '''DA''' dacă există cel puțin un transport și '''NU''' dacă nu există niciun transport.

0170 - Cif Max Min

2023-04-28T17:46:00Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/170/cifmaxmin]
== Cerinţa ==
Să se scrie un program care să determine suma dintre cea mai mică şi cea mai mare cifră ale unui număr natural citit de la tastatură.
== Date de intrare ==
Programul va citi de la tastatură un număr natural.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afişa pe ecran suma dintre cea mai mică şi cea mai mare cifră ale numărului citit. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* numărul citit va fi mai mic decât '''2.000.000.000'''

== Exemplu ==
; Intrare
: 2745
; Ieșire
: Datele introduse sunt corecte.
: 9
== Rezolvare ==

<syntaxhighlight lang="python" line>

# Verifica daca numarul dat ca argument este mai mic decat 2 miliarde
def verificare_date(numar):
if numar >= 2000000000:
return False
return True

# Calculeaza suma dintre cel mai mic si cel mai mare cifra din numar
def determina_suma_min_max(numar):
minim = min(str(numar)) # Converteste numarul in string si gaseste cea mai mica cifra
maxim = max(str(numar)) # Converteste numarul in string si gaseste cea mai mare cifra
return int(minim) + int(maxim) # Converteste cele doua cifre in int si calculeaza suma lor

if __name__ == "__main__":
numar = int(input("Introduceți un număr: ")) # Primeste de la utilizator un numar intreg
if verificare_date(numar):
print("Datele introduse sunt corecte.")
suma = determina_suma_min_max(numar) # Calculeaza suma dintre cel mai mic si cel mai mare cifra din numar
print(suma)
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

3251 - Asociat Par

2023-04-28T17:42:09Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/3251/asociat-par]
== Cerinţa ==
Se dau '''n''' numere naturale. Se numește număr par asociat unui număr x numărul obținut din cifrele pare ale lui x luate în ordinea în care apar ele în x. De exemplu, numărul 3246456 are ca număr par asociat pe 24646, iar 37030 pe 0. Dacă numărul nu are cifre pare, atunci el nu are număr par asociat. Numărul 3731 nu are număr par asociat.
Se cere să se determine câte dintre cele '''n''' numere citite au numărul par asociat palindrom. Se numește palindom un număr care citit de la dreapta la stânga are aceeași valoare.
== 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 introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa numărul '''c''', reprezentând numărul de numere citite care au numărul asociat palindrom. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* '''1 &les; n &les;100 '''
* cele '''n''' numere citite vor fi mai mici decât 1.000.000.000

== Exemplu ==
; Intrare
: 5
: 45456 474 201102 2352345 234
; Ieșire
: Datele introduse sunt corecte.
: 2
== Rezolvare ==

<syntaxhighlight lang="python" line>
#3251

def este_palindrom(num):
return str(num) == str(num)[::-1]

def verifica_date(n, numere):
for numar in numere:
if numar >= 1000000000:
return False
return True

def numere_cu_numar_par_asociat_palindrom(n, numere):
citite = 0
for i in range(n):
x = str(numere[i])
even_digits = [digit for digit in x if int(digit) % 2 == 0]
even_num = int("".join(even_digits)) if even_digits else None
if even_num and este_palindrom(even_num):
citite += 1
return citite

if __name__ == '__main__':
n = int(input("Introduceți numărul de numere: "))
numere = list(map(int, input("Introduceți cele {} numere: ".format(n)).split()))
if verifica_date(n, numere):
print("Datele introduse sunt corecte.")
print(numere_cu_numar_par_asociat_palindrom(n, numere))
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''este_palindrom(num)''' primește un număr și returnează '''True''' dacă numărul este palindrom (adică poate fi citit în același fel în ambele direcții), altfel returnează '''False'''. Funcția '''verifica_date(n, numere)''' primește un număr și o listă de numere și verifică dacă niciuna dintre numerele din listă nu este mai mare sau egală cu 1000000000. Dacă cel puțin un număr din listă este mai mare sau egal cu 1000000000, funcția returnează '''False'''. Dacă toate numerele sunt mai mici decât 1000000000, funcția returnează '''True'''. Funcția '''numere_cu_numar_par_asociat_palindrom(n, numere)''' primește un număr și o listă de numere și returnează numărul de numere din listă care au un număr par asociat care este palindrom. Mai întâi, funcția transformă fiecare număr într-un șir de caractere, apoi extrage cifrele pare din fiecare șir și le transformă înapoi într-un număr. Dacă numărul obținut din cifrele pare este palindrom, acesta este numărat și funcția continuă la următorul număr din listă. Funcția '''main()''' primește un număr și o listă de numere de la utilizator și apelează '''verifica_date(n, numere)''' pentru a verifica validitatea datelor introduse. Dacă datele sunt corecte, funcția afișează numărul de numere din listă care au un număr par asociat care este palindrom. Dacă datele nu sunt corecte, funcția afișează un mesaj de eroare.

3251 - Asociat Par

2023-04-28T17:41:35Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/3251/asociat-par]
== Cerinţa ==
Se dau '''n''' numere naturale. Se numește număr par asociat unui număr x numărul obținut din cifrele pare ale lui x luate în ordinea în care apar ele în x. De exemplu, numărul 3246456 are ca număr par asociat pe 24646, iar 37030 pe 0. Dacă numărul nu are cifre pare, atunci el nu are număr par asociat. Numărul 3731 nu are număr par asociat.
Se cere să se determine câte dintre cele '''n''' numere citite au numărul par asociat palindrom. Se numește palindom un număr care citit de la dreapta la stânga are aceeași valoare.
== 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 introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa numărul '''c''', reprezentând numărul de numere citite care au numărul asociat palindrom. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* '''1 &les; n &les;100 '''
* cele '''n''' numere citite vor fi mai mici decât 1.000.000.000

== Exemplu ==
; Intrare
: 5
: 45456 474 201102 2352345 234
; Ieșire
: Datele sunt introduse corect.
: 2
== Rezolvare ==

<syntaxhighlight lang="python" line>
#3251

def este_palindrom(num):
return str(num) == str(num)[::-1]

def verifica_date(n, numere):
for numar in numere:
if numar >= 1000000000:
return False
return True

def numere_cu_numar_par_asociat_palindrom(n, numere):
citite = 0
for i in range(n):
x = str(numere[i])
even_digits = [digit for digit in x if int(digit) % 2 == 0]
even_num = int("".join(even_digits)) if even_digits else None
if even_num and este_palindrom(even_num):
citite += 1
return citite

if __name__ == '__main__':
n = int(input("Introduceți numărul de numere: "))
numere = list(map(int, input("Introduceți cele {} numere: ".format(n)).split()))
if verifica_date(n, numere):
print("Datele introduse sunt corecte.")
print(numere_cu_numar_par_asociat_palindrom(n, numere))
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''este_palindrom(num)''' primește un număr și returnează '''True''' dacă numărul este palindrom (adică poate fi citit în același fel în ambele direcții), altfel returnează '''False'''. Funcția '''verifica_date(n, numere)''' primește un număr și o listă de numere și verifică dacă niciuna dintre numerele din listă nu este mai mare sau egală cu 1000000000. Dacă cel puțin un număr din listă este mai mare sau egal cu 1000000000, funcția returnează '''False'''. Dacă toate numerele sunt mai mici decât 1000000000, funcția returnează '''True'''. Funcția '''numere_cu_numar_par_asociat_palindrom(n, numere)''' primește un număr și o listă de numere și returnează numărul de numere din listă care au un număr par asociat care este palindrom. Mai întâi, funcția transformă fiecare număr într-un șir de caractere, apoi extrage cifrele pare din fiecare șir și le transformă înapoi într-un număr. Dacă numărul obținut din cifrele pare este palindrom, acesta este numărat și funcția continuă la următorul număr din listă. Funcția '''main()''' primește un număr și o listă de numere de la utilizator și apelează '''verifica_date(n, numere)''' pentru a verifica validitatea datelor introduse. Dacă datele sunt corecte, funcția afișează numărul de numere din listă care au un număr par asociat care este palindrom. Dacă datele nu sunt corecte, funcția afișează un mesaj de eroare.

2223 - Cifre 004

2023-04-28T17:32:57Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2223/cifre004]
== Cerinţa ==
Se dă '''n''' număr natural. Aflaţi cel mai mare număr natural care are numărul de cifre şi suma cifrelor egale cu suma cifrelor lui '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa cel mai mare număr natural care are numărul de cifre şi suma cifrelor egale cu suma cifrelor lui '''n'''. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* '''1 &les; n &les;2.000.000.000 '''

== Exemplu ==
; Intrare
: 203
; Ieșire
: Datele introduse sunt corecte.
: 50000
== Rezolvare ==

<syntaxhighlight lang="python" line>
#2223

def verificare_date(n):
if n < 1 or n > 2000000000:
return False
return True

def cel_mai_mare_numar(n):
if not verificare_date(n):
print("Datele introduse nu sunt corecte.")
return
print("Datele introduse sunt corecte.")
s = sum(int(i) for i in str(n))
k = s // 9
rest = s % 9
if rest == 0:
print(int("9" * k))
else:
print(int("9" * k + str(rest) + "0" * (len(str(n)) - k - 1)))

if __name__ == "__main__":
n = int(input("Introduceti un numar natural: "))
cel_mai_mare_numar(n)

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''verificare_date(n)''' primește ca parametru numărul '''n''' și returnează '''True''' dacă acesta este cuprins între 1 și 2.000.000.000, altfel returnează '''False'''. Funcția '''cel_mai_mare_numar(n)''' primește ca parametru un număr natural '''n'''. Mai întâi se verifică dacă '''n''' este valid (folosind funcția verificare_date(n)). Dacă nu este valid, se afișează un mesaj corespunzător și funcția se oprește. În caz contrar, se afișează un mesaj corespunzător. Se calculează suma cifrelor lui '''n''' (folosind expresia sum(int(i) for i in str(n))). Se determină câte cifre de 9 poate avea numărul căutat (folosind expresia s // 9, unde s este suma cifrelor lui n). Se calculează restul cifrelor necesare prin adăugarea unor cifre 0 (folosind expresia int("9" * k + str(rest) + "0" * (len(str(n)) - k - 1)), unde '''k''' este numărul de cifre de 9 și '''rest''' este restul cifrelor necesare). Funcția principală citește de la tastatură numărul '''n''', apoi apelează funcția '''cel_mai_mare_numar(n)'''.

2223 - Cifre 004

2023-04-28T17:30:48Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2223/cifre004]
== Cerinţa ==
Se dă '''n''' număr natural. Aflaţi cel mai mare număr natural care are numărul de cifre şi suma cifrelor egale cu suma cifrelor lui '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa cel mai mare număr natural care are numărul de cifre şi suma cifrelor egale cu suma cifrelor lui '''n'''. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* '''1 &les; n &les;2.000.000.000 '''

== Exemplu ==
; Intrare
: 203
; Ieșire
: Datele introduse sunt corecte.
: 50000
== Rezolvare ==

<syntaxhighlight lang="python" line>
#2223

def verificare_date(n):
if n < 1 or n > 2000000000:
return False
return True

def cel_mai_mare_numar(n):
if not verificare_date(n):
print("Datele introduse nu sunt corecte.")
return
print("Datele introduse sunt corecte.")
s = sum(int(i) for i in str(n))
k = s // 9
rest = s % 9
if rest == 0:
print(int("9" * k))
else:
print(int("9" * k + str(rest) + "0" * (len(str(n)) - k - 1)))

if __name__ == "__main__":
n = int(input("Introduceti un numar natural: "))
cel_mai_mare_numar(n)

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''verificare_date(n)''' primește ca parametru numărul '''n''' și returnează '''True''' dacă acesta este cuprins între 1 și 2.000.000.000, altfel returnează '''False'''. Funcția '''cel_mai_mare_numar(n)''' primește ca parametru numărul '''n''' și, dacă datele sunt corecte (verificate cu ajutorul funcției verificare_date(n)), calculează suma cifrelor lui n, determină câte cifre de 9 poate avea numărul căutat și calculează restul cifrelor necesare prin adăugarea unor cifre 0. Funcția principală citește de la tastatură numărul '''n''', apoi apelează funcția cel_mai_mare_numar(n).

4215 - Alipit

2023-04-28T17:25:28Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/4215/alipit]
== Cerinţa ==
Să se verifice dacă un număr natural '''n''' este “alipit”.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa mesajul '''DA''' dacă '''n''' este “alipit”, sau mesajul '''NU''' în caz contrar . În cazul în care datele introduse nu sunt corecte, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* '''1 &les; n &les;100.000.000.000 '''

== Exemplu ==
; Intrare
: 1212
; Ieșire
: Datele introduse sunt corecte.
: DA

== Rezolvare ==

<syntaxhighlight lang="python" line>
#4215

def verificare_numar(n):
if not isinstance(n, int) or n < 1 or n > 100000000000:
return False
return True

def este_alipit(n):
numar = str(n)
lungime = len(numar)

# parcurgem toate lungimile posibile pentru un șir repetat
for lungime_subsir in range(1, lungime // 2 + 1):
# extragem șirul repetat
subsir = numar[:lungime_subsir]
# verificam daca șirul se poate repeta pentru a forma numarul dat
if subsir * (lungime // lungime_subsir) + subsir[:lungime % lungime_subsir] == numar:
return True
return False

if __name__ == "__main__":
n = int(input("Introduceti un numar natural: "))
if verificare_numar(n):
print("Datele introduse sunt corecte.")
if este_alipit(n):
print("DA")
else:
print("NU")
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''verificare_numar(n)''' primește ca parametru un număr întreg '''n''' și returnează '''True''' dacă '''n''' este un număr natural între 1 și 100000000000 și '''False''' în caz contrar. Aceasta se realizează prin verificarea dacă '''n''' nu este un număr întreg (utilizând funcția isinstance) sau dacă este mai mic decât 1 sau mai mare decât 100000000000. Funcția '''este_alipit(n)''' primește ca parametru un număr întreg '''n''' și returnează '''True''' dacă '''n''' este "alipit" și '''False''' în caz contrar. Pentru a verifica acest lucru, se convertește numărul la un șir de caractere (numar = str(n)) și se calculează lungimea acestuia (lungime = len(numar)). Se parcurg toate lungimile posibile pentru un șir repetat, începând cu lungimea 1 și mergând până la jumătate din lungimea totală a șirului (for lungime_subsir in range(1, lungime // 2 + 1):). Se extrage șirul repetat (subsir = numar[:lungime_subsir]) și se verifică dacă acesta poate fi repetat de un număr de ori astfel încât să formeze numărul dat (if subsir * (lungime // lungime_subsir) + subsir[:lungime % lungime_subsir] == numar:). În caz afirmativ, se returnează True. În caz contrar, se continuă parcurgerea lungimilor posibile pentru șirul repetat până la epuizarea acestora, moment în care se returnează False. Funcția principală se ocupă de interacțiunea cu utilizatorul și afișează rezultatul final în funcție de valorile returnate de funcțiile anterioare. Se citeste numarul de la tastatură (n = int(input("Introduceti un numar natural: "))) și se verifică dacă datele introduse sunt corecte folosind funcția '''verificare_numar(n)'''. Dacă datele sunt corecte, se afișează mesajul corespunzător (print("Datele introduse sunt corecte.")) și se verifică dacă numărul este "alipit" folosind funcția este_alipit(n). În funcție de rezultatul obținut, se afișează mesajul '''"DA"''' sau '''"NU"'''. Dacă datele introduse nu sunt corecte, se afișează mesajul corespunzător (`print("Datele introduse nu sunt corecte.").

4215 - Alipit

2023-04-28T17:25:09Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/4215/alipit]
== Cerinţa ==
Să se verifice dacă un număr natural '''n''' este “alipit”.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa mesajul '''DA''' dacă '''n''' este “alipit”, sau mesajul '''NU''' în caz contrar . În cazul în care datele introduse nu sunt corecte, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* '''1 &les; n &les;100.000.000.000 '''

== Exemplu ==
; Intrare
: 1212
; Ieșire
: "Datele introduse sunt corecte."
: DA

== Rezolvare ==

<syntaxhighlight lang="python" line>
#4215

def verificare_numar(n):
if not isinstance(n, int) or n < 1 or n > 100000000000:
return False
return True

def este_alipit(n):
numar = str(n)
lungime = len(numar)

# parcurgem toate lungimile posibile pentru un șir repetat
for lungime_subsir in range(1, lungime // 2 + 1):
# extragem șirul repetat
subsir = numar[:lungime_subsir]
# verificam daca șirul se poate repeta pentru a forma numarul dat
if subsir * (lungime // lungime_subsir) + subsir[:lungime % lungime_subsir] == numar:
return True
return False

if __name__ == "__main__":
n = int(input("Introduceti un numar natural: "))
if verificare_numar(n):
print("Datele introduse sunt corecte.")
if este_alipit(n):
print("DA")
else:
print("NU")
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''verificare_numar(n)''' primește ca parametru un număr întreg '''n''' și returnează '''True''' dacă '''n''' este un număr natural între 1 și 100000000000 și '''False''' în caz contrar. Aceasta se realizează prin verificarea dacă '''n''' nu este un număr întreg (utilizând funcția isinstance) sau dacă este mai mic decât 1 sau mai mare decât 100000000000. Funcția '''este_alipit(n)''' primește ca parametru un număr întreg '''n''' și returnează '''True''' dacă '''n''' este "alipit" și '''False''' în caz contrar. Pentru a verifica acest lucru, se convertește numărul la un șir de caractere (numar = str(n)) și se calculează lungimea acestuia (lungime = len(numar)). Se parcurg toate lungimile posibile pentru un șir repetat, începând cu lungimea 1 și mergând până la jumătate din lungimea totală a șirului (for lungime_subsir in range(1, lungime // 2 + 1):). Se extrage șirul repetat (subsir = numar[:lungime_subsir]) și se verifică dacă acesta poate fi repetat de un număr de ori astfel încât să formeze numărul dat (if subsir * (lungime // lungime_subsir) + subsir[:lungime % lungime_subsir] == numar:). În caz afirmativ, se returnează True. În caz contrar, se continuă parcurgerea lungimilor posibile pentru șirul repetat până la epuizarea acestora, moment în care se returnează False. Funcția principală se ocupă de interacțiunea cu utilizatorul și afișează rezultatul final în funcție de valorile returnate de funcțiile anterioare. Se citeste numarul de la tastatură (n = int(input("Introduceti un numar natural: "))) și se verifică dacă datele introduse sunt corecte folosind funcția '''verificare_numar(n)'''. Dacă datele sunt corecte, se afișează mesajul corespunzător (print("Datele introduse sunt corecte.")) și se verifică dacă numărul este "alipit" folosind funcția este_alipit(n). În funcție de rezultatul obținut, se afișează mesajul '''"DA"''' sau '''"NU"'''. Dacă datele introduse nu sunt corecte, se afișează mesajul corespunzător (`print("Datele introduse nu sunt corecte.").

2221 - Cifre 003

2023-04-28T17:14:34Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/2221/cifre003]
== Cerinţa ==
Se dă un număr natural '''n'''. Să se afle câte dintre numerele obținute din '''n''' prin ștergerea unei cifre, sunt divizibile cu 3.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa '''"Datele introduse sunt corecte."''', apoi programul va afișa numărul numerelor obţinute din '''n''' prin ștergerea unei cifre, care sunt divizibile cu 3. În caz contrar, se va afișa pe ecran mesajul '''"Datele introduse nu sunt corecte."'''.
== Restricții și precizări ==
* 1 &les; n &les;2.000.000.000
* dacă '''n''' are o cifră, prin ştergerea unei cifre el devine 0
* dacă prin ştergerea unei cifre numărul rămas începe cu 0, zerourile de la început se elimină
== Exemplu ==
; Intrare
: 23701
; Ieșire
: "Datele introduse sunt corecte."
: 2
== Explicație ==
Prin eliminarea cifrei 1 se obţine numărul 2370 divizibil cu 3, iar prin eliminarea cifrei 7 se obţine 2301 divizibil cu 3.
== Rezolvare ==

<syntaxhighlight lang="python" line>

def este_numar_valid(numar):
if numar.isdigit() and int(numar) >= 1 and int(numar) <= 2000000000:
return True
return False

def numar_divizibile_cu_3(numar):
numere_divizibile_cu_3 = 0
for i in range(len(numar)):
cifra = int(numar[i])
numar_fara_cifra = numar[:i] + numar[i + 1:]
if int(numar_fara_cifra) % 3 == 0:
numere_divizibile_cu_3 += 1
return numere_divizibile_cu_3

if __name__ == '__main__':
numar = input("Introduceti numarul: ").strip()
if este_numar_valid(numar):
print("Datele introduse sunt corecte.")
print(numar_divizibile_cu_3(numar))
else:
print("Datele introduse nu sunt corecte.")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''este_numar_valid(numar)''' verifică dacă '''numar''' este un număr natural valid, adică este format doar din cifre și este în intervalul [1, 2000000000]. Dacă numărul este valid, funcția returnează '''True''', altfel returnează '''False'''. Funcția '''numar_divizibile_cu_3(numar)''' primește ca parametru un număr și determină câte dintre numerele obținute prin ștergerea unei cifre sunt divizibile cu 3. Aceasta folosește o buclă for pentru a itera prin fiecare cifră din numar, elimină cifra curentă și verifică dacă numărul obținut este divizibil cu 3. Dacă acesta este divizibil cu 3, funcția incrementează un contor '''numere_divizibile_cu_3'''. Funcția returnează numărul de numere divizibile cu 3. Funcția principală primește un număr de la utilizator folosind funcția input(). Aceasta verifică dacă numărul este valid folosind funcția '''este_numar_valid(numar)'''. Dacă numărul este valid, se afișează un mesaj de confirmare și numărul de numere divizibile cu 3 prin apelul funcției '''numar_divizibile_cu_3(numar)'''. Dacă numărul nu este valid, se afișează un mesaj de eroare.

1566 - Cif Sort

2023-04-28T06:00:40Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/1566/cifsort]
== Cerinţa ==
Se da numarul natural '''n'''. Afisati numarul, cu prima cifra inversata cu a 2-a, a 3-a cu a 4-a, etc.
== 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 '''"Datele sunt introduse corect."''', apoi se va afișa numarul, cu prima cifra inversata cu a 2-a, a 3-a cu a 4-a, etc. În caz contrar, se va afișa pe ecran. '''"Datele nu au fost introduse corect."'''.
== Restricții și precizări ==
* '''10 &les; n &les; 99.999.999'''
* '''n''' are un numar par de cifre.
== Exemplu ==
; Intrare
: 123456
; Ieșire
: Datele au fost introduse corect.
: 214365
== Explicație ==
1 a fost inversat cu 2, 3 cu 4, iar 5 cu 6.
== Rezolvare ==

<syntaxhighlight lang="python" line>
#1566

def verificare(numar):
if len(numar) % 2 != 0:
return False
try:
int(numar)
return True
except ValueError:
return False

def rezolvare(numar):
invers = ""
for i in range(0, len(numar), 2):
invers += numar[i+1]
invers += numar[i]
return int(invers)

if __name__ == "__main__":
numar = input("Introduceti un numar cu un numar par de cifre: ")
if verificare(numar):
print("Datele sunt introduse corect.")
print(rezolvare(numar))
else:
print("Datele nu au fost introduse corect.")

</syntaxhighlight>

== Explicație cod ==
Funcția '''verificare(numar)''' verifică dacă numărul are un număr par de cifre și dacă toate cifrele sunt cifre întregi. Dacă aceste condiții sunt îndeplinite, funcția returnează '''True''', altfel returnează '''False'''. Funcția '''rezolvare(numar)''' primește numărul și creează un șir de caractere în care cifrele inversează poziția. Algoritmul funcției merge prin număr începând cu prima cifră și adăugând în noul șir caracterul de pe poziția impară și apoi caracterul de pe poziția pară, adică inversând poziția acestora. Funcția returnează numărul întors. Instrucțiunea '''if __name__ == "__main__":''' citește numărul de la tastatură, verifică dacă datele sunt introduse corect folosind funcția '''verificare(numar)''' și afișează rezultatul apelând funcția '''rezolvare(numar)''' în cazul în care datele sunt corecte sau afișează mesajul '''"Datele au fost introduse corect."''' în caz contrar, se afișează mesajul '''"Datele nu au fost introduse corect"'''.

1566 - Cif Sort

2023-04-28T06:00:28Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/1566/cifsort]
== Cerinţa ==
Se da numarul natural '''n'''. Afisati numarul, cu prima cifra inversata cu a 2-a, a 3-a cu a 4-a, etc.
== 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 '''"Datele sunt introduse corect."''', apoi se va afișa numarul, cu prima cifra inversata cu a 2-a, a 3-a cu a 4-a, etc. În caz contrar, se va afișa pe ecran. '''"Datele nu au fost introduse corect."'''.
== Restricții și precizări ==
* '''10 &les; n &les; 99.999.999'''
* '''n''' are un numar par de cifre.
== Exemplu ==
; Intrare
: 123456
; Ieșire
: Datele au fost introduse corect.
: 214365
== Explicație ==
1 a fost inversat cu 2, 3 cu 4, iar 5 cu 6.
== Rezolvare ==

<syntaxhighlight lang="python" line>
#1566

def verificare(numar):
if len(numar) % 2 != 0:
return False
try:
int(numar)
return True
except ValueError:
return False

def rezolvare(numar):
invers = ""
for i in range(0, len(numar), 2):
invers += numar[i+1]
invers += numar[i]
return int(invers)

if __name__ == "__main__":
numar = input("Introduceti un numar cu un numar par de cifre: ")
if verificare(numar):
print("Datele sunt introduse corect.")
print(rezolvare(numar))
else:
print("Datele nu au fost introduse corect.")

</syntaxhighlight>

== Explicație cod ==
Funcția '''verificare(numar)''' verifică dacă numărul are un număr par de cifre și dacă toate cifrele sunt cifre întregi. Dacă aceste condiții sunt îndeplinite, funcția returnează '''True''', altfel returnează '''False'''. Funcția '''rezolvare(numar)''' primește numărul și creează un șir de caractere în care cifrele inversează poziția. Algoritmul funcției merge prin număr începând cu prima cifră și adăugând în noul șir caracterul de pe poziția impară și apoi caracterul de pe poziția pară, adică inversând poziția acestora. Funcția returnează numărul întors. Instrucțiunea '''if __name__ == "__main__":''' citește numărul de la tastatură, verifică dacă datele sunt introduse corect folosind funcția '''verificare(numar)''' și afișează rezultatul apelând funcția '''rezolvare(numar)''' în cazul în care datele sunt corecte sau afișează mesajul '''"Datele au fost introduse corect."''' în caz contrar, se afișează mesajul '''"Date nu au fost introduse corect"'''.

1566 - Cif Sort

2023-04-28T06:00:10Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/1566/cifsort]
== Cerinţa ==
Se da numarul natural '''n'''. Afisati numarul, cu prima cifra inversata cu a 2-a, a 3-a cu a 4-a, etc.
== 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 '''"Datele sunt introduse corect."''', apoi se va afișa numarul, cu prima cifra inversata cu a 2-a, a 3-a cu a 4-a, etc. În caz contrar, se va afișa pe ecran. '''"Datele nu au fost introduse corect."'''.
== Restricții și precizări ==
* '''10 &les; numar &les; 99.999.999'''
* '''numar''' are un numar par de cifre.
== Exemplu ==
; Intrare
: 123456
; Ieșire
: Datele au fost introduse corect.
: 214365
== Explicație ==
1 a fost inversat cu 2, 3 cu 4, iar 5 cu 6.
== Rezolvare ==

<syntaxhighlight lang="python" line>
#1566

def verificare(numar):
if len(numar) % 2 != 0:
return False
try:
int(numar)
return True
except ValueError:
return False

def rezolvare(numar):
invers = ""
for i in range(0, len(numar), 2):
invers += numar[i+1]
invers += numar[i]
return int(invers)

if __name__ == "__main__":
numar = input("Introduceti un numar cu un numar par de cifre: ")
if verificare(numar):
print("Datele sunt introduse corect.")
print(rezolvare(numar))
else:
print("Datele nu au fost introduse corect.")

</syntaxhighlight>

== Explicație cod ==
Funcția '''verificare(numar)''' verifică dacă numărul are un număr par de cifre și dacă toate cifrele sunt cifre întregi. Dacă aceste condiții sunt îndeplinite, funcția returnează '''True''', altfel returnează '''False'''. Funcția '''rezolvare(numar)''' primește numărul și creează un șir de caractere în care cifrele inversează poziția. Algoritmul funcției merge prin număr începând cu prima cifră și adăugând în noul șir caracterul de pe poziția impară și apoi caracterul de pe poziția pară, adică inversând poziția acestora. Funcția returnează numărul întors. Instrucțiunea '''if __name__ == "__main__":''' citește numărul de la tastatură, verifică dacă datele sunt introduse corect folosind funcția '''verificare(numar)''' și afișează rezultatul apelând funcția '''rezolvare(numar)''' în cazul în care datele sunt corecte sau afișează mesajul '''"Datele au fost introduse corect."''' în caz contrar, se afișează mesajul '''"Date nu au fost introduse corect"'''.

1566 - Cif Sort

2023-04-28T05:59:40Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/1566/cifsort]
== Cerinţa ==
Se da numarul natural '''n'''. Afisati numarul, cu prima cifra inversata cu a 2-a, a 3-a cu a 4-a, etc.
== 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 '''"Datele sunt introduse corect."''', apoi se va afișa pe ecran numarul, cu prima cifra inversata cu a 2-a, a 3-a cu a 4-a, etc. În caz contrar, se va afișa pe ecran. '''"Datele nu au fost introduse corect."'''.
== Restricții și precizări ==
* '''10 &les; numar &les; 99.999.999'''
* '''numar''' are un numar par de cifre.
== Exemplu ==
; Intrare
: 123456
; Ieșire
: Datele au fost introduse corect.
: 214365
== Explicație ==
1 a fost inversat cu 2, 3 cu 4, iar 5 cu 6.
== Rezolvare ==

<syntaxhighlight lang="python" line>
#1566

def verificare(numar):
if len(numar) % 2 != 0:
return False
try:
int(numar)
return True
except ValueError:
return False

def rezolvare(numar):
invers = ""
for i in range(0, len(numar), 2):
invers += numar[i+1]
invers += numar[i]
return int(invers)

if __name__ == "__main__":
numar = input("Introduceti un numar cu un numar par de cifre: ")
if verificare(numar):
print("Datele sunt introduse corect.")
print(rezolvare(numar))
else:
print("Datele nu au fost introduse corect.")

</syntaxhighlight>

== Explicație cod ==
Funcția '''verificare(numar)''' verifică dacă numărul are un număr par de cifre și dacă toate cifrele sunt cifre întregi. Dacă aceste condiții sunt îndeplinite, funcția returnează '''True''', altfel returnează '''False'''. Funcția '''rezolvare(numar)''' primește numărul și creează un șir de caractere în care cifrele inversează poziția. Algoritmul funcției merge prin număr începând cu prima cifră și adăugând în noul șir caracterul de pe poziția impară și apoi caracterul de pe poziția pară, adică inversând poziția acestora. Funcția returnează numărul întors. Instrucțiunea '''if __name__ == "__main__":''' citește numărul de la tastatură, verifică dacă datele sunt introduse corect folosind funcția '''verificare(numar)''' și afișează rezultatul apelând funcția '''rezolvare(numar)''' în cazul în care datele sunt corecte sau afișează mesajul '''"Datele au fost introduse corect."''' în caz contrar, se afișează mesajul '''"Date nu au fost introduse corect"'''.

3665 - CMMCP

2023-04-28T05:48:04Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/3665/cmmcp]

==Cerința==
Se dă un număr natural '''n'''. Determinaţi cea mai mare cifră pară a sa. Dacă numărul nu are cifre pare se va afişa numărul 10.
==Date de intrare==
Programul citește de la tastatură numărul '''n'''.
==Date de ieșire==
Dacă datele sunt introduse corect, se va afișa '''"Datele sunt introduse corect."''', apoi se va afișa pe ecran cea mai mare cifră pară a numărului introdus. În caz contrar, se va afișa pe ecran. '''"Datele nu au fost introduse corect"'''.
== Restricții și precizări ==
* 0 &les; număr1 &les; 1.000.000.000.000
== Exemplu ==
; Intrare
: 1440
; Ieșire
: Cea mai mare cifră pară a numărului este: 4
 
== Rezolvare ==

<syntaxhighlight lang="python" line>
#3665

def verificare_restricții(număr):
#Verifică dacă numărul este între 0 și 1.000.000.000.000

if număr < 0 or număr > 1000000000000:
return False
else:
return True

def rezolvare_problema(număr):

maxim = 10 # inițializăm maximul cu 10

while număr != 0:
cifră = număr % 10 # extragem ultima cifră
if cifră % 2 == 0 and cifră > maxim: # dacă este pară și mai mare decât maximul curent
maxim = cifră # actualizăm maximul
număr //= 10 # eliminăm ultima cifră

return maxim
def verificare_restricții(numar):
# Verifică dacă numărul este între 0 și 1.000.000.000.000
if numar < 0 or numar > 1000000000000:
return False
else:
return True

def rezolvare_problema(numar):
maxim = -1 # inițializăm maximul cu -1 pentru a putea verifica dacă am găsit vreo cifră pară
while numar != 0:
cifra = numar % 10 # extragem ultima cifră
if cifra % 2 == 0 and cifra > maxim: # dacă este pară și mai mare decât maximul curent
maxim = cifra # actualizăm maximul
numar //= 10 # eliminăm ultima cifră
if maxim == -1: # dacă nu am găsit vreo cifră pară, setăm maximul la 10
maxim = 10
return maxim

if __name__ == "__main__":
numar = int(input("Introduceți numărul: "))
if verificare_restricții(numar):
print("Datele sunt introduse corect.")
maxim_par = rezolvare_problema(numar)
print("Cea mai mare cifră pară a numărului este:", maxim_par)
else:
print("Datele nu au fost introduse corect.")

</syntaxhighlight>

3665 - CMMCP

2023-04-28T05:47:36Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/3665/cmmcp]

==Cerința==
Se dă un număr natural '''număr1'''. Determinaţi cea mai mare cifră pară a sa. Dacă numărul nu are cifre pare se va afişa numărul 10.
==Date de intrare==
Programul citește de la tastatură numărul '''număr1'''.
==Date de ieșire==
Dacă datele sunt introduse corect, se va afișa '''"Datele sunt introduse corect."''', apoi se va afișa pe ecran cea mai mare cifră pară a numărului introdus. În caz contrar, se va afișa pe ecran. '''"Datele nu au fost introduse corect"'''.
== Restricții și precizări ==
* 0 &les; număr1 &les; 1.000.000.000.000
== Exemplu ==
; Intrare
: 1440
; Ieșire
: Cea mai mare cifră pară a numărului este: 4
 
== Rezolvare ==

<syntaxhighlight lang="python" line>
#3665

def verificare_restricții(număr):
#Verifică dacă numărul este între 0 și 1.000.000.000.000

if număr < 0 or număr > 1000000000000:
return False
else:
return True

def rezolvare_problema(număr):

maxim = 10 # inițializăm maximul cu 10

while număr != 0:
cifră = număr % 10 # extragem ultima cifră
if cifră % 2 == 0 and cifră > maxim: # dacă este pară și mai mare decât maximul curent
maxim = cifră # actualizăm maximul
număr //= 10 # eliminăm ultima cifră

return maxim
def verificare_restricții(numar):
# Verifică dacă numărul este între 0 și 1.000.000.000.000
if numar < 0 or numar > 1000000000000:
return False
else:
return True

def rezolvare_problema(numar):
maxim = -1 # inițializăm maximul cu -1 pentru a putea verifica dacă am găsit vreo cifră pară
while numar != 0:
cifra = numar % 10 # extragem ultima cifră
if cifra % 2 == 0 and cifra > maxim: # dacă este pară și mai mare decât maximul curent
maxim = cifra # actualizăm maximul
numar //= 10 # eliminăm ultima cifră
if maxim == -1: # dacă nu am găsit vreo cifră pară, setăm maximul la 10
maxim = 10
return maxim

if __name__ == "__main__":
numar = int(input("Introduceți numărul: "))
if verificare_restricții(numar):
print("Datele sunt introduse corect.")
maxim_par = rezolvare_problema(numar)
print("Cea mai mare cifră pară a numărului este:", maxim_par)
else:
print("Datele nu au fost introduse corect.")

</syntaxhighlight>

2871 - Fulger

2023-04-27T17:47:42Z

Tamas Claudia:

Sursa: [https://www.pbinfo.ro/probleme/2871/fulger]
----
== Cerinţa ==
Pentru a putea ajunge la concursul de mașini, Fulger Mcqueen, trebuie să termine de asfaltat drumul din Valea Radiator. La intrarea în Valea Radiator, Bucșă are pregătite '''numar''' bidoane, fiecare având înscris pe el câte un număr. Dintre cele '''numar''' bidoane doar câteva conțin asfalt.

Bucșă îi spune lui Fulger:

– Fulger, prietene, vreau să te ajut să găsești bidoanele corecte, așa că îți spun că fiecare număr de pe bidon are asociat un cod secret, codul secret al fiecărui număr se obține prin diferența dintre numărul alcătuit din atâtea cifre de 9 câte are numărul scris pe bidon și numărul de pe bidon. Bidoanele cu asfalt au cifra unităților 0 și cifra zecilor 1.

Scrieți un program care să determine:

a) Codul secret asociat fiecărui număr de pe bidon;
b) Numărul de bidoane care conțin asfalt.
== Date de intrare ==
Fișierul de intrare '''fulger.in''' conține pe prima linie un număr natural '''numar''' ce reprezintă numărul de bidoane pregătite de Bucșă, iar următoarele '''numar''' linii, câte un număr natural, diferit de 0, ce reprezintă numărul asociat fiecărui bidon.
== Date de ieșire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa mesajul: '''"Datele sunt introduse corect."''', apoi fișierul de ieșire '''fulger.out''' va conține pe prima linie, despărțite prin spațiu codul secret al fiecărui număr de pe bidon, iar pe cea de-a doua linie, un număr natural ce reprezintă numărul de bidoane cu asfalt, pe care le-a descoperit Fulger. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''1''' < '''numar''' ≤ '''100'''
* numerele de pe a doua linie a fișierului de intrare vor fi situate în intervalul '''[1, 1.000.000.000]'''

== Exemple ==
===Exemplul 1===
; fulger.in
: 5
: 2138
: 531649
: 154289
: 798
: 96489
; Ecran
: Datele sunt introduse corect.
; fulger.out
: 7861 468350 845710 201 3510
: 2
== Explicație ==
Bucșă a pregătit pentru Fulger '''5''' bidoane.

Cerința a)

Primul bidon are codul secret '''7861''', deoarece '''9999 – 2138 = 7861'''
Al doilea are codul secret '''468350''', deoarece '''999999 – 531649 = 468350'''
Al treilea are codul secret '''845710''', deoarece '''999999 – 154289 = 845710'''
Al patrulea are codul secret '''201''', deoarece '''999 – 798 = 201'''
Al cincilea are codul secret '''3510''', deoarece '''99999 – 96489 = 3510'''

Cerința b)

Numărul de bidoane cu asfalt este '''2'''.

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

def cod_secret(numar):
cifre_noua = 9 * len(str(numar))
return cifre_noua - numar

def citire_date():
with open("fulger.in") as f:
numar_bidoane = int(f.readline().strip())
if not 1 < numar_bidoane <= 100:
print("Datele nu corespund restricțiilor impuse.")
return None
bidoane = [int(f.readline().strip()) for _ in range(numar_bidoane)]
for b in bidoane:
if not 1 <= b <= 1000000000:
print("Datele nu corespund restricțiilor impuse.")
return None
print("Datele sunt introduse corect.")
return bidoane

def main():
bidoane = citire_date()
if bidoane is None:
return

coduri_secrete = [cod_secret(b) for b in bidoane]
numar_bidoane_cu_asfalt = sum(1 for b in bidoane if b % 10 == 0 and b // 10 % 10 == 1)

with open("fulger.out", "w") as f:
f.write(" ".join(str(c) for c in coduri_secrete) + "\n")
f.write(str(numar_bidoane_cu_asfalt))

if __name__ == "__main__":
main()

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''def cod_secret()''' primeste un numar intreg si calculeaza un cod secret pentru acesta, prin inmultirea numarului de cifre ale numarului dat cu 9 si apoi scazand numarul initial din aceasta valoare. Returneaza rezultatul ca un numar intreg. Funcția '''def citire_date()''' citeste datele de intrare din fisierul "fulger.in". Mai intai, se citeste numarul de bidoane din primul rand al fisierului si se verifica daca este intre 2 si 100, dupa care se citesc capacitatea fiecarui bidon si se verifica daca fiecare dintre acestea este intre 1 si 1000000000. Daca datele de intrare nu corespund acestor restrictii, se afiseaza un mesaj de eroare si se returneaza valoarea nula. Daca toate datele sunt introduse corect, se afiseaza un mesaj de confirmare si se returneaza o lista de intregi reprezentand capacitatea bidoanelor. Funcția '''def main()''' este functia principala a programului. Incepe prin apelarea functiei citire_date() pentru a obtine datele de intrare. Daca acestea sunt invalide, programul se opreste. Altfel, se aplica functia cod_secret() pe fiecare element din lista de capacitatea bidoanelor, stocand rezultatele in lista coduri_secrete. De asemenea, programul numara numarul de bidoane cu capacitatea 10x + 1 si il stocheaza in variabila numar_bidoane_cu_asfalt. La final, rezultatele sunt scrise intr-un fisier numit "fulger.out".

4212 - IncCifPare

2023-04-27T17:47:01Z

Tamas Claudia:

Sursa: [https://www.pbinfo.ro/probleme/4212/inccifpare]

== Cerința ==
Să se scrie un program care citește un număr natural '''n''' și care crește cu 1 valoarea cifrelor pare. De exemplu, dacă '''n'''=1234 atunci se va obține numărul 1335, iar dacă '''n'''=135 atunci numărul rămâne neschimbat.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa mesajul: '''"Datele sunt introduse corect."''', apoi programul va afișa numărul obținut prin creșterea cu 1 a cifrelor pare ale lui '''n'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricții și precizări ==
* 0 ≤ '''n''' ≤ 1.000.000.000
== Exemplu ==
; Intrare
: 1234
; Ieșire
: "Datele sunt introduse corect."
: 1335
== Rezolvare ==
<syntaxhighlight lang="python" line>
#4212

def verificare_numar(n: int) -> bool:
return 0 <= n <= 1000000000

def creste_cifre_pare(n: int) -> int:
r = 0
p = 1
while n > 0:
cifra = n % 10
if cifra % 2 == 0:
cifra += 1
r += cifra * p
p = p * 10
n = n // 10
return r

if __name__ == '__main__':
n = int(input("Introduceti un numar natural: "))
if not verificare_numar(n):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")
rezultat = creste_cifre_pare(n)
print(f"Numarul obtinut este: {rezultat}")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''verificare_numar''' primește un parametru '''n''' și returnează '''True''' dacă '''n''' este un număr întreg între 0 și 1000000000 (conform restricțiilor din cerință), altfel returnează '''False'''. Funcția '''creste_cifre_pare''' primește un număr întreg '''n''' și folosește o buclă '''while''' pentru a parcurge cifrele lui de la dreapta la stânga. Pentru fiecare cifră, se verifică dacă este pară și, dacă este, se crește cu 1. Apoi, cifra este adunată la rezultatul '''r''', care se actualizează în fiecare iterație prin înmulțirea cu '''p''', care reprezintă puterea de '''10''' corespunzătoare poziției curente a cifrei în numărul inițial. La final, funcția returnează '''r'''. În funcția '''main''', utilizatorul este întâmpinat cu un mesaj de introducere și se citește numărul '''n''' de la tastatură folosind input. Apoi, se verifică dacă '''n''' este valid folosind '''verificare_numar'''. Dacă nu este, se afișează un mesaj de eroare și programul se încheie folosind '''exit()'''. Dacă este valid, se calculează numărul obținut prin apelul funcției '''creste_cifre_pare''' și se afișează pe ecran folosind print.

4212 - IncCifPare

2023-04-27T17:46:24Z

Tamas Claudia:

Sursa: [https://www.pbinfo.ro/probleme/4212/inccifpare]

== Cerința ==
Să se scrie un program care citește un număr natural '''n''' și care crește cu 1 valoarea cifrelor pare. De exemplu, dacă '''n'''=1234 atunci se va obține numărul 1335, iar dacă '''n'''=135 atunci numărul rămâne neschimbat.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa mesajul: '''"Datele sunt introduse corect."''', apoi programul va afișa numărul obținut prin creșterea cu 1 a cifrelor pare ale lui '''n'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricții și precizări ==
* 0 ≤ '''n''' ≤ 1.000.000.000
== Exemplu ==
; Intrare
: 1234
; Ieșire
: 1335
== Rezolvare ==
<syntaxhighlight lang="python" line>
#4212

def verificare_numar(n: int) -> bool:
return 0 <= n <= 1000000000

def creste_cifre_pare(n: int) -> int:
r = 0
p = 1
while n > 0:
cifra = n % 10
if cifra % 2 == 0:
cifra += 1
r += cifra * p
p = p * 10
n = n // 10
return r

if __name__ == '__main__':
n = int(input("Introduceti un numar natural: "))
if not verificare_numar(n):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele introduse sunt corecte.")
rezultat = creste_cifre_pare(n)
print(f"Numarul obtinut este: {rezultat}")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''verificare_numar''' primește un parametru '''n''' și returnează '''True''' dacă '''n''' este un număr întreg între 0 și 1000000000 (conform restricțiilor din cerință), altfel returnează '''False'''. Funcția '''creste_cifre_pare''' primește un număr întreg '''n''' și folosește o buclă '''while''' pentru a parcurge cifrele lui de la dreapta la stânga. Pentru fiecare cifră, se verifică dacă este pară și, dacă este, se crește cu 1. Apoi, cifra este adunată la rezultatul '''r''', care se actualizează în fiecare iterație prin înmulțirea cu '''p''', care reprezintă puterea de '''10''' corespunzătoare poziției curente a cifrei în numărul inițial. La final, funcția returnează '''r'''. În funcția '''main''', utilizatorul este întâmpinat cu un mesaj de introducere și se citește numărul '''n''' de la tastatură folosind input. Apoi, se verifică dacă '''n''' este valid folosind '''verificare_numar'''. Dacă nu este, se afișează un mesaj de eroare și programul se încheie folosind '''exit()'''. Dacă este valid, se calculează numărul obținut prin apelul funcției '''creste_cifre_pare''' și se afișează pe ecran folosind print.

3966 - Adunare

2023-04-27T17:40:16Z

Tamas Claudia:

Sursă: [https://www.pbinfo.ro/probleme/3966/adunare]

== Cerinţa ==
Gigel are 2 bancnote, de '''a''' și '''b''' lei. El nu a învățat încă adunarea cu transport – cea în care adunarea a două cifre corespunzătoare depășește 10 (de exemplu 11 + 99), ci doar cea simplă, în care adunând cifre corespunzătoare din cele două numere nu se depășește 10 (de exemplu 11 + 22).
 
Stabiliți dacă Gigel știe să determine câte bomboane va cumpăra cu cele două bancnote, știind că o bomboană costă 1 leu. Dacă Gigel nu reușește să afle numărul de bomboane, va trebui să îl ajutați voi!
== Date de intrare ==
Programul citește de la tastatură numerele '''a''', '''b'''.
== Date de ieşire ==
Dacă datele introduse sunt corecte, pe ecran se va afișa mesajul: '''"Datele sunt introduse corect."''', apoi programul va afișa pe un mesaj, în funcție de valorile citite. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.
== Restricții și precizări ==
* 1 &les; '''a''', '''b''' &les; 2.000.000.000
== Exemplu ==
; Intrare
: 11 22
; Ieșire
: Datele sunt introduse corect.
: Gigel stie!
 
; Intrare
: 11 99
; Ieșire
: Datele sunt introduse corect.
: Gigel nu stie! El poate cumpara 110 bomboane!
== Rezolvare ==

<syntaxhighlight lang="python" line>

def verifica_datele(a: int, b: int) -> bool:
if 1 <= a <= 2000000000 and 1 <= b <= 2000000000:
return True
else:
return False

def rezolva_problema(a: int, b: int) -> str:
if (a % 10) + (b % 10) <= 9:
return "Gigel stie!"
else:
numar_bomboane = (a // 10) * 10 + a % 10 + (b // 10) * 10 + b % 10
return f"Gigel nu stie! El poate cumpara {numar_bomboane} bomboane!"

if __name__ == "__main__":
a, b = map(int, input().split())
if verifica_datele(a, b):
print("Datele sunt introduse corect.")
print(rezolva_problema(a, b))
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția '''verifica_datele''' primește două argumente '''a''' și '''b''' (de tip întreg) și returnează '''True''' dacă acestea se află între 1 și 2.000.000.000 (inclusiv), și '''False''' în caz contrar. Funcția '''rezolva_problema''' primește de asemenea două argumente '''a''' și '''b''', și returnează un mesaj corespunzător cerinței problemei. Dacă suma ultimei cifre ale lui '''a''' cu ultima cifră ale lui '''b''' este mai mică sau egală cu '''9''', atunci Gigel știe să determine numărul de bomboane pe care le poate cumpăra. În caz contrar, se calculează numărul de bomboane pe care le poate cumpăra Gigel (suma tuturor cifrelor lui '''a''' și '''b''', cu excepția ultimei cifre a fiecăruia), și se afișează un mesaj corespunzător. Funcția '''main''' citește cele două bancnote de la tastatură, verifică dacă datele sunt corecte, și afișează un mesaj corespunzător (în funcție de verificarea făcută de verifica_datele). Dacă datele sunt corecte, se afișează mesajul '''"Datele sunt introduse corect."''' și se calculează numărul de bomboane pe care le poate cumpăra Gigel, în caz contrar se afișează mesajul '''"Datele nu corespund restricțiilor impuse."'''.