Bitnami MediaWiki - User contributions [en]

E:15714

2024-01-04T09:45:54Z

Miriam: tot

'''E:15714 (Traian Covaciu)'''

''Se consideră mulțimea numerelor naturale de patru cifre, cifre care, într-o anumită ordine, sunt consecutive. Determinați probabilitatea ca, alegând la întâmplare un număr din această mulțime, acesta să fie divizibil cu 36.''

'''Soluție'''

Avem următoarele posibilități de a alege patru cifre consecutive: 0, 1, 2, 3; 1, 2, 3, 4; 2, 3, 4, 5; . . ., 6, 7, 8, 9. Cu acestea putem forma 18 + 6 '''·''' 24 = 162 numere. Acestea sunt cazurile posibile. Numerele divizibile cu 36 trebuie să se dividă cu 9 și cu 4. Pentru a fi divizibil cu 9 suma cifrelor trebuie să se dividă cu 9. Convine numai grupa 3, 4, 5, 6. Pentru a fi divizibil cu 4 numărul format din ultimele două cifre trebuie să se dividă cu 4. Obținem numerele 4536, 5436, 3456, 4356, 3564, 5364. Avem deci 6 cazuri favoriabile. Probabilitatea este <math>{1 \over27}</math>.

2340 – Sumă Min Max

2023-04-15T21:23:21Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/2340/sumaminmax Suma Min Max]
----
==Cerinţă==
Scrieți funcția <code>sumaMinMax</code> care primește ca parametri un tablou unidimensional sir format din <code>n</code> elemente și un număr natural <code>n</code>. Funcția va returna un vector cu două elemente, primul element reprezentând cea mai mică sumă formată din exact <code>n-1</code> elemente dintre cele <code>n</code> ale lui sir, iar cel de-al doilea element reprezentând cea mai mare sumă formată din exact <code>n-1</code> elemente dintre cele <code>n</code> ale lui sit.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, care conține cele 2 valori menționate mai sus. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100
*valorile elementelor șirului vor fi cuprinse între 1 și 50
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:1 2 3 4 5
;Ieșire
:Datele introduse sunt corecte!
:[10, 14]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:13 23 2 3 1 6
;Ieșire
:Datele introduse sunt corecte!
:[25, 47]
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 3
:Introduceti 3 numere separate prin spatiu:132 13 1
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 100:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if 1 <= int(i) < 50:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def suma_min_max(sir, n):
sir.sort()
min_sum = 0
for i in range(n - 1):
min_sum += sir[i]
max_sum = 0
for i in range(1, n):
max_sum += sir[i]
res = [min_sum, max_sum]
print(res)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
suma_min_max(lst_int, int(n))

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește ca input un număr natural reprezentând numărul de elemente ale unui tablou, urmat de o listă de numere întregi separate prin spațiu. Programul verifică mai întâi dacă numărul introdus ca input este un număr natural în intervalul [1, 100] prin apelul funcției verificare_nr_elemente. Dacă inputul nu este valid, programul afișează un mesaj de eroare și se încheie prin apelul funcției exit().

Funcția verificare_nr_elemente utilizează funcția is_integer pentru a verifica dacă inputul este un număr valid. Dacă acest lucru este adevărat, funcția verifică dacă inputul este un număr natural în intervalul [1, 100]. Dacă inputul nu este valid, programul afișează un mesaj de eroare și se încheie prin apelul funcției exit().

După ce inputul a fost validat, programul continuă prin apelul funcției verificare_vector, care verifică dacă lista de numere introdusă ca input are dimensiunea corespunzătoare și dacă fiecare element din listă este un număr întreg între 1 și 49. Dacă aceste condiții nu sunt îndeplinite, programul afișează un mesaj de eroare și se încheie prin apelul funcției exit().

Dacă inputul este validat cu succes, programul apelează funcția suma_min_max pentru a calcula cea mai mică și cea mai mare sumă formată din exact n-1 elemente dintre cele n ale lui v. Funcția suma_min_max sortează mai întâi lista de numere primite ca input, apoi calculează suma primelor n-1 numere ca fiind cea mai mică sumă și suma tuturor elementelor din lista de numere cu excepția primului element ca fiind cea mai mare sumă. Funcția returnează un tablou cu cele două sume calculate.

În cele din urmă, programul afișează tabloul returnat de funcția suma_min_max.

2732 – Succesor

2023-04-15T21:14:03Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/2732/succesor Succesor]
----
==Cerinţă==
Se consideră vectorul ordonat strict crescător sir <code>= (sir[1], sir[2], ..., sir[k])</code> ce memorează o submulțime de <code>k</code> elemente a mulțimii <code>{1, 2, ..., n}</code>. Trebuie determinată următoarea submulțime din punct de vedere lexicografic. De exemplu, dacă <code>n=4</code> și <code>k=3</code>, atunci submulțimile de trei elemente, în ordine lexicografică, sunt: <code>{1,2,3}</code>, <code>{1,2,4}</code>, <code>{1,3,4}</code>, <code>{2,3,4}</code>.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi k, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma determinării următoarei submulțimi din punct de vedere lexicografic. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 < k < n < 30.000
*valorile elementelor șirului vor fi < 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti elementul n: 9
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:2 4 5 8 9
;Ieșire
:Datele introduse sunt corecte!
:[2, 4, 6, 7, 8]
===Exemplul 2===
;Intrare
:Introduceti elementul n: 10
:Introduceti numarul de elemente a sirului: 2
:Introduceti 2 numere separate prin spatiu:14 12 3
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(k, n):
if is_integer(k):
if 1 < int(k) <= int(n):
return k
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verif_ordonare(lst):
for i in range(1, len(lst)):
if lst[i] < lst[i-1]:
print("Datele introduse sunt incorecte!")
exit()
return True

def verificare_vector(k, vector, n):
if len(vector) != int(k):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if 1 <= int(i) <= int(n):
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()
verif_ordonare(vector)

def verificare_n(n):
if is_integer(n):
if 2 <= int(n) <= 30000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def succesor(sir, n, k):
i = k - 1
while i >= 0 and sir[i] == n - k + i + 1:
i -= 1
if i >= 0:
sir[i] += 1
for j in range(i+1, k):
sir[j] = sir[j-1] + 1
print(sir)

if __name__ == '__main__':
n = input("Introduceti elementul n: ")
verificare_n(n)
k = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(k,n)
elem = input(f"Introduceti {k} numere separate prin spatiu:").split()
verificare_vector(k, elem, n)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
succesor(lst_int, int(n), int(k))

</syntaxhighlight>
==Explicație rezolvare==
Funcția <code>is_integer(value)</code> verifică dacă valoarea <code>value</code> este un număr întreg, returnând <code>True</code> dacă este și <code>False</code> în caz contrar.

Funcția <code>verificare_nr_elemente(k, n)</code> verifică dacă numărul <code>k</code> este un număr întreg și se află între 1 și <code>n</code>, returnând <code>k</code> în cazul în care este valid, iar în caz contrar, afișează un mesaj de eroare și iese din program cu <code>exit()</code>.

Funcția <code>verif_ordonare(lst)</code> verifică dacă elementele listei <code>lst</code> sunt în ordine crescătoare, comparând fiecare element cu elementul anterior. În cazul în care nu sunt în ordine crescătoare, afișează un mesaj de eroare și iese din program cu <code>exit()</code>. Dacă toate elementele sunt în ordine crescătoare, returnează <code>True</code>.

Funcția <code>verificare_vector(k, vector, n)</code> verifică dacă lungimea listei <code>vector</code> este egală cu <code>k</code> și dacă toate elementele sunt întregi și se află între 1 și <code>n</code>. Dacă există elemente invalide sau lista nu este ordonată crescător, afișează un mesaj de eroare și iese din program cu <code>exit()</code>. Dacă toate elementele sunt valide și lista este ordonată crescător, funcția se încheie cu succes.

Funcția <code>verificare_n(n)</code> verifică dacă numărul <code>n</code> este un număr întreg și se află între 2 și 30000, returnând <code>n</code> în cazul în care este valid, iar în caz contrar, afișează un mesaj de eroare și iese din program cu <code>exit()</code>.

Funcția <code>succesor(sir, n, k)</code> primește lista <code>sir</code>, reprezentând submulțimea de <code>k</code> elemente din mulțimea {1,2,...,n}, și returnează succesorul lexicografic al acestei submulțimi, adică următoarea submulțime de <code>k</code> elemente din mulțimea {1,2,...,n}, ordonată crescător. Pentru a găsi succesorul, se parcurge lista de la dreapta la stânga și se caută prima poziție <code>i</code> pentru care <code>sir[i]</code> nu este egal cu <code>n - k + i + 1</code>. Dacă se găsește o astfel de poziție, se incrementează <code>sir[i]</code> cu 1 și se ajustează restul elementelor astfel încât să formeze o submulțime ordonată crescător. Dacă nu există o astfel de poziție, submulțimea inițială era deja maximă și succesorul nu există.

În <code>if __name__ == '__main__':</code>, se citesc valorile <code>n</code> și <code>k</code>, se verifică dacă sunt valide folosind funcțiile <code>verificare_n</code> și <code>verificare_nr_elemente</code>, apoi se citește lista <code>elem</code> și se verifică folosind funcția verif_ordonare. Aceasta parcurge elementele vectorului și verifică dacă fiecare element este mai mare sau egal cu cel anterior. Dacă se găsește un element care nu respectă această condiție, programul afișează mesajul "Datele introduse sunt incorecte!" și se oprește cu exit().

În continuare, se verifică elementele vectorului dacă respectă intervalul impus, adică să fie între 1 și n, folosind funcția verificare_vector. Dacă un element nu se încadrează în acest interval, programul afișează mesajul "Datele introduse sunt incorecte!" și se oprește cu exit().

Se afișează mesajul "Datele introduse sunt corecte!" și se apelează funcția succesor, care primește ca parametri vectorul, n și k. Funcția calculează succesorul submulțimii memorate inițial în vectorul a și afișează rezultatul.

4235 – Perechi DivP

2023-04-15T20:54:35Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/4235/perechidivp Perechi DivP]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi și un nr întreg p. Subprogramul returnează numărul de perechi <code>(sir[i], sir[j])</code> cu <code>i < j</code> și suma sir<code>[i]+sir[j]</code> este multiplu de <code>P</code>.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului, urmate de elementul p.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa numărul de perechi care îndeplinesc condițiile mai sus precizate. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*2 <= n <= 20000
*valorile elementelor șirului vor fi cuprinse între 1 și 30.000
*2 <= p <= 1000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:9 2 4 7 3
:Introduceti elementul p: 3
;Ieșire
:Datele introduse sunt corecte!
:3
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:1 411 3 4 1 2
:Introduceti elementul p: 2
;Ieșire
:Datele introduse sunt corecte!
:7
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 3
:Introduceti 3 numere separate prin spatiu:131 131 41 2
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 2 <= int(n) <= 200000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if 1 <= int(i) <= 30000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_p(p):
if is_integer(p):
if 2 <= int(p) <= 1000:
return p
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def nr_perechi_multiplu_p(sir, n, P):
cnt = [0] * int(P)
res = 0

for i in range(int(n)):
if sir[i] % int(P) == 0:
res += cnt[0]
else:
res += cnt[int(P) - sir[i] % int(P)]
cnt[sir[i] % int(P)] += 1

return res

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
p = input("Introduceti elementul p: ")
verificare_p(p)
print("Datele introduse sunt corecte!")
print(nr_perechi_multiplu_p(lst_int, n, p))

</syntaxhighlight>
==Explicație rezolvare==
Această soluție implementează o funcție numită <code>nr_perechi_multiplu_p</code> care primește ca argumente un vector de numere întregi <code>sir</code>, lungimea acestuia <code>n</code> și un număr întreg <code>P</code>. Scopul acestei funcții este de a returna numărul de perechi <code>(a[i], a[j])</code> pentru care <code>i < j</code> și <code>a[i] + a[j]</code> este multiplu de <code>P</code>.

Pentru a verifica validitatea datelor de intrare, au fost definite mai multe funcții de verificare: <code>verificare_nr_elemente</code>, <code>verificare_vector</code> și <code>verificare_p</code>. Toate acestea utilizează funcția <code>is_integer</code> pentru a verifica dacă valorile introduse sunt numere întregi valide. Dacă valorile introduse nu sunt corecte, programul afișează un mesaj de eroare și se oprește prin utilizarea funcției <code>exit</code>.

Funcția <code>nr_perechi_multiplu_p</code> utilizează un vector <code>cnt</code> inițializat cu valori de 0 pentru a număra aparițiile fiecărui rest modulo <code>P</code> al elementelor din vectorul <code>sir</code>. Pe măsură ce se parcurge vectorul, se calculează restul fiecărui element <code>sir[i]</code> împărțit la <code>P</code>, iar apoi se adaugă numărul de perechi în care suma lor este multiplu de <code>P</code>. Numărul de astfel de perechi este reprezentat de <code>cnt[0]</code> dacă <code>sir[i]</code> este el însuși multiplu de <code>P</code>. În caz contrar, numărul de perechi corespunzătoare este reprezentat de <code>cnt[P - sir[i] % P]</code>. La sfârșit, funcția returnează numărul total de perechi găsite.

În blocul <code>if __name__ == '__main__':</code>, programul citește datele de intrare (lungimea vectorului, elementele acestuia și numărul <code>P</code>), verifică dacă acestea sunt corecte și, dacă sunt, afișează numărul de perechi cerute utilizând funcția <code>nr_perechi_multiplu_p</code>.

3215 – Kth

2023-04-15T20:42:29Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/3215/kth Kth]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Funcția va returna poziția din vector unde <code>x</code> apare pentru a <code>k</code>-a oară, sau <code>-1</code> dacă <code>x</code> nu apare de cel puțin <code>k</code> ori
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului, iar mai apoi, elementele x și k.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa poziția din vector în care x apare pentru a k-a oară, sau -1 dacă x nu apare de cel puțin k ori. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 1000
*valorile elementelor șirului vor fi cuprinse între -1000 și 1000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:4 2 5 2 6 2
:Introduceti elementul x:2
:Introduceti elementul k:2
;Ieșire
:Datele introduse sunt corecte!
:3
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:2 3 4 5
:Introduceti elementul x:5
:Introduceti elementul k:5
;Ieșire
:Datele introduse sunt corecte!
:-1
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 123456
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 1000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000 <= int(i) <= 1000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_x(x, lst_int):
if is_integer(x):
if -1000 <= int(x) <= 1000:
if x in lst_int:
return x
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_k(k):
if is_integer(k):
if 0 <= int(k) <= 1000:
return k
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def Kth(sir, n, x, k):
count = 0
for i in range(int(n)):
if sir[i] == int(x):
count += 1
if count == int(k):
print(i)
exit()
print("-1")

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
x = input("Introduceti elementul x:")
verificare_x(x, lst_int)
k = input("Introduceti elementul k:")
verificare_k(k)
print("Datele introduse sunt corecte!")
Kth(lst_int, n, x, k)

</syntaxhighlight>
==Explicație rezolvare==
Funcția <code>is_integer(value)</code> verifică dacă o valoare este de tip integer și returnează un boolean.

Funcția <code>verificare_nr_elemente(n)</code> primește ca parametru <code>n</code>, numărul de elemente ale vectorului. Verifică dacă valoarea este un integer și se află în intervalul [1, 1000]. Dacă nu respectă aceste condiții, se afișează un mesaj de eroare și programul se oprește cu <code>exit()</code>. Altfel, funcția returnează <code>n</code>.

Funcția <code>verificare_vector(n, vector)</code> primește ca parametri <code>n</code> și <code>vector</code>, respectiv numărul de elemente și vectorul în sine. Verifică dacă numărul de elemente din vector corespunde cu <code>n</code>. Dacă da, verifică pentru fiecare element din vector dacă este un integer și se află în intervalul [-1000, 1000]. Dacă nu, se afișează un mesaj de eroare și programul se oprește cu <code>exit()</code>. Altfel, funcția nu returnează nimic.

Funcția <code>verificare_x(x)</code> primește ca parametru <code>x</code> și verifică dacă este un integer și se află în intervalul [-1000, 1000]. Dacă nu respectă aceste condiții, se afișează un mesaj de eroare și programul se oprește cu <code>exit()</code>. Altfel, funcția returnează <code>x</code>.

Funcția <code>verificare_k(k)</code> primește ca parametru <code>k</code> și verifică dacă este un integer și se află în intervalul [0, 1000]. Dacă nu respectă aceste condiții, se afișează un mesaj de eroare și programul se oprește cu <code>exit()</code>. Altfel, funcția returnează <code>k</code>.

Funcția <code>Kth(sir, n, x, k)</code> primește ca parametri <code>sir</code>, <code>n</code>, <code>x</code> și <code>k</code>, respectiv vectorul, numărul de elemente din vector, valoarea căutată și numărul de apariții căutate. Funcția caută valoarea <code>x</code> în vector și numără de câte ori apare. Când numărul de apariții dorit <code>k</code> este atins, se afișează poziția elementului și programul se oprește cu <code>exit()</code>. Dacă <code>x</code> nu apare de cel puțin <code>k</code> ori, se afișează <code>-1</code>.

În funcția principală (<code>__main__</code>), se citesc valorile <code>n</code>, <code>elem</code>, <code>x</code> și <code>k</code> de la utilizator. Se verifică ca toate valorile să respecte condițiile cu ajutorul funcțiilor <code>verificare_nr_elemente(n)</code>, <code>verificare_vector(n, elem)</code>, <code>verificare_x(x)</code> și <code>verificare_k(k)</code>. Dacă toate valorile sunt corecte, se afișează un mesaj de confirmare și se apelează funcția <code>Kth(lst_int, n, x, k)</code>.

0895 – PermutarePF

2023-04-15T20:20:50Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/895/permutarepf PermutarePF]
----
==Cerinţă==
Se numește ''permutare'' a unei mulțimi o aranjare a elementelor mulțimii în altă ordine. De exemplu, permutările mulțimii <code>{1,2,3}</code> sunt: <code>(1,2,3)</code>, <code>(1,3,2)</code>, <code>(2,1,3)</code>, <code>(2,3,1)</code>, <code>(3,1,2)</code>, <code>(3,2,1)</code>.

Fie <code>(p1, p2, ..., pn</code>) o permutare a mulțimii <code>{1,2,...,n}</code>. Se numește punct fix al permutării o valoare <code>k</code> din mulțime cu proprietatea că <code>pk = k</code>.

Scrieţi definiția completă a subprogramulu<code>permutare</code> care are <code>2</code> parametri: sir, prin care primeşte un tablou unidimensional cu maximum <code>100</code> de numere naturale mai mici decât <code>1000</code> și <code>n</code>, numărul efectiv de elemente ale tabloului.

Subprogramul verifică dacă elementele vectorului sir reprezintă o permutare fără puncte fixe a mulțimii <code>{1,2,...,n}</code> și returnează valoarea <code>1</code> în caz afirmativ, respectiv <code>0</code> în caz negativ.

==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa valoare 1 dacă șirul reprezintă o permutare fără puncte fixe, și 0 în caz contrar. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100
*valorile elementelor șirului vor fi < 1.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:2 3 1 4
;Ieșire
:Datele introduse sunt corecte!
:0
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:2 3 1 6 4 5
;Ieșire
:Datele introduse sunt corecte!
:1
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 103
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 100:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) < 1000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def permutare(sir, n):
for i in range(int(n)):
if sir[i] == i+1:
return 0
return 1

def det_puncte_fixe(sir):
if permutare(sir, n) == 1:
print("1")
else:
print("0")

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
det_puncte_fixe(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește de la utilizator un număr n reprezentând numărul de elemente ale vectorului și apoi primește un vector unidimensional de lungime n cu numere întregi prin intermediul funcției input(). Programul verifică dacă n este un număr natural cuprins între 1 și 100 și dacă elementele vectorului sunt numere întregi mai mici decât 1000. Aceste verificări sunt efectuate de funcțiile verificare_nr_elemente() și verificare_vector(), care ies din program prin intermediul funcției exit() în cazul în care datele introduse sunt incorecte.

Programul utilizează apoi o funcție permutare() pentru a determina dacă vectorul primit reprezintă o permutare fără puncte fixe a mulțimii {1,2,...,n}. Funcția parcurge vectorul și verifică dacă există un element al vectorului care se află pe aceeași poziție cu valoarea sa (adică este un punct fix). Dacă se găsește cel puțin un punct fix, funcția returnează valoarea 0, altfel returnează valoarea 1.

În cele din urmă, programul utilizează funcția det_puncte_fixe() pentru a determina dacă vectorul primit reprezintă o permutare fără puncte fixe și afișează valoarea 1 în caz afirmativ și valoarea 0 în caz negativ.

Datele introduse sunt considerate corecte dacă toate verificările sunt trecute fără probleme și programul ajunge la afișarea valorii 1 sau 0.

3658 – NrTriplete

2023-04-15T20:08:16Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/3658/nrtriplete NrTriplete]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi și s, un nr întreg. Funcția returnează numărul de triplete <code>(sir[i], sir[j], sir[k])</code>, unde <code>0 ≤ i < j < k < n</code> și sir<code>[i] + sir[j] + sir[k] < S</code>.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului, apoi valoarea s.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa totalul de triplete care îndeplinesc condițiile date. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*3 <= n <= 2000
*valorile elementelor șirului vor fi cuprinse între -100.000.000 și 100.000.000
*-100.000.000 <= s <= 100.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:1 -2 0 4
:Introduceti valoarea s: 5
;Ieșire
:Datele introduse sunt corecte!
:count: 3
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 3
:Introduceti 3 numere separate prin spatiu: 1231 1 321 41
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 3 <= int(n) <= 2000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != n:
print("Datele introduse sunt incorecte!")
exit()
for i in vector:
if -100000000 <= int(i) <= 100000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_s(s):
if is_integer(s):
if 3 <= int(s) <= 2000:
return s
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def nr_triplete(sir, n, S):
count = 0
for i in range(n-2):
for j in range(i+1, n-1):
for k in range(j+1, n):
if sir[i]+sir[j]+sir[k] < S:
count += 1
print("count:",count)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
lst_int = list(map(int, input(f"Introduceti {n} numere separate prin spatiu:").split()))
verificare_vector(n, lst_int)
s = input("Introduceti valoarea s: ")
verificare_s(s)
print("Datele introduse sunt corecte!")
nr_triplete(lst_int, int(n), int(s))

</syntaxhighlight>
==Explicație rezolvare==

# Funcția <code>is_integer(value)</code> verifică dacă <code>value</code> este un string reprezentând un număr întreg (adică conține doar cifre). Returnează <code>True</code> dacă este și <code>False</code> în caz contrar.
# Funcția <code>verificare_nr_elemente(n)</code> verifică dacă <code>n</code> este un string reprezentând un număr întreg între 3 și 2000. În cazul în care este valid, returnează <code>n</code>, altfel afișează un mesaj de eroare și iese din program.
# Funcția <code>verificare_vector(n, vector)</code> verifică dacă toate elementele din <code>vector</code> sunt numere întregi între -100000000 și 100000000. În cazul în care sunt valide, nu face nimic, altfel afișează un mesaj de eroare și iese din program.
# Funcția <code>verificare_s(s)</code> verifică dacă <code>s</code> este un string reprezentând un număr întreg între 3 și 2000. În cazul în care este valid, returnează <code>s</code>, altfel afișează un mesaj de eroare și iese din program.
# Funcția <code>nr_triplete(sir, n, S)</code> primește un tablou <code>sir</code> de <code>n</code> numere întregi și un număr întreg <code>S</code>. Parcurge toate tripletele posibile din tablou și numără cele pentru care suma este strict mai mică decât <code>S</code>. Afișează rezultatul final.
# În funcția <code>main</code>, se citesc numărul de elemente, vectorul și valoarea <code>S</code> cu ajutorul unor input-uri și se validează folosind funcțiile de mai sus. Apoi, se apelează funcția <code>nr_triplete</code> cu argumentele corespunzătoare.
# Comanda <code>list(map(int, input(f"Introduceti {n} numere separate prin spatiu:").split()))</code> transformă string-ul citit de la tastatură într-o listă de numere întregi. Mai întâi se citesc valorile cu <code>input(f"Introduceti {n} numere separate prin spatiu:")</code>, apoi se separă folosind funcția <code>split()</code> și se transformă fiecare element din listă într-un număr întreg folosind funcția <code>int</code>.

2620 – FNext Number

2023-04-15T19:53:42Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/2620/fnextnumber FNext Number]
----
==Cerinţă==
Se primește ca parametru un număr natural nenul <code>n</code> și returnează cel mai mic număr natural, strict mai mare decât <code>n</code>, care are în reprezentarea în baza <code>2</code> același număr de biți de <code>1</code> ca și <code>n</code>.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n.</code>
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi va afișa cel mai mic număr natural, strict mai mare decât <code>n</code>, care are în reprezentarea în baza <code>2</code> același număr de biți de <code>1</code> ca și <code>n</code>. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*n > 0
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul: 30
;Ieșire
:Datele introduse sunt corecte!
:39
===Exemplul 2===
;Intrare
:Introduceti numarul: 456
;Ieșire
:Datele introduse sunt corecte!
:464
===Exemplul 3===
;Intrare
:Introduceti numarul: -5
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr(n):
if is_integer(n):
if 0 < int(n):
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def next_number(n: int) -> int:
numar_de_biti_de_1 = bin(n).count('1')
while True:
n += 1
if bin(n).count('1') == numar_de_biti_de_1:
return n

if __name__ == '__main__':
n = input("Introduceti numarul: ")
verificare_nr(n)
print("Datele introduse sunt corecte!")
print(next_number(int(n)))

</syntaxhighlight>
==Explicație rezolvare==

* Funcția <code>is_integer(value)</code> verifică dacă un șir de caractere reprezintă un număr întreg pozitiv și returnează <code>True</code> sau <code>False</code> în funcție de acest lucru.
* Funcția <code>verificare_nr(n)</code> verifică dacă numărul primit ca parametru este un număr natural nenul și îl returnează dacă este corect, altfel afișează un mesaj de eroare și încheie programul cu funcția <code>exit()</code>.
* Funcția <code>next_number(n)</code> primește un număr natural <code>n</code> și calculează cel mai mic număr natural, strict mai mare decât <code>n</code>, care are în reprezentarea în baza 2 același număr de biți de 1 ca și <code>n</code>.
* În interiorul funcției <code>next_number(n)</code> se numără numărul de biți de 1 din reprezentarea în baza 2 a lui <code>n</code> prin utilizarea funcției <code>bin(n)</code>, care transformă numărul <code>n</code> în reprezentarea sa în baza 2 sub formă de șir de caractere, și apoi numărând câte biți de 1 conține acest șir de caractere prin utilizarea metodei <code>count('1')</code>.
* Folosind un ciclu infinit, se verifică fiecare număr natural, începând de la <code>n + 1</code>, prin incrementarea lui cu 1 în fiecare iterație și numărarea numărului de biți de 1 din reprezentarea sa în baza 2. Dacă numărul de biți de 1 din reprezentarea în baza 2 a numărului verificat este egal cu cel al lui <code>n</code>, se returnează acest număr.
* În programul principal se primește numărul <code>n</code> de la utilizator prin intermediul funcției <code>input()</code> și se verifică dacă acesta este un număr natural nenul prin apelul funcției <code>verificare_nr(n)</code>. Dacă acesta este corect, se afișează mesajul "Datele introduse sunt corecte!" și se calculează cel mai mic număr natural care are în reprezentarea în baza 2 același număr de biți de 1 ca și <code>n</code> prin apelul funcției <code>next_number(int(n))</code>, care primește numărul <code>n</code> sub forma unui întreg. Rezultatul este afișat prin intermediul funcției <code>print()</code>.

3642 – F expo

2023-04-15T19:46:40Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/3642/f-expo F expo]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Pentru fiecare element a sirului, se calculează exponentul maxim <code>e</code> cu proprietatea că <code>2e</code> <code>≤ sir[i]</code>, iar rezultatul se va memora tot în sir<code>[i]</code>.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma calculării exponentului maxim. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*2 <= n <= 5.000.000
*valorile elementelor șirului vor fi cuprinse între 1 și 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:9 1 5 15 19 30
;Ieșire
:Datele introduse sunt corecte!
:Vectorul nou este: [3, 0, 2, 3, 4, 4]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:1 141 4 14
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 7
:Introduceti 7 numere separate prin spatiu:25254 4567 564 3 4 7 45
;Ieșire
:Datele introduse sunt corecte!
:Vectorul nou este: [14, 12, 9, 1, 2, 2, 5]
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 2 < int(n) < 5000000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if 1 <= int(i) < 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def f_expo(sir, n):
for i in range(int(n)):
e = 0
while 2 ** (e+1) <= sir[i]:
e += 1
sir[i] = e

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
f_expo(lst_int, n)
print("Vectorul nou este:", lst_int)

</syntaxhighlight>
==Explicație rezolvare==

# Funcția <code>is_integer(value)</code> verifică dacă un string reprezintă un număr întreg. Folosim această funcție pentru a valida input-ul utilizatorului.
# Funcția <code>verificare_nr_elemente(n)</code> verifică dacă numărul de elemente introdus de utilizator este corect (îndeplinește condițiile din enunț) și returnează valoarea dacă este valid sau afișează un mesaj de eroare și oprește programul cu <code>exit()</code> în caz contrar.
# Funcția <code>verificare_vector(n, vector)</code> verifică dacă lungimea vectorului introdus de utilizator este corectă și dacă fiecare element este valid (îndeplinește condițiile din enunț). În caz contrar, afișează un mesaj de eroare și oprește programul cu <code>exit()</code>.
# Funcția <code>f_expo(sir, n)</code> primește ca parametrii vectorul și lungimea sa și, pentru fiecare element din vector, calculează exponentul maxim e cu proprietatea că 2e ≤ sir[i] și îl memorează în locul valorii inițiale a lui sir[i].
# În blocul <code>if __name__ == '__main__':</code> se citește numărul de elemente și vectorul de la utilizator, se validează datele de intrare și se apelează funcția <code>f_expo()</code> pentru a calcula exponenții. Ulterior, se afișează noul vector.

4214 – Două Numere

2023-04-15T19:37:01Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/4214/douanumere Doua Numere]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Subprogramul returnează suma maximă care poate fi obținută adunând două numere din sir care au aceeași sumă a cifrelor. Dacă nu există două numere cu aceeași sumă a cifrelor, atunci funcția va returna <code>-1</code>.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa suma elementelor precizate mai sus. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*2 <= n <= 100.000
*valorile elementelor șirului vor fi < 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:14 66 41 50 93
;Ieșire
:Datele introduse sunt corecte!
:Suma maxima care poate fi obtinuta este: 159
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:123 12 3 5
;Ieșire
:Datele introduse sunt corecte!
:Suma maxima care poate fi obtinuta este: 15
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:1231 31 213 1
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 2 < int(n) < 1000000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) < 1000000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def sum_cif(n):
s = 0
while n > 0:
s += n % 10
n //= 10
return s

def suma_max(a, n):
max_sum = -1
for i in range(int(n)):
for j in range(i+1, int(n)):
if sum_cif(a[i]) == sum_cif(a[j]):
max_sum = max(max_sum, a[i]+a[j])
return max_sum

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
print("Suma maxima care poate fi obtinuta este:",suma_max(lst_int, n))

</syntaxhighlight>
==Explicație rezolvare==
Acest program are ca scop găsirea sumei maxime care poate fi obținută prin adunarea a două numere dintr-un tablou, care au aceeași sumă a cifrelor. În cazul în care nu există două numere cu aceeași sumă a cifrelor, programul va returna -1.

Funcția is_integer: Această funcție primește un parametru numit value și verifică dacă acesta este un număr întreg (adică este format din cifre). În caz afirmativ, funcția returnează True, în caz contrar, returnează False.

Funcția verificare_nr_elemente: Această funcție primește un parametru numit n și verifică dacă acesta este un număr întreg cuprins între 2 și 1000000. Dacă este adevărat, funcția returnează valoarea lui n, în caz contrar afișează un mesaj de eroare și întrerupe programul cu ajutorul funcției exit().

Funcția verificare_vector: Această funcție primește două parametri: n și vector. Ea verifică dacă lungimea vectorului este egală cu n și dacă toate elementele vectorului sunt numere întregi cuprinse între 0 și 1000000000. Dacă totul este corect, funcția nu returnează nimic, în caz contrar afișează un mesaj de eroare și întrerupe programul cu ajutorul funcției exit().

Funcția sum_cif: Această funcție primește un parametru numit n și calculează suma cifrelor acestui număr utilizând operatorul modulo (%) și operatorul de împărțire întreagă (//). Funcția returnează suma cifrelor.

Funcția suma_max: Această funcție primește doi parametri: a și n. Funcția parcurge două bucle for pentru a compara suma cifrelor a fiecărui element din vector cu suma cifrelor ale celorlalte elemente și pentru a găsi perechi de numere cu aceeași sumă a cifrelor. Dacă este găsită o pereche cu aceeași sumă a cifrelor, suma celor două numere este comparată cu valoarea maximă anterioară și, dacă este mai mare, aceasta este setată ca noua valoare maximă. Funcția returnează valoarea maximă găsită. Dacă nu este găsită nicio pereche cu aceeași sumă a cifrelor, funcția returnează -1.

Funcția principală: Funcția principală primește de la utilizator lungimea vectorului și vectorul, verifică dacă acestea sunt corecte cu ajutorul funcțiilor verificare_nr_elemente și verificare_vector, apoi calculează suma maximă a două numere din vector cu aceeași sumă a cifrelor cu ajutorul funcției suma_max. Dacă suma maximă este -1, funcția afișează un mesaj corespunzător, în caz contrar afișează valoarea găsită.

4035 – Nr SecvS

2023-04-15T19:26:32Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/4035/nrsecvs Nr SecvS]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi și s, un nr natural nenul. Subprogramul returnează numărul de secvențe din vector care au suma strict mai mare decât <code>S</code>.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului, apoi valoarea s.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa numărul de secvențe din vector care au suma strict mai mare decât s. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*2 <= n <= 1.000.000
*valorile elementelor șirului vor fi cuprinse între 1 și 1000
*1 <= s <= 10.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:3 6 3 1
:Introduceti valoarea s:10
;Ieșire
:Datele introduse sunt corecte!
:Numarul de secvente accepate este: 2
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:123 12 3 5 4
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:IntroducIntroduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:123 1 3 1 4
:Introduceti valoarea s:15
;Ieșire
:Datele ntroduse sunt corecte!
:Numarul de secvente accepate este: 5
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 2 < int(n) < 1000000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if 0 < int(i) < 1000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_s(s):
if is_integer(s):
if 0 < int(s) < 10000:
return s
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def nr_secv_s(sir, n, S):
count = 0
for i in range(int(n)):
for j in range(i, int(n)):
if sum(sir[i:j+1]) > int(S):
count += 1
print("Numarul de secvente accepate este:",count)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
s = input("Introduceti valoarea s:")
verificare_s(s)
print("Datele ntroduse sunt corecte!")
nr_secv_s(lst_int, n, s)

</syntaxhighlight>
==Explicație rezolvare==
Programul implementează o funcție numită "nr_secv_s" care primește ca parametrii un tablou de numere nenule, numărul efectiv de elemente al tabloului și un număr natural nenul "S". Scopul funcției este de a calcula numărul de secvențe din tabloul dat care au suma strict mai mare decât "S" și de a afișa acest număr.

Funcția începe prin a inițializa un contor la zero și apoi parcurge toate perechile de poziții din tablou (folosind două bucle for îmbricate). Pentru fiecare astfel de pereche, funcția calculează suma elementelor din secvența corespunzătoare și dacă această sumă este strict mai mare decât "S", atunci contorul este incrementat.

La final, funcția afișează valoarea contorului, care reprezintă numărul de secvențe care îndeplinesc condiția cerută.

Înainte de apelarea funcției, sunt efectuate verificări asupra datelor introduse de utilizator: se verifică dacă numărul de elemente este un număr întreg între 2 și 1.000.000, dacă fiecare element din tablou este un număr întreg între 0 și 1000, și dacă numărul "S" este un număr întreg între 0 și 10.000. În cazul în care aceste verificări eșuează, programul va afișa un mesaj de eroare și va ieși din program.

4238 – Nr Zero

2023-04-15T19:11:42Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/4238/nrzero NrZero]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Toate cifrele impare se află la începutul vectorului ordonate descrescător, iar cifrele pare se găsesc la finalul vectorului, ordonate crescător. Subprogramul returnează numărul de valori egale cu <code>0</code> din vectorul <code>a</code>.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va numărul de valori egale cu 0 din vectorul a. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*2 <= n <= 500.000
*valorile elementelor șirului vor fi cuprinse între 0 și 9
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 13
:Introduceti 13 numere separate prin spatiu:7 7 3 1 1 0 0 0 2 2 4 6 6
;Ieșire
:Datele introduse sunt corecte!
:Numarul de aparitii a cifrei 0: 3
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 3
:Introduceti 3 numere separate prin spatiu:7 2 1
;Ieșire
:Datele ntroduse sunt corecte!
:Lista nu indeplineste conditia
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:7 3 2 4 6
;Ieșire
:Datele ntroduse sunt corecte!
:Numarul de aparitii a cifrei 0: 0
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 2 < int(n) < 500000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1 < int(i) < 10:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_lista(lista):
impare = sorted([x for x in lista if x % 2 == 1], reverse=True)
if impare != lista[:len(impare)]:
print("Lista nu indeplineste conditia")
exit()
pare = sorted([x for x in lista if x % 2 == 0])
if pare != lista[len(impare):]:
print("Lista nu indeplineste conditia")
exit()
zero_count = lista.count(0)

print("Numarul de aparitii a cifrei 0:", zero_count)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele ntroduse sunt corecte!")
verificare_lista(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Programul verifică o listă de numere pentru a se asigura că respectă anumite condiții, și anume că toate numerele impare sunt la începutul listei, ordonate descrescător, iar toate numerele pare sunt la sfârșitul listei, ordonate crescător. În plus, programul returnează numărul de apariții al cifrei 0 în listă.

Funcția <code>is_integer</code> verifică dacă o valoare dată este un număr întreg.

Funcția <code>verificare_nr_elemente</code> verifică dacă valoarea dată ca parametru reprezintă un număr întreg și se află în intervalul [3, 499999].

Funcția <code>verificare_vector</code> verifică dacă vectorul dat ca parametru are aceeași lungime ca numărul de elemente specificat, iar toate elementele sunt numere întregi și se află în intervalul [-1, 9].

Funcția <code>verificare_lista</code> verifică dacă lista dată ca parametru respectă condiția de a avea numerele impare la începutul listei, ordonate descrescător, și numerele pare la sfârșitul listei, ordonate crescător. În caz contrar, se afișează un mesaj corespunzător. De asemenea, se numără aparițiile cifrei 0 în listă și se afișează acest număr.

În cadrul programului principal, se citesc numărul de elemente ale listei și elementele listei, se verifică vectorul și se verifică dacă lista respectă condiția specificată, iar apoi se afișează numărul de apariții al cifrei 0.

0042 – Șterge Elemente

2023-04-15T18:58:29Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/42/stergeelemente StergereElemente]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi cuprinse în intervalul [-1000, 1000] și două valori naturale i și j. Să se afișeze toate elementele vectorului, mai puțin cele aflate de pe pozițiile i+1 la j-1.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului, apoi valorile i și j.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa vectorul, mai puțin elementele de pe pozițiile mai sus menționate. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100
*valorile elementelor șirului vor fi cuprinse între -1000 și 1000
*1≤i≤j≤n
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:12 7 6 3 8 5
:Introduceti valoarea i:2
:Intoduceti valoarea j:4
;Ieșire
:Datele introduse sunt corecte!
:Sirul nou este [12, 8, 5]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:123 12 3 5
:Introduceti valoarea i:1
:Intoduceti valoarea j:5
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 102
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 2 < int(n) < 101:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000 < int(i) < 1000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_i(i, n):
if is_integer(i):
if 1 <= int(i) < int(n)-1:
return i
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_j(i, n, j):
if is_integer(j):
if int(i) <= int(j) <= int(n):
return j
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def eliminare_elemente(sir, i, j, n):
sir_nou = []
for k in range(0, int(n)):
if k < int(i)-1 or k > int(j)-1:
sir_nou.append(sir[k])
print("Sirul nou este",sir_nou)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
i = input("Introduceti valoarea i:")
verificare_i(i, n)
j = input("Intoduceti valoarea j:")
verificare_j(i, n, j)
print("Datele ntroduse sunt corecte!")
eliminare_elemente(lst_int, i, j, n)

</syntaxhighlight>
==Explicație rezolvare==
Acest program verifică dacă datele introduse sunt corecte și apoi calculează suma elementelor dintr-un șir, cu excepția elementelor cu indexul între două valori i și j date de utilizator.

Funcția <code>is_integer(value)</code> returnează <code>True</code> dacă <code>value</code> este un număr întreg și <code>False</code> în caz contrar.

Funcția <code>verificare_nr_elemente(n)</code> verifică dacă numărul de elemente introdus este un număr întreg între 2 și 100 și returnează <code>n</code> dacă este corect sau afișează un mesaj de eroare și oprește programul cu <code>exit()</code> dacă este incorect.

Funcția <code>verificare_vector(n, vector)</code> verifică dacă numerele introduse în șir sunt numere întregi între -1000 și 1000 și dacă numărul de elemente este egal cu <code>n</code>. Dacă există o problemă, afișează un mesaj de eroare și oprește programul cu <code>exit()</code>.

Funcția <code>verificare_i(i, n)</code> verifică dacă <code>i</code> este un număr întreg între 1 și <code>n</code> - 1. Dacă există o problemă, afișează un mesaj de eroare și oprește programul cu <code>exit()</code>.

Funcția <code>verificare_j(i, n, j)</code> verifică dacă <code>j</code> este un număr întreg între <code>i</code> și <code>n</code>. Dacă există o problemă, afișează un mesaj de eroare și oprește programul cu <code>exit()</code>.

Funcția <code>suma(sir, i, j, n)</code> calculează suma elementelor din șir, cu excepția elementelor cu indexul între <code>i</code> și <code>j</code>.

În <code>if __name__ == '__main__':</code>, programul primește numărul de elemente ale șirului și verifică dacă acesta este corect. Apoi primește valorile șirului, verifică dacă acestea sunt corecte și le converteste într-un listă de întregi. Programul primește valorile pentru <code>i</code> și <code>j</code>, verifică dacă sunt corecte și apoi calculează suma elementelor șirului folosind funcția <code>suma()</code>.
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Să se ordoneze descrescător elementele vectorului.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma ordonării descrescătoare a tuturor elementelor vectorului. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 1000
*valorile elementelor șirului vor fi < 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:63 273 9 83 93 123
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [273, 123, 93, 83, 63, 9]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 123456
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:13 1 31 31 1 3 1
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 2 < int(n) < 101:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000 < int(i) < 1000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_i(i, n):
if is_integer(i):
if 1 <= int(i) < int(n)-1:
return i
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_j(i, n, j):
if is_integer(j):
if int(i) <= int(j) <= int(n):
return j
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def eliminare_elemente(sir, i, j, n):
sir_nou = []
for k in range(0, int(n)):
if k < int(i)-1 or k > int(j)-1:
sir_nou.append(sir[k])
print("Sirul nou este",sir_nou)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
i = input("Introduceti valoarea i:")
verificare_i(i, n)
j = input("Intoduceti valoarea j:")
verificare_j(i, n, j)
print("Datele ntroduse sunt corecte!")
eliminare_elemente(lst_int, i, j, n)

</syntaxhighlight>
==Explicație rezolvare==
Acest program elimină elementele unui șir dat prin excluderea elementelor de pe pozițiile dintre două poziții date, i și j (inclusiv acestea). Iată o explicație detaliată a fiecărei funcții:

# Funcția <code>is_integer(value)</code> primește o valoare sub formă de string și returnează <code>True</code> dacă string-ul poate fi convertit într-un număr întreg și <code>False</code> altfel.
# Funcția <code>verificare_nr_elemente(n)</code> primește numărul de elemente <code>n</code> și verifică dacă acesta este un număr întreg cuprins între 3 și 100. Dacă <code>n</code> nu este valid, afișează un mesaj de eroare și iese din program cu <code>exit()</code>. Dacă <code>n</code> este valid, returnează valoarea.
# Funcția <code>verificare_vector(n, vector)</code> primește numărul de elemente <code>n</code> și vectorul <code>vector</code> și verifică dacă vectorul are lungimea corectă (adică trebuie să aibă <code>n</code> elemente). Pentru fiecare element <code>i</code> din vector, verifică dacă este un număr întreg între -1000 și 1000. Dacă vectorul nu este valid, afișează un mesaj de eroare și iese din program cu <code>exit()</code>.
# Funcția <code>verificare_i(i, n)</code> primește poziția <code>i</code> și numărul de elemente <code>n</code> și verifică dacă <code>i</code> este un număr întreg între 1 și <code>n</code>-1. Dacă <code>i</code> nu este valid, afișează un mesaj de eroare și iese din program cu <code>exit()</code>. Dacă <code>i</code> este valid, returnează valoarea.
# Funcția <code>verificare_j(i, n, j)</code> primește poziția <code>i</code>, numărul de elemente <code>n</code> și poziția <code>j</code> și verifică dacă <code>j</code> este un număr întreg între <code>i</code> și <code>n</code>. Dacă <code>j</code> nu este valid, afișează un mesaj de eroare și iese din program cu <code>exit()</code>. Dacă <code>j</code> este valid, returnează valoarea.
# Funcția <code>eliminare_elemente(sir, i, j, n)</code> primește șirul <code>sir</code>, poziția <code>i</code>, poziția <code>j</code> și numărul de elemente <code>n</code> și construiește un nou șir <code>sir_nou</code> prin excluderea elementelor de pe pozițiile dintre <code>i</code> și <code>j</code> (inclusiv acestea). Noua listă este afișată la sfârșit.

În blocul principal, programul primește input-urile de la utilizator, verifică dacă acestea sunt corecte folosind funcțiile de verificare și, dacă sunt corecte, calculează șirul nou folosind funcția <code>eliminare_elemente</code>.

0072 – FSum Vec

2023-04-15T18:51:31Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/72/fsumvec FSum Vec]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi cuprinse în intervalul [-1000, 1000] și două valori naturale i și j. Să se facă suma tuturor elementelor vectorului, mai puțin cele aflate de pe pozițiile i+1 la j-1.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului, apoi valorile i și j.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa suma elementelor precizate mai sus. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100
*valorile elementelor șirului vor fi cuprinse între -1000 și 1000
*1≤i≤j≤n
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:12 7 6 3 8 5
:Introduceti valoarea i:2
:Intoduceti valoarea j:4
;Ieșire
:Datele introduse sunt corecte!
:Suma este 25
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:123 12 3 5
:Introduceti valoarea i:1
:Intoduceti valoarea j:5
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 102
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) <= 1000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) < 1000000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def ordonare_descrescator(sir):
lista_sortata = sorted(sir, reverse=True)
print("Noul vector este:",lista_sortata)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
ordonare_descrescator(lst_int)

def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 2 < int(n) < 101:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000 < int(i) < 1000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_i(i, n):
if is_integer(i):
if 1 <= int(i) < int(n)-1:
return i
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_j(i, n, j):
if is_integer(j):
if int(i) <= int(j) <= int(n):
return j
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def suma(sir, i, j, n):
suma = 0
for k in range(0, int(n)):
if k < int(i)-1 or k > int(j)-1:
suma += sir[k]
print("Suma este",suma)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
i = input("Introduceti valoarea i:")
verificare_i(i, n)
j = input("Intoduceti valoarea j:")
verificare_j(i, n, j)
print("Datele introduse sunt corecte!")
suma(lst_int, i, j, n)

</syntaxhighlight>
==Explicație rezolvare==
Acest program verifică dacă datele introduse sunt corecte și apoi calculează suma elementelor dintr-un șir, cu excepția elementelor cu indexul între două valori i și j date de utilizator.

Funcția <code>is_integer(value)</code> returnează <code>True</code> dacă <code>value</code> este un număr întreg și <code>False</code> în caz contrar.

Funcția <code>verificare_nr_elemente(n)</code> verifică dacă numărul de elemente introdus este un număr întreg între 2 și 100 și returnează <code>n</code> dacă este corect sau afișează un mesaj de eroare și oprește programul cu <code>exit()</code> dacă este incorect.

Funcția <code>verificare_vector(n, vector)</code> verifică dacă numerele introduse în șir sunt numere întregi între -1000 și 1000 și dacă numărul de elemente este egal cu <code>n</code>. Dacă există o problemă, afișează un mesaj de eroare și oprește programul cu <code>exit()</code>.

Funcția <code>verificare_i(i, n)</code> verifică dacă <code>i</code> este un număr întreg între 1 și <code>n</code> - 1. Dacă există o problemă, afișează un mesaj de eroare și oprește programul cu <code>exit()</code>.

Funcția <code>verificare_j(i, n, j)</code> verifică dacă <code>j</code> este un număr întreg între <code>i</code> și <code>n</code>. Dacă există o problemă, afișează un mesaj de eroare și oprește programul cu <code>exit()</code>.

Funcția <code>suma(sir, i, j, n)</code> calculează suma elementelor din șir, cu excepția elementelor cu indexul între <code>i</code> și <code>j</code>.

În <code>if __name__ == '__main__':</code>, programul primește numărul de elemente ale șirului și verifică dacă acesta este corect. Apoi primește valorile șirului, verifică dacă acestea sunt corecte și le converteste într-un listă de întregi. Programul primește valorile pentru <code>i</code> și <code>j</code>, verifică dacă sunt corecte și apoi calculează suma elementelor șirului folosind funcția <code>suma()</code>.

0805 – Valuri

2023-04-15T18:28:00Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/805/valuri Valuri]
----
==Cerinţă==
Se dă un nr natural n. Programul furnizează un tablou unidimensional cu <code>2*n</code> elemente, valori naturale distincte din intervalul <code>[1,2*n]</code>.

Subprogramul construieşte tabloul <code>v</code> astfel încât, în acesta, şirul elementelor impare să fie strict crescător, iar şirul elementelor pare să fie strict descrescător. Primul element al tabloului este impar, iar două elemente cu aceeaşi paritate nu pot ocupa poziţii consecutive în tablou.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa vectorul conform specificațiilor mai sus menționate. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*2 < n < 50
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 4
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [1, 8, 3, 6, 5, 4, 7, 2]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 57
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 15
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [1, 30, 3, 28, 5, 26, 7, 24, 9, 22, 11, 20, 13, 18, 15, 16, 17, 14, 19, 12, 21, 10, 23, 8, 25, 6, 27, 4, 29, 2]
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 2 < int(n) < 50:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def valuri(n):
vector = [0] * (int(n) * 2)
for i in range(0, (int(n)*2)-1):
if i % 2 == 0:
vector[i] = i+1
else:
vector[i] = 0
vector.reverse()
for i in range((int(n)*2-1), -1, -1):
if i % 2 == 0:
vector[i] = i+2
vector.reverse()
print("Noul vector este:",vector)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
print("Datele introduse sunt corecte!")
valuri(n)

</syntaxhighlight>
==Explicație rezolvare==
Codul conține următoarele funcții:

* <code>is_integer(value)</code>: funcție care primește o valoare și returnează <code>True</code> dacă valoarea este un număr întreg și <code>False</code> în caz contrar. Această funcție este folosită pentru a verifica dacă inputul dat este un număr întreg valid.
* <code>verificare_nr_elemente(n)</code>: funcție care primește o valoare <code>n</code> și verifică dacă este un număr întreg valid și dacă se află între 2 și 50. Dacă inputul este corect, funcția returnează valoarea <code>n</code>, altfel afișează un mesaj de eroare și oprește programul cu ajutorul funcției <code>exit()</code>.
* <code>valuri(n)</code>: funcție care primește un număr întreg <code>n</code> și construiește un vector cu perechi de numere. Vectorul începe cu <code>1</code> și este format din <code>n</code> perechi de numere de forma <code>(0, i+2)</code>, cu <code>i</code> un număr par de la <code>0</code> la <code>n*2-2</code>. Aceste perechi sunt stocate în vector în ordinea descrescătoare a valorii primului element al perechii. Funcția afișează vectorul final.

În funcția <code>valuri(n)</code>, procesul de construcție a vectorului este împărțit în două părți:

* Mai întâi, se construiește jumătatea din dreapta a vectorului, parcurgând lista <code>vector</code> și setând elementele la valori specifice (conform descrierii de mai sus). Aceste valori sunt setate în ordine crescătoare de la dreapta la stânga în lista, prin aceeași rază de pas. După această construcție, lista este inversată pentru a se obține valori ordonate descrescător de la stânga la dreapta.
* În a doua parte, se completează jumătatea stângă a vectorului, parcurgând lista <code>vector</code> de la dreapta la stânga și setând elementele în funcție de indicele lor (conform descrierii de mai sus).

0899 – OrdonareF

2023-04-15T18:03:31Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/899/ordonaref OrdonareF]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Să se ordoneze crescător elementele vectorului.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma ordonării crescătoare a tuturor elementelor vectorului. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 1000
*valorile elementelor șirului vor fi < 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:63 273 9 83 93 123
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [9, 63, 83, 93, 123, 273]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 123456
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:13 1 31 31 1 3 1
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) <= 1000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) < 1000000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def ordonare_crescator(sir):
lista_sortata = sorted(sir)
print("Noul vector este:",lista_sortata)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
ordonare_crescator(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește ca intrare un șir de numere întregi și le sortează în ordine crescătoare.

Funcția is_integer(value) este o funcție simplă care primește o valoare și returnează adevărat dacă valoarea este un număr întreg sau fals în caz contrar.

Funcția verificare_nr_elemente(n) verifică dacă n este un număr întreg valid și dacă este între 1 și 1000. Dacă n nu este valid sau nu este în intervalul specificat, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția verificare_vector(n, vector) verifică dacă vectorul are lungimea corectă și dacă toate elementele sale sunt numere întregi valide și mai mici decât 1 miliard. Dacă vectorul nu are lungimea corectă sau conține elemente invalide, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția ordonare_crescator(sir) primește ca argument o listă <code>sir</code> de numere întregi și returnează lista sortată în ordine crescătoare utilizând funcția built-in <code>sorted()</code>.

În funcția principală, programul primește input-ul de la utilizator pentru n și elem și apoi verifică validitatea acestor intrări utilizând funcțiile verificare_nr_elemente(n) și verificare_vector(n, elem). Dacă toate intrările sunt valide, programul afișează "Datele introduse sunt corecte!" și apoi se continuă cu apelul funcției ordonare_crescator(lst_int). La final, programul afișează lista sortată crescător.

0900 – OrdonareF1

2023-04-15T17:59:45Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/900/ordonaref1 OrdonareF1]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Să se ordoneze descrescător elementele vectorului.
==Date de intrare==
Programul va citi de la tastatură valoarea<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma ordonării descrescătoare a tuturor elementelor vectorului. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 1000
*valorile elementelor șirului vor fi < 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:63 273 9 83 93 123
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [273, 123, 93, 83, 63, 9]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 123456
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:13 1 31 31 1 3 1
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) <= 1000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) < 1000000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def ordonare_descrescator(sir):
lista_sortata = sorted(sir, reverse=True)
print("Noul vector este:",lista_sortata)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
ordonare_descrescator(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește ca intrare un șir de numere întregi și le sortează în ordine descrescătoare.

Funcția is_integer(value) este o funcție simplă care primește o valoare și returnează adevărat dacă valoarea este un număr întreg sau fals în caz contrar.

Funcția verificare_nr_elemente(n) verifică dacă n este un număr întreg valid și dacă este între 1 și 1000. Dacă n nu este valid sau nu este în intervalul specificat, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția verificare_vector(n, vector) verifică dacă vectorul are lungimea corectă și dacă toate elementele sale sunt numere întregi valide și mai mici decât 1 miliard. Dacă vectorul nu are lungimea corectă sau conține elemente invalide, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția ordonare_descrescator(sir) primește ca argument o listă <code>sir</code> de numere întregi și returnează lista sortată în ordine descrescătoare utilizând funcția built-in <code>sorted()</code> cu parametrul <code>reverse=True</code>.

În funcția principală, programul primește input-ul de la utilizator pentru n și elem și apoi verifică validitatea acestor intrări utilizând funcțiile verificare_nr_elemente(n) și verificare_vector(n, elem). Dacă toate intrările sunt valide, programul afișează "Datele introduse sunt corecte!" și apoi se continuă cu apelul funcției ordonare_descrescator(lst_int). La final, programul afișează lista sortată descrescător.

0901 – Ordonare SecvF

2023-04-15T17:50:40Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/901/ordonaresecvf Ordonare SecvF]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente naturale mai mici decât <code>1.000.000.000</code> și doi indici <code>st dr</code>.

Subprogramul ordonează crescător elementele tabloului <code>a</code> cu indici între <code>st</code> și <code>dr</code>, inclusiv aceștia, fără a modifica celelalte elemente ale tabloului.

==Date de intrare==
Programul va citi de la tastatură valoarea <code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului, după care citește indicii st și dr.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma ordonării crescătoare a elementelor aflate între indicii st și dr. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 1000
*valorile elementelor șirului vor fi < 1.000.000.000
*0 <= st <= dr < n
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:1 4 3 2 5
:Introduceti valoarea pt st:1
:Introduceti valoare pt dr:3
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [1, 2, 3, 4, 5]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:12 31 145 4 4 3
:Introduceti valoarea pt st:4
:Introduceti valoare pt dr:6
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:1 321 5 3
:Introduceti valoarea pt st:3
:Introduceti valoare pt dr:1
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 1500:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_pozitie_de_sters(p, n):
if is_integer(p):
if 1 <= int(p) <= int(n):
return p
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000000 <= int(i) <= 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def eliminare_elem_p(vector, p):
print("Datele introduse sunt corecte!")
vector.pop(int(p) - 1)
print("Noul vector este:", vector)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
p = input("Introduceti pozitia de sters: ")
verificare_pozitie_de_sters(p, n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
eliminare_elem_p(elem, p)

def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) <= 100:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_st(st, n):
if is_integer(st):
if 0 <= int(st) <= int(n)-1:
return st
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_dr(dr, n, st):
if is_integer(dr):
if int(st) < int(dr) < int(n):
return dr
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
continue
else:
print("Datele introduse sunt incorecte!")
exit()

def ordonare_st_dr(sir, st, dr, n):
sir_de_ord = []
sir_final = []
k = 0
for i in range(0, int(n)):
if int(st) <= i <= int(dr):
sir_de_ord.append(sir[i])
minisir_ord = sorted(sir_de_ord)
for j in range(0, int(n)):
if int(st) <= j <= int(dr):
sir_final.append(minisir_ord[k])
k += 1
else:
sir_final.append(sir[j])
print("Noul vector este:",sir_final)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
st = input("Introduceti valoarea pt st:")
verificare_st(st, n)
dr = input("Introduceti valoare pt dr:")
verificare_dr(dr, n, st)
print("Datele introduse sunt corecte!")
ordonare_st_dr(lst_int, st, dr, n)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește ca intrare un șir de numere întregi, o valoare st reprezentând poziția de început a unui subșir și o valoare dr reprezentând poziția de sfârșit a acelui subșir. Programul sortează subșirul și apoi întoarce șirul inițial cu subșirul sortat.

Funcția is_integer(value) este o funcție simplă care primește o valoare și returnează adevărat dacă valoarea este un număr întreg sau fals în caz contrar.

Funcția verificare_nr_elemente(n) verifică dacă n este un număr întreg valid și dacă este între 1 și 100. Dacă n nu este valid sau nu este în intervalul specificat, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția verificare_st(st, n) verifică dacă st este un număr întreg valid și dacă este între 1 și n-1. Dacă st nu este valid sau nu este în intervalul specificat, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția verificare_dr(dr, n, st) verifică dacă dr este un număr întreg valid și dacă este între st+1 și n. Dacă dr nu este valid sau nu este în intervalul specificat, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția verificare_vector(n, vector) verifică dacă vectorul are lungimea corectă și dacă toate elementele sale sunt numere întregi valide. Dacă vectorul nu are lungimea corectă sau conține elemente invalide, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția ordonare_st_dr(sir, st, dr, n) primește ca argumente șirul inițial, poziția de început a subșirului st, poziția de sfârșit a subșirului dr și lungimea șirului n. Funcția extrage subșirul din șirul inițial, îl sortează și îl înlocuiește în șirul inițial. Funcția apoi afișează șirul inițial cu subșirul sortat.

În funcția principală, programul primește input-ul de la utilizator pentru n, elem, st și dr și apoi verifică validitatea acestor intrări utilizând funcțiile verificare_nr_elemente(n), verificare_vector(n, elem), verificare_st(st, n) și verificare_dr(dr, n, st). Dacă toate intrările sunt valide, programul afișează "Datele introduse sunt corecte!" și apoi se continuă cu apelul funcției ordonare_st

1510 – FCăutare

2023-04-15T17:30:43Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/1510/fcautare FCautare]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi și un număr <code>v</code>. Să se returneze poziția din șir unde găsim elementul v. Dacă există mai multe poziții se va afișa doar una dintre ele, dacă nu există se va afișa -1.
==Date de intrare==
Programul va citi de la tastatură o valoare<code>n</code>, apoi <code>n</code> numere întregi în ordine crescătoare reprezentând elementele șirului, și valoarea v
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa poziția în care găsim valoarea v, sau -1 dacă valoarea respectivă nu se găsește deloc în vector. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:12 12 3 4 2
:Introduceti valoarea pe care doriti sa o cautati:12
;Ieșire
:Datele introduse sunt corecte!
:Pozitia este: 1
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 3
:Introduceti 3 numere separate prin spatiu:12321 12 3
:Introduceti valoarea pe care doriti sa o cautati:2
;Ieșire
:Datele introduse sunt corecte!
:-1
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:13 11 2 1 1
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) <= 100:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_v(v):
if is_integer(v):
return v
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
continue
else:
print("Datele introduse sunt incorecte!")
exit()

def afisare_pozitie(v, vector):
for i in range(0, int(n)):
if vector[i] == int(v):
print("Pozitia este:", i+1)
exit()
print("-1")

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
v = input("Introduceti valoarea pe care doriti sa o cautati:")
verificare_v(v)
print("Datele introduse sunt corecte!")
afisare_pozitie(v, lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește ca intrare un număr întreg n reprezentând numărul de elemente dintr-un vector și vectorul însuși, format din n numere întregi. Programul mai primește o valoare v și afișează poziția primei apariții a valorii v în vector sau -1 dacă v nu se găsește în vector.

Funcția is_integer(value) este o funcție simplă care primește o valoare și returnează adevărat dacă valoarea este un număr întreg sau fals în caz contrar.

Funcția verificare_nr_elemente(n) verifică dacă n este un număr întreg valid și dacă este între 1 și 100. Dacă n nu este valid sau nu este în intervalul specificat, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția verificare_v(v) verifică dacă v este un număr întreg valid. Dacă v nu este valid, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția verificare_vector(n, vector) verifică dacă vectorul are lungimea corectă și dacă toate elementele sale sunt numere întregi valide. Dacă vectorul nu are lungimea corectă sau conține elemente invalide, programul afișează "Datele introduse sunt incorecte!" și se termină prin apelul funcției exit().

Funcția afisare_pozitie(v, vector) parcurge vectorul și returnează poziția primei apariții a valorii v în vector sau -1 dacă v nu se găsește în vector.

În funcția principală, programul primește input-ul de la utilizator pentru n, elem și v și apoi verifică validitatea acestor intrări utilizând funcțiile verificare_nr_elemente(n), verificare_vector(n, elem) și verificare_v(v). Dacă toate intrările sunt valide, programul afișează "Datele introduse sunt corecte!" și apoi se continuă cu apelul funcției afisare_pozitie(v, lst_int) pentru a găsi poziția primei apariții a valorii v în vector.

2630 – Permd

2023-04-15T17:12:21Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/2630/permd Permd]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi unde exact una din aceste valori apare în vector de două ori. Funcția trebuie să returneze valoarea care apare de două ori.
==Date de intrare==
Programul va citi de la tastatură o valoare<code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa elementul vectorului care apare de două ori în acesta. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 1.000.000
*valorile elementelor șirului vor fi cuprinse între 0 și n-1
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 5
:Introduceti 5 numere separate prin spatiu:1 1 1 3 4
;Ieșire
:Datele introduse sunt corecte! Nu exista o singura cifra care sa apara de exact 2 ori
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:1 1 2 3 4 5
;Ieșire
:Datele introduse sunt corecte!
:Singura cifra care apare de exact 2 ori este: 1
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:2 2 3 3 4 4
;Ieșire
:Datele introduse sunt corecte!
:Nu exista o singura cifra care sa apara de exact 2 ori
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 1500:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_pozitie_de_sters(p, n):
if is_integer(p):
if 1 <= int(p) <= int(n):
return p
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000000 <= int(i) <= 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def eliminare_elem_p(vector, p):
print("Datele introduse sunt corecte!")
vector.pop(int(p) - 1)
print("Noul vector este:", vector)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
p = input("Introduceti pozitia de sters: ")
verificare_pozitie_de_sters(p, n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
eliminare_elem_p(elem, p)

def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) <= 400000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def cifra_apare_de_doua_ori(lista):
aparitii = [0] * 10
for numar in lista:
aparitii[numar] += 1
cifre_de_doua_ori = [i for i, count in enumerate(aparitii) if count == 2]
if len(cifre_de_doua_ori) == 1:
print("Singura cifra care apare de exact 2 ori este:", cifre_de_doua_ori[0])
else:
print("Nu exista o singura cifra care sa apara de exact 2 ori")

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
cifra_apare_de_doua_ori(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program are scopul de a verifica dacă într-o listă de numere întregi există o singură cifră care apare de exact 2 ori și, dacă există, o afișează. Programul conține mai multe funcții pentru a verifica și procesa datele introduse de utilizator.

Funcții:

# is_integer(value): Verifică dacă valoarea introdusă este un număr întreg și returnează un rezultat boolean.
# verificare_nr_elemente(n): Verifică dacă numărul de elemente 'n' introdus de utilizator este valid (un întreg între 1 și 400000). Dacă nu este valid, programul va afișa un mesaj de eroare și se va închide.
# verificare_vector(n, vector): Verifică dacă lungimea vectorului introdus corespunde cu 'n', iar toate elementele din vector sunt numere întregi mai mici sau egale cu 1000000. Dacă nu, programul va afișa un mesaj de eroare și se va închide.
# cifra_apare_de_doua_ori(lista): Această funcție preia o listă de numere întregi și verifică dacă există o singură cifră care apare de exact 2 ori în acea listă. Dacă există o astfel de cifră, o afișează, altfel afișează un mesaj că nu există o astfel de cifră.

Programul începe prin solicitarea numărului de elemente din listă (n) și apoi a elementelor listei. Apoi, verifică dacă datele introduse sunt corecte și validează numărul de elemente și vectorul introdus. Dacă datele sunt valide, programul converteste lista de șiruri de caractere într-o listă de numere întregi și apoi apelează funcția "cifra_apare_de_doua_ori()" pentru a verifica dacă există o singură cifră care apare de exact 2 ori și afișează rezultatul.

0073 – FSum Vec Min

2023-04-15T16:59:48Z

Miriam:

Sursa: [https://www.pbinfo.ro/probleme/73/fsumvecmin FSum Vec Min]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Programul returnează suma celor mai mici <code>m</code> elemente din tabloul de n elemente.
==Date de intrare==
Programul va citi de la tastatură două valori <code>n m</code>, cu semnificația precizată, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa suma primelor m elemente cele mai mici ale șirului. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*0 < m <= n <= 100
*valorile elementelor șirului vor fi cuprinse între -1.000.000 și 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 8
:Introduceti numarul m: 3
:Introduceti 8 numere separate prin spatiu:1321 123 22 312 1 12 2 1
;Ieșire
:Datele introduse sunt corecte!
:Suma este: 4
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 123
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti numarul m: 6
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 1500:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_pozitie_de_sters(p, n):
if is_integer(p):
if 1 <= int(p) <= int(n):
return p
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000000 <= int(i) <= 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def eliminare_elem_p(vector, p):
print("Datele introduse sunt corecte!")
vector.pop(int(p) - 1)
print("Noul vector este:", vector)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
p = input("Introduceti pozitia de sters: ")
verificare_pozitie_de_sters(p, n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
eliminare_elem_p(elem, p)

</syntaxhighlight>
==Explicație rezolvare==
Acest program preia un număr <code>n</code> de elemente, un număr <code>m</code> și <code>n</code> numere separate prin spațiu. Apoi, calculează suma celor mai mici <code>m</code> numere dintre cele <code>n</code> numere introduse. Programul verifică și validează datele introduse înainte de a efectua operațiunea de calcul a sumei.

# <code>is_integer(value)</code>: Verifică dacă valoarea introdusă este un număr întreg.
# <code>verificare_nr_elemente(n)</code>: Verifică dacă <code>n</code> este un număr întreg între 0 și 100. Dacă nu, programul se oprește.
# <code>verificare_m(m, n)</code>: Verifică dacă <code>m</code> este un număr întreg între 1 și <code>n</code>. Dacă nu, programul se oprește.
# <code>verificare_vector(n, vector)</code>: Verifică dacă lungimea vectorului este egală cu <code>n</code> și dacă toate elementele din vector sunt numere întregi mai mici sau egale cu 10000. Dacă nu, programul se oprește.
# <code>suma_celor_m_mai_mici(sir, m)</code>: Calculează suma celor mai mici <code>m</code> numere din lista <code>sir</code> și afișează suma.

În secțiunea <code>if __name__ == '__main__'</code>, programul execută următoarele acțiuni:

# Preia numărul <code>n</code> de elemente de la utilizator și verifică dacă este valid.
# Preia numărul <code>m</code> de la utilizator și verifică dacă este valid în raport cu <code>n</code>.
# Preia <code>n</code> numere de la utilizator, separate prin spațiu, și verifică dacă sunt valide.
# Convertește elementele în numere întregi și le stochează în lista <code>lst_int</code>.
# Afișează un mesaj care indică faptul că datele introduse sunt corecte.
# Apelează funcția <code>suma_celor_m_mai_mici(lst_int, m)</code> pentru a calcula și afișa suma celor mai mici <code>m</code> numere din lista <code>lst_int</code>.

2721 – Insert

2023-04-15T16:58:46Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/2721/insert Insert]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Să se insereze după fiecare număr impar dublul său.
==Date de intrare==
Programul va citi de la tastatură o valoare<code>n</code>, urmată de n numere întregi.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma adăugării după fiecare element impar dublul său. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 400000
*valorile elementelor șirului vor fi cuprinse între 0 și 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 3
:Introduceti 3 numere separate prin spatiu:13 56 34
;Ieșire
:Datele introduse sunt corecte!
:Noul sir este: [13, 26, 56, 34]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 5 Introduceti 5 numere separate prin spatiu:1 1 1 3
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) <= 400000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def adaugare_dublu_impar(sir):
sir_nou = []
for elem in sir:
sir_nou.append(elem)
if elem % 2 == 1:
sir_nou.append(int(elem)*2)
print("Noul sir este:", sir_nou)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
adaugare_dublu_impar(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program Python are scopul de a crea un nou șir de numere, în care după fiecare număr impar se adaugă dublul său. Programul conține mai multe funcții pentru a verifica și procesa datele introduse de utilizator.

Funcții:

# is_integer(value): Verifică dacă valoarea introdusă este un număr întreg și returnează un rezultat boolean.
# verificare_nr_elemente(n): Verifică dacă numărul de elemente 'n' introdus de utilizator este valid (un întreg între 1 și 400000). Dacă nu este valid, programul va afișa un mesaj de eroare și se va închide.
# verificare_vector(n, vector): Verifică dacă lungimea vectorului introdus corespunde cu 'n', iar toate elementele din vector sunt numere întregi mai mici sau egale cu 1000000. Dacă nu, programul va afișa un mesaj de eroare și se va închide.
# adaugare_dublu_impar(sir): Această funcție preia un șir de numere întregi și creează un nou șir în care, după fiecare număr impar, se adaugă dublul său. Apoi afișează noul șir creat.

Programul începe prin solicitarea numărului de elemente din șirul inițial (n) și apoi a elementelor șirului. Apoi, verifică dacă datele introduse sunt corecte și validează numărul de elemente și vectorul introdus. Dacă datele sunt valide, programul converteste șirul de caractere într-un șir de numere întregi și apoi apelează funcția "adaugare_dublu_impar()" pentru a crea și afișa noul șir cu dublurile numerelor impare adăugate.

3656 – FGreater

2023-04-15T16:49:01Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/3656/fgreater FGreater]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi și un număr <code>x</code> întreg. Funcția returnează cel mai mic număr din șir, strict mai mare decât <code>x</code>. În caz că nu există o asemenea valoare, funcția va returna valoarea <code>-1</code>
==Date de intrare==
Programul va citi de la tastatură o valoare<code>n</code>, urmată de n numere întregi, și un nr x.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa cel mai mic număr din șir, strict mai mare decât x (dacă nu există, se va returna -1). În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*0 <=n[i], x <= 2^31 - 1
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:1234 21 12 1
:Introduceti valoarea x: 11
;Ieșire
:Datele introduse sunt corecte!
:Cel mai mic nr strict mai mare decat x este 12
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 4
:Introduceti 4 numere separate prin spatiu:1234 21 12 1
:Introduceti valoarea x: 123456
;Ieșire
:Datele introduse sunt corecte!
:-1
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente a sirului: 6
:Introduceti 6 numere separate prin spatiu:23443 323 23 23 2 34
:Introduceti valoarea x: 5
;Ieșire
:Datele introduse sunt corecte!
:Cel mai mic nr strict mai mare decat x este 23
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) <= 1000000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 2**31 - 1:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_x(x):
if is_integer(x):
if int(x) <= 2**31 - 1:
return x
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def nr_strict_mai_mare(sir, x):
nr_mai_mari = []
for elem in sir:
if elem > int(x):
nr_mai_mari.append(elem)
if len(nr_mai_mari) == 0:
print("-1")
exit()
else:
nr_mai_mari_sortate = sorted(nr_mai_mari)
print("Cel mai mic nr strict mai mare decat x este", nr_mai_mari_sortate[0])

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
x = input("Introduceti valoarea x: ")
verificare_x(x)
print("Datele introduse sunt corecte!")
nr_strict_mai_mare(lst_int, x)

</syntaxhighlight>
==Explicație rezolvare==
Acest program este creat pentru a găsi cel mai mic număr strict mai mare decât o valoare dată (x) într-un șir de numere introdus de utilizator. Programul conține mai multe funcții pentru a verifica și procesa datele introduse:

# <code>is_integer(value)</code> - Verifică dacă un șir de caractere conține doar cifre și returnează <code>True</code> în acest caz sau <code>False</code> în caz contrar.
# <code>verificare_nr_elemente(n)</code> - Verifică dacă numărul de elemente introdus este un număr întreg între 1 și 1.000.000. Dacă nu este, afișează un mesaj de eroare și închide programul.
# <code>verificare_vector(n, vector)</code> - Verifică dacă lungimea vectorului introdus este egală cu <code>n</code> și dacă toate elementele sunt numere întregi mai mici sau egale cu 2^31 - 1. Dacă nu, afișează un mesaj de eroare și închide programul.
# <code>verificare_x(x)</code> - Verifică dacă valoarea x introdusă este un număr întreg mai mic sau egal cu 2^31 - 1. Dacă nu este, afișează un mesaj de eroare și închide programul.
# <code>nr_strict_mai_mare(sir, x)</code> - Primeste un sir de numere întregi și valoarea x, găsește cel mai mic număr strict mai mare decât x în sir, și afișează rezultatul. Dacă nu există un astfel de număr, afișează "-1".

În secțiunea <code>__main__</code>, programul solicită utilizatorului să introducă numărul de elemente și elementele sirului, apoi verifică datele introduse. De asemenea, se cere valoarea x și se verifică dacă este corectă. Dacă toate datele sunt corecte, programul apelează funcția <code>nr_strict_mai_mare()</code> pentru a găsi cel mai mic număr strict mai mare decât x în sir și afișează rezultatul.

2083 – Ordon123

2023-04-15T16:34:06Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/2083/ordon123 Ordon123]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi de tipul 1, 2 sau 3. Să se ordoneze elementele în ordine crescătoare.
==Date de intrare==
Programul va citi de la tastatură valoarea <code>n</code>, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma ordonării crescătoare a elementelor. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 1.000.000
*valorile elementelor șirului vor fi cuprinse în intervalul [1, 3]
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente a sirului: 8 Introduceti 8 numere separate prin spatiu:1 2 3 1 2 3 1 2
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [1, 1, 1, 2, 2, 2, 3, 3]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente a sirului: 123456789
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) <= 1000000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if 1 <= int(i) <= 3:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def ordonare_crescator(sir):
sir_ordonat = sorted(sir)
print("Noul vector este:",sir_ordonat)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente a sirului: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
ordonare_crescator(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program este conceput pentru a ordona crescător un sir de numere introdus de utilizator. Programul conține mai multe funcții pentru a verifica și procesa datele introduse:

# <code>is_integer(value)</code> - Verifică dacă un șir de caractere conține doar cifre și returnează <code>True</code> în acest caz sau <code>False</code> în caz contrar.
# <code>verificare_nr_elemente(n)</code> - Verifică dacă numărul de elemente introdus este un număr întreg între 1 și 1.000.000. Dacă nu este, afișează un mesaj de eroare și închide programul.
# <code>verificare_vector(n, vector)</code> - Verifică dacă lungimea vectorului introdus este egală cu <code>n</code> și dacă toate elementele sunt numere întregi între 1 și 3. Dacă nu, afișează un mesaj de eroare și închide programul.
# <code>ordonare_crescator(sir)</code> - Primește un sir de numere întregi, le sortează în ordine crescătoare și afișează sirul ordonat.

În secțiunea <code>__main__</code>, programul solicită utilizatorului să introducă numărul de elemente și elementele sirului, apoi verifică datele introduse. Dacă datele sunt corecte, programul apelează funcția <code>ordonare_crescator()</code> pentru a sorta sirul în ordine crescătoare și afișează rezultatul.

3791 – Interclas No Memory

2023-04-15T16:25:28Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/3791/interclasnomemory Interclas No Memory]
----
==Cerinţă==
Se dau două șiruri de numere naturale, cu <code>n</code>, respectiv <code>m</code> elemente, ordonate crescător. Să se scrie definiția funcției <code>interclasare</code> care nu are parametri și nu întoarce niciun rezultat, și care să determine al treilea șir care să conţină, în ordine crescătoare, elementele din primele două şiruri.
==Date de intrare==
Programul va citi de la tastatură o valoare n, urmată de n numere întregi, după care va citi o valoare m, urmată de m numere întregi.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut prin ordonarea elementelor obținute prin alăturarea celor doi vectori. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n, m <= 100.000
*valorile elementelor șirului vor fi < 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente pentru primul sir: 3
:Introduceti 3 numere separate prin spatiu:12 1 1
:Introduceti numarul de elemente pentru cel de al doilea sir: 4
:Introduceti 4 numere separate prin spatiu:123 12 24 56
;Ieșire
:Datele introduse sunt corecte!
:Vectorul nou este: [1, 1, 12, 12, 24, 56, 123]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente pentru primul sir: 4 Introduceti 4 numere separate prin spatiu:12 1 31 12 2
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) < 100000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 1000000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def reuneste_si_ordoneaza(lista1, lista2):
lista_combinata = lista1 + lista2
lista_sortata = sorted(lista_combinata)
print("Vectorul nou este:",lista_sortata)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente pentru primul sir: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int1 = list(map(int, elem))
m = input("Introduceti numarul de elemente pentru cel de al doilea sir: ")
verificare_nr_elemente(m)
elem2 = input(f"Introduceti {m} numere separate prin spatiu:").split()
verificare_vector(m, elem2)
lst_int2 = list(map(int, elem2))
print("Datele introduse sunt corecte!")
reuneste_si_ordoneaza(lst_int1, lst_int2)

</syntaxhighlight>
==Explicație rezolvare==
Acest program conține funcții pentru a verifica și procesa două siruri de numere introduse de utilizator. După ce utilizatorul introduce numerele, programul combină și sortează cele două siruri de numere în ordine crescătoare.

# <code>is_integer(value)</code> - Verifică dacă un șir de caractere conține doar cifre și returnează <code>True</code> în acest caz sau <code>False</code> în caz contrar.
# <code>verificare_nr_elemente(n)</code> - Verifică dacă numărul de elemente introdus este un număr întreg între 1 și 9. Dacă nu este, afișează un mesaj de eroare și închide programul.
# <code>verificare_vector(n, vector)</code> - Verifică dacă lungimea vectorului introdus este egală cu <code>n</code> și dacă toate elementele sunt numere întregi mai mici sau egale cu 1.000.000.000. Dacă nu, afișează un mesaj de eroare și închide programul.
# <code>reuneste_si_ordoneaza(lista1, lista2)</code> - Primește două liste de numere întregi, le combină și le sortează în ordine crescătoare, apoi afișează lista sortată.

În secțiunea <code>__main__</code>, programul solicită utilizatorului să introducă numărul de elemente și elementele pentru fiecare dintre cele două siruri, apoi verifică datele introduse. Dacă datele sunt corecte, programul apelează funcția <code>reuneste_si_ordoneaza()</code> pentru a combina și sorta cele două siruri și afișează rezultatul.

0041 – Creare Număr

2023-04-15T16:11:07Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/41/crearenumar CreareNumar]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi și un număr <code>p</code>. Să se șteargă din șirul <code>X</code> elementul aflat pe poziția <code>p</code>.
==Date de intrare==
Programul va citi de la tastatură două valori <code>n p</code>, cu semnificația precizată, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma eliminării elementului de pe poziția p. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*0 < n < 10
*valorile elementelor șirului vor fi < 10
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 6
:Introduceti 6 numere separate prin spatiu:1 2 3 4 5 6
;Ieșire
:Datele introduse sunt corecte!
:Numarul obtinut prin concatenarea elementelor pare este: 246
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 123
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 3
:Introduceti 3 numere separate prin spatiu:3 5 7
;Ieșire
:Datele introduse sunt corecte!
:Nu exista elemente pare in vector
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 < int(n) < 10:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 10:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def concatenare_cifre_pare(vector):
nr = ''
cont = 0
for elem in vector:
if elem % 2 == 0:
nr += str(elem)
cont += 1
if cont == 0:
print("Nu exista elemente pare in vector")
exit()
print("Numarul obtinut prin concatenarea elementelor pare este:", nr)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
concatenare_cifre_pare(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește un șir de <code>n</code> numere întregi, verifică validitatea datelor introduse și apoi concatenează și afișează cifrele pare din vector. Iată o explicație pas cu pas a programului:

# Verifică dacă <code>n</code>, numărul de elemente, este întreg și între 1 și 9 (strict mai mic decât 10).
# Verifică dacă șirul de numere introdus are lungimea <code>n</code> și dacă toate elementele sunt numere întregi între 1 și 10 (strict mai mic sau egal cu 10).
# Definește funcția <code>concatenare_cifre_pare</code> care parcurge vectorul și verifică dacă un element este par (restul împărțirii la 2 este 0). Dacă este par, adaugă cifra respectivă la un șir <code>nr</code>. De asemenea, actualizează variabila <code>cont</code> pentru a număra câte elemente pare au fost întâlnite.
# După ce parcurge întregul vector, verifică dacă există elemente pare (<code>cont</code> > 0). Dacă nu există, afișează un mesaj corespunzător și încheie execuția programului. Altfel, afișează numărul obținut prin concatenarea cifrelor pare din vector.
# Apelă funcția <code>concatenare_cifre_pare</code> cu vectorul introdus de utilizator și afișează rezultatul.

Programul urmează acești pași pentru a se asigura că datele introduse sunt corecte și pentru a oferi informațiile cerute despre vector (concatenarea cifrelor pare din vector).

0040 – Vector Max Min Sum

2023-04-15T16:03:21Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/40/vectormaxminsum Vector Max Min Sum]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Să se afișeze valoarea minimă, valoarea maximă și suma elementelor șirului.
==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>, iar apoi <code>n</code> numere întregi, separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se vor afișa minimul, maximul și suma tuturor elementelor vectorului. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100
*valorile elementelor șirului vor fi < 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 5
:ntroduceti 5 numere separate prin spatiu:12 13 121 312 3
;Ieșire
:Datele introduse sunt corecte!
:mini: 3 maxi: 312 sum: 461
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 12345
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti 5 numere separate prin spatiu:1 1 1 1 1
;Ieșire
:Datele introduse sunt corecte!
:mini: 1 maxi: 1 sum: 5
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 <= int(n) <= 100:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 10000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def min_max_sum(vector):
mini = 100000000
maxi = 0
sum = 0
for elem in vector:
if elem < mini:
mini = elem
if elem > maxi:
maxi = elem
sum += elem
print("mini:", mini, "maxi:", maxi, "sum:", sum)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
min_max_sum(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește un șir de <code>n</code> numere întregi, verifică validitatea datelor introduse și apoi calculează și afișează valoarea minimă, valoarea maximă și suma elementelor din vector. Iată o explicație pas cu pas a programului:

# Verifică dacă <code>n</code>, numărul de elemente, este întreg și între 0 și 100.
# Verifică dacă șirul de numere introdus are lungimea <code>n</code> și dacă toate elementele sunt numere întregi între 1 și 10000.
# Definește funcția <code>min_max_sum</code> care calculează valoarea minimă, valoarea maximă și suma elementelor din vector. Inițializează variabilele <code>mini</code>, <code>maxi</code> și <code>sum</code>. Iterează prin elementele vectorului și actualizează valoarea minimă, valoarea maximă și suma elementelor.
# Apelă funcția <code>min_max_sum</code> cu vectorul introdus de utilizator și afișează valoarea minimă, valoarea maximă și suma elementelor din vector.

Programul urmează acești pași pentru a se asigura că datele introduse sunt corecte și pentru a oferi informațiile cerute despre vector (valoarea minimă, valoarea maximă și suma elementelor).

0038 – Shift

2023-04-15T15:53:41Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/38/shift Shift]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Programul va permuta cu o poziție spre stânga elementele vectorului.
==Date de intrare==
Programul va citi de la tastatură o valoare <code>n</code>, urmată de <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma permutării cu o poziție spre stânga a elementelor vectorului. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100
*valorile elementelor șirului vor fi < 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 6
:Introduceti 6 numere separate prin spatiu: 1 2 3 4 5 6
;Ieșire
:Datele introduse sunt corecte!
:Vectorul obtinut dupa permutare este: [2, 3, 4, 5, 6, 1]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 1234
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 1500:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_pozitie_de_sters(p, n):
if is_integer(p):
if 1 <= int(p) <= int(n):
return p
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000000 <= int(i) <= 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def eliminare_elem_p(vector, p):
print("Datele introduse sunt corecte!")
vector.pop(int(p) - 1)
print("Noul vector este:", vector)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
p = input("Introduceti pozitia de sters: ")
verificare_pozitie_de_sters(p, n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
eliminare_elem_p(elem, p)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește un șir de <code>n</code> numere întregi, verifică validitatea datelor introduse și apoi permută elementele vectorului o poziție spre stânga. Iată o explicație pas cu pas a programului:

# Verifică dacă <code>n</code>, numărul de elemente, este întreg și între 0 și 100.
# Verifică dacă șirul de numere introdus are lungimea <code>n</code> și dacă toate elementele sunt numere întregi între 1 și 10000.
# Definește funcția <code>permuta_stanga</code> care permută elementele vectorului o poziție spre stânga. Funcția stochează primul element al vectorului în variabila <code>primul_element</code>, apoi mută toate celelalte elemente cu o poziție spre stânga. La final, adaugă <code>primul_element</code> la sfârșitul vectorului.
# Apelă funcția <code>permuta_stanga</code> cu vectorul introdus de utilizator și afișează vectorul permutat.

Programul urmează acești pași pentru a se asigura că datele introduse sunt corecte și pentru a oferi vectorul permutat după aplicarea permutării spre stânga.

0073 – FSum Vec Min

2023-04-15T15:40:42Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/159/inseraredupa Stergere_Element]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Programul returnează suma celor mai mici <code>m</code> elemente din tabloul de n elemente.
==Date de intrare==
Programul va citi de la tastatură două valori <code>n m</code>, cu semnificația precizată, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa suma primelor m elemente cele mai mici ale șirului. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*0 < m <= n <= 100
*valorile elementelor șirului vor fi cuprinse între -1.000.000 și 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 8
:Introduceti numarul m: 3
:Introduceti 8 numere separate prin spatiu:1321 123 22 312 1 12 2 1
;Ieșire
:Datele introduse sunt corecte!
:Suma este: 4
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 123
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti numarul m: 6
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 1500:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_pozitie_de_sters(p, n):
if is_integer(p):
if 1 <= int(p) <= int(n):
return p
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000000 <= int(i) <= 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def eliminare_elem_p(vector, p):
print("Datele introduse sunt corecte!")
vector.pop(int(p) - 1)
print("Noul vector este:", vector)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
p = input("Introduceti pozitia de sters: ")
verificare_pozitie_de_sters(p, n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
eliminare_elem_p(elem, p)

</syntaxhighlight>
==Explicație rezolvare==
Acest program preia un număr <code>n</code> de elemente, un număr <code>m</code> și <code>n</code> numere separate prin spațiu. Apoi, calculează suma celor mai mici <code>m</code> numere dintre cele <code>n</code> numere introduse. Programul verifică și validează datele introduse înainte de a efectua operațiunea de calcul a sumei.

# <code>is_integer(value)</code>: Verifică dacă valoarea introdusă este un număr întreg.
# <code>verificare_nr_elemente(n)</code>: Verifică dacă <code>n</code> este un număr întreg între 0 și 100. Dacă nu, programul se oprește.
# <code>verificare_m(m, n)</code>: Verifică dacă <code>m</code> este un număr întreg între 1 și <code>n</code>. Dacă nu, programul se oprește.
# <code>verificare_vector(n, vector)</code>: Verifică dacă lungimea vectorului este egală cu <code>n</code> și dacă toate elementele din vector sunt numere întregi mai mici sau egale cu 10000. Dacă nu, programul se oprește.
# <code>suma_celor_m_mai_mici(sir, m)</code>: Calculează suma celor mai mici <code>m</code> numere din lista <code>sir</code> și afișează suma.

În secțiunea <code>if __name__ == '__main__'</code>, programul execută următoarele acțiuni:

# Preia numărul <code>n</code> de elemente de la utilizator și verifică dacă este valid.
# Preia numărul <code>m</code> de la utilizator și verifică dacă este valid în raport cu <code>n</code>.
# Preia <code>n</code> numere de la utilizator, separate prin spațiu, și verifică dacă sunt valide.
# Convertește elementele în numere întregi și le stochează în lista <code>lst_int</code>.
# Afișează un mesaj care indică faptul că datele introduse sunt corecte.
# Apelează funcția <code>suma_celor_m_mai_mici(lst_int, m)</code> pentru a calcula și afișa suma celor mai mici <code>m</code> numere din lista <code>lst_int</code>.

0075 – FSum Div3

2023-04-15T15:30:21Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/75/fsumdiv3 FSum DIv3]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi și un număr <code>p</code>. Să se șteargă din șirul <code>X</code> elementul aflat pe poziția <code>p</code>.
==Date de intrare==
Programul va citi de la tastatură două valori <code>n p</code>, cu semnificația precizată, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa suma elementelor divizibile cu 3 din șir. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*0 <= n <= 100
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti 5 numere separate prin spatiu:3 2 6 9 12
;Ieșire
:Datele introduse sunt corecte!
:Suma este: 30
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 1234
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 6
:Introduceti 6 numere separate prin spatiu:1 2 4 5 6 3
;Ieșire
:Datele introduse sunt corecte!
:Suma este: 9
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 <= int(n) <= 100:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 10000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def suma_div_cu_3(sir):
suma = 0
for elem in sir:
if elem % 3 == 0:
suma += elem
print("Suma este:", suma )

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
suma_div_cu_3(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program preia un număr <code>n</code> de elemente și <code>n</code> numere separate prin spațiu. Apoi, calculează suma tuturor numerelor divizibile cu 3 dintre acestea. Programul verifică și validează datele introduse înainte de a efectua operațiunea de calcul a sumei.

# <code>is_integer(value)</code>: Verifică dacă valoarea introdusă este un număr întreg.
# <code>verificare_nr_elemente(n)</code>: Verifică dacă <code>n</code> este un număr întreg între 0 și 100. Dacă nu, programul se oprește.
# <code>verificare_vector(n, vector)</code>: Verifică dacă lungimea vectorului este egală cu <code>n</code> și dacă toate elementele din vector sunt numere întregi mai mici sau egale cu 10000. Dacă nu, programul se oprește.
# <code>suma_div_cu_3(sir)</code>: Calculează suma elementelor divizibile cu 3 din lista <code>sir</code> și afișează suma.

În secțiunea <code>if __name__ == '__main__'</code>, programul execută următoarele acțiuni:

# Preia numărul <code>n</code> de elemente de la utilizator și verifică dacă este valid.
# Preia <code>n</code> numere de la utilizator, separate prin spațiu, și verifică dacă sunt valide.
# Convertește elementele în numere întregi și le stochează în lista <code>lst_int</code>.
# Afișează un mesaj care indică faptul că datele introduse sunt corecte.
# Apelează funcția <code>suma_div_cu_3(lst_int)</code> pentru a calcula și afișa suma numerelor divizibile cu 3 din lista <code>lst_int</code>.
#

0117 – Creare Număr1

2023-04-15T15:23:44Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/117/crearenumar1 CreareNumar1]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Să se afișeze numărul obținut prin concatenarea numărului de valoare maximă și a celui de valoare minimă, în această ordine.
==Date de intrare==
Programul va citi de la tastatură o valoare <code>n</code>, urmată de n numere naturale.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa numărul obținut prin concatenarea celei mai mari și a celei mai mici valori din vector. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 10
:Introduceti 10 numere separate prin spatiu:12 1 12 1231 123 1 2 31 12 1
;Ieșire
:Datele introduse sunt corecte!
:12311
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 134
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti 5 numere de maxim 4 cifre separate prin spatiu:12342 12 21 sa
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 100:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 10000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def concatenare(sir):
minim = 100000
maxim = 0
for elem in sir:
if elem < minim:
minim = elem
if elem > maxim:
maxim = elem
print(str(maxim)+str(minim))

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
concatenare(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program preia un număr <code>n</code> de elemente și <code>n</code> numere separate prin spațiu. Apoi, el găsește cel mai mic și cel mai mare număr dintre acestea și le concatenează pentru a forma un nou număr. Programul verifică și validează datele introduse înainte de a efectua operațiunea de concatenare.

# <code>is_integer(value)</code>: Verifică dacă valoarea introdusă este un număr întreg.
# <code>verificare_nr_elemente(n)</code>: Verifică dacă <code>n</code> este un număr întreg între 1 și 100. Dacă nu, programul se oprește.
# <code>verificare_vector(n, vector)</code>: Verifică dacă lungimea vectorului este egală cu <code>n</code> și dacă toate elementele din vector sunt numere întregi mai mici sau egale cu 10000. Dacă nu, programul se oprește.
# <code>concatenare(sir)</code>: Găsește minimul și maximul din lista <code>sir</code> și le concatenează într-un singur număr. Afișează numărul rezultat.

În secțiunea <code>if __name__ == '__main__'</code>, programul execută următoarele acțiuni:

# Preia numărul <code>n</code> de elemente de la utilizator și verifică dacă este valid.
# Preia <code>n</code> numere de la utilizator, separate prin spațiu, și verifică dacă sunt valide.
# Convertește elementele în numere întregi și le stochează în lista <code>lst_int</code>.
# Afișează un mesaj care indică faptul că datele introduse sunt corecte.
# Apelează funcția <code>concatenare(lst_int)</code> pentru a găsi și afișa numărul rezultat din concatenarea minimului și maximului din lista <code>lst_int</code>.

0802 – Sum Imp K

2023-04-15T15:08:40Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/802/sumimpk SumImpK]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Să se facă suma primelor k numere impare din șir. Dacă nu există k elemente impare în șir se va returna un mesaj de eroare.
==Date de intrare==
Programul va citi de la tastatură două valori <code>n k</code> cu semnificația precizată, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa suma primelor k elemente impare, dacă exsită k elemente impare în șir. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*2 < n < 50
*valorile elementelor șirului vor fi < 10.000
*0 < k <= n
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti 5 numere de maxim 4 cifre separate prin spatiu:1 1 1 1 1
:Introduceti un nr k: 3
;Ieșire
:Datele introduse sunt corecte!
:Suma este: 3
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti 5 numere de maxim 4 cifre separate prin spatiu:1 3 2 6 4
:Introduceti un nr k: 3
;Ieșire
:Datele introduse sunt corecte!
:Nu exista destule elemente impare
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti 5 numere de maxim 4 cifre separate prin spatiu:1 56 3 1 21
:Introduceti un nr k: 6
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 3 <= int(n) <= 49:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def k_valid(k, n):
if is_integer(k):
if int(k) <= int(n):
return True
else:
print("Datele introduse sunt incorecte!")

else:
print("Datele introduse sunt incorecte!")

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 10000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def suma_primele_k_elemente_impare(lst, k):
count = 0
suma = 0
for num in lst:
if num % 2 == 1:
suma += num
count += 1
if count == int(k):
print("Suma este: ", suma)
exit()
if count < int(k):
print("Nu exista destule elemente impare")

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere de maxim 4 cifre separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
k = input("Introduceti un nr k: ")
k_valid(k, n)
print("Datele introduse sunt corecte!")
suma_primele_k_elemente_impare(lst_int, k)

</syntaxhighlight>
==Explicație rezolvare==
Acest program preia ca intrare un număr <code>n</code> de elemente, <code>n</code> numere separate prin spațiu și un număr <code>k</code>. Programul calculează suma primelor <code>k</code> elemente impare dintre cele <code>n</code> numere introduse. Programul conține mai multe funcții care validează și verifică dacă datele introduse sunt corecte, înainte de a efectua operația de calcul a sumei.

# <code>is_integer(value)</code>: Verifică dacă valoarea introdusă este un număr întreg.
# <code>verificare_nr_elemente(n)</code>: Verifică dacă <code>n</code> este un număr întreg între 3 și 49. Dacă nu, programul se oprește.
# <code>k_valid(k, n)</code>: Verifică dacă <code>k</code> este un număr întreg mai mic sau egal cu <code>n</code>. Dacă nu, afișează un mesaj de eroare.
# <code>verificare_vector(n, vector)</code>: Verifică dacă lungimea vectorului este egală cu <code>n</code> și dacă toate elementele din vector sunt numere întregi mai mici sau egale cu 10000. Dacă nu, programul se oprește.
# <code>suma_primele_k_elemente_impare(lst, k)</code>: Calculează suma primelor <code>k</code> elemente impare din lista <code>lst</code>. Dacă nu există suficiente elemente impare în lista, afișează un mesaj corespunzător.

În secțiunea <code>if __name__ == '__main__'</code>, programul execută următoarele acțiuni:

# Preia numărul <code>n</code> de elemente de la utilizator și verifică dacă este valid.
# Preia <code>n</code> numere de la utilizator, separate prin spațiu, și verifică dacă sunt valide.
# Convertește elementele în numere întregi și le stochează în lista <code>lst_int</code>.
# Preia numărul <code>k</code> de la utilizator și verifică dacă este valid.
# Afișează un mesaj care indică faptul că datele introduse sunt corecte.
# Calculează și afișează suma primelor <code>k</code> elemente impare din lista <code>lst_int</code>.

0808 – Mutare

2023-04-15T14:11:29Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/808/mutare Mutare]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi și un număr X. Să se reordoneze elementele șirului astfel încât toate elementele care sunt egale cu X să apare primele, iar restul elementelor să fie afișate după, în ordine în care apar în vectorul inițial.
==Date de intrare==
Programul va citi de la tastatură valoare <code>n</code> apoi <code>n</code> numere întregi reprezentând elementele șirului, și valoarea x.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa șirul reordonat. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*2 < n < 50
*Valoarea x trebuie să existe măcar odată în șirul inițial.
*valorile elementelor șirului vor fi < 10.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti 5 numere de maxim 4 cifre separate prin spatiu:45 2 3 2 6
:Introduceti un nr x: 2
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [2, 2, 45, 3, 6]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 3
:Introduceti 3 numere de maxim 4 cifre separate prin spatiu:12 2 3
:Introduceti un nr x: 4
;Ieșire
:Nu exista numarul x in sirul dat
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 56
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 3 <= int(n) <= 49:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_x(x, sir):
if is_integer(x):
este = False
for elem in sir:
if int(elem) == int(x):
este = True
if este:
return x
else:
print("Nu exista numarul x in sirul dat")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 10000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def modificare_vector(vector, x):
elemente_x = []
elemente_non_x = []
for elem in vector:
if int(elem) == int(x):
elemente_x.append(elem)
else:
elemente_non_x.append(elem)
vector_nou = elemente_x + elemente_non_x
print("Noul vector este: ", vector_nou)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere de maxim 4 cifre separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
x = input("Introduceti un nr x: ")
verificare_x(x, lst_int)
print("Datele introduse sunt corecte!")
modificare_vector(lst_int, x)

</syntaxhighlight>
==Explicație rezolvare==
Acest program implementează o soluție pentru problema de a muta toate elementele dintr-un vector care au o anumită valoare specificată (x) la începutul vectorului, în aceeași ordine, în timp ce elementele rămase rămân la sfârșitul vectorului, în aceeași ordine. Programul cere utilizatorului să introducă numărul de elemente ale vectorului, vectorul și valoarea x. Apoi, verifică dacă datele introduse sunt corecte și, în caz afirmativ, aplică funcția modificare_vector(vector, x) pentru a muta elementele x la începutul vectorului și a afișa noul vector.

Funcția is_integer(value) verifică dacă un caracter reprezintă un număr întreg și returnează True dacă este, altfel returnează False.

Funcția verificare_nr_elemente(n) verifică dacă numărul de elemente n este un număr întreg între 3 și 49 și returnează acest număr. Dacă n nu este valid, se afișează un mesaj de eroare și se oprește programul.

Funcția verificare_x(x, sir) verifică dacă valoarea x se află în vectorul sir și returnează acest număr. Dacă x nu este valid, se afișează un mesaj de eroare și se oprește programul.

Funcția verificare_vector(n, vector) verifică dacă vectorul are n elemente și dacă fiecare element este un număr întreg între -10000 și 10000. Dacă vectorul este valid, nu se întoarce nimic. Dacă nu, se afișează un mesaj de eroare și se oprește programul.

Funcția modificare_vector(vector, x) creează două liste separate pentru elementele x și cele non-x, apoi le concatenează într-un nou vector și afișează vectorul nou.

Instrucțiunea if name == 'main': verifică dacă programul este rulat ca script și, în caz afirmativ, apelează funcțiile verificare_nr_elemente(n), verificare_x(x, lst_int), verificare_vector(n, elem) și modificare_vector(lst_int, x) pentru a verifica datele introduse și a muta elementele x la începutul vectorului.

0811 – Înlocuire0

2023-04-15T13:44:31Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/811/inlocuire0 Inlocuire0]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Să se înlocuiască toate elementele cu valoare mai mică sau egală decât primul element al vectorului cu 0.
==Date de intrare==
Programul va citi de la tastatură <code>n</code> , numărul de elemente care vor fi introduse și n numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma înlocuirii elementelor mai mici sau egale cu prima cifră a șirului cu 0. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*2 < n < 50
*valorile elementelor șirului vor fi < 10.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 4
:Introduceti 4 numere de maxim 4 cifre separate prin spatiu:4 3 5 2
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [0, 0, 5, 0]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 51
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 7
:Introduceti 7 numere de maxim 4 cifre separate prin spatiu:10 4 3 56 2 12 14
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [0, 0, 0, 56, 0, 12, 14]
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 3 <= int(n) <= 49:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -int(i) <= 10000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def inlocuire_cu_0(sir):
elem_de_inloc = sir[0]
sir_nou = []
for elem in sir:
if elem <= elem_de_inloc:
sir_nou.append(0)
else:
sir_nou.append(elem)
print("Noul vector este: ", sir_nou)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere de maxim 4 cifre separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
inlocuire_cu_0(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program implementează o soluție pentru problema înlocuirii elementelor dintr-un vector cu 0, dacă acestea sunt mai mici sau egale cu primul element din vector. Utilizatorul introduce un număr de elemente, urmat de elementele vectorului. Se verifică dacă datele introduse sunt corecte și, în caz afirmativ, se creează un nou vector cu elementele înlocuite cu 0, după criteriul specificat.

Funcția is_integer(value) verifică dacă un caracter reprezintă un număr întreg și returnează True dacă este, altfel returnează False.

Funcția verificare_nr_elemente(n) verifică dacă numărul de elemente n este un număr întreg între 3 și 49 și returnează acest număr. Dacă n nu este valid, se afișează un mesaj de eroare și se oprește programul.

Funcția verificare_vector(n, vector) verifică dacă vectorul are n elemente și dacă fiecare element este un număr întreg între -10000 și 10000. Dacă vectorul este valid, nu se întoarce nimic. Dacă nu, se afișează un mesaj de eroare și se oprește programul.

Funcția inlocuire_cu_0(sir) creează un nou vector cu elementele din sir înlocuite cu 0, după criteriul specificat în cerință, și afișează noul vector.

Instrucțiunea if name == 'main': verifică dacă programul este rulat ca script și, în caz afirmativ, apelează funcțiile verificare_nr_elemente(n), verificare_vector(n, elem) și inlocuire_cu_0(lst_int) pentru a verifica datele introduse și crea noul vector.

1827 – Vector Sum Prim

2023-04-15T13:08:52Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/1827/vectorsumprim VectorSumPrim]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi. Să se afișeze suma elementelor prime din șir.
==Date de intrare==
Programul va citi de la tastatură <code>n</code> , reprezentând numărul de elemente ale șirului, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa suma elementelor prime, dacă nu există, se va afișa mesajul "Nu există numere prime!". În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*0 <= n <= 100
*valorile elementelor șirului vor fi < 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numere de maxim 6 cifre separate prin spatiu:7 9 1 234
;Ieșire
:Datele introduse sunt corecte!
:Suma elementelor prime este: 7
===Exemplul 2===
;Intrare
:Introduceti numere de maxim 6 cifre separate prin spatiu:1234000 12 121 2
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numere de maxim 6 cifre separate prin spatiu:4 6 8 12 15
;Ieșire
:Datele introduse sunt corecte!
:Nu exista numere prime in sir!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

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

def verificare_vector(vector):
n = 0
for i in vector:
if is_integer(i):
if 0 < int(i) < 1000000:
n += 1
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()
if n > 100 or n < 0:
print("Datele introduse sunt incorecte!")
exit()

def suma_elementelor_prime(sir):
suma = 0
for nr in sir:
if este_prim(nr):
suma += nr
if suma == 0:
print("Nu exista numere prime in sir!")
exit()
print("Suma elementelor prime este:", suma)

if __name__ == '__main__':
elem = input(f"Introduceti numere de maxim 6 cifre separate prin spatiu:").split()
verificare_vector(elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
suma_elementelor_prime(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program implementează o funcție care calculează suma elementelor prime dintr-un șir de numere date de la tastatură.

Funcția is_integer(value) este folosită pentru a verifica dacă un caracter reprezintă un număr întreg și returnează True dacă este, altfel returnează False.

Funcția este_prim(n) primește ca parametru un număr întreg și verifică dacă acesta este prim sau nu. Dacă numărul este mai mic decât 2, se consideră că nu este prim. În caz contrar, se verifică dacă numărul este divizibil cu orice număr întreg din intervalul [2, sqrt(n)]. Dacă numărul este divizibil cu un astfel de număr, se consideră că nu este prim, altfel se consideră că este prim.

Funcția verificare_vector(vector) verifică dacă vectorul are cel mult 100 elemente și dacă fiecare element este un număr întreg între 1 și 999999. Dacă vectorul este valid, nu se întoarce nimic. Dacă nu, se afișează un mesaj de eroare și se oprește programul.

Funcția suma_elementelor_prime(sir) primește ca parametru un șir de numere și calculează suma elementelor prime din acest șir. Pentru fiecare număr din șir, se verifică dacă acesta este prim folosind funcția este_prim(n). Dacă este prim, numărul este adunat la suma. Dacă nu există niciun număr prim în șir, se afișează un mesaj corespunzător și se oprește programul. În caz contrar, se afișează suma elementelor prime din șir.

Instrucțiunea if name == 'main': verifică dacă programul este rulat ca script și, în caz afirmativ, apelează funcțiile verificare_vector(elem) și suma_elementelor_prime(lst_int) pentru a verifica datele introduse și calcula suma elementelor prime.

0187 - CifFrecv

2023-04-15T12:42:06Z

Miriam: tot

Sursă: [https://www.pbinfo.ro/probleme/187/ciffrecv 0187 - CifFrecv]
----
==Cerinţă==
Să se scrie un program care citeşte cel mult <code>1.000.000</code> de numere naturale din intervalul închis <code>[0,9]</code> şi determină cel mai mare număr prim citit şi numărul său de apariții.
==Date de intrare==
Programul va citi de la tastatură cel mult <code>1.000.000</code> numere naturale din intervalul închis <code>[0,9]</code>, separate prin spaţii.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se vor afișa două numere naturale <code>MAX</code> şi <code>NR_AP.</code> În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 1000000
*valorile elementelor șirului vor fi cuprinse între 0 și 9
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numere de maxim o cifra separate prin spatiu:1 2 3 4 5 6 7 8 9
;Ieșire
:Datele introduse sunt corecte!
:7 1
===Exemplul 2===
;Intrare
:Introduceti numere de maxim o cifra separate prin spatiu:12 1 2 3
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numere de maxim o cifra separate prin spatiu:1 2 3 3 3 6
;Ieșire
:Datele introduse sunt corecte!
:3 3
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

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

def verificare_vector(vector):
n = 0
for i in vector:
if is_integer(i):
if 0 < int(i) < 10:
n += 1
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()
if n > 1000000 or n < 0:
print("Datele introduse sunt incorecte!")
exit()

def cel_mai_mare_prim_si_aparitii(lst):
aparitii = {}
cel_mai_mare_prim = None
for nr in lst:
if este_prim(nr):
if nr in aparitii:
aparitii[nr] += 1
else:
aparitii[nr] = 1
if cel_mai_mare_prim is None or nr > cel_mai_mare_prim:
cel_mai_mare_prim = nr
if cel_mai_mare_prim is None:
print("Nu s-au găsit numere prime în listă.")
exit()
max_aparitii = max(aparitii.values())
for nr, aparitie in aparitii.items():
if aparitie == max_aparitii and nr > cel_mai_mare_prim:
cel_mai_mare_prim = nr
print(cel_mai_mare_prim, max_aparitii)

if __name__ == '__main__':
elem = input(f"Introduceti numere de maxim o cifra separate prin spatiu:").split()
verificare_vector(elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
cel_mai_mare_prim_si_aparitii(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program citeste de la tastatură o listă de numere naturale cu o singură cifră, cu o limită maximă de 1.000.000 de numere, iar apoi determină cel mai mare număr prim din listă și numărul său de apariții în listă.

Funcția <code>is_integer(value)</code> verifică dacă o valoare dată este un număr întreg.

Funcția <code>este_prim(n)</code> primește un număr <code>n</code> și returnează <code>True</code> dacă acesta este un număr prim, <code>False</code> altfel. Funcția verifică numerele în intervalul <code>[2, sqrt(n)]</code>, pentru a optimiza timpul de execuție.

Funcția <code>verificare_vector(vector)</code> primește o listă și verifică dacă toate elementele acesteia sunt numere întregi cu o singură cifră, iar numărul total de elemente nu depășește 1.000.000.

Funcția <code>cel_mai_mare_prim_si_aparitii(lst)</code> primește lista de numere și determină cel mai mare număr prim din listă și numărul său de apariții. Verifică fiecare număr dacă este prim și dacă da, îl adaugă într-un dicționar, cu numărul de apariții. Dacă un număr prim are mai multe apariții decât numărul cel mai mare prim de până acum, atunci acesta devine noul număr cel mai mare prim.

Programul afișează numărul cel mai mare prim și numărul său de apariții în listă. Dacă nu există numere prime în listă, se afișează un mesaj corespunzător.

0525 - Numere1

2023-04-15T12:29:27Z

Miriam: tot

Sursă: [https://www.pbinfo.ro/probleme/525/numere1 0525 - Numere1]
----
==Cerinţă==
Se dau <code>n</code> numere naturale. Determinaţi cele mai mari două numere cu trei cifre care nu apar printre numerele date.
==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>, iar apoi <code>n</code> numere naturale, separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se vor afișa cele mai mari două numere cu trei cifre care nu apar printre numerele date. În cazul în care nu există astfel 2 numere, se afișează "Nu există!". În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 500.000
*valorile elementelor șirului vor fi < 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 3
:Introduceti 3 elem separate prin spatiu:999 998 996
;Ieșire
:Datele introduse sunt corecte!
:Cele mai mari 2 numere de 3 cifre care nu apar în listă: [997, 995]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 123451234
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 500000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 1000000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def cele_mai_mari_numere(lst):
numere = [int(i) for i in range(100, 1000)]
for elem in lst:
if elem in numere:
numere.remove(elem)
numere.sort(reverse=True)
lista_noua = []
print("Cele mai mari 2 numere de 3 cifre care nu apar în listă:")
for numar in numere[:2]:
lista_noua.append(numar)
print(lista_noua)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
lst_int = list(map(int, elem))
print("Datele introduse sunt corecte!")
cele_mai_mari_numere(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest cod este un exemplu de program care validează datele introduse de utilizator și afișează cele mai mari două numere de trei cifre care nu apar într-o listă dată.

Mai exact, programul începe prin definirea unei funcții numite <code>is_integer</code>, care verifică dacă un anumit string reprezintă un număr întreg.

Apoi, există o funcție numită <code>verificare_nr_elemente</code>, care primește ca parametru un număr și verifică dacă este un număr întreg cuprins între 1 și 500000.

Funcția <code>verificare_vector</code> primește două parametri, un număr și un vector de numere sub formă de string-uri. Această funcție verifică dacă numărul de elemente din vector este egal cu numărul dat ca parametru și dacă fiecare element al vectorului este un număr întreg mai mic sau egal cu 1000000000.

Următoarea funcție, numită <code>cele_mai_mari_numere</code>, primește un vector de numere sub formă de int-uri și afișează cele mai mari două numere de trei cifre care nu apar în listă. Mai exact, funcția creează o listă cu toate numerele de trei cifre posibile și apoi elimină toate elementele din această listă care apar în vectorul dat. Cele mai mari două elemente rămase sunt apoi adăugate într-o altă listă și afișate la sfârșit.

În funcția principală, utilizatorul este întâi întrebat să introducă numărul de elemente pe care le va introduce, iar apoi vectorul de elemente. Datele introduse sunt verificate prin apelarea funcțiilor menționate mai sus și, dacă sunt valide, este afișat mesajul "Datele introduse sunt corecte!". Ulterior, cele mai mari două numere de trei cifre care nu apar în listă sunt afișate apelând funcția <code>cele_mai_mari_numere</code>.

1005 - Numere8

2023-04-15T12:13:13Z

Miriam: tot

Sursă: [https://www.pbinfo.ro/probleme/1005/numere8 1005 - Numere8]
----
==Cerinţă==
Se dă o listă cu numere naturale. Să se determine numerele naturale nenule cu cel mult patru cifre care nu apar în lista dată.
==Date de intrare==
Programul va citi de la tastatură numere întregi reprezentând elementele șirului, cu cel mult patru cifre, separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se vor afișa în ordine descrescătoare, numerele nenule cu cel mult patru cifre care nu se află în listă, separate prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*valorile elementelor șirului vor fi < 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numere de maxim 4 cire separate prin spatiu:9999 9998 9997
;Ieșire
:Datele introduse sunt corecte!
:Numerele cu cel mult 4 cifre, în ordine descrescătoare, cu excepția celor prezente în listă:
:[9996, 9995, 9994, 9993, 9992, 9991, ... , 184, 183, 182, 181, ..., 2, 1, 0]
===Exemplul 2===
;Intrare
:Introduceti numere de maxim 4 cire separate prin spatiu:1234 12345 23
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_vector(vector):
for i in vector:
if is_integer(i):
if int(i) <= 10000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def afisare_numere(lst):
numere = [int(i) for i in range(10000)]
for elem in lst:
if elem in numere:
numere.remove(elem)

numere.sort(reverse=True)
lista_numere = []
print("Numerele cu cel mult 4 cifre, în ordine descrescătoare, cu excepția celor prezente în listă:")
for numar in numere:
lista_numere.append(numar)
print(lista_numere)

if __name__ == '__main__':
elem = input("Introduceti numere de maxim 4 cire separate prin spatiu:").split()
verificare_vector(elem)
print("Datele introduse sunt corecte!")
lst_int = list(map(int, elem))
afisare_numere(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește o listă de numere întregi de maxim 4 cifre de la utilizator și afișează toate numerele întregi de maxim 4 cifre, în ordine descrescătoare, care nu sunt prezente în lista dată.
Explicația programului este următoarea:

* Funcția <code>is_integer()</code> primește un șir de caractere și returnează <code>True</code> dacă toate caracterele din șir sunt cifre, altfel returnează <code>False</code>.
* Funcția <code>verificare_vector()</code> primește o listă de numere sub formă de string-uri și verifică dacă toate elementele listei sunt numere întregi cu maxim 4 cifre. Dacă toate elementele sunt valide, funcția se termină normal; în caz contrar, afișează un mesaj de eroare și oprește programul prin apelul funcției <code>exit()</code>.
* Funcția <code>afisare_numere()</code> primește o listă de numere întregi și creează o listă cu toate numerele întregi de maxim 4 cifre utilizând expresia <code>range(10000)</code>. Apoi, funcția elimină numerele prezente în lista dată și sortează lista rezultată în ordine descrescătoare. Lista sortată este afișată folosind o buclă <code>for</code>.

0267 - Unice

2023-04-15T11:52:56Z

Miriam: tot

Sursă: [https://www.pbinfo.ro/probleme/267/unice Unice]
----
==Cerinţă==
Se dau <code>n</code> numere numere naturale cu cel mult două cifre fiecare. Să se determine acele numere care apar o singură dată.
==Date de intrare==
Se va introduce valoarea <code>n</code> urmată de <code>n</code> numere naturale cu cel mult două cifre fiecare, separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", după care va afișa în ordine crescătoare, valorile care apar o singură dată, separate printr-un spaţiu. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100.000
*valorile elementelor șirului vor fi mai mici decât 100
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 6
:Introduceti 6 numere de maxim 2 cire separate prin spatiu:2 3 12 1 3 2
;Ieșire
:Datele introduse sunt corecte!
:Elementele care apar o singura data in sir sunt: [1, 12]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 4
:Introduceti 4 numere de maxim 2 cire separate prin spatiu:1 234 1 12
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 100000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 99:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def elemente_unice_crescator(sir):
aparitii = {}
elemente_unice = []
for element in sir:
if element in aparitii:
aparitii[element] += 1
else:
aparitii[element] = 1
for element, aparitie in aparitii.items():
if aparitie == 1:
elemente_unice.append(element)
elemente_unice.sort()
print("Elementele care apar o singura data in sir sunt:", elemente_unice)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} numere de maxim 2 cire separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
lst_int = list(map(int, elem))
elemente_unice_crescator(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește de la utilizator o listă de numere și afișează elementele care apar o singură dată în listă, ordonate în ordine crescătoare. Iată cum funcționează acest program:

* Funcția <code>is_integer(value)</code> este folosită pentru a verifica dacă un element este un număr întreg. Funcția returnează <code>True</code> dacă elementul este un număr întreg și <code>False</code> în caz contrar.
* Funcția <code>verificare_nr_elemente(n)</code> primește numărul de elemente din listă și verifică dacă acesta este un număr întreg cuprins între 1 și 100000. Dacă numărul este valid, funcția returnează valoarea. În caz contrar, afișează "Datele introduse sunt incorecte!" și iese din program.
* Funcția <code>verificare_vector(n, vector)</code> primește numărul de elemente și vectorul de elemente și verifică dacă vectorul are exact <code>n</code> elemente și dacă fiecare element este un număr întreg cu cel mult două cifre. Dacă vectorul este valid, funcția afișează "Datele introduse sunt corecte!". În caz contrar, afișează "Datele introduse sunt incorecte!" și iese din program.
* Funcția <code>elemente_unice_crescator(sir)</code> primește lista dată ca argument și calculează numărul de apariții al fiecărui element din listă. După aceea, adaugă într-o listă separată elementele care apar o singură dată în listă și le sortează în ordine crescătoare. Lista cu elemente unice este afișată la final.
* În funcția <code>main</code>, numărul de elemente și vectorul de elemente sunt citite de la utilizator și sunt verificate utilizând funcțiile <code>verificare_nr_elemente</code> și <code>verificare_vector</code>. Dacă lista este validă, funcția <code>elemente_unice_crescator</code> este apelată și afișează elementele care apar o singură dată în listă, ordonate în ordine crescătoare.

0264 - MaxCif

2023-04-15T11:28:29Z

Miriam: tot

Sursă: [https://www.pbinfo.ro/probleme/264/maxcif 0264 - MaxCif]
----
==Cerinţă==
Se dau mai multe numere naturale formate din exact o cifră. Determinaţi cifrele cu număr maxim de apariţii.
==Date de intrare==
Se vor introduce cel mult <code>100.000</code> de numere naturale formate dintr-o singură cifră separate prin spaţii.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se vor afișa cifrele cu număr maxim de apariții. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100.000
*valorile șirului vor fi cuprinse între 1 și 9
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numere de o singura cifra separate prin spatiu:1 1 2 21 2 11
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 2===
;Intrare
:Introduceti numere de o singura cifra separate prin spatiu:5 6 4 1 2 5 7 2
;Ieșire
:Datele introduse sunt corecte!
:Cifrele cu numar maxim de aparitii sunt: ['5', '2']
===Exemplul 3===
;Intrare
:Introduceti numere de o singura cifra separate prin spatiu:1 2 3 2 6 4 2 5 3 2 3 3 2 3 4
;Ieșire
:Datele introduse sunt corecte!
:Cifrele cu numar maxim de aparitii sunt: ['2', '3']
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_vector(vector):
n = 0
for i in vector:
if is_integer(i) and int(i) < 10:
n += 1
else:
print("Datele introduse sunt incorecte!")
exit()
if n > 100000:
print("Datele introduse sunt incorecte!")
exit()

def cifre_max_aparitii(lst):
aparitii = {}
for cifra in lst:
if isinstance(cifra, int):
cifra = str(cifra)
if cifra in aparitii:
aparitii[cifra] += 1
else:
aparitii[cifra] = 1
max_aparitii = max(aparitii.values())
cifre_max_aparitii = [cifra for cifra, aparitie in aparitii.items() if aparitie == max_aparitii]
print("Cifrele cu numar maxim de aparitii sunt: ", cifre_max_aparitii)

if __name__ == '__main__':
elem = input(f"Introduceti numere de o singura cifra separate prin spatiu:").split()
verificare_vector(elem)
print("Datele introduse sunt corecte!")
lst_int = list(map(int, elem))
cifre_max_aparitii(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Acest program primește de la utilizator o listă de numere cu o singură cifră și afișează cifrele cu numărul maxim de apariții din listă.
Iată cum funcționează acest program:

* Funcția <code>is_integer(value)</code> este folosită pentru a verifica dacă un element este un număr întreg. Funcția returnează <code>True</code> dacă elementul este un număr întreg și <code>False</code> în caz contrar.
* Funcția <code>verificare_vector(vector)</code> verifică dacă elementele din lista dată sunt numere întregi cu o singură cifră și are cel mult 100000 de astfel de elemente. Dacă elementele din listă sunt valide, funcția afișează "Datele introduse sunt corecte!". În caz contrar, afișează "Datele introduse sunt incorecte!" și iese din program.
* Funcția <code>cifre_max_aparitii(lst)</code> primește lista dată ca argument și numără numărul de apariții al fiecărei cifre din listă. După aceea, determină numărul maxim de apariții și afișează cifrele care au numărul maxim de apariții.
* În funcția <code>main</code>, lista de elemente este citită de la utilizator și este verificată utilizând funcția <code>verificare_vector</code>. Dacă lista este validă, funcția <code>cifre_max_aparitii</code> este apelată și afișează cifrele cu numărul maxim de apariții.

0244 - CifreOrd

2023-04-15T11:07:32Z

Miriam: tot

Sursa: [https://www.pbinfo.ro/probleme/244/cifreord CifreOrd]
----
==Cerinţă==
Se dau <code>n</code> cifre zecimale. Să se afişeze aceste cifre în ordine crescătoare.
==Date de intrare==
Programul va citi de la tastatură o valoare <code>n</code>, semnificând numerele de elemente introduse, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma ordonării crescătoare a elementelor. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 7
:Introduceti 7 elem separate prin spatiu:1212 1 2 12 1 2 2
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [1, 1, 2, 2, 2, 12, 1212]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 10
:Introduceti 10 elem separate prin spatiu:12 31 3 1 2
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 1000:
return n
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
continue
else:
print("Datele introduse sunt incorecte!")
exit()

def ordonare_sir(lst):
print("Noul vector este: ",sorted(lst))

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
n = verificare_nr_elemente(n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
lst_int = list(map(int, elem))
ordonare_sir(lst_int)

</syntaxhighlight>
==Explicație rezolvare==
Programul dat primește de la utilizator un număr de elemente și un vector de elemente sub formă de șiruri de caractere (string-uri), verifică validitatea datelor, le transformă în numere întregi și ordonează vectorul în ordine crescătoare, apoi afișează vectorul ordonat.

Funcția <code>is_integer</code> primește un argument de tip șir de caractere și returnează <code>True</code> dacă șirul reprezintă un număr întreg, altfel returnează <code>False</code>. Această funcție se folosește pentru a verifica dacă datele introduse de utilizator reprezintă un număr întreg valid.

Funcția <code>verificare_nr_elemente</code> primește un argument de tip șir de caractere care reprezintă numărul de elemente din vectorul de intrare. Funcția verifică dacă șirul reprezintă un număr întreg valid între 1 și 1000 și returnează valoarea convertită la întreg. Dacă șirul nu reprezintă un număr întreg valid, funcția afișează un mesaj de eroare și oprește programul prin apelarea funcției <code>exit()</code>.

Funcția <code>verificare_vector</code> primește două argumente: numărul de elemente din vectorul de intrare și vectorul de intrare în sine. Funcția verifică dacă numărul de elemente coincide cu lungimea vectorului și dacă fiecare element din vector reprezintă un număr întreg valid. Dacă datele de intrare nu sunt valide, funcția afișează un mesaj de eroare și oprește programul prin apelarea funcției <code>exit()</code>.

Funcția <code>ordonare_sir</code> primește un vector ca argument și îl ordonează în ordine crescătoare folosind metoda <code>sorted()</code> din Python. Funcția afișează noul vector ordonat.

În secțiunea <code>__name__ == '__main__'</code>, programul citește numărul de elemente și vectorul de intrare de la utilizator, verifică validitatea datelor cu ajutorul funcțiilor <code>verificare_nr_elemente</code> și <code>verificare_vector</code>, apoi apelează funcția <code>ordonare_sir</code> pentru a ordona vectorul și a-l afișa.

În plus, în interiorul secțiunii <code>__name__ == '__main__'</code>, programul transformă vectorul de intrare din șiruri de caractere în numere întregi utilizând funcția <code>map()</code> și apoi aplică funcția <code>ordonare_sir</code> pentru a ordona vectorul convertit în numere întregi.

2734 - Se citește un șir cu n elemente, numere întregi. Să se șteargă elementele care se repetă, păstrându-se doar primul de la stânga la dreapta.

2023-04-15T10:52:10Z

Miriam: toate problema

Sursa: [https://www.pbinfo.ro/probleme/2734/elimrep ElimRep]
----
==Cerinţă==
Se citește un șir cu <code>n</code> elemente, numere întregi. Să se șteargă elementele care se repetă, păstrându-se doar primul de la stânga la dreapta.
==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>, iar apoi <code>n</code> numere întregi, separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma eliminării elementelor care se repetă, în afara primului de la stânga la dreapta. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 1000
*valorile elementelor șirului vor fi < 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 7
:Introduceti 7 elem separate prin spatiu:1 1 1 3 4 7 7
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: ['1', '3', '4', '7']
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 1100
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 6
:Introduceti 6 elem separate prin spatiu:1 a ds 12
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 1000:
return n
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 1000000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def eliminare_duplicate(lst):
elemnte_diferite = {}
sir_nou = []
for elem in lst:
if elem not in elemnte_diferite:
elemnte_diferite[elem] = True
sir_nou.append(elem)
print(sir_nou)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
n = verificare_nr_elemente(n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
eliminare_duplicate(elem)

</syntaxhighlight>
==Explicație rezolvare==
Codul dat conține o funcție (<code>is_integer</code>) și trei funcții de verificare a datelor (<code>verificare_nr_elemente</code>, <code>verificare_vector</code>, <code>eliminare_duplicate</code>), urmate de o secțiune de cod care citește datele de intrare și le trimite funcțiilor de verificare și de eliminare a duplicatelor.

Funcția <code>is_integer</code> primește un argument de tip șir de caractere și returnează <code>True</code> dacă șirul reprezintă un număr întreg, altfel returnează <code>False</code>. Această funcție se folosește pentru a verifica dacă datele introduse de utilizator reprezintă un număr întreg valid.

Funcția <code>verificare_nr_elemente</code> primește un argument de tip șir de caractere care reprezintă numărul de elemente din vectorul de intrare. Funcția verifică dacă șirul reprezintă un număr întreg valid între 1 și 1000 și returnează valoarea convertită la întreg. Dacă șirul nu reprezintă un număr întreg valid, funcția afișează un mesaj de eroare și oprește programul prin apelarea funcției <code>exit()</code>.

Funcția <code>verificare_vector</code> primește două argumente: numărul de elemente din vectorul de intrare și vectorul de intrare în sine. Funcția verifică dacă numărul de elemente coincide cu lungimea vectorului și dacă fiecare element din vector reprezintă un număr întreg valid mai mic sau egal cu 1000000000. Dacă datele de intrare nu sunt valide, funcția afișează un mesaj de eroare și oprește programul prin apelarea funcției <code>exit()</code>.

Funcția <code>eliminare_duplicate</code> primește un vector ca argument și elimină toate duplicatle din vector, păstrând doar prima apariție a fiecărui element. Funcția utilizează un dicționar pentru a verifica dacă un element a mai fost întâlnit anterior și adaugă elementele unice într-un nou vector. Funcția afișează noul vector.

În secțiunea <code>__name__ == '__main__'</code>, programul citește numărul de elemente și vectorul de intrare de la utilizator, verifică validitatea datelor cu ajutorul funcțiilor <code>verificare_nr_elemente</code> și <code>verificare_vector</code>, apoi apelează funcția <code>eliminare_duplicate</code> pentru a elimina duplicatle și a afișa vectorul fără duplicat.

0596 - Numere2

2023-04-15T10:32:05Z

Miriam: explicat

Sursa: [https://www.pbinfo.ro/probleme/596/numere2 Numere2]
----

==Cerinţă==
Gigel a găsit un șir cu <code>n</code> numere naturale. În fiecare zi Gigel parcurge șirul și când găsește o pereche de elemente consecutive egale o elimină din șir și se oprește. Determinați în câte zile va elimina Gigel elemente din șir și care sunt valorile din șir după eliminări.
==Date de intrare==
Programul citește de la tastatură cel mult 25.000 de numere naturale.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa în cât timp a terminat Gigel de eliminat elemente din șir și cum arată șirul în urma eliminării elementelor consecutive egale. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*numerele citite vor fi mai mici decât 100
*în șir sunt cel puțin un număr și cel mult 20.000 de numere naturale
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 8
:Introduceti 8 elem separate prin spatiu:1 2 3 3 2 2 3 3
;Ieșire
:Datele introduse sunt corecte!
:Gigel a terminat de eliminat elementele dupa 4 zile.
:Valorile din sirul initial dupa eliminari sunt: [1, 2]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 3
:Introduceti 3 elem separate prin spatiu:1 130 4
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 8
:Introduceti 8 elem separate prin spatiu:1 1 2 3 44 44 4 44
;Ieșire
:Datele introduse sunt corecte!
:Gigel a terminat de eliminat elementele dupa 3 zile.
:Valorile din sirul initial dupa eliminari sunt: [2, 3, 4, 44]
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 20000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 100:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def eliminare_duplicate(lista):
noua_lista = [int(i) for i in lista]
eliminari = 0
while True:
i = 0
eliminat = False
while i < len(noua_lista) - 1:
if noua_lista[i] == noua_lista[i + 1]:
del noua_lista[i:i + 2]
eliminari += 1
eliminat = True
else:
i += 1
if not eliminat:
break
print(f"Gigel a terminat de eliminat elementele dupa {eliminari + 1} zile.")
print("Valorile din sirul initial dupa eliminari sunt:", noua_lista)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
eliminare_duplicate(elem)

</syntaxhighlight>

== Explicație ==
Acest program primește un număr întreg <code>n</code> și un șir de <code>n</code> numere întregi separate prin spațiu. Apoi, elimină toate perechile de elemente consecutive și egale până când nu mai pot fi eliminate astfel de perechi. Programul afișează numărul de zile necesar pentru a elimina toate perechile și șirul final.

# <code>is_integer(value)</code>: Această funcție verifică dacă valoarea dată este un număr întreg, returnând <code>True</code> dacă valoarea este formată doar din cifre, altfel <code>False</code>.
# <code>verificare_nr_elemente(n)</code>: Această funcție validează <code>n</code>, numărul de elemente din șir. Dacă <code>n</code> nu este un număr întreg între 1 și 20.000, programul va afișa un mesaj de eroare și se va încheia.
# <code>verificare_vector(n, vector)</code>: Această funcție verifică dacă vectorul are <code>n</code> elemente și dacă toate elementele sunt numere întregi mai mici sau egale cu 100. Dacă nu, programul va afișa un mesaj de eroare și se va încheia.
# <code>eliminare_duplicate(lista)</code>: Această funcție elimină toate perechile de elemente consecutive și egale din șir până când nu mai pot fi eliminate astfel de perechi. Numără numărul de zile necesar pentru a elimina toate perechile și afișează șirul final.
# În secțiunea <code>if __name__ == '__main__':</code>, programul solicită numărul de elemente și șirul de numere, validează datele introduse și afișează rezultatele după eliminarea duplicatelor.

0162 - PermCirc

2023-04-15T09:27:31Z

Miriam: explicație

Sursa: [https://www.pbinfo.ro/probleme/162/permcirc PermCirc]
----
==Cerinţă==
Se dă un vector cu <code>n</code> elemente numere naturale. Determinați toate permutările circulare spre stânga ale vectorului.
==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>, iar apoi <code>n</code> numere naturale, separate prin spaţii, reprezentând elementele vectorului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se vor afișa vectorii obținuți în urma fiecărei permutări circulare. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*0 < n < 16
*elementele vectorului vor fi cuprinse între <code>-1000</code> și <code>1000</code>
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 3
:Introduceti 3 elem separate prin spatiu:1 2 3
;Ieșire
:Datele introduse sunt corecte!
:['1', '2', '3']
:['2', '3', '1']
:['3', '1', '2']
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 6
:Introduceti 6 elem separate prin spatiu:6 5 4 3 2 1
;Ieșire
:Datele introduse sunt corecte!
:['6', '5', '4', '3', '2', '1']
:['5', '4', '3', '2', '1', '6']
:['4', '3', '2', '1', '6', '5']
:['3', '2', '1', '6', '5', '4']
:['2', '1', '6', '5', '4', '3']
:['1', '6', '5', '4', '3', '2']

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 15:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000 <= int(i) <= 1000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def permutari_circulare(vector):
for i in range(len(vector)):
permutare = vector[i:] + vector[:i]
print(permutare)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
permutari_circulare(elem)

</syntaxhighlight>

== Explicație ==
Acest program primește un număr întreg <code>n</code> și un șir de <code>n</code> numere întregi separate prin spațiu. Apoi, afișează toate permutările circulare ale șirului.

# <code>is_integer(value)</code>: Această funcție verifică dacă valoarea dată este un număr întreg, returnând <code>True</code> dacă valoarea este formată doar din cifre, altfel <code>False</code>.
# <code>verificare_nr_elemente(n)</code>: Această funcție validează <code>n</code>, numărul de elemente din șir. Dacă <code>n</code> nu este un număr întreg între 1 și 15, programul va afișa un mesaj de eroare și se va încheia.
# <code>verificare_vector(n, vector)</code>: Această funcție verifică dacă vectorul are <code>n</code> elemente și dacă toate elementele sunt numere întregi între -1.000 și 1.000. Dacă nu, programul va afișa un mesaj de eroare și se va încheia.
# <code>permutari_circulare(vector)</code>: Această funcție afișează toate permutările circulare ale șirului. Parcurge șirul și pentru fiecare index, realizează o permutare circulară și o afișează.
# În secțiunea <code>if __name__ == '__main__':</code>, programul solicită numărul de elemente și șirul de numere, validează datele introduse și afișează permutările circulare ale șirului.

1365 - Aceeasi Paritate

2023-04-15T09:19:38Z

Miriam: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/1365/aceeasi-paritate aceeasi_paritate]

----
==Cerinţă==
Se dau <code>n</code> numere întregi. Să se insereze între oricare două numere de aceeași paritate media lor aritmetică.
==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>, iar apoi <code>n</code> numere întregi, separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma adăugării între oricare 2 numere de aceeași paritate, media lor aritmetică. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100
*valorile elementelor șirului vor fi cuprinse între -1.000.000.000 și 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 3
:Introduceti 3 elem separate prin spatiu:2 5 3
;Ieșire
:Datele introduse sunt corecte!
:Nou vector este: [2, 5, 4, 3]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: ads
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 10
:Introduceti 10 elem separate prin spatiu:1 2 3 2 3 2 4 5 7 9
;Ieșire
:Datele introduse sunt corecte!
:Nou vector este: [1, 2, 3, 2, 3, 2, 3, 4, 5, 6, 7, 8, 9]
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 100:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000000000 <= int(i) <= 1000000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def adauga_medie(sir):
i = 0
sir_cu_int = [int(x) for x in sir]
while i < len(sir_cu_int)-1:
if sir_cu_int[i] % 2 == 0 and sir_cu_int[i+1] % 2 == 0:
media = (sir_cu_int[i] + sir_cu_int[i+1]) / 2
sir_cu_int.insert(i+1, int(media))
i += 2
elif sir_cu_int[i] % 2 != 0 and sir_cu_int[i+1] % 2 != 0:
media = int((sir_cu_int[i] + sir_cu_int[i+1]) / 2)
sir_cu_int.insert(i+1, int(media))
i += 2
else:
i += 1
return sir_cu_int

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
print("Nou vector este: ", adauga_medie(elem))

</syntaxhighlight>

== Explicație ==
Acest program primește un număr întreg <code>n</code> și un șir de <code>n</code> numere întregi separate prin spațiu. Apoi, pentru fiecare pereche de numere consecutive de același paritate (ambele pare sau ambele impare), adaugă media aritmetică a acestor numere între ele în șir.

# <code>is_integer(value)</code>: Această funcție verifică dacă valoarea dată este un număr întreg, returnând <code>True</code> dacă valoarea este formată doar din cifre, altfel <code>False</code>.
# <code>verificare_nr_elemente(n)</code>: Această funcție validează <code>n</code>, numărul de elemente din șir. Dacă <code>n</code> nu este un număr întreg între 1 și 100, programul va afișa un mesaj de eroare și se va încheia.
# <code>verificare_vector(n, vector)</code>: Această funcție verifică dacă vectorul are <code>n</code> elemente și dacă toate elementele sunt numere întregi între -1.000.000.000 și 1.000.000.000. Dacă nu, programul va afișa un mesaj de eroare și se va încheia.
# <code>adauga_medie(sir)</code>: Această funcție parcurge șirul și adaugă media aritmetică între numerele consecutive de aceeași paritate. Dacă ambele numere sunt pare, media va fi întreagă. Dacă ambele numere sunt impare, media va fi întreagă și rotunjită în jos.
# În secțiunea <code>if __name__ == '__main__':</code>, programul solicită numărul de elemente și șirul de numere, validează datele introduse și afișează noul șir cu mediile adăugate.

1366 - Aceeasi paritate 2

2023-04-15T09:19:06Z

Miriam: explicatie

Sursa: [https://www.pbinfo.ro/probleme/1366/aceeasi-paritate-2 aceeasi_paritate_2]
----
==Cerinţă==
Se dau <code>n</code> numere întregi. Să se insereze între oricare două numere de aceeași paritate media lor aritmetică. Algoritmul se va relua în mod repetat până când nu se mai poate adăuga șirului niciun nou element.
==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>, iar apoi <code>n</code> numere întregi, separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma adăugării mediei aritmetice a oricare două numere alăturate de aceeași paritate, operație care se efectuează până când nu mai există elemente alăturate de aceeași paritate, excluzându-se cazul în care au valori egale. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*în cazul în care șirul conține două elemente consecutive egale, între acestea nu se va insera media aritmetică
*1 <=n <= 100
*1.000.000.000 <= elementele șirului <= 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 6
:Introduceti 6 elem separate prin spatiu:2 2 4 2 6 8
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [2, 2, 3, 4, 3, 2, 3, 4, 5, 6, 7, 8]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 6
:Introduceti 6 elem separate prin spatiu:1 41 3 3 4 8
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [1, 6, 11, 16, 21, 26, 31, 36, 41, 22, 3, 3, 4, 5, 6, 7, 8]
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti 5 elem separate prin spatiu:a d 12 a 3
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 100:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000000000 <= int(i) <= 1000000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def adauga_medie(sir):
i = 0
while i < len(sir) - 1:
if sir[i] % 2 == sir[i + 1] % 2 and sir[i] != sir[i + 1]:
media = (sir[i] + sir[i + 1]) / 2
sir.insert(i + 1, int(media))
i += 2
else:
i += 1

def exista_elem_aceeasi_paritate(sir):
for elem in range(0, len(sir)-1):
if sir[elem] % 2 == sir[elem+1] % 2 and sir[elem] != sir[elem+1]:
return True
return False

def procesare_sir(sir):
while exista_elem_aceeasi_paritate(sir):
adauga_medie(sir)
print("Noul vector este: ", sir)

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
sir = [int(x) for x in elem]
procesare_sir(sir)

</syntaxhighlight>

== Explicație ==
Acest program primește un număr întreg <code>n</code> și un șir de <code>n</code> numere întregi separate prin spațiu. Apoi, adaugă media aritmetică între numerele consecutive de aceeași paritate (ambele pare sau ambele impare) și diferite, în șir. Acest proces se repetă până când nu mai există perechi de numere consecutive de aceeași paritate și diferite.

# <code>is_integer(value)</code>: Această funcție verifică dacă valoarea dată este un număr întreg, returnând <code>True</code> dacă valoarea este formată doar din cifre, altfel <code>False</code>.
# <code>verificare_nr_elemente(n)</code>: Această funcție validează <code>n</code>, numărul de elemente din șir. Dacă <code>n</code> nu este un număr întreg între 1 și 100, programul va afișa un mesaj de eroare și se va încheia.
# <code>verificare_vector(n, vector)</code>: Această funcție verifică dacă vectorul are <code>n</code> elemente și dacă toate elementele sunt numere întregi între -1.000.000.000 și 1.000.000.000. Dacă nu, programul va afișa un mesaj de eroare și se va încheia.
# <code>adauga_medie(sir)</code>: Această funcție parcurge șirul și adaugă media aritmetică între numerele consecutive de aceeași paritate și diferite. Dacă se adaugă o medie, indexul se incrementează cu 2.
# <code>exista_elem_aceeasi_paritate(sir)</code>: Această funcție verifică dacă există perechi de numere consecutive de aceeași paritate și diferite în șir. Dacă există, returnează <code>True</code>, altfel <code>False</code>.
# <code>procesare_sir(sir)</code>: Această funcție repetă adăugarea mediilor în șir până când nu mai există perechi de numere consecutive de aceeași paritate și diferite. Apoi, afișează noul șir rezultat.
# În secțiunea <code>if __name__ == '__main__':</code>, programul solicită numărul de elemente și șirul de numere, validează datele introduse, convertește elementele șirului în numere întregi și procesează șirul.

1365 - Aceeasi Paritate

2023-04-15T09:07:42Z

Miriam: explicație

Sursa: [https://www.pbinfo.ro/probleme/1365/aceeasi-paritate aceeasi_paritate]

----
==Cerinţă==
Se dau <code>n</code> numere întregi. Să se insereze între oricare două numere de aceeași paritate media lor aritmetică.
==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>, iar apoi <code>n</code> numere întregi, separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma adăugării între oricare 2 numere de aceeași paritate, media lor aritmetică. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 100
*valorile elementelor șirului vor fi cuprinse între -1.000.000.000 și 1.000.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 3
:Introduceti 3 elem separate prin spatiu:2 5 3
;Ieșire
:Datele introduse sunt corecte!
:Nou vector este: [2, 5, 4, 3]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: ads
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 10
:Introduceti 10 elem separate prin spatiu:1 2 3 2 3 2 4 5 7 9
;Ieșire
:Datele introduse sunt corecte!
:Nou vector este: [1, 2, 3, 2, 3, 2, 3, 4, 5, 6, 7, 8, 9]
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 1 <= int(n) <= 100:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("1Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000000000 <= int(i) <= 1000000000:
continue
else:
print("2Datele introduse sunt incorecte!")
exit()
else:
print("3Datele introduse sunt incorecte!")
exit()

def adauga_medie(sir):
i = 0
sir_cu_int = [int(x) for x in sir]
while i < len(sir_cu_int)-1:
if sir_cu_int[i] % 2 == 0 and sir_cu_int[i+1] % 2 == 0:
media = (sir_cu_int[i] + sir_cu_int[i+1]) / 2
sir_cu_int.insert(i+1, int(media))
i += 2
elif sir_cu_int[i] % 2 != 0 and sir_cu_int[i+1] % 2 != 0:
media = int((sir_cu_int[i] + sir_cu_int[i+1]) / 2)
sir_cu_int.insert(i+1, int(media))
i += 2
else:
i += 1
return sir_cu_int

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
print("Nou vector este: ", adauga_medie(elem))

</syntaxhighlight>

== Explicație ==
Acest program primește un număr întreg <code>n</code> și un șir de <code>n</code> numere întregi separate prin spațiu. Apoi, pentru fiecare pereche de numere consecutive de același paritate (ambele pare sau ambele impare), adaugă media aritmetică a acestor numere între ele în șir.

# <code>is_integer(value)</code>: Această funcție verifică dacă valoarea dată este un număr întreg, returnând <code>True</code> dacă valoarea este formată doar din cifre, altfel <code>False</code>.
# <code>verificare_nr_elemente(n)</code>: Această funcție validează <code>n</code>, numărul de elemente din șir. Dacă <code>n</code> nu este un număr întreg între 1 și 100, programul va afișa un mesaj de eroare și se va încheia.
# <code>verificare_vector(n, vector)</code>: Această funcție verifică dacă vectorul are <code>n</code> elemente și dacă toate elementele sunt numere întregi între -1.000.000.000 și 1.000.000.000. Dacă nu, programul va afișa un mesaj de eroare și se va încheia.
# <code>adauga_medie(sir)</code>: Această funcție parcurge șirul și adaugă media aritmetică între numerele consecutive de aceeași paritate. Dacă ambele numere sunt pare, media va fi întreagă. Dacă ambele numere sunt impare, media va fi întreagă și rotunjită în jos.
# În secțiunea <code>if __name__ == '__main__':</code>, programul solicită numărul de elemente și șirul de numere, validează datele introduse și afișează noul șir cu mediile adăugate.

0160 - Să se insereze într-un șir înaintea fiecărui element pătrat perfect rădăcina sa pătrată.

2023-04-15T08:55:32Z

Miriam: explicatie

Sursa: [https://www.pbinfo.ro/probleme/160/inserareinainte InserareInainte]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente naturale. Să se insereze în șir înaintea fiecărui element pătrat perfect rădăcina sa pătrată.
==Date de intrare==
Programul va citi de la tastatură numărul <code>n</code>, apoi <code>n</code> numere naturale reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma adăugării înainte fiecărui pătrat perfect, rădăcina sa pătrată. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= n <= 25
*valorile elementelor șirului vor fi cuprinse între 0 și 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 4
:Introduceti 4 elem separate prin spatiu:1 2 3 4
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [1, 1, 2, 3, 2, 4]
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 3
:Introduceti 3 elem separate prin spatiu:1 245 2 4 31
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 5
:Introduceti 5 elem separate prin spatiu:1 sfd 2 12 3
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 <= int(n) <= 25:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def este_patrat_perfect(nr):
if int((int(nr)) ** 0.5) ** 2 == int(nr):
return True
else:
return False

def adaugare_element(vector):
vector_nou = []
for nr in vector:
if este_patrat_perfect(nr):
vector_nou.append(int((int(nr) ** 0.5)))
vector_nou.append(int(nr))
return vector_nou

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
print("Noul vector este: ", adaugare_element(elem))

</syntaxhighlight>

== Explicație ==
Acest cod implementează o soluție pentru problema adăugării unui element într-un vector, în funcție de paritatea elementelor existente. Utilizatorul introduce un număr de elemente și apoi elementele vectorului. Se verifică dacă datele introduse sunt corecte și, în caz afirmativ, se adaugă elemente în vector conform regulilor și se afișează noul vector.

Funcția <code>is_integer(value)</code> verifică dacă un caracter reprezintă un număr întreg și returnează True dacă este, altfel returnează False.

Funcția <code>verificare_nr_elemente(n)</code> verifică dacă numărul de elemente <code>n</code> este un număr întreg între 0 și 25 și returnează acest număr. Dacă <code>n</code> nu este valid, se afișează un mesaj de eroare și se oprește programul.

Funcția <code>verificare_vector(n, vector)</code> verifică dacă vectorul are <code>n</code> elemente și dacă fiecare element este un număr întreg mai mic sau egal cu 1.000.000. Dacă vectorul este valid, nu se întoarce nimic. Dacă nu, se afișează un mesaj de eroare și se oprește programul.

Funcția <code>este_par(nr)</code> verifică dacă un număr <code>nr</code> este par și returnează True dacă este, altfel returnează False.

Funcția <code>adaugare_element(vector)</code> primește un vector și adaugă un element după fiecare număr par din vector, care este dublul numărului par. Rezultatul este returnat sub formă de listă.

Instrucțiunea <code>if __name__ == '__main__':</code> verifică dacă programul este rulat ca script și, în caz afirmativ, apelează funcțiile <code>verificare_nr_elemente(n)</code> și <code>verificare_vector(n, elem)</code> pentru a verifica datele introduse și apoi apelează funcția <code>adaugare_element(elem)</code> pentru a modifica vectorul. Se afișează și un mesaj care confirmă că datele introduse sunt corecte înainte de a afișa noul vector.

0159 - Să se insereze într-un șir după fiecare element par dublul său.

2023-04-15T08:47:51Z

Miriam: explicate

Sursa: [https://www.pbinfo.ro/probleme/159/inseraredupa InserareDupa]
----
==Cerinţă==
Să se insereze în șir după fiecare element par dublul său.
==Date de intrare==
Programul va citi de la tastatură <code>n</code> numere naturale reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma adăugării după fiecare element par a dublului său. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*în șir sunt cel mult 25 de numere
*elementele șirului vor fi cuprinse între 0 si 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 10
:Introduceti 10 elem separate prin spatiu:1 12 4 1 12 3 4 1 2 3
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: ['1', '12', 24, '4', 8, '1', '12', 24, '3', '4', 8, '1', '2', 4, '3']
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 7
:Introduceti 7 elem separate prin spatiu:1 3 4 1a d a 2
;Ieșire
:Datele introduse sunt incorecte!
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 <= int(n) <= 25:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if int(i) <= 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def este_par(nr):
if int(nr) % 2 == 0:
return True
else:
return False

def adaugare_element(vector):
vector_nou = []
for nr in vector:
vector_nou.append(nr)
if este_par(nr):
vector_nou.append(int(nr)*2)
return vector_nou

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
print("Noul vector este: ", adaugare_element(elem))

</syntaxhighlight>

== Explicație ==
Acest cod implementează o soluție pentru problema adăugării unui element într-un vector, în funcție de paritatea elementelor existente. Utilizatorul introduce un număr de elemente și apoi elementele vectorului. Se verifică dacă datele introduse sunt corecte și, în caz afirmativ, se adaugă elemente în vector conform regulilor și se afișează noul vector.

Funcția <code>is_integer(value)</code> verifică dacă un caracter reprezintă un număr întreg și returnează True dacă este, altfel returnează False.

Funcția <code>verificare_nr_elemente(n)</code> verifică dacă numărul de elemente <code>n</code> este un număr întreg între 0 și 25 și returnează acest număr. Dacă <code>n</code> nu este valid, se afișează un mesaj de eroare și se oprește programul.

Funcția <code>verificare_vector(n, vector)</code> verifică dacă vectorul are <code>n</code> elemente și dacă fiecare element este un număr întreg mai mic sau egal cu 1.000.000. Dacă vectorul este valid, nu se întoarce nimic. Dacă nu, se afișează un mesaj de eroare și se oprește programul.

Funcția <code>este_par(nr)</code> verifică dacă un număr <code>nr</code> este par și returnează True dacă este, altfel returnează False.

Funcția <code>adaugare_element(vector)</code> primește un vector și adaugă un element după fiecare număr par din vector, care este dublul numărului par. Rezultatul este returnat sub formă de listă.

Instrucțiunea <code>if __name__ == '__main__':</code> verifică dacă programul este rulat ca script și, în caz afirmativ, apelează funcțiile <code>verificare_nr_elemente(n)</code> și <code>verificare_vector(n, elem)</code> pentru a verifica datele introduse și apoi apelează funcția <code>adaugare_element(elem)</code> pentru a modifica vectorul. Se afișează și un mesaj care confirmă că datele introduse sunt corecte înainte de a afișa noul vector.

0158 - Să se insereze pe o poziție dată într-un șir o valoare precizată.

2023-04-15T08:30:30Z

Miriam: explicație

Sursa: [https://www.pbinfo.ro/probleme/158/inserare inserare]
----
==Cerinţă==
Se dă un șir cu <code>n</code> elemente întregi, valoare întreagă <code>X</code> și un număr <code>p</code>. Să se insereze pe poziția <code>p</code> în șir valoarea <code>X</code>.
==Date de intrare==
Programul va citi de la tastatură trei valori <code>n</code>, <code>X</code>, <code>p</code>, cu semnificația precizată, apoi <code>n</code> numere întregi reprezentând elementele șirului.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa noul vector, obținut în urma adăugării elementului x pe poziția p. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*1 <= p <= n <= 25
*valorile elementelor șirului vor fi cuprinse între -1.000.000 și 1.000.000
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul de elemente: 2
:Introduceti valoarea x pentru a fi adaugata: 1234
:Introduceti pozitia p pe care se va adauga: 1
:Introduceti 2 elem separate prin spatiu:1 3
;Ieșire
:Datele introduse sunt corecte!
:Noul vector este: [1234, '1', '3']
===Exemplul 2===
;Intrare
:Introduceti numarul de elemente: 3
:Introduceti valoarea x pentru a fi adaugata: 2
:Introduceti pozitia p pe care se va adauga: 10
;Ieșire
:Datele introduse sunt incorecte!
===Exemplul 3===
;Intrare
:Introduceti numarul de elemente: 14541
;Ieșire
:Datele introduse sunt incorecte!
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def is_integer(value):
return value.isdigit()

def verificare_nr_elemente(n):
if is_integer(n):
if 0 <= int(n) <= 1000:
return n
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_x(x):
if is_integer(x):
if -1000000 <= int(n) <= 1000000:
return x
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_p(p, n):
if is_integer(p):
if -1 <= int(p) <= int(n):
return p
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def verificare_vector(n, vector):
if len(vector) != int(n):
print("Datele introduse sunt incorecte!")
exit()
else:
for i in vector:
if is_integer(i):
if -1000000 <= int(i) <= 1000000:
continue
else:
print("Datele introduse sunt incorecte!")
exit()
else:
print("Datele introduse sunt incorecte!")
exit()

def adaugare_element(vector, x, p):
vector.insert(int(p)-1, int(x))
return vector

if __name__ == '__main__':
n = input("Introduceti numarul de elemente: ")
verificare_nr_elemente(n)
x = input("Introduceti valoarea x pentru a fi adaugata: ")
verificare_x(x)
p = input("Introduceti pozitia p pe care se va adauga: ")
verificare_p(p, n)
elem = input(f"Introduceti {n} elem separate prin spatiu:").split()
verificare_vector(n, elem)
print("Datele introduse sunt corecte!")
vector_nou = adaugare_element(elem, x, p)
print("Noul vector este: ", vector_nou)

</syntaxhighlight>

== Explicație ==
Acest cod implementează o soluție pentru problema adăugării unui element pe o anumită poziție într-un vector. Utilizatorul introduce un număr de elemente, valoarea de adăugat și poziția pe care să fie adăugată apoi elementele vectorului. Se verifică dacă datele introduse sunt corecte și, în caz afirmativ, se adaugă elementul în vector și se afișează noul vector.

Funcția <code>is_integer(value)</code> verifică dacă un caracter reprezintă un număr întreg și returnează True dacă este, altfel returnează False.

Funcția <code>verificare_nr_elemente(n)</code> verifică dacă numărul de elemente <code>n</code> este un număr întreg între 0 și 1000 și returnează acest număr. Dacă <code>n</code> nu este valid, se afișează un mesaj de eroare și se oprește programul.

Funcția <code>verificare_x(x)</code> verifică dacă valoarea <code>x</code> este un număr întreg între -1.000.000 și 1.000.000 și returnează acest număr. Dacă <code>x</code> nu este valid, se afișează un mesaj de eroare și se oprește programul.

Funcția <code>verificare_p(p, n)</code> verifică dacă poziția <code>p</code> este un număr întreg între -1 și <code>n</code> și returnează acest număr. Dacă <code>p</code> nu este valid, se afișează un mesaj de eroare și se oprește programul.

Funcția <code>verificare_vector(n, vector)</code> verifică dacă vectorul are <code>n</code> elemente și dacă fiecare element este un număr întreg între -1.000.000 și 1.000.000. Dacă vectorul este valid, nu se întoarce nimic. Dacă nu, se afișează un mesaj de eroare și se oprește programul.

Funcția <code>adaugare_element(vector, x, p)</code> primește un vector, o valoare <code>x</code> și o poziție <code>p</code> și adaugă valoarea <code>x</code> în vector pe poziția <code>p</code>. Rezultatul este returnat sub formă de listă.

Instrucțiunea <code>if __name__ == '__main__':</code> verifică dacă programul este rulat ca script și, în caz afirmativ, apelează funcțiile <code>verificare_nr_elemente(n)</code>, <code>verificare_x(x)</code>, <code>verificare_p(p, n)</code> și <code>verificare_vector(n, elem)</code> pentru a verifica datele introduse, adăuga elementul în vector și afișa noul vector. Se afișează și un mesaj care confirmă că datele introduse sunt corecte înainte de a afișa noul vector