Bitnami MediaWiki - User contributions [en]

2807 - Matrice 10

2023-04-22T14:18:26Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/2807/matrice10]
== Cerinţa ==
Scrieți un program care citește de la tastatură două numere naturale din intervalul '''[2,50]''', '''n''' și '''m''', și elementele unui tablou bidimensional cu '''n''' linii și '''m''' coloane, numere naturale distincte din intervalul '''[0,104]'''.
Programul interschimbă valoarea minimă din ultima coloană a tabloului cu valoarea minimă din prima coloană a tabloului, apoi afișează pe ecran tabloul modificat, câte o linie a tabloului pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spațiu.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m''', iar apoi cele '''n • m''' elemente ale tabloului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul va afișa pe ecran elementele tabloului modificat, conform cerinței. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''2 ≤ n,m ≤ 50'''
* elementele tabloului aparțin intervalului'''[0,104]'''
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 4 3
: 7 5 19
: 3 8 4
: 23 6 1
: 10 2 9
; Ieșire
: 7 5 19
: 1 8 4
: 23 6 3
: 10 2 9
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if 2 <= n <= 50 and 2 <= m <= 50:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

matrice = []
for linie in range(n):
matrice.append([])
for coloana in range(m):
for i in range(3):
try:
valoare = int(input(f"Introduceti un numar pentru linia {linie+1}, coloana {coloana+1}: "))
if 0<= valoare <= 10**4:
print("Datele sunt corecte.")
matrice[linie].append(valoare)
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
else:
print("Prea multe incercari esuate.")
exit()

return matrice

def Matrice10(matrice):
n, m = len(matrice), len(matrice[0])
a = matrice

i1, j1, i2, j2, min1, min2 = 0, 0, 0, 0, 10000, 10000

for i in range(n):
if a[i][0] < min1:
min1 = a[i][0]
i1, j1 = i, 0
if a[i][m - 1] < min2:
min2 = a[i][m - 1]
i2, j2 = i, m - 1

a[i1][j1], a[i2][j2] = a[i2][j2], a[i1][j1]

for i in range(n):
print(*a[i])

if _name_ == "_main_":
matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Matricea transformata:")
Matrice10(matrice)
</syntaxhighlight>
== Explicații ==
Acest cod este scris in limbajul Python si contine doua functii: "citire_matrice" si "Matrice10".

Functia "citire_matrice" citeste de la tastatura numarul de linii si coloane ale matricei, verifica daca acestea se incadreaza in intervalul [2,50], apoi citeste elementele matricei, verificand daca acestea sunt numere intregi in intervalul [0,104]. Daca valorile introduse nu respecta cerintele, programul se va opri.

Functia "Matrice10" citeste de la tastatura dimensiunile matricei si elementele acesteia, apoi interschimba valorile minime din prima si ultima coloana a matricei. La final, afiseaza matricea modificata.

In program, functia "citire_matrice" este apelata la inceput pentru a citi matricea initiala, iar apoi functia "Matrice10" este apelata pentru a modifica si afisa matricea finala.

0222 - Min Cols

2023-04-22T12:53:54Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/222/mincols] == Enunt == Se consideră tabloul bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere întregi cu cel mult patru cifre fiecare. == Cerinţa == Să se determine, pentru fiecare coloană, valoarea minimă de pe coloana respectivă. == Date de intrare == Fişierul de intrare '''mincols.in''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere naturale separate prin...

Sursă: [https://www.pbinfo.ro/probleme/222/mincols]
== Enunt ==
Se consideră tabloul bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere întregi cu cel mult patru cifre fiecare.
== Cerinţa ==
Să se determine, pentru fiecare coloană, valoarea minimă de pe coloana respectivă.
== Date de intrare ==
Fişierul de intrare '''mincols.in''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fişierul de ieşire '''mincols.out''' va conţine pe prima linie '''n''' numere, reprezentând în ordine minimele de pe coloane, separate printr-un spaţiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''2 ≤ n ≤ 50'''
* elementele tabloului sunt cuprinse între '''-1000''' şi '''1000'''.
== Exemple ==
=== Exemplu 1 ===
; '''mincols.in'''
: 4
: 122 103 5 10
: -7 18 -10 2
: 107 999 59 4
: 1 200 100 7
; '''mincols.out'''
: -7 18 -10 2
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
try:
with open("mincols.in", "r") as fin:
n = int(fin.readline())
if 2 <= n <= 50:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice = []
for linie in range(n):
linie_matrice = []
valori = fin.readline().split()
for coloana in range(n):
try:
valoare = int(valori[coloana])
if -1000 <= valoare <= 1000:
print("Datele sunt corecte.")
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
matrice.append(linie_matrice)

return n, matrice
except FileNotFoundError:
print("Fisierul mincols.in nu exista.")
exit()

def mincols():
n, a = citire_matrice()
with open("mincols.out", "w") as fout:
for j in range(n):
mini = 1001
for i in range(n):
if a[i][j] < mini:
mini = a[i][j]
fout.write(str(mini) + " ")

if _name_ == "_main_":
col_zero = mincols()
print("rezultatul este: ", col_zero)
</syntaxhighlight>

== Explicații ==
Acest cod implementează o funcție numită citire_matrice() care citește o matrice de numere întregi dintr-un fișier de intrare numit "mincols.in" și verifică dacă dimensiunile și valorile matricei îndeplinesc anumite restricții. Dacă matricea nu îndeplinește aceste restricții, programul se oprește prin apelarea funcției exit().

Funcția mincols() deschide fișierul "mincols.in" și citește dimensiunea matricei și elementele acesteia. Apoi, pentru fiecare coloană a matricei, determină valoarea minimă din acea coloană și o scrie într-un fișier de ieșire numit "mincols.out".

În funcția main, programul apelează funcția mincols() și afișează un mesaj de confirmare.

0191 - Max Mat

2023-04-22T12:45:14Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/191/maxmat] == Enunt == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere întregi. == Cerinţa == Să se determine, pentru fiecare linie a matricei, valoarea maximă și indicele coloanei pe care se află valoarea maximă. == Date de intrare == Fişierul de intrare '''maxmat.in''' conţine pe prima linie numerele '''n''' și '''m''', iar următoarele '''n''' linii câte '''m''' numere întregi, reprezentând ele...

Sursă: [https://www.pbinfo.ro/probleme/191/maxmat]
== Enunt ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere întregi.
== Cerinţa ==
Să se determine, pentru fiecare linie a matricei, valoarea maximă și indicele coloanei pe care se află valoarea maximă.
== Date de intrare ==
Fişierul de intrare '''maxmat.in''' conţine pe prima linie numerele '''n''' și '''m''', iar următoarele '''n''' linii câte '''m''' numere întregi, reprezentând elementele matricei.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fişierul de ieşire '''maxmat.out''' va conţine '''n''' linii; pe fiecare linie se vor afla două numere, separate prin exact un spațiu, reprezentând valoarea maximă de pe linia curentă și indicele coloanei pe care se află aceasta . În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n,m ≤ 25'''
* elementele matricei aparțin intervalului '''[-1000,1000]'''
* dacă pe o linie a matricei, elementul maxim apare de mai multe ori, se va afișa indicele de coloană minim
* liniile și coloanele matricei sunt numerotate de la '''1'''
== Exemple ==
=== Exemplu 1 ===
; '''maxmat.in'''
: 4 5
: -2 -9 7 -7 -7
: 1 -7 -8 -1 4
: 8 2 5 -7 2
: 8 -9 -7 10 -9
; '''maxmat.out'''
: 7 3
: 4 5
: 8 1
: 10 4
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
try:
with open("maxmat.in", "r") as fin:
n, m = map(int, fin.readline().split())
if 1 <= n <= 25 and 1 <= m <= 25:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice = []
for linie in range(n):
linie_matrice = []
valori = fin.readline().split()
for coloana in range(m):
try:
valoare = int(valori[coloana])
if -1000 <= valoare <= 1000:
print("Datele sunt corecte.")
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
matrice.append(linie_matrice)

return n, m, matrice
except FileNotFoundError:
print("Fisierul maxmat.in nu exista.")
exit()

def maxmat():
n, m, a = citire_matrice()
with open("maxmat.out", "w") as fout:
for i in range(n):
maxi = -1001
for j in range(m):
if a[i][j] > maxi:
maxi = a[i][j]
ind = j
fout.write(str(maxi) + " " + str(ind + 1) + "\n")

if _name_ == "_main_":
col_zero = maxmat()
print("rezultatul este: ", col_zero)
</syntaxhighlight>

== Explicații ==
Acest cod este format din doua functii:

citire_matrice() - aceasta functie deschide fisierul "maxmat.in", citeste dimensiunile matricei si verfica daca sunt in conformitate cu restrictiile impuse (1<=n,m<=25). Apoi, citeste matricea din fisier, verifica daca valorile matricei sunt in intervalul [-1000, 1000], si construieste matricea in memorie. Daca valorile nu sunt valide sau fisierul nu exista, se afiseaza un mesaj corespunzator si se iese din program. Se returneaza dimensiunile matricei si matricea construita in memorie.

maxmat() - aceasta functie apeleaza citire_matrice() pentru a obtine dimensiunile matricei si matricea in memorie. Apoi, deschide fisierul "maxmat.out" pentru a scrie rezultatele si parcurge matricea in linii, cautand cel mai mare element de pe fiecare linie. Daca gaseste un element mai mare, salveaza valoarea si pozitia acestuia. Dupa ce a terminat de parcurs fiecare linie, scrie in fisier valoarea maxima si pozitia acesteia pentru fiecare linie.
In final, codul verifica daca a fost obtinut un rezultat si afiseaza un mesaj corespunzator.

0314 - Col Zero

2023-04-22T12:32:00Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/314/colzero] == Cerinţa == Se consideră tabloul bidimensional cu '''m''' linii şi '''n''' coloane şi elemente numere naturale. Să se determine numărul de coloane care conţin doar elemente egale cu '''0'''. == Date de intrare == Fişierul de intrare '''colzero.in''' conţine pe prima linie numerele '''m''' şi '''n''', iar pe următoarele '''m''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele t...

Sursă: [https://www.pbinfo.ro/probleme/314/colzero]
== Cerinţa ==
Se consideră tabloul bidimensional cu '''m''' linii şi '''n''' coloane şi elemente numere naturale. Să se determine numărul de coloane care conţin doar elemente egale cu '''0'''.
== Date de intrare ==
Fişierul de intrare '''colzero.in''' conţine pe prima linie numerele '''m''' şi '''n''', iar pe următoarele '''m''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fişierul de ieşire '''colzero.out''' va conţine numărul '''NR''', reprezentând valoarea determinată. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''2≤m,n≤10'''
* elementele tabloului sunt ≤ '''1000''';
== Exemple ==
=== Exemplu 1 ===
; '''colzero.in'''
: 4 5
: 2 0 3 0 0
: 4 0 3 0 0
: 1 0 3 0 0
: 4 0 3 0 0
; '''colzero.out'''
: 3
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
try:
with open("interschimbarelinii.in", "r") as fin:
n, m = map(int, fin.readline().split())
if 2 <= n <= 10 and 2 <= m <= 10:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice = []
for linie in range(n):
linie_matrice = []
valori = fin.readline().split()
for coloana in range(m):
try:
valoare = int(valori[coloana])
if valoare <= 10000:
print("Datele sunt corecte.")
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
matrice.append(linie_matrice)

return n, m, matrice
except FileNotFoundError:
print("Fisierul interschimbarelinii.in nu exista.")
exit()

def ColZero():
with open("colzero.in", "r") as fin:
n, m = map(int, fin.readline().split())
a = []
for i in range(n):
row = list(map(int, fin.readline().split()))
a.append(row)

cnt = 0
with open("colzero.out", "w") as fout:
for j in range(m):
ok = True
for i in range(n):
if a[i][j] != 0:
ok = False
break
if ok:
cnt += 1
fout.write(str(cnt))

if _name_ == "_main_":
col_zero=ColZero()
print("rezultatul este: ", col_zero)
</syntaxhighlight>

== Explicații ==
Acest cod este format din două funcții: citire_matrice() și ColZero(), și o secțiune care apelează funcția ColZero() și afișează rezultatul.

Funcția citire_matrice() citește din fișierul "interschimbarelinii.in" dimensiunile unei matrice și valorile acesteia, verificând dacă valorile se încadrează în limitele specificate. Dacă valorile sunt valide, funcția returnează dimensiunile și matricea.

Funcția ColZero() citește din fișierul "colzero.in" o matrice și verifică câte coloane conțin doar elemente egale cu 0. Rezultatul este scris în fișierul "colzero.out" și întors de funcție.

În secțiunea if _name_ == "_main_":, se apelează funcția ColZero() și se afișează rezultatul obținut.

0669 - Lin Col

2023-04-22T12:24:04Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/669/lincol] == Cerinţa == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Se cere să se determine suma elementelor de pe anumite linii și coloane, precizate. == Date de intrare == Fișierul de intrare '''lincol.in''' va conține pe prima linie numerele '''n m''', Următoarele '''n''' linii conțin câte '''m''' numere naturale, separate prin spații, reprezentând elementele matricei. Următoarea l...

Sursă: [https://www.pbinfo.ro/probleme/669/lincol]
== Cerinţa ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Se cere să se determine suma elementelor de pe anumite linii și coloane, precizate.
== Date de intrare ==
Fișierul de intrare '''lincol.in''' va conține pe prima linie numerele '''n m''', Următoarele '''n''' linii conțin câte '''m''' numere naturale, separate prin spații, reprezentând elementele matricei. Următoarea linie conține numărul de întrebări, '''p''', iar fiecare dintre următoarele '''p''' linii conține câte o întrebare, de forma '''Q I''', unde '''Q''' poate fi unul dintre caracterele '''L''' sau '''C''', iar '''I''' este un număr natural. Dacă '''Q = L''', se cere determinarea sumei elementelor de pe linia '''I''', iar dacă '''Q = C''' se cere determinarea sumei elementelor de pe coloana '''I'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''lincol.out'''va conține '''p''' linii, fiecare conținând, în ordine, răspunsul la întrebarea corespunzătoare. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n , m ≤ 100'''
* elementele matricei sunt numere naturale mai mici decât '''1.000.000'''
* '''1 ≤ p ≤ 100'''
* liniile sunt numerotate de la '''1''' la '''n''', iar coloanele de la '''1''' la '''m'''
== Exemple ==
=== Exemplu 1 ===
; '''lincol.in'''
: 4 5
: 4 7 5 4 2
: 1 1 2 3 4
: 2 2 0 0 3
: 4 8 2 6 1
: 6
: C 2
: L 1
: C 3
: C 5
: L 4
: C 3
; '''lincol.out'''
: 18
: 22
: 9
: 10
: 21
: 9
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
# Deschide fișierul de intrare și citește n, m și matricea
with open("lincol.in", "r") as fin:
n, m = map(int, fin.readline().split())
if not (1 <= n <= 100 and 1 <= m <= 100):
print("Datele nu sunt conform restrictiilor impuse.")
exit()
matrice = []
# Citește matricea din fișierul de intrare
for i in range(n):
row = list(map(int, fin.readline().split()))
# Verifică dacă elementele matricei sunt conform cerințelor
if not all(x <= 1000000 for x in row):
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice.append(row)

# Citește numărul de întrebări
p = int(fin.readline())
intrebari = []
# Citește întrebările din fișierul de intrare
for i in range(p):
linie = fin.readline().split()
intrebare = {'tip': linie[0], 'index': int(linie[1])}
intrebari.append(intrebare)

return n, m, matrice, intrebari

def LinCol(n, m, matrice, intrebari):
with open("lincol.out", "w") as fout:
for intrebare in intrebari:
s = 0
if intrebare['tip'] == 'C':
for i in range(n):
s += matrice[i][intrebare['index'] - 1]
elif intrebare['tip'] == 'L':
for j in range(m):
s += matrice[intrebare['index'] - 1][j]
fout.write(str(s) + "\n")

if _name_ == "_main_":
n, m, matrice, intrebari = citire_matrice()
LinCol(n, m, matrice, intrebari)
</syntaxhighlight>

== Explicații ==
Acesta este un program Python care citeste o matrice dintr-un fisier de intrare, efectueaza operatii de suma pe coloane sau linii ale matricei, si afiseaza rezultatele intr-un fisier de iesire.

Functia citire_matrice() citeste dimensiunile matricei si elementele acesteia din fisierul de intrare. De asemenea, citeste numarul de intrebari si construieste o lista de dictionare, unde fiecare dictionar contine tipul de intrebare (linie sau coloana) si indexul acesteia. Functia returneaza toate aceste informatii.

Functia LinCol() efectueaza operatiile de suma cerute in intrebari si afiseaza rezultatele in fisierul de iesire. Pentru fiecare intrebare, functia parcurge linia sau coloana corespunzatoare si calculeaza suma elementelor. Rezultatul este afisat in fisierul de iesire.

In if _name_ == "_main_": se apeleaza functia citire_matrice() pentru a obtine informatiile necesare, si apoi se apeleaza functia LinCol() pentru a efectua operatiile si afisa rezultatele.

0635 - Vecini 1

2023-04-22T12:14:39Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/635/vecini1] == Cerinţa == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Determinați pentru câte dintre elementele matricei toți vecinii au valori diferite între ele. == Date de intrare == Fișierul de intrare '''vecini1.in''' conține pe prima linie numerele '''n m'''; urmează '''n''' linii cu câte '''m''' numere naturale separate prin spații – elementele matricei. == Date de ieșire == D...

Sursă: [https://www.pbinfo.ro/probleme/635/vecini1]
== Cerinţa ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Determinați pentru câte dintre elementele matricei toți vecinii au valori diferite între ele.
== Date de intrare ==
Fișierul de intrare '''vecini1.in''' conține pe prima linie numerele '''n m'''; urmează '''n''' linii cu câte '''m''' numere naturale separate prin spații – elementele matricei.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.".Fișierul de ieșire '''vecini1.out''' va conține pe prima linie numărul '''C''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n,m ≤ 100'''
* elementele matricei vor fi mai mici decât '''1 000 000'''
* considerăm că un element al matricei poate avea patru vecini: elementele situate pe aceeași linie și pe coloanele adiacente și elementele aflate pe aceeași coloană și liniile adiacente
== Exemple ==
=== Exemplu 1 ===
; '''vecini1.in'''
:4 5
: 6 6 4 6 6
: 2 2 6 4 6
: 1 1 7 3 6
: 6 3 6 5 6
; '''vecini1.out'''
: 9
==== Explicatie ====
Cele '''9''' elemente sunt marcate mai jos:
: '''6 6''' 4 6 6
: '''2''' 2 6 4 6
: '''1 1''' 7 '''3''' 6
: '''6''' 3 '''6''' 5 '''6'''
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
# Deschide fișierul de intrare și citește n, m și p
with open("vecini1.in", "r") as fin:
line = fin.readline().split()
if len(line) != 2:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
n, m = map(int, line)
if not (1 <= n <= 100 and 1 <= m <= 100):
print("Datele nu sunt conform restrictiilor impuse.")
exit()
matrice = []
# Citește matricea din fișierul de intrare
for i in range(n):
row = list(map(int, fin.readline().split()))
# Verifică dacă elementele matricei sunt conform cerințelor
if not all(x <= 1000000 for x in row):
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice.append(row)

return n, m, matrice

def vecini1(n, m, matrice):
a = [[0] * (m + 2) for i in range(n + 2)]
cnt = 0

# Adăugarea de margini de numere mari în matrice
for i in range(1, n + 1):
for j in range(1, m + 1):
a[i][j] = matrice[i-1][j-1]
a[i][0] = 1000001
a[i][m + 1] = 1000002
for j in range(1, m + 1):
a[0][j] = 1000003
a[n + 1][j] = 1000004

# Parcurgerea matricei pentru a verifica vecinii
for i in range(1, n + 1):
for j in range(1, m + 1):
if a[i][j - 1] != a[i][j + 1] and a[i][j - 1] != a[i - 1][j] and a[i][j - 1] != a[i + 1][j] and a[i][j + 1] != a[i - 1][j] and a[i - 1][j] != a[i + 1][j] and a[i][j + 1] != a[i + 1][j]:
cnt += 1

return cnt

if _name_ == "_main_":
n, m, matrice = citire_matrice()
col_divizibile = vecini1(n, m, matrice)
with open("vecini1.out", "w") as fout:
fout.write(str(col_divizibile) + "\n")
print("Numarul de elemente cu toti vecinii diferiti intre ei este:", col_divizibile)
</syntaxhighlight>

== Explicații ==
Acest cod este scris în limbajul de programare Python și conține două funcții:

Funcția citire_matrice():

Deschide fișierul "vecini1.in" și citește din el două numere întregi, n și m.
Verifică dacă valorile citite respectă restricțiile impuse (n și m trebuie să fie între 1 și 100).
Citește matricea de dimensiune n x m din fișier, verificând dacă valorile sunt conforme cu restricțiile (toate elementele matricei trebuie să fie mai mici sau egale cu 1000000).
Returnează dimensiunile matricei n și m, împreună cu matricea citită.
Funcția vecini1(n, m, matrice):

Inițializează o matrice a cu n+2 rânduri și m+2 coloane, toate inițializate cu valoarea 0.
Adaugă o margine de numere mari în jurul matricei matrice, astfel încât să fie mai ușor de verificat vecinii.
Parcurge matricea a și verifică dacă fiecare element are toți vecinii diferiți între ei.
În caz afirmativ, incrementeză numărul de astfel de elemente.
Returnează numărul de elemente cu toți vecinii diferiți între ei.
La final, se citește matricea din fișierul "vecini1.in", se apelează funcția vecini1() cu parametrii corespunzători și se scrie rezultatul în fișierul "vecini1.out". Rezultatul este afișat și în consolă

1450 - Memory 003

2023-04-22T11:32:20Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1450/memory003] == Cerinţa == Se dă o matrice cu '''m''' linii şi '''n''' coloane, având elementele numere naturale nenule. Aflaţi câte coloane ale matricei au produsul elementelor divizibil cu un număr dat '''p'''. == Date de intrare == Fișierul de intrare '''memory003.in''' conține pe prima linie numerele '''m''', '''n''' şi '''p''', iar pe următoarele '''m''' linii câte '''n''' numere naturale separate prin spații, repre...

Sursă: [https://www.pbinfo.ro/probleme/1450/memory003]
== Cerinţa ==
Se dă o matrice cu '''m''' linii şi '''n''' coloane, având elementele numere naturale nenule. Aflaţi câte coloane ale matricei au produsul elementelor divizibil cu un număr dat '''p'''.
== Date de intrare ==
Fișierul de intrare '''memory003.in''' conține pe prima linie numerele '''m''', '''n''' şi '''p''', iar pe următoarele '''m''' linii câte '''n''' numere naturale separate prin spații, reprezentând elementele matricei.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''memory003.out''' va conține pe prima linie numărul de coloane ale matricei pentru care produsul elementelor este divizibil cu '''p'''. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ m ≤ 1.000''''
* '''1 ≤ n ≤ 300'''
* '''1 ≤ p ≤ 1.000.000.000'''
* elementele matricei sunt mai mici sau egale cu '''100'''
== Exemple ==
=== Exemplu 1 ===
; '''memory003.in'''
: 2 3 10
: 4 7 5
: 25 8 6
; '''memory003.out'''
: 2
==== Explicatie ====
Produsul elementelor pe coloane este '''100''', '''56''', respectiv '''30'''. Avem astfel '''două''' coloane cu produsul elementelor divizibil cu '''10'''.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
# Deschide fișierul de intrare și citește n, m și p
with open("memory003.in", "r") as fin:
n, m, p = map(int, fin.readline().split())
if not (1 <= n <= 300 and 1 <= m <= 1000 and 1 <= p <= 1000000000):
print("Datele nu sunt conform restrictiilor impuse.")
exit()
matrice = []
# Citește matricea din fișierul de intrare
for i in range(n):
row = list(map(int, fin.readline().split()))
# Verifică dacă elementele matricei sunt conform cerințelor
if not all(x <= 100 for x in row):
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice.append(row)

return n, m, p, matrice

def Memory003(n, m, p, matrice):
count = 0
for j in range(m):
produs = 1
for i in range(n):
produs *= matrice[i][j]
if produs % p == 0:
count += 1
return count

if _name_ == "_main_":
n, m, p, matrice = citire_matrice()
col_divizibile = Memory003(n, m, p, matrice)
with open("memory003.out", "w") as fout:
fout.write(str(col_divizibile) + "\n")
print("Numarul de coloane cu produsul divizibil cu p este:", col_divizibile)
</syntaxhighlight>

== Explicații ==
Acest cod este o soluție pentru problema "Memory003" din cadrul concursului "ONI 2021" (Olimpiada Națională de Informatică). Scopul problemei este de a găsi numărul de coloane dintr-o matrice ale căror elemente au un produs divizibil cu un număr dat.

Funcția read_matrix() citește matricea din fișierul de intrare "memory003.in" și verifică dacă dimensiunile matricei și valorile elementelor îndeplinesc cerințele impuse de problema. Funcția returnează dimensiunile matricei n și m, numărul p, și matricea propriu-zisă.

Funcția Memory003(n, m, p, matrice) primește dimensiunile matricei, numărul p, și matricea propriu-zisă și calculează numărul de coloane ale căror elemente au un produs divizibil cu p. Pentru fiecare coloană j a matricei, funcția calculează produsul elementelor de pe fiecare linie i, folosind un for loop îmbricat. Dacă produsul este divizibil cu p, se incrementează numărul de coloane găsite.

În funcția principală, se apelează read_matrix() pentru a citi datele din fișierul de intrare, apoi se apelează Memory003() pentru a rezolva problema. Rezultatul este scris în fișierul de ieșire "memory003.out" și afișat pe ecran.

0192 - Sum Col Max

2023-04-22T11:21:19Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/192/sumcolmax] == Enunt == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere întregi. == Cerinţa == Să se afișeze elementele de pe coloana din matrice cu suma elementelor maximă == Date de intrare == Fişierul de intrare '''sumcolmax.in''' conţine pe prima linie numerele '''n''' și '''m''', iar următoarele '''n''' linii câte '''m''' numere întregi, reprezentând elementele matricei. == Date de ieșire =...

Sursă: [https://www.pbinfo.ro/probleme/192/sumcolmax]
== Enunt ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere întregi.
== Cerinţa ==
Să se afișeze elementele de pe coloana din matrice cu suma elementelor maximă
== Date de intrare ==
Fişierul de intrare '''sumcolmax.in''' conţine pe prima linie numerele '''n''' și '''m''', iar următoarele '''n''' linii câte '''m''' numere întregi, reprezentând elementele matricei.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fişierul de ieşire '''sumcolmax.ou'''t va conţine '''1''' linii, cu n valori, separate prin spații, reprezentând elementele de pe coloana cu suma elementelor maximă. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n,m ≤ 25'''
* elementele matricei aparțin intervalului '''[-1000,1000]'''
* dacă sunt mai multe coloane cu suma elementelor maximă, se va considera coloana cu indicele mai mic
* elementele coloanei rezultat se afișează de sus în jos
== Exemple ==
=== Exemplu 1 ===
; '''sumcolmax.in'''
: 4 5
: -2 -9 7 9 -7
: 1 -7 -8 -1 4
: 8 2 5 7 2
: 8 -9 -7 10 -9
; '''sumcolmax.out'''
: 9 -1 7 10
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def read_matrix():
# Deschide fișierul de intrare și citește n și m
with open("sumcolmax.in", "r") as fin:
n, m = map(int, fin.readline().split())

# Verifică dacă datele sunt conform cerințelor
if not (1 <= n <= 25 and 1 <= m <= 25):
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice = []

# Citește matricea din fișierul de intrare
for i in range(n):
row = list(map(int, fin.readline().split()))

# Verifică dacă elementele matricei sunt conform cerințelor
if not all(-1000 <= x <= 1000 for x in row):
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice.append(row)

return n, m, matrice

def sumcolmax(n, m, matrice):
smax = -100001
ind = 0
for j in range(m):
s = 0
for i in range(n):
s += matrice[i][j]
if s > smax:
smax = s
ind = j

max_col = []
for i in range(n):
max_col.append(matrice[i][ind])
return max_col

if _name_ == "_main_":
n, m, matrice = read_matrix()
max_col = sumcolmax(n, m, matrice)
with open("sumcolmax.out", "w") as fout:
fout.write(" ".join(map(str, max_col)))
print("Elementele de pe coloana cu suma maxima sunt:", max_col)
</syntaxhighlight>
== Explicații ==
Acest cod primește o matrice cu n linii și m coloane, precum și suma tuturor elementelor de pe fiecare coloană a matricei. Scopul codului este de a identifica coloana cu cea mai mare sumă și de a returna elementele de pe acea coloană într-o listă. În primul rând, funcția read_matrix deschide fișierul de intrare, citește n și m, și apoi citeste matricea din fișier. Dacă datele de intrare nu sunt conforme cu cerințele, codul va afișa un mesaj de eroare și se va opri. Funcția sumcolmax parcurge fiecare coloană și calculează suma tuturor elementelor de pe acea coloană. Dacă suma este mai mare decât suma maximă până în acel moment, atunci această coloană devine noua coloană cu suma maximă. Apoi, funcția creează o listă care conține elementele de pe coloana cu suma maximă și o returnează. În if _name_ == "_main_":, codul citește matricea cu read_matrix, calculează elementele de pe coloana cu suma maximă cu sumcolmax, scrie rezultatul în fișierul de ieșire sumcolmax.out, și afișează elementele de pe coloana cu suma maximă.

1495 - Memory 004

2023-04-22T11:05:25Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1495/memory004] == Cerinţa == Se dă o matrice cu '''m''' linii şi '''n''' coloane, având elementele numere naturale nenule. Parcurgând matricea pe coloane de sus în jos şi de la stânga la dreapta, determinaţi lungimea maximă a unei secvenţe de numere prime. == Date de intrare == Fișierul de intrare '''memory004.in''' conține pe prima linie numerele '''m''' şi '''n''', iar pe următoarele '''m''' linii câte '''n''' numere...

Sursă: [https://www.pbinfo.ro/probleme/1495/memory004]
== Cerinţa ==
Se dă o matrice cu '''m''' linii şi '''n''' coloane, având elementele numere naturale nenule. Parcurgând matricea pe coloane de sus în jos şi de la stânga la dreapta, determinaţi lungimea maximă a unei secvenţe de numere prime.
== Date de intrare ==
Fișierul de intrare '''memory004.in''' conține pe prima linie numerele '''m''' şi '''n''', iar pe următoarele '''m''' linii câte '''n''' numere naturale, separate prin spații, reprezentând elementele matricei.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''memory004.out''' va conține pe prima linie numărul '''L''', reprezentând lungimea maximă a unei secvenţe de numere prime din matrice obţinută prin parcurgerea matricei pe coloane, de sus în jos şi de la stânga la dreapta. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''2 ≤ m , n ≤ 1000'''
*elementele matricei sunt numere naturale mai mici decât '''10.000'''
== Exemple ==
=== Exemplu 1 ===
; '''memory004.in'''
: 3 4
: 1 6 5 11
: 2 4 3 9
: 2 4 7 8
; '''memory004.out'''
: 4
==== Explicatie ====
Se dă o matrice cu '''3''' linii şi '''4''' coloane. Parcurgând matricea pe coloane de sus în jos şi de la stânga la dreapta se obţin secvenţele de numere prime, puse în evidenţă cu ajutorul culorilor, în matricea de mai jos:
: 1 6 '''5 11'''
: '''2''' 4 '''3''' 9
: '''2''' 4 '''7''' 8
Secvenţele de numere prime sunt 2,2 şi 5,3,7,11, lungimea maximă fiind '''4'''.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
import math
def is_prime(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 citire_matrice():
try:
with open("memory004.in", "r") as fin:
n, m = map(int, fin.readline().split())
if 2 <= n <= 1000 and 2 <= m <= 1000:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice = []
for linie in range(n):
linie_matrice = []
valori = fin.readline().split()
for coloana in range(m):
try:
valoare = int(valori[coloana])
if valoare <= 10000:
print("Datele sunt corecte.")
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
matrice.append(linie_matrice)

return n, m, matrice
except FileNotFoundError:
print("Fisierul memory004.in nu exista.")
exit()

def Memory004(n, m, matrice):
L_max = 0
for j in range(m):
L = 0
for i in range(n):
if is_prime(matrice[i][j]):
L += 1
if L > L_max:
L_max = L
else:
L = 0
return L_max

if _name_ == "_main_":
n, m, matrice = citire_matrice()
L_max = Memory004(n, m, matrice)
print("Lungimea maximă a unei secvenţe de numere prime este:", L_max)
</syntaxhighlight>

== Explicații ==
Acesta este un cod Python care rezolvă problema "Memory004".

Funcția "is_prime(n)" este folosită pentru a verifica dacă un număr este prim sau nu. Funcția primește un număr întreg n și returnează valoarea True dacă n este prim și False în caz contrar.

Funcția "citire_matrice()" este folosită pentru a citi matricea din fișierul "memory004.in". Aceasta verifică dacă valorile m și n sunt conforme cu restricțiile impuse, apoi citeste valorile matricei și le adaugă într-o listă bidimensională "matrice". Funcția returnează n, m și matricea.

Funcția "Memory004(n, m, matrice)" primește parametrii n, m și matricea și calculează lungimea maximă a unei secvențe de numere prime din matrice, parcurgând matricea pe coloane, de sus în jos și de la stânga la dreapta. Funcția utilizează funcția "is_prime(n)" pentru a verifica dacă un element al matricei este prim sau nu și utilizează o variabilă L pentru a număra lungimea secvenței de numere prime pe coloană. Variabila L_max este utilizată pentru a reține lungimea maximă a unei secvențe de numere prime găsită până în acel moment.

În funcția "main", se apelează funcția "citire_matrice()" pentru a obține datele de intrare și se apelează apoi funcția "Memory004(n, m, matrice)" pentru a obține lungimea maximă a unei secvențe de numere prime. Rezultatul este afișat în consolă.

1444 - Memory 001

2023-04-22T10:57:24Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1444/memory001] == Cerinţa == Se dă o matrice cu '''m''' linii şi '''n''' coloane şi elemente numere naturale. Determinaţi coloana din matrice pentru care suma elementelor este minimă. Dacă sunt mai multe coloane cu suma minimă, se va afişa indicele minim al unei asemenea coloane. == Date de intrare == Fișierul de intrare '''memory001.in''' conține pe prima linie numerele '''m''' şi '''n''' reprezentând dimensiunile matrice...

Sursă: [https://www.pbinfo.ro/probleme/1444/memory001]
== Cerinţa ==
Se dă o matrice cu '''m''' linii şi '''n''' coloane şi elemente numere naturale. Determinaţi coloana din matrice pentru care suma elementelor este minimă. Dacă sunt mai multe coloane cu suma minimă, se va afişa indicele minim al unei asemenea coloane.
== Date de intrare ==
Fișierul de intrare '''memory001.in''' conține pe prima linie numerele '''m''' şi '''n''' reprezentând dimensiunile matricei, iar pe următoarele '''m''' linii câte '''n''' numere naturale separate prin spații reprezentând elementele matricei.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''memory001.out''' va conține pe prima linie cel mai mic indice al unei coloane din matrice având suma elementelor minimă. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''2 ≤ m , n ≤ 1000'''
* elementele matricei vor fi mai mici decât '''2.000.000.000'''
* numerotarea liniilor și a coloanelor matricei începe de la '''1'''
== Exemple ==
=== Exemplu 1 ===
; '''memory001.in'''
: 2 3
: 1 2 3
: 7 10 5
; '''memory001.out'''
: 1
==== Explicatie ====
Suma elementelor pe cele trei coloane este '''8''' , '''12''', respectiv '''8'''. Coloana cu indice minim având suma elementelor minimă este coloana '''1'''.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
import math

def read_matrix():
try:
with open("memory001.in", "r") as fin:
n, m = map(int, fin.readline().split())
if 2 <= n <= 1000 and 2 <= m <= 2000000000:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrix = []
for linie in range(n):
linie_matrice = []
valori = fin.readline().split()
for coloana in range(m):
try:
valoare = int(valori[coloana])
if valoare <= 10000:
print("Datele sunt corecte.")
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
matrix.append(linie_matrice)

return n, m, matrix
except FileNotFoundError:
print("Fisierul memory001.in nu exista.")
exit()

def min_coloana(n, m, matrix):
sums = [0] * m
for j in range(m):
for i in range(n):
sums[j] += matrix[i][j]

min_sum = min(sums)
min_index = sums.index(min_sum)

return min_index + 1

if _name_ == "_main_":
n, m, matrix = read_matrix()
min= min_coloana(n, m, matrix)
with open("memory001.out", "w") as fout:
fout.write(str(min))
print("Cel mai mic indice este:", min)
</syntaxhighlight>

== Explicații ==
Acest cod implementează o funcție citire_matrice() care citeste o matrice dintr-un fișier de intrare (Memory001.in). Mai întâi se deschide fișierul de intrare, se citesc dimensiunile matricei (m, n) de pe prima linie și se verifică dacă acestea sunt în limitele impuse de cerințe (2 ≤ m , n ≤ 1000). Dacă valorile sunt valide, se citesc valorile matricei de pe următoarele n linii, fiecare linie conținând m elemente. Pentru fiecare element se verifică dacă este un număr întreg și dacă respectă restricțiile impuse de cerințe (elementele matricei vor fi mai mici decât 2.000.000.000). Dacă toate verificările sunt trecute cu succes, matricea este returnată sub forma unei liste de liste.

Funcția Memory001(n, m, matrice) primește ca argumente dimensiunile matricei și matricea însăși și determină coloana din matrice pentru care suma elementelor este minimă. Mai întâi se deschide fișierul de intrare, se initializează un vector v cu m elemente inițializate cu zero, se parcurge fiecare linie a matricei și se adună elementele de pe fiecare coloană în vectorul v. După ce toate elementele au fost adunate, se găsește indicele elementului minim din vectorul v, care reprezintă coloana cu suma elementelor minimă. Acest indice este scris în fișierul de ieșire (memory001.out).

În funcția main se apelează mai întâi funcția citire_matrice() pentru a obține matricea din fișierul de intrare. Apoi se apelează funcția Memory001(n, m, matrice) pentru a obține cel mai mic indice al unei coloane din matrice având suma elementelor minimă, iar acest indice este afișat la ieșire.

0193 - Interschimbare Linii

2023-04-22T10:49:38Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/193/interschimbarelinii] == Enunt == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale diferite. == Cerinţa == Să se afișeze matricea obținută prin interschimbarea în matricea dată a liniei care conține valoarea maximă cu linia care conține valoarea minim == Date de intrare == Fişierul de intrare '''interschimbarelinii.in''' conţine pe prima linie numerele '''n''' și '''m''', iar pe următoa...

Sursă: [https://www.pbinfo.ro/probleme/193/interschimbarelinii]
== Enunt ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale diferite.
== Cerinţa ==
Să se afișeze matricea obținută prin interschimbarea în matricea dată a liniei care conține valoarea maximă cu linia care conține valoarea minim
== Date de intrare ==
Fişierul de intrare '''interschimbarelinii.in''' conţine pe prima linie numerele '''n''' și '''m''', iar pe următoarele '''n''' linii câte '''m''' numere naturale diferite.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fişierul de ieşire '''interschimbarelinii.out''' va conţine matricea transformată, câte o linia matricei pe o linie a fișierului, elementele de pe fiecare linie fiind separate printr-un spațiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n,m ≤ 25'''
* numerele matricei vor fi mai mici decât 10000'''
== Exemple ==
=== Exemplu 1 ===
; '''interschimbarelinii.in'''
: 4 6
: 8 33 35 28 20 10
: 23 17 24 6 22 31
: 15 25 12 43 27 13
: 21 3 19 29 5 30
; '''interschimbarelinii.out'''
: 8 33 35 28 20 10
: 23 17 24 6 22 31
: 21 3 19 29 5 30
: 15 25 12 43 27 13
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
try:
with open("interschimbarelinii.in", "r") as fin:
n, m = map(int, fin.readline().split())
if 1 <= n <= 25 and 1 <= m <= 25:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice = []
for linie in range(n):
linie_matrice = []
valori = fin.readline().split()
for coloana in range(m):
try:
valoare = int(valori[coloana])
if valoare <= 10000:
print("Datele sunt corecte.")
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
matrice.append(linie_matrice)

return n, m, matrice
except FileNotFoundError:
print("Fisierul interschimbarelinii.in nu exista.")
exit()

def interschimbarelinii():
with open("interschimbarelinii.in", "r") as fin, open("interschimbarelinii.out", "w") as fout:
n, m = map(int, fin.readline().split())
a = [[0 for j in range(m)] for i in range(n)]
mini = 10001
maxi = 0
lmax = 0
lmin = 0
for i in range(n):
line = list(map(int, fin.readline().split()))
for j in range(m):
a[i][j] = line[j]
if a[i][j] > maxi:
maxi = a[i][j]
lmax = i
if a[i][j] < mini:
mini = a[i][j]
lmin = i
for i in range(n):
for j in range(m):
if i == lmax:
fout.write(str(a[lmin][j]) + " ")
elif i == lmin:
fout.write(str(a[lmax][j]) + " ")
else:
fout.write(str(a[i][j]) + " ")
fout.write("\n")

if _name_ == "_main_":
n, m, a = citire_matrice()
inter=interschimbarelinii()
print("Matricea transformată este: ", inter)
</syntaxhighlight>

== Explicații ==
codul este scris in limbajul de programare Python si rezolva problema "Se dă o matrice cu n linii și m coloane și elemente numere naturale diferite. Să se afișeze matricea obținută prin interschimbarea în matricea dată a liniei care conține valoarea maximă cu linia care conține valoarea minimă".

Functia citire_matrice() citeste matricea din fisierul de intrare "interschimbarelinii.in" si verifica daca datele respecta restrictiile impuse (1 <= n,m <= 25 si numerele din matrice sunt mai mici decat 10000). Daca datele nu respecta restrictiile sau fisierul nu exista, se afiseaza un mesaj corespunzator si programul se opreste.

Functia interschimbarelinii() citeste matricea din fisierul de intrare, interschimba liniile care contin valorile maxima si minima si scrie matricea rezultata in fisierul de iesire "interschimbarelinii.out". Pentru a interschimba liniile, se folosesc variabilele mini si maxi pentru a retine valorile minima si maxima si variabilele lmin si lmax pentru a retine indecsii liniilor corespunzatoare. Apoi, se parcurge matricea si se scriu in fisierul de iesire valorile interschimbate sau, daca linia curenta nu contine valorile minima sau maxima, se scriu valorile acelei linii.

In _main_, se apeleaza functia citire_matrice() pentru a obtine matricea si se apeleaza functia interschimbarelinii() pentru a rezolva problema.

0224 - Rotire

2023-04-22T09:35:15Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/224/rotire] == Cerinţa == Se consideră tabloul bidimensional cu '''m''' linii şi '''n''' coloane şi elemente numere naturale. Să se construiască un nou tablou bidimensional cu '''n''' linii şi '''m''' coloane, obţinut din primul prin rotirea acestuia în sens trigonometric cu 90 o. == Date de intrare == Fişierul de intrare '''rotire.in''' conţine pe prima linie numerele '''m''' şi '''n''', iar pe următoarele '''m''' linii c...

Sursă: [https://www.pbinfo.ro/probleme/224/rotire]
== Cerinţa ==
Se consideră tabloul bidimensional cu '''m''' linii şi '''n''' coloane şi elemente numere naturale. Să se construiască un nou tablou bidimensional cu '''n''' linii şi '''m''' coloane, obţinut din primul prin rotirea acestuia în sens trigonometric cu 90 o.
== Date de intrare ==
Fişierul de intrare '''rotire.in''' conţine pe prima linie numerele '''m''' şi '''n''', iar pe următoarele '''m''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fişierul de ieşire '''rotire.out''' va conţine tabloul nou construit, câte o linie a tabloului pe o linie a fişierului, elementele fiecărei linii fiind separare printr-un spaţiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''2≤m,n≤10'''
* elementele tabloului sunt numere naturale mai mici decât '''2.000.000.000'''
== Exemple ==
=== Exemplu 1 ===
; '''rotire.in'''
: 4 5
: 21 22 23 24 25
: 26 27 28 29 30
: 31 32 33 34 35
: 36 37 38 39 40
; '''rotire.out'''
: 25 30 35 40
: 24 29 34 39
: 23 28 33 38
: 22 27 32 37
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
try:
with open("rotire.in", "r") as fin:
n, m = map(int, fin.readline().split())
if m % 2 == 0:
print("Numarul de coloane trebuie sa fie impar.")
exit()
if 2 <= n <= 10 and 2 <= m <= 10:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()

matrice = []
for linie in range(n):
linie_matrice = []
valori = fin.readline().split()
for coloana in range(m):
try:
valoare = int(valori[coloana])
if valoare <= 2000000000:
print("Datele sunt corecte.")
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
matrice.append(linie_matrice)

return n, m, matrice
except FileNotFoundError:
print("Fisierul rotire.in nu exista.")
exit()

def rotire():
# rotire matrice
a_rotit = [[0 for j in range(n)] for i in range(m)]
for i in range(n):
for j in range(m):
a_rotit[m-j-1][i] = a[i][j]

# scriere matrice in fisier
try:
with open("rotire.out", "w") as fout:
for linie in a_rotit:
fout.write(" ".join(str(x) for x in linie))
fout.write("\n")
except IOError:
print("Nu s-a putut scrie in fisierul rotire.out.")

if _name_ == "_main_":
n, m, a = citire_matrice()
rotire()
</syntaxhighlight>

== Explicații ==
Acest cod are două funcții principale: citire_matrice() și rotire().

Funcția citire_matrice() este utilizată pentru a citi o matrice din fișierul "rotire.in". În primul rând, se deschide fișierul și se citesc dimensiunile matricei. Apoi, se verifică dacă numărul de coloane este impar, pentru că este necesar pentru a putea face rotația. În continuare, se verifică dacă dimensiunile matricei sunt conforme cu restricțiile impuse (2<=n<=10 și 2<=m<=10). Dacă sunt conform, se începe citirea matricei linie cu linie. Pe fiecare linie, se citesc valorile și se verifică dacă sunt numere întregi și dacă respectă restricțiile impuse (valoarea <= 2000000000). Dacă toate verificările trec cu succes, matricea este returnată.

Funcția rotire() este utilizată pentru a roti matricea citită în sensul acelor de ceasornic și pentru a scrie matricea rotită în fișierul "rotire.out". În primul rând, se creează o matrice goală a_rotit cu dimensiunile inverse ale matricei citite. Se parcurge matricea citită și se adaugă elementele în matricea rotită la poziția corespunzătoare. Apoi, matricea rotită este scrisă în fișierul "rotire.out".

În main, se apelează mai întâi citire_matrice() pentru a obține matricea, apoi se apelează rotire() pentru a roti și scrie matricea rotită în fișier.

0212 - Max Min Matrice

2023-04-22T07:40:08Z

Andor Giulia: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/212/maxminmatrice] == Enunt == Se consideră tabloul bidimensional cu '''m''' linii şi '''n''' coloane ce conţine numere naturale cu cel mult patru cifre fiecare. == Cerinţa == Să se determine cea mai mică valoare de pe fiecare linie, iar dintre acestea să se determine valoarea maximă. == Date de intrare == Fişierul de intrare '''maxminmatrice.in''' conţine pe prima linie numerele '''m''' şi '''n''', iar pe următoarele '''m'''...

Sursa: [https://www.pbinfo.ro/probleme/212/maxminmatrice]
== Enunt ==
Se consideră tabloul bidimensional cu '''m''' linii şi '''n''' coloane ce conţine numere naturale cu cel mult patru cifre fiecare.
== Cerinţa ==
Să se determine cea mai mică valoare de pe fiecare linie, iar dintre acestea să se determine valoarea maximă.
== Date de intrare ==
Fişierul de intrare '''maxminmatrice.in''' conţine pe prima linie numerele '''m''' şi '''n''', iar pe următoarele '''m''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.". Fişierul de ieşire '''maxminmatrice.out''' va conţine pe prima linie numărul cerut, cea mai mare valoare dintre minimele de pe linii. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''2 ≤ m, n ≤ 23'''
* elementele tabloului sunt mai mici decât '''1000'''.
== Exemple ==
=== Exemplu 1 ===
; '''maxminmatrice.in'''
: 3 5
: 3 2 7 13 5
: 10 9 12 6 9
: 7 4 5 6 3
; '''maxminmatrice.out'''
: 6
==== Explicatie ====
Minimele de pe cele trei linii sunt: 2 6 3. Dintre acestea, cea mai mare valoare este 6.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_matrice():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if m % 2 == 0:
print("Numarul de coloane trebuie sa fie impar.")
exit()
if 2 <= n <= 23 and 2 <= m <= 23:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

matrice = []
for linie in range(n):
linie_matrice = []
for coloana in range(m):
try:
valoare = int(input(f"Introduceti un numar pentru linia {linie+1}, coloana {coloana+1}: "))
if valoare <= 1000:
print("Datele sunt corecte.")
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
matrice.append(linie_matrice)

return n, m, matrice

def maxminmatrice():
with open("maxminmatrice.in", "r") as fin:
n, m = map(int, fin.readline().split())
a = []
for i in range(n):
mini = 1001
row = list(map(int, fin.readline().split()))
for j in range(m):
if row[j] < mini:
mini = row[j]
a.append(row)
fin.close()

v = []
for i in range(n):
v.append(min(a[i]))

v.sort()
with open("maxminmatrice.out", "w") as fout:
fout.write(str(v[-1]))
fout.close()

if _name_ == "_main_":
maxminmatrice()
</syntaxhighlight>
== Explicații ==
Acest cod realizează două funcții: citire_matrice() și maxminmatrice(), și o verificare if _name_ == "_main_": pentru a rula maxminmatrice() atunci când fișierul este executat direct.

Funcția citire_matrice() citeste datele de intrare de la tastatură și construiește o matrice, aplicând anumite restricții impuse pentru a verifica validitatea datelor introduse. Funcția întoarce dimensiunile matricei și matricea propriu-zisă.

Funcția maxminmatrice() citeste datele de intrare din fișierul "maxminmatrice.in" și calculează cea mai mică valoare de pe fiecare linie, iar dintre acestea calculează valoarea maximă. Rezultatul este scris în fișierul "maxminmatrice.out".

0220 - Prod Max

2023-04-22T07:33:39Z

Andor Giulia: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/220/prodmax] == Enunt == Se consideră tabloul bidimensional cu '''m''' linii şi '''n''' coloane, care conţine doar valorile '''{0,1,2}'''. == Cerinţa == Să se determine numerele de ordine ale coloanelor pentru care produsul elementelor este maxim. == Date de intrare == Fişierul de intrare '''prodmax.in''' conţine pe prima linie numerele '''m''' şi '''n''', iar pe următoarele '''m''' linii câte '''n''' numere naturale separate p...

Sursa: [https://www.pbinfo.ro/probleme/220/prodmax]
== Enunt ==
Se consideră tabloul bidimensional cu '''m''' linii şi '''n''' coloane, care conţine doar valorile '''{0,1,2}'''.
== Cerinţa ==
Să se determine numerele de ordine ale coloanelor pentru care produsul elementelor este maxim.
== Date de intrare ==
Fişierul de intrare '''prodmax.in''' conţine pe prima linie numerele '''m''' şi '''n''', iar pe următoarele '''m''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.".Fişierul de ieşire '''prodmax.out''' va conţine pe prima linie numerele cerute, separate prin spatii, în ordine crescătoare. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''2≤m,n≤100'''
* numere de ordine ale liniilor sunt între '''1''' şi '''m'''
* numere de ordine ale coloanelor sunt între '''1''' şi '''n'''
== Exemple ==
=== Exemplu 1 ===
; '''prodmax.in'''
: 4 4
: 2 1 1 0
: 1 1 1 1
: 2 2 2 1
: 1 2 1 1
; '''prodmax.out'''
: 1 2
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_lin_col():
with open("prodmax.in", "r") as fin:
try:
n, m = map(int, fin.readline().split())
if 2 <= n <= 100 and 2 <= m <= 100:
print("Datele sunt corecte.")
return n, m
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(m, n):
matrice = []
with open("prodmax.in", "r") as fin:
fin.readline()
for linie in range(m):
matrice.append(list(map(int, fin.readline().split())))
if len(matrice[linie]) != n:
print("Dimensiunile matricei nu sunt cele așteptate.")
exit()
for elem in matrice[linie]:
if elem not in [0, 1, 2]:
print("Elementele matricei nu sunt corecte.")
exit()
return matrice

def prodmax():
n, m = citire_lin_col()
a = citeste_valori_matrice(m, n)
pmax = -1
for j in range(m):
p = 1
for i in range(n):
p *= a[i][j]
if p > pmax:
pmax = p
with open("prodmax.out", "w") as fout:
for j in range(m):
p = 1
for i in range(n):
p *= a[i][j]
if p == pmax:
fout.write(str(j + 1) + " ")

if _name_ == "_main_":
prodmax()
</syntaxhighlight>
== Explicații ==
Acest cod implementează o funcție numită prodmax() care citește o matrice de dimensiune n x m și găsește numărul de coloană a produsului maxim de elemente din acea matrice.

Funcția citire_lin_col() este utilizată pentru a citi numerele întregi n și m din fișierul de intrare prodmax.in și verifica dacă sunt în conformitate cu restricțiile impuse (2 <= n <= 100 și 2 <= m <= 100).

Funcția citeste_valori_matrice(m, n) este utilizată pentru a citi valorile matricei din fișierul de intrare prodmax.in. În timpul citirii, se verifică dacă dimensiunile matricei sunt cele așteptate și dacă elementele matricei sunt corecte (adica 0, 1 sau 2).

În funcția principală prodmax(), matricea este citită prin apelarea funcțiilor citire_lin_col() și citeste_valori_matrice(m, n). Apoi, se găsește produsul maxim de elemente din fiecare coloană, iar coloana cu cel mai mare produs este înregistrată în variabila pmax. Această coloană este găsită prin parcurgerea matricei și înmulțind elementele de pe fiecare coloană, apoi comparând produsul cu pmax. Dacă produsul este egal cu pmax, atunci numărul de coloană este scris în fișierul de ieșire prodmax.out.

În general, acest cod utilizează citirea din fișier și scrierea în fișier pentru a efectua o operație matriceală simplă și returnează numărul de coloană cu cel mai mare produs de elemente.

0763 - Matrice 3

2023-04-22T07:26:31Z

Andor Giulia: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/763/matrice3] ---- == Cerinţa == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale și o valoare '''k'''. Să se modifice cel mult '''k''' elemente ale matricei, astfel încât toate liniile matricei să aibă aceeași sumă a elementelor. == Date de intrare == Programul citește de la tastatură numerele '''n m k''', apoi elementele matricei, linie cu linie. == Date de ieșire == Pe ecran se va afișa...

Sursa: [https://www.pbinfo.ro/probleme/763/matrice3]
----
== Cerinţa ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale și o valoare '''k'''. Să se modifice cel mult '''k''' elemente ale matricei, astfel încât toate liniile matricei să aibă aceeași sumă a elementelor.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m k''', apoi elementele matricei, linie cu linie.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.". Programul va afișa pe ecran numărul numărul de elemente modificate, '''p''', apoi '''p''' triplete '''i j x''', cu semnificația: elementul din matrice de pe linia '''i''' și coloana '''j''' devine '''x'''. '''x''' trebuie să fie număr natural.În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''1 ≤ n , m ≤ 100'''
* '''1 ≤ k < n'''
* elementele matricei vor fi mai mici decât '''1.000.000'''
* liniile și coloanele matricei sunt numerotate de la '''1'''
* pentru toate datele de test există soluție
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 3 4 2
: 7 4 1 6
: 5 5 7 3
: 4 7 2 3
; Ieșire
: 2
: 1 3 3
: 3 1 8
== Rezolvare ==
<syntaxhighlight lang="python" line>

0566 - Mese

2023-04-22T07:18:34Z

Andor Giulia: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/566/mese] ---- == Cerinţa == Gigel este patronul unui '''fast-food''' destul de cunoscut. Restaurantul are formă dreptunghiulară, și conține mai multe mese de formă de asemenea dreptunghiulară dar de dimensiuni neregulate. Gigel vă pune la dispoziție planul restaurantului, sub forma unei matrice cu '''n''' linii și '''m''' coloane, în care elementele care corespund unor spații libere sunt egale cu '''0''', iar elementele care...

Sursa: [https://www.pbinfo.ro/probleme/566/mese]
----
== Cerinţa ==
Gigel este patronul unui '''fast-food''' destul de cunoscut. Restaurantul are formă dreptunghiulară, și conține mai multe mese de formă de asemenea dreptunghiulară dar de dimensiuni neregulate. Gigel vă pune la dispoziție planul restaurantului, sub forma unei matrice cu '''n''' linii și '''m''' coloane, în care elementele care corespund unor spații libere sunt egale cu '''0''', iar elementele care fac parte din mese sunt egale cu '''1'''. Mai precis, mesele sunt zone dreptunghiulare maximale din matrice care au toate elementele '''1'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m''', iar apoi '''n*m''' numere naturale '''(0 sau 1)''', dispuse pe '''n''' ,linii, reprezentând planul restaurantului.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.". Programul va afișa pe ecran numerele ''C M''', separate prin exact un spațiu reprezentând numărul total de mese și suprafața maximă a unei mese. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''1 ≤ n, m ≤ 250'''
* mesele nu au laturi comune
* nici o masă nu va conține spații libere
* suprafața unei mese este egală cu numărul de elemente din matrice din care este alcătuită
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 5 6
: 0 0 1 1 1 0
: 0 0 1 1 1 0
: 1 0 0 0 0 1
: 1 0 1 1 0 1
: 1 0 1 1 0 0
; Ieșire
: 4 6
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_matrice():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if 1 <= n <= 250 and 1 <= m <= 250:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

matrice = []
for linie in range(n):
linie_matrice = []
for coloana in range(m):
try:
valoare = int(input(f"Introduceti un numar pentru linia {linie+1}, coloana {coloana+1}: "))
if valoare in [0, 1]:
print("Datele sunt corecte.")
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
matrice.append(linie_matrice)

return n, m, matrice

def Mese(n, m, matrice):
a = matrice

p = 0
k = 0
max_area = 0

# function to check if a cell is inside the matrix
def inside(i, j):
return i >= 0 and i < n and j >= 0 and j < m

# function to perform BFS from a cell
def bfs(i, j):
nonlocal a
nonlocal max_area
q = [(i, j)]
area = 0
while q:
i, j = q.pop(0)
if not inside(i, j) or a[i][j] != 1:
continue
a[i][j] = 2
area += 1
q.append((i - 1, j))
q.append((i + 1, j))
q.append((i, j - 1))
q.append((i, j + 1))
max_area = max(max_area, area)

# find the maximum area of a rectangle of 1s
for i in range(n):
for j in range(m):
if a[i][j] == 1:
lat = 0
col = 0
while j + lat < m and a[i][j + lat] == 1:
lat += 1
while i + col < n and a[i + col][j] == 1:
col += 1
if lat * col > max_area:
max_area = lat * col

# perform BFS from cells on the border
for i in range(n):
if a[i][0] == 1:
p += 1
bfs(i, 0)
if a[i][m - 1] == 1:
p += 1
bfs(i, m - 1)
for j in range(m):
if a[0][j] == 1:
p += 1
bfs(0, j)
if a[n - 1][j] == 1:
p += 1
bfs(n - 1, j)

return p, max_area

if _name_ == '_main_':
n, m, matrice = citire_matrice()
p, max_area = Mese(n, m, matrice)
print(p, max_area)
</syntaxhighlight>
== Explicații ==
Acest cod este o implementare a problemei "Mese" - se dă o matrice binară, iar scopul este de a determina numărul de bucătării (zone de 1-uri) și aria celei mai mari bucătării.

În funcția citire_matrice(), utilizatorul este întâmpinat cu mesaje pentru a introduce numărul de linii și coloane ale matricei, iar apoi matricea propriu-zisă este citită de la tastatură. Matricea este reprezentată ca o listă de liste, fiecare listă interioară reprezentând o linie a matricei.

Funcția Mese(n, m, matrice) primește numărul de linii și coloane ale matricei și matricea însăși. În interiorul acestei funcții sunt două funcții ajutătoare:

Funcția inside(i, j) verifică dacă o anumită celulă (i, j) este în interiorul matricei, astfel încât să nu se producă erori în timpul parcurgerii matricei.
Funcția bfs(i, j) implementează o parcurgere BFS (breadth-first search) a matricei pornind de la poziția (i, j).
Funcția explorează vecinii celulelor și marchează celulele care au fost deja explorate cu o valoare diferită de 1 sau 0 (în cazul de față, cu 2). Aria bucătăriei este calculată prin numărarea numărului de celule marcate.
Funcția principală Mese(n, m, matrice) începe prin inițializarea a trei variabile: a este o copie a matricei inițiale, p reprezintă numărul de bucătării, iar max_area este aria maximă a unei bucătării.

În prima buclă for, se parcurge matricea și se verifică câte bucătării pot fi formate din linii și coloane consecutive de 1. Se calculează aria acestora, iar dacă aria este mai mare decât aria maximă găsită până în acel moment, aceasta este actualizată.

În a doua buclă for, se caută celulele de la marginea matricei care au valoarea 1 și se pornește o parcurgere BFS de la fiecare dintre acestea. Numărul de bucătării și aria maximă a unei bucătării sunt actualizate după fiecare parcurgere BFS.

În cele din urmă, funcția returnează numărul de bucătării și aria maximă a unei bucătării, care sunt apoi afișate în funcția principală _main_.

0568 - Pod

2023-04-22T07:12:02Z

Andor Giulia: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/568/pod] ---- == Cerinţa == Pentru traversarea unui râu se folosește un pod, alcătuit din '''n*m''' sectoare, dispuse pe '''n''' linii și '''m''' coloane. Datorită vechimii, fiecare sector al podului are un factor de siguranță cunoscut, exprimat printr-un număr natural, care scade cu o unitate de fiecare dată când o persoană pășește pe acel sector. Sectoarele cu factorul de siguranță nul nu sunt accesibile. Traversarea p...

Sursa: [https://www.pbinfo.ro/probleme/568/pod]
----
== Cerinţa ==
Pentru traversarea unui râu se folosește un pod, alcătuit din '''n*m''' sectoare, dispuse pe '''n''' linii și '''m''' coloane. Datorită vechimii, fiecare sector al podului are un factor de siguranță cunoscut, exprimat printr-un număr natural, care scade cu o unitate de fiecare dată când o persoană pășește pe acel sector. Sectoarele cu factorul de siguranță nul nu sunt accesibile.
Traversarea podului constă în parcurgerea unei anumite coloane de la prima linie spre ultima. Nu este posibilă, din motive de siguranță, schimbarea coloanei în timpul traversării.
Administratorul podului, Gigel, vă cere să determinați numărul de persoane care vor putea traversa podul până la degradarea lui totală, pentru a argumenta cererea de finanțare pentru refacerea acestuia.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m''', iar apoi '''n''' șiruri cu câte '''m''' numere naturale, care descriu podul.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.".Programul va afișa pe ecran numărul C, reprezentând valoarea cerută. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''1 ≤ n, m ≤ 1000'''
* pentru fiecare sector, factorul de siguranță este cel mult '''10000'''
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 4 5
: 5 3 6 2 1
: 4 4 0 4 3
: 6 2 2 3 4
: 3 4 4 5 1
; Ieșire
: 8
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_matrice():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if 1 <= n <= 100 and 1 <= m <= 100:
print("Datele sunt corecte.")
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

matrice = []
for linie in range(n):
linie_matrice = []
for coloana in range(m):
try:
valoare = int(input(f"Introduceti un numar pentru linia {linie+1}, coloana {coloana+1}: "))
if valoare <= 10000:
print("Datele sunt corecte.")
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
matrice.append(linie_matrice)

return n, m, matrice

def Pod(n, m, matrice):
s = 0
for j in range(m):
mini = 10001
for i in range(n):
if matrice[i][j] < mini and matrice[i][j] != 0:
mini = matrice[i][j]
s += mini
print(s)

if _name_ == '_main_':
n, m, matrice = citire_matrice()
Pod(n, m, matrice)
</syntaxhighlight>
== Explicații ==
Acest cod este scris in limbajul Python si contine doua functii: citire_matrice() si Pod().

citire_matrice() primeste de la utilizator numarul de linii si coloane ale matricei si citeste valorile matricei de la tastatura. In cazul in care valorile introduse de utilizator nu sunt conforme cu cerintele problemei, functia va afisa un mesaj de eroare si va opri programul cu ajutorul functiei exit(). Daca toate valorile sunt valide, functia va returna numarul de linii, numarul de coloane si matricea citita.
Pod() primeste numarul de linii, numarul de coloane si matricea. In interiorul functiei se initializeaza suma s cu 0 si se parcurge matricea coloana cu coloana. Pentru fiecare coloana se gaseste valoarea minima nenula si se adauga la suma s. La final, functia afiseaza suma calculata.
In functia citire_matrice() se folosesc instructiuni try-except pentru a gestiona erorile la citirea datelor de la tastatura, iar in functia Pod() se utilizeaza doua instructiuni for pentru a parcurge matricea si a extrage valorile minime.

0662 - Sum El Pare

2023-04-21T12:45:28Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/662/sumelpare] == Cerință == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Să se determine indicele liniei pentru care suma elementelor pare este maximă. == Date de intrare == Programul citește de la tastatură numerele '''n m''', iar apoi '''n''' șiruri cu câte '''m''' numere naturale, reprezentând elementele matricei. == Date de ieșire == Dacă datele sunt introduse corect, pe ecran se v...

Sursă: [https://www.pbinfo.ro/probleme/662/sumelpare]
== Cerință ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Să se determine indicele liniei pentru care suma elementelor pare este maximă.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m''', iar apoi '''n''' șiruri cu câte '''m''' numere naturale, reprezentând elementele matricei.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul va afișa pe ecran numărul '''I''', reprezentând indicele determinat. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n , m ≤ 100'''
* elementele matricei sunt numere naturale mai mici decât '''1.000.000'''
* liniile matricei sunt numerotate de '''1''' la '''n''', iar coloanele de la '''1''' la '''m'''
* matricea conține cel puțin un element par
* dacă sunt mai multe linii cu suma elementelor pare maximă, se poate afișa indicele oricăreia
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 3 4
: 5 5 10 5
: 3 9 1 2
: 4 10 1 2
; Date de ieșire
: 3
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 1000000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def SumElPare(matrice, n, m):
vmax = 0
I = 0

for i in range(n):
s = 0
for j in range(m):
if matrice[i][j] % 2 == 0:
s += matrice[i][j]
if s > vmax:
vmax = s
I = i + 1

print(I)

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
SumElPare(matrice, n, m)
</syntaxhighlight>
== Explicatii ==
Acest cod este scris in limbajul de programare Python si implementeaza o functie numita SumElPare care primeste ca parametri o matrice de dimensiune n x m si afiseaza indicele liniei care contine suma maxima a elementelor pare din acea linie.

Pentru a realiza aceasta functie, codul contine mai multe functii ajutatoare. Functia citire_lin_col este folosita pentru a citi numarul de linii si de coloane ale matricei. Aceasta functie verifica daca numerele introduse respecta constrangerile impuse (1 <= lin <= 100 si 1 <= col <= 100) si afiseaza un mesaj corespunzator in caz contrar. Daca numerele introduse sunt corecte, functia returneaza valorile citite.

Functia citeste_valori_matrice este folosita pentru a citi valorile matricei. Aceasta functie creaza o lista vida pentru matrice si foloseste doua bucle for pentru a citi fiecare element al matricei. Pentru fiecare element citit, functia verifica daca valoarea introdusa este intre 0 si 1000000 si afiseaza un mesaj corespunzator in caz contrar. Daca valoarea este corecta, aceasta este adaugata in matrice.

Functia SumElPare este functia principala a codului. Aceasta primeste ca parametri matricea si dimensiunile sale n si m. Aceasta foloseste doua bucle for pentru a parcurge fiecare linie si coloana a matricei si calculeaza suma elementelor pare din fiecare linie. Daca suma elementelor pare dintr-o linie este mai mare decat vmax (initializat cu 0), functia actualizeaza vmax si I (indicele liniei cu suma maxima a elementelor pare).

In final, functia afiseaza indicele liniei cu suma maxima a elementelor pare din matrice.

Blocul if name == "main" este folosit pentru a verifica daca acest script este rulat ca un program independent sau este importat ca un modul in alt script. Daca acest script este rulat ca un program independent, acesta citeste dimensiunile matricei si valorile matricei de la utilizator si apeleaza functia SumElPare pentru a afisa indicele liniei cu suma maxima a elementelor pare.

2800 - Chenar 1

2023-04-21T12:40:08Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/2800/chenar1] == Cerință == Scrieți un program care citește de la tastatură două numere naturale din intervalul '''[3,50]''', '''n''' și '''m''', și elementele unui tablou bidimensional cu '''n''' linii și '''m''' coloane, numere naturale din intervalul '''[0,104]'''. Programul modifică în memorie tabloul dat, atribuind valoarea elementului aflat pe ultima linie și pe ultima coloană a tabloului fiecărui element aflat pe co...

Sursă: [https://www.pbinfo.ro/probleme/2800/chenar1]
== Cerință ==
Scrieți un program care citește de la tastatură două numere naturale din intervalul '''[3,50]''', '''n''' și '''m''', și elementele unui tablou bidimensional cu '''n''' linii și '''m''' coloane, numere naturale din intervalul '''[0,104]'''.
Programul modifică în memorie tabloul dat, atribuind valoarea elementului aflat pe ultima linie și pe ultima coloană a tabloului fiecărui element aflat pe conturul acestuia (pe prima linie, ultima linie, prima coloană, ultima coloană), apoi afișează pe ecran tabloul modificat, câte o linie a tabloului pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spațiu.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m''', iar apoi cele '''n • m''' elemente ale tabloului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul va afișa pe ecran elementele tabloului modificat, conform cerinței. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''3 ≤ n,m ≤ 50'''
* lementele tabloului aparțin intervalului '''[0,104]'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 5 4
: 0 5 2 11
: 3 2 10 2
: 3 1 4
: 4 5 0 12
: 8 13 7 5
; Date de ieșire
: 5 5 5 5
: 5 2 10 5
: 5 3 1 5
: 5 5 0 5
: 5 5 5 5
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 3 <= lin <= 50 and 3 <= col <= 50:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 10000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def Chenar1(matrice, n, m):
val = matrice[-1][-1]
for i in range(n):
matrice[i][0] = val
matrice[i][-1] = val
for i in range(m):
matrice[0][i] = val
matrice[-1][i] = val

for i in range(n):
for j in range(m):
print(matrice[i][j], end=' ')
print()

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
Chenar1(matrice, n, m)
</syntaxhighlight>
== Explicatii ==
Acest cod este o implementare în Python a problemei "Chenar 1" care solicită să se înlocuiască cu o valoare fixă elementele din marginile unei matrice, unde această valoare este preluată din celula din colțul din dreapta jos.

Programul este structurat în trei funcții:

citire_lin_col() - citește de la tastatură numărul de linii și coloane ale matricei și validează dacă respectă condițiile problemei; dacă da, returnează aceste valori ca tuple, altfel iese din program cu o eroare.
citeste_valori_matrice(lin, col) - citește de la tastatură valorile matricei, verificând în timpul citirii dacă sunt conforme cerinței problemei; matricea este stocată într-o listă de liste și returnată.
Chenar1(matrice, n, m) - primește ca parametri matricea și dimensiunile acesteia și înlocuiește elementele din margini cu valoarea preluată din celula din colțul din dreapta jos; apoi afișează matricea.
În funcția principală (if _name_ == "_main_":) se apelează cele trei funcții în ordine pentru a obține și afișa matricea cu valorile din margini înlocuite.

0770 - Perm Col

2023-04-21T12:29:32Z

Andor Giulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/770/permcol] == Cerință == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Să se permute coloanele matricei circular spre stânga cu o poziție. == Date de intrare == Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi '''n*m''' numere naturale, separate prin spații, reprezentând elementele matricei, linie cu linie. == Date de ieșire == Dacă datele sunt introduse corect,...

Sursă: [https://www.pbinfo.ro/probleme/770/permcol]
== Cerință ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Să se permute coloanele matricei circular spre stânga cu o poziție.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi '''n*m''' numere naturale, separate prin spații, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul afișează pe ecran elementele matricei transformate, câte un linie a matricei pe o linie a ecranului, elementele de pe o linie fiind separate prin câte un spațiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ m, n ≤ 100'''
* elementele matricei vor fi mai mici decât '''1.000.000'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 4 6
: 4 20 15 23 18 9
: 1 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Date de ieșire
: 20 15 23 18 9 4
: 8 23 22 14 18 1
: 15 13 18 12 15 17
: 18 8 20 12 5 3
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 1000000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def PermCol(matrice, n, m):
for i in range(n):
aux = matrice[i][0]
for j in range(m - 1):
matrice[i][j] = matrice[i][j + 1]
matrice[i][m - 1] = aux

for i in range(n):
for j in range(m):
print(matrice[i][j], end=' ')
print()

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
PermCol(matrice, n, m)
</syntaxhighlight>
== Explicatii ==
Acest cod citeste de la tastatura dimensiunile si valorile unei matrice, apoi efectueaza o permutare a elementelor fiecarei coloane a matricei si afiseaza matricea rezultata.

Mai exact, functia citire_lin_col() citeste numarul de linii si coloane ale matricei de la tastatura, verificand ca valorile introduse sa se incadreze in intervalul [1,100], si returneaza aceste valori.

Functia citeste_valori_matrice(lin, col) creeaza o matrice de dimensiunea specificata, apoi citeste valori intregi pentru fiecare element din matrice, verificand ca acestea sa fie in intervalul [0,1000000], si adauga elementele la matricea creata anterior.

Functia PermCol(matrice, n, m) primeste ca parametri matricea citita anterior, precum si numarul de linii si coloane, si permuta fiecare coloana a matricei astfel incat primul element sa ajunga ultimul si toate celelalte elemente sa se deplaseze cu o pozitie spre stanga. Rezultatul permutarii este afisat apoi la consola.

In final, functiile sunt apelate in ordinea: citire_lin_col() pentru a citi dimensiunile matricei, citeste_valori_matrice(lin, col) pentru a citi valorile matricei, si PermCol(matrice, n, m) pentru a permuta si afisa matricea rezultata.

0766 - Nr Pare

2023-04-19T12:59:50Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/766/nrpare]
== Cerință ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Determinați indicele liniei care conține număr maxim de elemente pare. Dacă există mai multe linii cu număr maxim de elemente pare, se vor afișa toți indicii, în ordine crescătoare.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi '''n*m''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.", Programul afișează pe ecran indicii liniilor cu număr maxim de elemente pare, în ordine crescătoare, separați prin câte un spaţiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* 1 ≤ m,n ≤ 100
* elementele matricei vor fi mai mici decât '''10000'''
* liniile matricei au indici de la '''1''' la '''n'''.
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 4 6
: 4 20 15 23 18 9
: 1 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Date de ieșire
: 2 4
==== explicatie ====
Liniile '''2''' și '''4''' din matrice conțin număr maxim de elemente pare, '''4'''
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if 1 <= n <= 100 and 1 <= m <= 100:
print("Datele sunt corecte.")
return n, m
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
for i in range(3):
try:
n = int(input(f"Introduceti un numar pentru linia {linie+1}, coloana {coloana+1}: "))
if n <= 10000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
else:
print("Prea multe incercari esuate.")
exit()
return matrice

def elemente_pare_numar_max(matrice, n, m):
max_contor = 0
max_linii = []
for i in range(n):
contor = sum(1 for x in matrice[i] if x % 2 == 0)
if contor > max_contor:
max_contor = contor
max_linii = [i+1]
elif contor == max_contor:
max_linii.append(i+1)

if max_contor == 0:
print("NU EXISTA")
else:
print(*max_linii)
if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
elemente_pare_numar_max(matrice, n, m)
</syntaxhighlight>
== Explicatii ==
Funcția citire_lin_col() citește de la tastatură numărul de linii n și de coloane m ale matricei. Se verifică dacă valorile citite se încadrează în intervalul [1, 100]. Dacă valorile sunt corecte, funcția returnează valorile citite.

Funcția citeste_valori_matrice(lin, col) citește de la tastatură valorile matricei. Se verifică dacă fiecare valoare este un număr întreg și se încadrează în intervalul [1, 10000]. Dacă o valoare introdusă nu respectă restricțiile, utilizatorul este avertizat și i se cere să introducă o nouă valoare. Dacă utilizatorul nu poate introduce o valoare corectă după trei încercări, programul se va opri. Funcția returnează matricea completată.

Funcția elemente_pare_numar_max(matrice, n, m) determină indicele liniei care conține cele mai multe elemente pare în matrice. Se verifică dacă matricea are cel puțin un element par. Dacă matricea nu are elemente pare, se va afișa mesajul "NU EXISTA". Altfel, se va afișa indicele/indicii liniilor care conțin cele mai multe elemente pare, în ordine crescătoare.

Funcția main() este punctul de intrare în program. Se citesc dimensiunile matricei și valorile acesteia utilizând funcțiile citire_lin_col() și citeste_valori_matrice(). Apoi, se determină indicele/indicii liniilor care conțin cele mai multe elemente pare în matrice utilizând funcția elemente_pare_numar_max().

0768 - Suma Pare 3

2023-04-19T12:47:44Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/768/sumapare3]
== Cerință ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Determinați suma valorilor pare distincte din matrice. Dacă o valoare pară apare în matrice de mai multe ori, se va aduna o singură dată.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi '''n*m'''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.", Programul afișează pe ecran suma căutată S. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n ≤ 100'''
* elementele matricei vor fi mai mici sau egale cu '''10000'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
:4 6
:4 20 15 23 18 9
:1 8 23 22 14 18
:17 15 13 18 12 15
:3 18 8 20 12 5
; Date de ieșire
: 98
=== Exemplu 2 ===
; Date de intrare
: a v
; Date de ieșire
: Datele nu sunt comform restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if 1 <= n <= 100 and 1 <= m <= 100:
print("Datele sunt corecte.")
return n, m
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
for i in range(3):
try:
n = int(input(f"Introduceti un numar pentru linia {linie+1}, coloana {coloana+1}: "))
if n <= 10000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
else:
print("Prea multe incercari esuate.")
exit()
return matrice

def elemente_pare(matrice, n, m):
numere_pare= set()
for i in range(n):
for j in range(m):
if matrice[i][j] % 2 == 0:
numere_pare.add(matrice[i][j])

print(sum(numere_pare))

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
s=elemente_pare(matrice, n, m)
print(s)
</syntaxhighlight>
== Explicatii ==
Acest cod definește trei funcții:

citire_lin_col(): Această funcție primește de la utilizator numărul de linii și de coloane pentru o matrice și verifică dacă acestea se încadrează în limitele impuse. Dacă valorile introduse sunt valide, funcția returnează aceste valori.

citeste_valori_matrice(lin, col): Această funcție primește numărul de linii și de coloane pentru o matrice și primește de la utilizator valorile matricei. Pentru fiecare element al matricei, utilizatorul este rugat să introducă un număr. Se vor face trei încercări de a introduce un număr valid. Dacă utilizatorul introduce un număr valid, valoarea este adăugată la matrice și se trece la următorul element. Dacă după trei încercări utilizatorul nu a introdus un număr valid, programul se oprește.

elemente_pare(matrice, n, m): Această funcție primește o matrice și numărul de linii și de coloane ale acesteia. Funcția calculează suma tuturor numerelor pare din matrice și o returnează.

În main(), se folosesc aceste funcții pentru a citi matricea și a calcula suma numerelor pare din matrice, care este apoi afișată.

0804 - Col Egale

2023-04-19T12:39:44Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/804/colegale]
== Cerință ==
Se dă o matrice cu '''m''' linii şi '''n''' coloane şi elemente numere naturale cu cel mult 4 cifre fiecare. Să se determine coloanele matricei care au toate elementele egale cu aceeași valoare.
== Date de intrare ==
Programul citește de la tastatură numerele '''m''' şi '''n''', iar apoi '''m*n''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.", Programul afișează pe ecran pentru fiecare coloană cu toate elementele egale, valoarea comună. Valorile afișate vor fi separate prin câte un spațiu, iar dacă nu există coloane cu toate elementele egale, se va afișa nu exista. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* 2 ≤ m,n ≤ 50
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
:4 5
:2 3 7 5 7
:3 3 7 4 7
:7 3 7 1 7
:8 3 7 6 7
; Date de ieșire
: 3 7 7
=== Exemplu 2 ===
; Date de intrare
: 4 1
; Date de ieșire
: Datele nu sunt comform restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if 2 <= n <= 50 and 2 <= m <= 50:
print("Datele sunt corecte.")
return n, m
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
for i in range(3):
try:
n = int(input(f"Introduceti un numar pentru linia {linie+1}, coloana {coloana+1}: "))
if n >= 0:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
else:
print("Prea multe incercari esuate.")
exit()
return matrice

def elemente_egale(matrice, n, m):
found = False
for j in range(m):
col = [matrice[i][j] for i in range(n)]
if len(set(col)) == 1:
print(f"Elementul {col[0]} se afla in coloana {j+1}.")
found = True

if not found:
print("Nu exista coloane cu elemente egale.")

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
elemente_egale(matrice, n, m)
</syntaxhighlight>
== Explicatii ==
Acest cod reprezintă o soluție Python pentru găsirea coloanelor dintr-o matrice care conțin elemente egale.

Funcția citire_lin_col() citește de la tastatură numărul de linii și coloane pentru matricea dată. Se verifică ca numerele introduse să fie întregi și să se încadreze în limitele 2-50, altfel se afișează un mesaj de eroare și programul se închide. Funcția returnează numărul de linii și coloane citite.

Funcția citeste_valori_matrice(lin, col) citește valorile matricei de la tastatură, linie cu linie și coloană cu coloană. Pentru fiecare element se verifică dacă a fost introdus un număr întreg pozitiv și se afișează un mesaj corespunzător. Dacă se încearcă introducerea unui număr invalid de trei ori consecutiv, programul se închide. Funcția returnează matricea.

Funcția elemente_egale(matrice, n, m) caută coloanele care conțin cel puțin două elemente egale. Dacă se găsește o astfel de coloană, se afișează valoarea comună și numărul coloanei corespunzător. În caz contrar, se afișează un mesaj care indică faptul că nu s-au găsit coloane cu elemente egale.

În cadrul blocului if _name_ == "_main_": se apelează funcțiile pentru citirea datelor de intrare și găsirea coloanelor cu elemente egale.

0789 - Max 2 Ap

2023-04-19T12:31:22Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/789/max2ap]
== Cerință ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se determine cea mai mare valoare care apare în matrice de cel puțin două ori.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi '''n*m''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.", Programul afișează pe ecran cea mai mare valoare care apare în matrice de cel puțin două ori. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* 1 ≤ '''m,n''' ≤ 1000
* elementele matricei vor fi mai mici decât '''1.000.000'''
* dacă în matrice nu se repeta nici o valoare se va afișa '''IMPOSIBIL'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
:4 6
:4 70 15 23 38 9
:1 8 23 23 14 18
:17 15 13 38 12 15
:3 18 8 23 12 5
; Date de ieșire
: 38
=== Exemplu 2 ===
; Date de intrare
: 3 4
: 1 2 3 4
: 5 6 7 8
: 9 10 11 12
; Date de ieșire
: IMOSIBIL
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if 1 <= n <= 100 and 1 <= m <= 100:
print("Datele sunt corecte.")
return n,m
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if n <= 1000000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def elemente_maxime_duble(matrice):
seen = set()
max_duplicat = None
for i in range(n):
for j in range(m):
valoare = matrice[i][j]
if valoare in seen and (max_duplicat is None or valoare > max_duplicat):
max_duplicat = valoare
else:
seen.add(valoare)

if max_duplicat is None:
print("IMPOSIBIL")
else:
print(max_duplicat)

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
elemente_maxime_duble(matrice)
</syntaxhighlight>
== Explicatii ==
citire_lin_col(): aceasta functie solicita utilizatorului sa introduca numarul de linii si numarul de coloane ale matricei. Daca valorile introduse sunt corecte (intre 1 si 100), functia va returna n si m. Altfel, se va afisa un mesaj de eroare si programul va iesi din executie. Aceasta functie este utilizata pentru a citi dimensiunile matricei.

citeste_valori_matrice(lin, col): aceasta functie solicita utilizatorului sa introduca valorile matricei pentru fiecare element in parte. Utilizatorul este intrebat sa introduca un numar, iar daca valoarea este corecta (mai mica sau egala cu 1.000.000), numarul este adaugat la matrice. Daca valoarea este incorecta, se va afisa un mesaj de eroare si se va cere introducerea unui alt numar. Aceasta functie este utilizata pentru a citi valorile din matrice.

elemente_maxime_duble(matrice): aceasta functie cauta valoarea maxima care apare cel putin de doua ori in matrice. Pentru a face acest lucru, se foloseste un set pentru a tine evidenta valorilor deja intalnite. In timpul iterarii prin matrice, se verifica daca valoarea curenta este deja prezenta in set. Daca da, aceasta este comparata cu valoarea maxima duplicata gasita pana in acel moment si se actualizeaza valoarea maxima daca este cazul. Daca nu, valoarea este adaugata la set. Daca nu exista valori duplicate, se va afisa "IMPOSIBIL". Altfel, se va afisa valoarea maxima duplicata gasita.

In functia main(), se citesc dimensiunile matricei, se citesc valorile matricei si se cauta valoarea maxima duplicata. Rezultatul functiei elemente_maxime_duble(matrice) este afisat direct in functie, astfel ca nu este necesar sa stocam valoarea intoarsa de aceasta functie intr-o variabila.

0779 - Vecini Pari

2023-04-19T12:16:46Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/779/vecinipari]
== Cerință ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se determine câte elemente din matrice au toți vecinii numere pare.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi '''n*m''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte." Programul afișează pe ecran numărul '''C''', reprezentând valoarea determinată. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* 1 ≤ '''m,n''' ≤ 100
* elementele matricei vor fi mai mici decât '''1.000.000'''
* un element al matricei are cel mult patru vecini: pe linia anterioară și aceeași coloană, pe linia următoare și aceeași coloană, pe aceeași linie și coloana anterioară, pe aceeași linie și coloana următoare.
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
:4 7
:15 27 40 41 32 42 12
:48 35 40 54 17 46 32
:37 52 40 18 11 46 23
:49 27 40 29 25 44 12
; Date de ieșire
:5
=== Exemplu 2 ===
; Date de intrare
: 2 2
: 1 3
: 4 5
; Date de ieșire
: Datele nu sunt comform restricțiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if 1 <= n <= 100 and 1 <= m <= 100:
print("Datele sunt corecte.")
return n,m
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if n <= 1000000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def vecini(matrice):
contor = 0
for i in range(n):
for j in range(m):
if i > 0 and matrice[i - 1][j] % 2 == 1: # verificăm vecinul de sus
continue
if i < n - 1 and matrice[i + 1][j] % 2 == 1: # verificăm vecinul de jos
continue
if j > 0 and matrice[i][j - 1] % 2 == 1: # verificăm vecinul din stânga
continue
if j < m - 1 and matrice[i][j + 1] % 2 == 1: # verificăm vecinul din dreapta
continue
contor += 1

print( contor)

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
vecini_elemente = vecini(matrice)
print(vecini_elemente)
</syntaxhighlight>
== Explicatii ==
Acest cod definește trei funcții și apoi le utilizează într-o structură if _name_ == "_main_": pentru a obține numărul de elemente din matrice care sunt "izolate", adică nu au vecini cu numere impare.

Funcția citire_lin_col() citește de la tastatură numărul de linii și coloane ale matricei, verifică dacă acestea se află în intervalul [1, 100], și returnează aceste valori dacă sunt valide.

Funcția citeste_valori_matrice(lin, col) citește valorile matricei de la tastatură, verificând dacă fiecare valoare se află în intervalul [1, 1000000], și le adaugă la matricea returnată.

Funcția vecini(matrice) numără numărul de elemente din matrice care nu au vecini cu numere impare. Pentru fiecare element din matrice, funcția verifică dacă vecinul de sus, cel de jos, cel din stânga sau cel din dreapta este un număr impar, iar dacă da, trece la următorul element. Dacă niciun vecin al elementului curent nu este impar, contorul de elemente izolate este incrementat. La final, funcția afișează numărul de astfel de elemente.

În if _name_ == "_main_":, se citește numărul de linii și coloane ale matricei, se citește matricea de la tastatură, se calculează numărul de elemente izolate și se afișează.

0778 - MChenar

2023-04-19T12:07:09Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/778/mchenar]
== Cerință ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se determine mulțimea formată din elementele distincte ale chenarului matricei.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi '''n*m''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.", Programul afișează pe ecran elementele mulțimii determinate, în ordine strict crescătoare, separate printr-un spațiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* 1 ≤ '''m,n''' ≤ 100
* elementele matricei vor fi mai mici decât '''1.000.000'''
* chenarul matricei este format din elementele situate pe prima linie, prima coloană, ultima linie, ultima coloană
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
:4 7
:15 27 40 41 32 42 12
:48 35 40 54 17 46 33
:37 52 40 19 11 46 23
:49 27 40 29 25 44 12
; Date de ieșire
: 12 15 23 25 27 29 32 33 37 40 41 42 44 48 49
=== Exemplu 2 ===
; Date de intrare
: 2 3
; Date de ieșire
: Datele nu sunt conform restrictiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 3 <= lin <= 100 and 3 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 3 <= n <= 100:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def elemente(matrice):
elemente_margini = set()
for element in matrice[0]:
elemente_margini.add(element)
for element in matrice[-1]:
elemente_margini.add(element)
for i in range(1, len(matrice) - 1):
elemente_margini.add(matrice[i][0])
elemente_margini.add(matrice[i][-1])
return sorted(elemente_margini)

if name == "main":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
bordura_elemente = elemente(matrice)
print(bordura_elemente)
</syntaxhighlight>
== Explicatii ==
citire_lin_col(): Această funcție cere utilizatorului să introducă numărul de linii și coloane ale matricei și verifică dacă numerele sunt corecte. Dacă numerele sunt în intervalul [3, 100], funcția va returna aceste valori. În caz contrar, programul va fi oprit prin apelarea funcției exit().

citeste_valori_matrice(lin, col): Această funcție primește ca parametri numărul de linii și coloane și întoarce o matrice cu aceste dimensiuni. Utilizatorul este invitat să introducă un număr pentru fiecare celulă din matrice, iar funcția verifică dacă numărul este în intervalul [3, 100]. În caz contrar, utilizatorul va fi invitat să reintroducă numărul până când acesta este valid.

citeste_numar_x(): Această funcție solicită utilizatorului să introducă un număr și verifică dacă acesta se încadrează în intervalul [3, 100]. În caz contrar, utilizatorul va fi invitat să reintroducă numărul până când acesta este valid.

elemente(matrice): Această funcție primește o matrice și determină elementele marginale (primele și ultimele elemente ale primei și ultimei linii și primele și ultimele elemente ale primei și ultimei coloane) ale matricei și le întoarce sub formă de set. De asemenea, setul este sortat în ordine crescătoare înainte de a fi întors.

În if _name_ == "_main_": se folosește cele trei funcții precedente pentru a citi matricea, a determina elementele marginale și a afișa aceste elemente în ordine crescătoare.

2825 - Chenar 2

2023-04-19T11:55:22Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/2825/chenar2]
== Cerință ==
Scrieți un program C/C++ care citește de la tastatură numere naturale din intervalul '''[3, 100]''', în această ordine: '''n''' și '''m''', apoi elementele unui tablou bidimensional cu '''n''' linii și '''m''' coloane, iar la final un număr '''x'''.

Programul afișează pe ecran mesajul '''DA''', dacă există cel puțin un element egal cu '''x''' aflat pe conturul tabloului (format din prima linie, ultima linie, prima coloană și ultima coloană), sau mesajul '''NU''' în caz contrar.
== Date de intrare ==
Programul citește de la tastatură de la tastatură numere naturale '''n''' și '''m''', apoi elementele unui tablou bidimensional cu '''n''' linii și '''m''' coloane, iar la final un număr '''x'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.", Programul va afișa pe ecran mesajul DA sau mesajul NU, conform cerinței. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
*toate valorile citite sunt numere naturale din intervalul '''[3, 100]'''.
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
:4 5
:12 5 12 11 4
:3 20 10 20 12
:4 5 30 12 6
:8 13 7 12 14
:12
; Date de ieșire
:DA
=== Exemplu 2 ===
; Date de intrare
: 3 2
; Date de ieșire
: NU, Datele nu sunt comform restricțiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 3 <= lin <= 100 and 3 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 3 <= n <= 100:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def citeste_numar_x():
while True:
try:
x = int(input("Introduceti numarul : "))
if 3 <= x <= 100:
print("Datele sunt corecte.")
return x
else :
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def element(matrice, n, m, x):
for i in range(n):
for j in range(m):
if i == 0 or i == n - 1 or j == 0 or j == m - 1:
if matrice[i][j] == x:
print("DA")
return
print("NU")

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
x = citeste_numar_x()
element(matrice, n, m, x)
</syntaxhighlight>
== Explicatii ==
Acest cod implementează o funcție pentru a căuta un anumit element x în matricea dată. Funcția primește matricea, numărul de linii și coloane ale acesteia și numărul căutat.

În primul rând, funcția citire_lin_col solicită introducerea numărului de linii și coloane, verifică dacă acestea sunt în intervalul [3,100], afișează un mesaj corespunzător și returnează valorile introduse.

Apoi, funcția citeste_valori_matrice primește numărul de linii și coloane și construiește matricea prin adăugarea de elemente la fiecare iterație a buclei. Se verifică dacă fiecare element este în intervalul [3,100], iar dacă acesta nu este valid, se va afișa un mesaj corespunzător.

Funcția citeste_numar_x solicită introducerea numărului căutat, verifică dacă acesta este în intervalul [3,100], afișează un mesaj corespunzător și returnează valoarea introdusă.

În cele din urmă, funcția element primește matricea, numărul de linii și coloane ale acesteia și numărul căutat. Se parcurge matricea și se caută elementul x pe marginea matricei (primele și ultimele linii și coloane). Dacă x este găsit pe una dintre margini, se afișează "DA" și se returnează. Dacă nu este găsit pe nicio margine, se afișează "NU".

În if _name_ == "_main_":, se apelează funcțiile pentru a efectua căutarea elementului x în matricea dată.

0777 - Cnt Coloane

2023-04-19T11:47:02Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/777/cntcoloane]
== Cerință ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se determine câte coloane ale matricei au elementele distincte două câte două.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi '''n*m''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.", Programul afișează pe ecran numărul '''C''', cu semnificația de mai sus. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* 1 ≤ '''m,n''' ≤ 1000
* elementele matricei vor fi mai mici decât '''1.000.000'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
:4 7
:15 27 40 41 32 42 12
:48 35 40 54 17 46 33
:37 52 40 19 11 46 23
:49 27 40 29 25 44 12
;Date de ieșire
: 3
=== Exemplu 2 ===
; Date de intrare
: 0
;Date de ieșire
: Datele nu sunt comform restricțiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 1000000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def elemente_distincte(matrice):
contor = 0
n = len(matrice)
for col in range(len(matrice[0])):
# folosim set pentru a elimina elementele duplicate din coloana
if len(set(matrice[lin][col] for lin in range(n))) == n:
contor += 1
return contor

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
nr_col_distincte = elemente_distincte(matrice)
print(f"Numarul de coloane cu toate elementele distincte doua cate doua este {nr_col_distincte}")
</syntaxhighlight>
== Explicatii ==
Funcția citire_lin_col() este utilizată pentru a citi numărul de linii și de coloane ale matricei, verificând dacă acestea sunt între 1 și 100. Dacă input-ul este invalid, se va afișa un mesaj corespunzător și se va opri programul cu ajutorul funcției exit().
Funcția citeste_valori_matrice(lin, col) este utilizată pentru a citi valorile matricei de la tastatură, verificând dacă acestea sunt mai mici decât 1.000.000. Dacă input-ul este invalid, se va afișa un mesaj corespunzător, dar citirea valorii respective va continua până când se va introduce un input valid. Funcția returnează matricea citită.
Funcția elemente_distincte(matrice) primește matricea și determină numărul de coloane ale matricei care au toate elementele distincte două câte două. Pentru fiecare coloană, se creează o listă cu elementele respective, iar apoi se verifică dacă toate elementele din lista respectivă sunt distincte. Dacă da, se va incrementa un contor. La final, funcția returnează valoarea acestui contor.
În blocul if _name_ == "_main_": se apelează funcțiile pentru a citi matricea și pentru a calcula numărul de coloane cu toate elementele distincte. Acest număr este afișat pe ecran cu ajutorul funcției print().

0776 - Cnt Linii

2023-04-19T11:39:41Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/776/cntlinii]
== Cerință ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se determine câte linii ale matricei au toate elementele egale.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi '''n*m''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.", Programul afișează pe ecran numărul '''C''', cu semnificația de mai sus. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* 1 ≤ '''m,n''' ≤ 100
*elementele matricei vor fi mai mici decât '''1.000.000'''
== Exemple ==
=== Exemplu 1 ===
;Date de intrare
:4 6
:23 23 15 23 18 23
:17 17 17 17 17 17
:17 18 13 18 12 15
:34 34 34 34 34 34
;Date de ieșire
: 2
=== Exemplu 2 ===
;Date de intrare
:0
;Date de ieșire
Datele nu sunt comform restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 1000000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def lini_egale(matrice):
contor = 0
for lin in matrice:
# verificam daca toate elementele din linie sunt egale cu primul element
if all(element == lin[0] for element in lin):
contor += 1
return contor

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
nr_lini_ega = lini_egale(matrice)
print(f"Numarul de linii cu toate elementele egale este {nr_lini_ega}")
</syntaxhighlight>
== Explicati ==
Acest cod este scris în limbajul de programare Python și conține trei funcții:
Funcția citire_lin_col() primește de la utilizator numărul de linii și coloane ale unei matrice și le validează pentru a se asigura că respectă restricțiile impuse (valorile trebuie să fie între 1 și 100 inclusiv). Dacă datele sunt corecte, funcția returnează numărul de linii și de coloane introduse de utilizator. Dacă valorile introduse nu sunt valide sau utilizatorul introduce caractere diferite de numere întregi, programul se oprește cu ajutorul funcției exit().
Funcția citeste_valori_matrice(lin, col) primește numărul de linii și coloane ale matricei și le folosește pentru a citi valorile fiecărei celule a matricei de la utilizator. Funcția validează datele introduse pentru a se asigura că sunt numere întregi și că respectă restricțiile impuse (valorile trebuie să fie între 0 și 1.000.000 inclusiv). Dacă valorile introduse nu sunt valide, programul va solicita introducerea de noi valori până când se vor introduce date valide. Funcția returnează matricea formată din valorile introduse.
Funcția lini_egale(matrice) primește o matrice și numără câte linii din matrice au toate elementele egale cu primul element al liniei respective. Funcția returnează numărul de linii cu această caracteristică.
În funcția main, programul apelează cele trei funcții și afișează numărul de linii din matrice cu toate elementele egale cu primul element al liniei respective.

0772 - Max Ap

2023-04-19T11:29:27Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/772/maxap]
== Cerință ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se determine elementul cu număr maxim de apariții în matrice. Dacă există mai multe elemente cu număr maxim de apariții se vor afișa toate, în ordine crescătoare.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi '''n*m''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.", Programul afișează pe ecran elementele cu număr maxim de apariții se vor afișa toate, în ordine crescătoare, separate printr-un spațiu.
În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* 1 ≤ '''m,n''' ≤ 100
* elementele matricei vor fi mai mici decât '''1.000.000'''
== Exemple ==
=== Exemplu 1 ===
;Date de intrare
:4 6
:4 20 15 23 18 9
:1 8 23 23 14 18
:17 15 13 18 12 15
:3 18 8 23 12 5
;Date de ieșire
:18 23
=== Exemplu 2 ===
;Date de intrare
:a b
;Date de ieșire
:Datele nu sunt comform restricțiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 1000000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def maxim_apariti(matrice):
contor = {} # initializam un dictionar pentru a numara aparitiile elementelor
max_contor = 0 # initializam numarul maxim de aparitii la 0

for linie in matrice:
for elem in linie:
if elem in contor:
contor[elem] += 1 # incrementam numarul de aparitii pentru un element existent
else:
contor[elem] = 1 # adaugam un element nou in dictionar cu numarul de aparitii initializat la 1
if contor[elem] > max_contor:
max_contor = contor[elem] # actualizam numarul maxim de aparitii

max_elems = sorted([elem for elem, contor in contor.items() if contor == max_contor])
return max_elems
if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
matrice_ordonata = maxim_apariti(matrice)
print("Elementele cu număr maxim de apariții sunt:", matrice_ordonata)
</syntaxhighlight>
== Explicații ==
Acest cod este o implementare Python a unei funcționalități care primește de la utilizator o matrice cu dimensiuni specifice și apoi identifică elementele care apar de cele mai multe ori în matrice. Mai precis, programul are trei funcții distincte:

Funcția "citire_lin_col()" primește de la utilizator numărul de linii și coloane ale matricei, asigurându-se că acestea respectă condițiile de a fi întregi și să se încadreze între 1 și 100. În caz contrar, programul afișează un mesaj de eroare și se oprește prin utilizarea funcției "exit()".

Funcția "citeste_valori_matrice(lin, col)" cere utilizatorului să introducă valorile matricei. Aceasta primește dimensiunile matricei, după care primește câte un element pe rând și îl adaugă la matricea creată. Funcția verifică, de asemenea, dacă numerele introduse sunt întregi și respectă condițiile de a fi cuprinse între 0 și 1.000.000, și afișează un mesaj de eroare în cazul în care introducerea nu este validă.

Funcția "maxim_apariti(matrice)" identifică elementele din matrice care apar cel mai frecvent. Folosind un dicționar, se numără de câte ori apare fiecare element, iar apoi se determină numărul maxim de apariții. Se întorc apoi toate elementele care apar de număr maxim de ori, sortate în ordine crescătoare.

În secțiunea principală a codului, se apelează cele trei funcții în ordine, după care se afișează elementele identificate de funcția "maxim_apariti(matrice)".

0659 - Suma Linii 1

2023-04-04T18:01:22Z

Andor Giulia: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/659/sumalinii1 0659 - Suma Linii 1]
----
== Cerinţa ==
Se dă o '''matrice''' cu '''lin''' linii şi '''col''' coloane şi elemente numere naturale. Să se determine pentru fiecare linie, cea mai mică valoare care se poate obține adunând elementele de pe linie, cu excepția unuia.
== Date de intrare ==
Programul citește de la tastatură numerele '''lin''' şi '''col''', iar apoi ''lin * col'' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.", urmat, pe rândul următor, de '''lin''' numere, separate prin câte un spațiu reprezentând valorile obținute pentru fiecare linie, de sus în jos. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''lin''', '''col''' ∈ ℕ
* 1 &les; '''lin''', '''col''' &les; 100
* ''element matrice'' ∈ ℕ
* 0 &les; ''element matrice'' < 1.000.000
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 3 4
: 5 5 10 5
: 3 9 1 9
: 4 10 1 2
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 15 13 7
=== Exemplu 2 ===
; Intrare
: 3 5
: 4 20 15 23 18 9
: 63.5 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
=== Exemplu 3 ===
; Intrare
: 2 -25
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 10_000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def suma_linie(matrice):
sume = []
for i, linie in enumerate(matrice):
# eliminam un element din linie si calculam suma
min_suma = sum(linie) - max(linie)
sume.append(min_suma)
return sume

if __name__ == "__main__":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
sume = suma_linie(matrice)
for i, min_suma in enumerate(sume):
print(f"Cea mai mica valoare obtinuta prin adunarea elementelor de pe linia {i + 1}, cu exceptia unuia, este {min_suma}.")
</syntaxhighlight>
== Explicații ==
Acest cod are ca scop citirea unei matrice de dimensiune specificată de utilizator, calcularea sumei minime pe fiecare linie a matricei, cu excepția unui singur element, și afișarea acestor sume pentru fiecare linie a matricei.

Funcția citire_lin_col primește de la utilizator numărul de linii și coloane pe care le va avea matricea. Se verifică ca numărul de linii și coloane să fie între 1 și 100, iar în caz contrar se afișează un mesaj de eroare și programul se închide. Dacă valorile introduse de utilizator sunt corecte, se afișează un mesaj de confirmare și se returnează numărul de linii și coloane.

Funcția citeste_valori_matrice primește numărul de linii și coloane ale matricei și cere utilizatorului să introducă valorile pentru fiecare element al matricei. Se verifică ca valorile introduse să fie între 0 și 10.000, iar în caz contrar se cere introducerea unor noi valori până când acestea respectă condiția. Valorile corecte sunt adăugate în matrice și aceasta este returnată.

Funcția suma_linie primește matricea și calculează suma minimă a elementelor de pe fiecare linie a matricei, cu excepția elementului maxim. Rezultatele sunt stocate într-o listă și aceasta este returnată.

În cadrul secțiunii if _name_ == "_main_":, programul citeste numărul de linii și coloane ale matricei, apoi valorile acesteia. În continuare se calculează și se afișează sumele minime pentru fiecare linie a matricei, cu excepția elementului maxim.

0659 - Suma Linii 1

2023-04-04T17:59:10Z

Andor Giulia:

Sursa: [https://www.pbinfo.ro/probleme/659/sumalinii1 0659 - Suma Linii 1]
----
== Cerinţa ==
Se dă o '''matrice''' cu '''lin''' linii şi '''col''' coloane şi elemente numere naturale. Să se determine pentru fiecare linie, cea mai mică valoare care se poate obține adunând elementele de pe linie, cu excepția unuia.
== Date de intrare ==
Programul citește de la tastatură numerele '''lin''' şi '''col''', iar apoi ''lin * col'' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.", urmat, pe rândul următor, de '''lin''' numere, separate prin câte un spațiu reprezentând valorile obținute pentru fiecare linie, de sus în jos. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''lin''', '''col''' ∈ ℕ
* 1 &les; '''lin''', '''col''' &les; 100
* ''element matrice'' ∈ ℕ
* 0 &les; ''element matrice'' < 1.000.000
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 3 4
: 5 5 10 5
: 3 9 1 9
: 4 10 1 2
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 15 13 7
=== Exemplu 2 ===
; Intrare
: 3 5
: 4 20 15 23 18 9
: 63.5 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
=== Exemplu 3 ===
; Intrare
: 2 -25
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 10_000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def suma_linie(matrice):
sume = []
for i, linie in enumerate(matrice):
# eliminam un element din linie si calculam suma
min_suma = sum(linie) - max(linie)
sume.append(min_suma)
return sume

if __name__ == "__main__":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
sume = suma_linie(matrice)
for i, min_suma in enumerate(sume):
print(f"Cea mai mica valoare obtinuta prin adunarea elementelor de pe linia {i + 1}, cu exceptia unuia, este {min_suma}.")
</syntaxhighlight>
== Rezolvare ==
Acest cod are ca scop citirea unei matrice de dimensiune specificată de utilizator, calcularea sumei minime pe fiecare linie a matricei, cu excepția unui singur element, și afișarea acestor sume pentru fiecare linie a matricei.

Funcția citire_lin_col primește de la utilizator numărul de linii și coloane pe care le va avea matricea. Se verifică ca numărul de linii și coloane să fie între 1 și 100, iar în caz contrar se afișează un mesaj de eroare și programul se închide. Dacă valorile introduse de utilizator sunt corecte, se afișează un mesaj de confirmare și se returnează numărul de linii și coloane.

Funcția citeste_valori_matrice primește numărul de linii și coloane ale matricei și cere utilizatorului să introducă valorile pentru fiecare element al matricei. Se verifică ca valorile introduse să fie între 0 și 10.000, iar în caz contrar se cere introducerea unor noi valori până când acestea respectă condiția. Valorile corecte sunt adăugate în matrice și aceasta este returnată.

Funcția suma_linie primește matricea și calculează suma minimă a elementelor de pe fiecare linie a matricei, cu excepția elementului maxim. Rezultatele sunt stocate într-o listă și aceasta este returnată.

În cadrul secțiunii if _name_ == "_main_":, programul citeste numărul de linii și coloane ale matricei, apoi valorile acesteia. În continuare se calculează și se afișează sumele minime pentru fiecare linie a matricei, cu excepția elementului maxim.

0316 - Min Cols 2

2023-04-04T17:58:46Z

Andor Giulia:

== Rezolvare ==
<syntaxhighlight lang="python" line>
m, n = map(int, input().split())
a = []
for i in range(m):
row = list(map(int, input().split()))
a.append(row)

# determinarea valorii minime din matrice
min_val = 10000
for i in range(m):
for j in range(n):
if a[i][j] < min_val:
min_val = a[i][j]

# înlocuirea elementelor de pe coloanele care conțin valoarea minimă cu valoarea minimă
for j in range(n):
col_min = 10000
for i in range(m):
if a[i][j] < col_min:
col_min = a[i][j]
if col_min == min_val:
for i in range(m):
a[i][j] = min_val

# afișarea matricei modificate
for i in range(m):
for j in range(n):
print(a[i][j], end=' ')
print()
</syntaxhighlight>

0316 - Min Cols 2

2023-04-04T17:57:37Z

Andor Giulia: Pagină nouă: == Rezolvare == # citirea datelor de intrare m, n = map(int, input().split()) a = [] for i in range(m): row = list(map(int, input().split())) a.append(row) # determinarea valorii minime din matrice min_val = 10000 for i in range(m): for j in range(n): if a[i][j] < min_val: min_val = a[i][j] # înlocuirea elementelor de pe coloanele care conțin valoarea minimă cu valoarea minimă for j in range(n): col_min = 10000 for i in range(m):...

== Rezolvare ==
# citirea datelor de intrare
m, n = map(int, input().split())
a = []
for i in range(m):
row = list(map(int, input().split()))
a.append(row)

# determinarea valorii minime din matrice
min_val = 10000
for i in range(m):
for j in range(n):
if a[i][j] < min_val:
min_val = a[i][j]

# înlocuirea elementelor de pe coloanele care conțin valoarea minimă cu valoarea minimă
for j in range(n):
col_min = 10000
for i in range(m):
if a[i][j] < col_min:
col_min = a[i][j]
if col_min == min_val:
for i in range(m):
a[i][j] = min_val

# afișarea matricei modificate
for i in range(m):
for j in range(n):
print(a[i][j], end=' ')
print()

0771 - Ord Lin

2023-04-04T17:36:12Z

Andor Giulia:

Sursa: [https://www.pbinfo.ro/probleme/771/ordlin 0771 - Ord Lin]
----
== Cerinţa ==
Se dă o '''matrice''' cu '''lin''' linii şi '''col''' coloane şi elemente numere naturale. Să se ordoneze liniile matricei crescător după suma elementelor.
== Date de intrare ==
Programul citește de la tastatură numerele '''lin''' şi '''col''', iar apoi ''lin * col'' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.", urmat, pe rândul următor, de '''lin''' numere, separate prin câte un spațiu reprezentând valorile obținute pentru fiecare linie, de sus în jos. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''lin''', '''col''' ∈ ℕ
* 1 &les; '''lin''', '''col''' &les; 100
* ''element matrice'' ∈ ℕ
* 0 &les; ''element matrice'' < 1.000.000
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 4 6
: 4 20 15 23 18 9
: 1 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 3 18 8 20 12 5
: 1 8 23 22 14 18
: 4 20 15 23 18 9
: 17 15 13 18 12 15
=== Exemplu 2 ===
; Intrare
: 3 5
: 4 20 15 23 18 9
: 63.5 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
=== Exemplu 3 ===
; Intrare
: 2 -25
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 1000000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def ord_lin(matrice):
sorted_matrix = sorted(matrice, key=lambda row: sum(row))
return sorted_matrix

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
matrice_ordonata = ord_lin(matrice)
print("Matricea ordonată după suma elementelor de pe fiecare linie:", matrice_ordonata)
</syntaxhighlight>
== Explicații ==
Acest cod definește trei funcții. Funcția "citire_lin_col" primește numărul de linii și coloane ale unei matrice și verifică dacă valorile introduse se încadrează în anumite restricții, apoi le returnează. Funcția "citeste_valori_matrice" primește dimensiunile matricei și citeste valorile elementelor acesteia, verificând dacă se încadrează într-un anumit interval de valori și returnând matricea completată. Funcția "ord_lin" primește o matrice și returnează aceeași matrice, dar cu liniile ordonate descrescător în funcție de suma elementelor de pe fiecare linie.

În cadrul buclei principale, se apelează funcția "citire_lin_col" pentru a obține dimensiunile matricei, apoi funcția "citeste_valori_matrice" pentru a completa matricea cu valorile corespunzătoare, iar apoi se apelează funcția "ord_lin" pentru a ordona liniile matricei. La final, se afișează matricea ordonată.

0666 - Nr Prime

2023-04-04T17:28:28Z

Andor Giulia:

Sursa: [https://www.pbinfo.ro/probleme/666/nrprime 0666 - Nr Prime]
----
== Cerinţa ==
Se dă o '''matrice''' cu '''lin''' linii şi '''col''' coloane şi elemente numere naturale. Să se determine câte dintre elementele situate pe linii cu indici pari sunt prime.
== Date de intrare ==
Programul citește de la tastatură numerele '''lin''' şi '''col''', iar apoi ''lin * col'' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.", urmat, pe rândul următor, de '''lin''' numere, separate prin câte un spațiu reprezentând valorile obținute pentru fiecare linie, de sus în jos. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''lin''', '''col''' ∈ ℕ
* 1 &les; '''lin''', '''col''' &les; 100
* ''element matrice'' ∈ ℕ
* 0 &les; ''element matrice'' < 1.000.000
* liniile matricei sunt numerotate de 1 la n, iar coloanele de la 1 la m
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 4 3
: 5 12 10
: 3 9 1
: 7 10 1
: 10 9 3
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 2
=== Exemplu 2 ===
; Intrare
: 3 5
: 4 20 15 23 18 9
: 63.5 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
=== Exemplu 3 ===
; Intrare
: 2 -25
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 1000000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def is_prime(numar):
if numar > 1:
for divizor in range(2, int(numar / 2) + 1):
if numar % divizor == 0:
return False
else:
return True
else:
return False

def prime(matrice):
k = 0
for i, linie in enumerate(matrice):
if i % 2 == 0:
for numar in linie:
if is_prime(numar):
k += 1
return k

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
k = prime(matrice)
print("Numarul de elemente situate pe linii cu indici pari care sunt prime este:", k)
</syntaxhighlight>
== Explicații ==
Acest cod Python definește o serie de funcții care citesc o matrice de numere întregi de la utilizator și determină câte numere prime sunt pe linii cu indici pari. Mai exact:

Funcția citire_lin_col() cere utilizatorului să introducă numărul de linii și de coloane ale matricei. Aceasta verifică dacă valorile introduse respectă restricțiile impuse (1 <= lin <= 100 și 1 <= col <= 100) și returnează valorile introduse dacă sunt valide, altfel afișează un mesaj de eroare și iese din program.

Funcția citeste_valori_matrice(lin, col) cere utilizatorului să introducă fiecare element al matricei, linie cu linie. Aceasta verifică dacă valorile introduse sunt numere întregi valide (folosind un bloc try-except), apoi verifică dacă sunt în intervalul permis (0 <= n <= 1000000). Dacă valorile sunt valide, ele sunt adăugate în matrice. Funcția returnează matricea creată.

Funcția is_prime(numar) primește un număr întreg și verifică dacă este prim. Funcția folosește o metodă simplă de verificare a divizorilor (încercând toți divizorii între 2 și jumătatea numărului) și returnează True dacă numărul este prim, altfel returnează False.

Funcția prime(matrice) primește matricea creată în pasul 2 și numără câte numere prime sunt pe linii cu indici pari. Aceasta parcurge fiecare linie cu un index (i) și verifică dacă este par (i % 2 == 0). Dacă linia are un index par, fiecare element este verificat cu ajutorul funcției is_prime(). Dacă numărul este prim, k este incrementat cu 1. Funcția returnează k.

În blocul principal if _name_ == "_main_":, se apelează funcțiile definite în ordine, iar rezultatul obținut este afișat utilizatorului.

Astfel, acest cod primește o matrice de la utilizator și numără câte numere prime sunt pe linii cu indici pari.

0658 - Suma Linii

2023-04-04T17:23:49Z

Andor Giulia:

Sursa: [https://www.pbinfo.ro/probleme/658/sumalinii 0658 - Suma Linii]
----
== Cerinţa ==
Se dă o '''matrice''' cu '''lin''' linii şi '''col''' coloane şi elemente numere naturale. Să se determine suma elementelor de pe fiecare linie.
== Date de intrare ==
Programul citește de la tastatură numerele '''lin''' şi '''col''', iar apoi ''lin * col'' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.", urmat, pe rândul următor, de '''lin''' numere, separate prin câte un spațiu reprezentând suma elementelor de pe fiecare linie, de sus în jos. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''lin''', '''col''' ∈ ℕ
* 1 &les; '''lin''', '''col''' &les; 100
* ''element matrice'' ∈ ℕ
* 0 &les; ''element matrice'' < 1.000.000
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 3 4
: 5 5 10 5
: 3 9 1 2
: 4 10 1 2
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 25 15 17
=== Exemplu 2 ===
; Intrare
: 3 5
: 4 20 15 23 18 9
: 63.5 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
=== Exemplu 3 ===
; Intrare
: 2 -25
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 10_000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def suma_linie(matrice):
sume_linii = []
for linie in matrice:
suma = 0
for element in linie:
suma += element
sume_linii.append(suma)
return sume_linii

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
sume = suma_linie(matrice)
for i, suma in enumerate(sume):
print(f"Suma elementelor de pe linia {i + 1} este {suma}.")
</syntaxhighlight>
== Explicații ==
Acest cod definește trei funcții și o secțiune de cod principal care le folosește pentru a citi o matrice de numere întregi și a calcula suma elementelor de pe fiecare linie.

Funcția citire_lin_col() citeste numarul de linii și coloane ale matricei de la utilizator și se asigură că sunt conform restricțiilor impuse: între 1 și 100. Dacă datele introduse de utilizator sunt corecte, funcția returnează aceste valori.

Funcția citeste_valori_matrice(lin, col) citește valorile matricei de la utilizator. Matricea este construită utilizând o listă de liste. Funcția citește fiecare valoare a matricei și se asigură că acestea sunt între 0 și 10.000. Funcția returnează matricea.

Funcția suma_linie(matrice) calculează suma elementelor de pe fiecare linie a matricei. Funcția parcurge fiecare linie a matricei, calculează suma elementelor de pe linie și stochează aceste sume într-o listă. Funcția returnează lista cu sumele elementelor de pe fiecare linie a matricei.

În secțiunea de cod principal, se apelează funcția citire_lin_col() pentru a citi dimensiunile matricei, apoi funcția citeste_valori_matrice() pentru a citi valorile matricei. Acestea sunt stocate în variabila matrice. Apoi, se apelează funcția suma_linie() pentru a calcula suma elementelor de pe fiecare linie a matricei. Rezultatele sunt stocate în lista sume. În final, se parcurge lista sume și se afișează suma elementelor de pe fiecare linie a matricei.

0767 - Suma Pare2

2023-04-04T17:19:54Z

Andor Giulia:

Sursa: [https://www.pbinfo.ro/probleme/767/sumapare2 0767 - Suma Pare 2]
----
== Cerinţa ==
Se dă o '''matrice''' cu '''lin''' linii şi '''col''' coloane şi elemente numere naturale. Determinați suma valorilor pare din '''matrice'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''lin''' şi '''col''', iar apoi ''lin * col'' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.", urmat, pe rândul următor, de suma căutată. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''lin''', '''col''' ∈ ℕ
* 1 &les; '''lin''', '''col''' &les; 100
* ''element matrice'' ∈ ℕ
* 0 &les; ''element matrice'' < 10000
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 4 6
: 4 20 15 23 18 9
: 1 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 192
=== Exemplu 2 ===
; Intrare
: 3 5
: 4 20 15 23 18 9
: 63.5 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
=== Exemplu 3 ===
; Intrare
: 2 -25
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.

== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 10_000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def suma_pare2(matrice):
raspuns = 0
for linie in matrice:
for element in linie:
if element % 2 == 0:
raspuns += element
return raspuns

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
rezultat = suma_pare2(matrice)
print(f"Suma elementelor pare din matrice este {rezultat}.")
</syntaxhighlight>
== Explicații ==
Acest cod este scris in limbajul de programare Python si contine trei functii:

citire_lin_col() - aceasta functie citeste de la tastatura numarul de linii si de coloane ale matricei, verificand daca acestea se incadreaza in intervalul [1, 100]. Daca datele sunt corecte, functia returneaza aceste doua valori.

citeste_valori_matrice() - aceasta functie creeaza o matrice goala si citeste de la tastatura valorile fiecarui element din matrice, verificand daca fiecare valoare este in intervalul [0, 10000]. Daca datele sunt corecte, functia adauga valoarea citita la matrice. Functia ruleaza intr-un loop infinit si poate fi oprita doar prin folosirea functiei exit().

suma_pare2() - aceasta functie primeste ca argument o matrice si calculeaza suma tuturor elementelor pare din aceasta matrice, inlocuind valoarea initiala a variabilei "raspuns" cu aceasta suma.

In programul principal, se apeleaza cele trei functii in ordinea citire_lin_col(), citeste_valori_matrice() si suma_pare2(), iar rezultatul este stocat in variabila "rezultat".

0659 - Suma Linii 1

2023-04-04T17:13:05Z

Andor Giulia:

Sursa: [https://www.pbinfo.ro/probleme/659/sumalinii1 0659 - Suma Linii 1]
----
== Cerinţa ==
Se dă o '''matrice''' cu '''lin''' linii şi '''col''' coloane şi elemente numere naturale. Să se determine pentru fiecare linie, cea mai mică valoare care se poate obține adunând elementele de pe linie, cu excepția unuia.
== Date de intrare ==
Programul citește de la tastatură numerele '''lin''' şi '''col''', iar apoi ''lin * col'' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.", urmat, pe rândul următor, de '''lin''' numere, separate prin câte un spațiu reprezentând valorile obținute pentru fiecare linie, de sus în jos. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, programul va afișa "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* '''lin''', '''col''' ∈ ℕ
* 1 &les; '''lin''', '''col''' &les; 100
* ''element matrice'' ∈ ℕ
* 0 &les; ''element matrice'' < 1.000.000
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 3 4
: 5 5 10 5
: 3 9 1 9
: 4 10 1 2
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 15 13 7
=== Exemplu 2 ===
; Intrare
: 3 5
: 4 20 15 23 18 9
: 63.5 8 23 22 14 18
: 17 15 13 18 12 15
: 3 18 8 20 12 5
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
=== Exemplu 3 ===
; Intrare
: 2 -25
; Ieșire
: Datele de intrare nu corespund restricțiilor impuse.
== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
def citire_lin_col():
try:
lin = int(input("Introduceti numarul de linii: "))
col = int(input("Introduceti numarul de coloane: "))
if 1 <= lin <= 100 and 1 <= col <= 100:
print("Datele sunt corecte.")
return lin, col
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori_matrice(lin, col):
matrice = []
for linie in range(lin):
matrice.append([])
for coloana in range(col):
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 10_000:
print("Datele sunt corecte.")
matrice[linie].append(n)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")
return matrice

def suma_linie(matrice):
sume = []
for i, linie in enumerate(matrice):
# eliminam un element din linie si calculam suma
min_suma = sum(linie) - max(linie)
sume.append(min_suma)
return sume

if __name__ == "__main__":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
sume = suma_linie(matrice)
for i, min_suma in enumerate(sume):
print(f"Cea mai mica valoare obtinuta prin adunarea elementelor de pe linia {i + 1}, cu exceptia unuia, este {min_suma}.")
</syntaxhighlight>
== Rezolvare ==
Acest cod are ca scop citirea unei matrice de dimensiune specificată de utilizator, calcularea sumei minime pe fiecare linie a matricei, cu excepția unui singur element, și afișarea acestor sume pentru fiecare linie a matricei.

Funcția citire_lin_col primește de la utilizator numărul de linii și coloane pe care le va avea matricea. Se verifică ca numărul de linii și coloane să fie între 1 și 100, iar în caz contrar se afișează un mesaj de eroare și programul se închide. Dacă valorile introduse de utilizator sunt corecte, se afișează un mesaj de confirmare și se returnează numărul de linii și coloane.

Funcția citeste_valori_matrice primește numărul de linii și coloane ale matricei și cere utilizatorului să introducă valorile pentru fiecare element al matricei. Se verifică ca valorile introduse să fie între 0 și 10.000, iar în caz contrar se cere introducerea unor noi valori până când acestea respectă condiția. Valorile corecte sunt adăugate în matrice și aceasta este returnată.

Funcția suma_linie primește matricea și calculează suma minimă a elementelor de pe fiecare linie a matricei, cu excepția elementului maxim. Rezultatele sunt stocate într-o listă și aceasta este returnată.

În cadrul secțiunii if _name_ == "_main_":, programul citeste numărul de linii și coloane ale matricei, apoi valorile acesteia. În continuare se calculează și se afișează sumele minime pentru fiecare linie a matricei, cu excepția elementului maxim.

0666 - Nr Prime

2023-04-04T17:03:18Z

Andor Giulia:

0766 - Nr Pare

2023-04-03T19:45:48Z

Andor Giulia: Pagină nouă: == Rezolvare == <syntaxhighlight lang="python" line="1"> n, m = map(int, input().split()) max_count = 0 max_rows = [] for i in range(n): row = list(map(int, input().split())) count = sum(1 for x in row if x % 2 == 0) if count > max_count: max_count = count max_rows = [i+1] elif count == max_count: max_rows.append(i+1) if max_count == 0: print("NU EXISTA") else: print(*max_rows) </syntaxhighlight>

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
n, m = map(int, input().split())

max_count = 0
max_rows = []

for i in range(n):
row = list(map(int, input().split()))
count = sum(1 for x in row if x % 2 == 0)
if count > max_count:
max_count = count
max_rows = [i+1]
elif count == max_count:
max_rows.append(i+1)

if max_count == 0:
print("NU EXISTA")
else:
print(*max_rows)
</syntaxhighlight>

0768 - Suma Pare 3

2023-04-03T19:42:18Z

Andor Giulia: Pagină nouă: == rezolvare == <syntaxhighlight lang="python" line="1"> n, m = map(int, input().split()) matrix = [list(map(int, input().split())) for _ in range(n)] unique_even = set() for i in range(n): for j in range(m): if matrix[i][j] % 2 == 0: unique_even.add(matrix[i][j]) print(sum(unique_even)) </syntaxhighlight>

== rezolvare ==
<syntaxhighlight lang="python" line="1">
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]

unique_even = set()
for i in range(n):
for j in range(m):
if matrix[i][j] % 2 == 0:
unique_even.add(matrix[i][j])

print(sum(unique_even))
</syntaxhighlight>

0804 - Col Egale

2023-04-03T19:34:58Z

Andor Giulia: Pagină nouă: == Rezolvare == <syntaxhighlight lang="python" line="1"> m, n = map(int, input().split()) matrix = [] for i in range(m): row = list(map(int, input().split())) matrix.append(row) found = False for j in range(n): col = [matrix[i][j] for i in range(m)] if len(set(col)) == 1: print(col[0], end=' ') found = True if not found: print("nu exista") </syntaxhighlight>

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
m, n = map(int, input().split())

matrix = []
for i in range(m):
row = list(map(int, input().split()))
matrix.append(row)

found = False
for j in range(n):
col = [matrix[i][j] for i in range(m)]
if len(set(col)) == 1:
print(col[0], end=' ')
found = True

if not found:
print("nu exista")
</syntaxhighlight>

0789 - Max 2 Ap

2023-04-03T19:31:33Z

Andor Giulia: Pagină nouă: == Rezolvare == <syntaxhighlight lang="python" line="1"> n, m = map(int, input().split()) matrix = [] for i in range(n): row = list(map(int, input().split())) matrix.append(row) seen = set() max_duplicate = None for i in range(n): for j in range(m): value = matrix[i][j] if value in seen and (max_duplicate is None or value > max_duplicate): max_duplicate = value else: seen.add(value) if max_duplicate is None:...

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
n, m = map(int, input().split())

matrix = []
for i in range(n):
row = list(map(int, input().split()))
matrix.append(row)

seen = set()
max_duplicate = None

for i in range(n):
for j in range(m):
value = matrix[i][j]
if value in seen and (max_duplicate is None or value > max_duplicate):
max_duplicate = value
else:
seen.add(value)

if max_duplicate is None:
print("IMPOSIBIL")
else:
print(max_duplicate)
</syntaxhighlight>

0357 - Perechi 1

2023-03-30T17:14:04Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/357/perechi1]
== Cerință ==
La concursul “Miss & Mister Boboc” participă '''n''' perechi de elevi, despre fiecare elev cunoscându-se înălțimea. Numim grad de disproporționalitate al unei perechi diferența în valoare absolută dintre înălțimile elevilor care formează perechea.

Să se determine numărul de ordine al perechii cu grad de disproporționalitate minim.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' perechi de numere naturale, separate prin spaţii, reprezentând înălțimile elevilor dintr-o pereche.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul afișează pe ecran numărul de ordine al perechii cu grad de disproporționalitate minim. Dacă există mai multe perechi cu grad minim de disproporționalitate, se va afișa numărul de ordine al ultimei perechi. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* ''' 1≤ n ≤ 1000'''
* perechile de elevi sunt numerotate de la '''1''' la '''n'''
* înălțimile elevilor sunt numere naturale cuprinse între '''1''' și '''1000''' – unitatea de măsură folosită este de origine extraterestră, nu încercați să o înțelegeți !!
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 6
: 7 9
: 6 7
: 8 12
: 11 10
: 10 6
: 11 13
; Ieșire
: 4
=== Exemplu 2 ===
; Intrare
: 0
; Ieșire
: Datele nu sunt conform restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
n = int(input("Introduceti numarul de perechi: "))
if n >= 1 and n <= 1000:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_perechi(n):
valori = []
for i in range(n):
while True:
try:
valoare1, valoare2 = map(int, input("Introduceti o pereche de valori separate prin spatiu: ").split())
if 1 <= valoare1 <= 1000 and 1 <= valoare2 <= 1000:
print("Datele sunt corecte.")
valori.append((valoare1, valoare2))
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori numerice.")

return valori

def pereche(valori):
pozitie = None
diff_min = 1000000
for i, pereche in enumerate(valori):
a, b = pereche
if a < b:
a, b = b, a
if a - b <= diff_min:
pozitie = i + 1
diff_min = a - b
return pozitie

if __name__ == '__main__':
n = citeste_n()
valori = citeste_perechi(n)
pozitie = pereche(valori)
print("Perechea cu diferența minimă este la poziția: ", pozitie)
</syntaxhighlight>
== Explicații ==
Acest cod este scris in limbajul de programare Python si contine 3 functii si o functie de testare (main function).

Prima functie, "citeste_n()", citeste numarul de perechi de valori si valideaza datele introduse de utilizator. Daca datele introduse sunt corecte, aceasta returneaza numarul de perechi.

A doua functie, "citeste_perechi(n)", citeste perechile de valori, valideaza datele introduse de utilizator si le adauga intr-o lista de tupluri. Pentru fiecare pereche, se verifica daca ambele valori sunt cuprinse intre 1 si 1000, in caz contrar, utilizatorul este avertizat si i se cere sa reintroduca valorile.

A treia functie, "pereche(valori)", calculeaza pozitia perechii cu cea mai mica diferenta dintre valori. Aceasta parcurge lista de perechi si pentru fiecare pereche, determina care dintre cele doua valori este mai mare si calculeaza diferenta dintre ele. Daca diferenta este mai mica sau egala decat cea anterioara, pozitia perechii este actualizata.

Functia de testare (main function) citeste numarul de perechi, citeste perechile de valori si calculeaza pozitia perechii cu cea mai mica diferenta dintre valori, apoi afiseaza rezultatul.

0172 - Dif Min

2023-03-30T16:58:28Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/172/difmin]
== Cerință ==
Să se scrie un program care citește un șir de '''n''' numere naturale şi determină perechea de valori consecutive în șir pentru care valoarea absolută a diferenței este minimă. Dacă există mai multe astfel de perechi se va afișa cea pentru care suma este minimă. Dacă există mai multe perechi de acest fel se va afișa prima pereche din șir.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.".Programul afișează pe ecran numerele '''x y''', reprezentând valorile cerute, separate prin exact un spaţiu. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n ≤ 10000'''
* cele '''n''' numere citite vor fi mai mici decât '''1 000 000 000'''
* cele două valori vor fi afișate în ordinea din șir
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 5
: 72 30 12 165 725
; Ieșire
: 30 12
=== Exemplu 2 ===
; Intrare
: a
: b c d e f
; Ieșire
: Datele nu sunt comform restricțiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
n = int(input("Introduceti numarul de valori: "))
if n >= 1 and n <= 10000:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_valori(n):
valori = []
for i in range(n):
while True:
try:
valoare = int(input("Introduceti o valoare: "))
if valoare <= 1000000000:
print("Datele sunt corecte.")
valori.append(valoare)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori numerice.")
return valori

def pereche(valori):
min_diff = float('inf')
smin_sum = float('inf')
a, b = valori[0], valori[1]
for i in range(len(valori) - 1):
for j in range(i + 1, len(valori)):
x, y = valori[i], valori[j]
if abs(x - y) < min_diff:
min_diff = abs(x - y)
a = x
b = y
smin_sum = x + y
elif abs(x - y) == min_diff and x + y < smin_sum:
smin_sum = x + y
a = x
b = y
return a, b

if __name__ == '__main__':
n = citeste_n()
valori = citeste_valori(n)
x, y = pereche(valori)
print("Valorile cerute sunt: ", x, y)
</syntaxhighlight>
== Explicații ==
Acest cod Python are trei funcții și un bloc de cod principal care apelează cele două funcții de citire a datelor și funcția de calcul a perechii cu diferența minimă.

Funcția citeste_n() cere utilizatorului să introducă numărul de valori și îl validează astfel încât să fie un număr întreg între 1 și 10000. Funcția returnează numărul validat.

Funcția citeste_valori(n) cere utilizatorului să introducă n valori și validează fiecare valoare astfel încât să fie un număr întreg mai mic sau egal cu 1000000000. Funcția returnează o listă de valori validate.

Funcția pereche(valori) primește o listă de valori și calculează perechea cu diferența minimă dintre două valori din listă. Funcția parcurge toate perechile posibile de valori din listă și calculează diferența dintre ele. Dacă diferența este mai mică decât diferența minimă anterioară, atunci se înlocuiesc valorile perechii. Dacă diferențele sunt egale, atunci se compară sumele valorilor din pereche și, dacă suma este mai mică decât suma minimă anterioară, se înlocuiesc valorile perechii.

Blocul de cod principal apelează cele două funcții de citire a datelor și funcția de calcul a perechii cu diferența minimă și afișează rezultatul.

3285 - Mos Craciun

2023-03-30T15:00:26Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/3285/moscraciun]
== Cerință ==
Cei '''n''' copii de la grădiniță stau cuminți în șir și așteaptă cadourile de la Moș Crăciun. Ei sunt numerotați de la 1 la '''n''' (se consideră că '''n''' este par) și în prima jumătate sunt copiii de la grupa mare iar în a doua jumătate sunt cei de la grupa mică (numărul de copii din fiecare grupă este același, '''n/2'''). După ce trece Moș Crăciun se știe câte cadouri a primit fiecare copil și noi dorim să aflăm câți copii din grupa mică au primit mai multe cadouri decât orice copil din grupa mare.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații, reprezentând, în ordine, numărul de cadouri ale fiecărui copil.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.".Programul va afișa pe ecran numărul '''c''', valoarea cerută. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''2 ≤ n ≤ 20''', par
* cele '''n''' numere citite vor fi naturale nenule mai mici decât '''1.000.000.000'''
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 6
: 1 6 3 6 8 2
; Ieșire
: 1
=== Exemplu 2 ===
; Intrare
: 1
: 1 5 3 8
; Ieșire
: Datele nu sunt comform restricțiilor impuse
=== Exemplu 3 ===
; Intrare
: 21
: 1 6 3 6 8 2 5 6 2 3 4 2 1 5 3 2 1 5 3 6 4
; Ieșire
: Datele nu sunt comform restricțiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
n = int(input("Introduceti numarul de valori: "))
if n >= 2 and n <= 20:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_valori(n):
valori = []
for i in range(n):
while True:
try:
valoare = int(input("Introduceti o valoare: "))
if valoare <= 1000000000:
print("Datele sunt corecte.")
valori.append(valoare)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori numerice.")
return valori

def cadouri(valori):
maxi = 0
k = 0
for i in range(1, len(valori) // 2 + 1):
if valori[i - 1] > maxi:
maxi = valori[i - 1]

for i in range(len(valori) // 2 + 1, len(valori) + 1):
if valori[i - 1] > maxi:
k += 1
return k

if __name__ == '__main__':
n = citeste_n()
valori = citeste_valori(n)
k = cadouri(valori)
print("Numarul de copii este:", k)
</syntaxhighlight>
== Explicații ==
citeste_n(): Această funcție citește de la tastatură numărul de valori pe care utilizatorul dorește să le introducă și verifică dacă acestea respectă restricțiile impuse (între 2 și 20). În caz contrar, utilizatorul este notificat că datele nu sunt conform restricțiilor și i se cere să introducă din nou un număr corect.

citeste_valori(n): Această funcție primește ca parametru numărul de valori introduse de utilizator și citește aceste valori de la tastatură, verificând dacă acestea sunt valori numerice și respectă restricțiile impuse (mai mici sau egale cu 1 miliard). În caz contrar, utilizatorul este notificat că datele nu sunt conform restricțiilor și i se cere să introducă din nou valori corecte.

cadouri(valori): Această funcție primește ca parametru lista de valori introduse de utilizator și calculează numărul de copii care vor primi cadouri în funcție de restricția dată: copiii vor primi cadouri de la jumătatea listei în sus numai dacă valoarea cadoului este mai mare decât orice valoare anterioară. Dacă valoarea maximă se găsește în prima jumătate a listei, atunci niciun copil nu va primi cadouri. Funcția returnează numărul de copii care primesc cadouri.

În funcția cadouri(valori), prima buclă for calculează valoarea maximă din prima jumătate a listei, iar cea de-a doua buclă for numără câți copii primesc cadouri în a doua jumătate a listei. Funcția returnează valoarea acestui număr, care este apoi afișată pe ecran în funcția main().

0274 - 3 Minime

2023-03-30T14:15:12Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/274/3minime]
== Cerință ==
Se dau '''n''' numere naturale. Determinaţi cele mai mici trei numere dintre cele date.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.".Programul afișează pe ecran, în ordine descrescătoare, cele mai mici trei numere date.În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''3 ≤ n ≤ 100'''
* cele '''n''' numere citite vor avea cel mult '''4''' cifre
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 5
: 1017 48 310 5710 162
; Ieșire
: 310 162 48
=== Exemplu 2 ===
; Intrare
: 2
: 10 4 30 510 16
; Ieșire
: Datele nu sunt comform restricțiilor impuse
=== Exemplu 3 ===
; Intrare
: 1
: 1017 48 310 5710 162
; Ieșire
: Datele nu sunt comform restricțiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
n = int(input("Introduceti numarul de valori: "))
if n >= 3 and n <= 100:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def nrcifre(nr):
nrcif = 0
while nr != 0:
nrcif += 1
nr //= 10
return nrcif

def citeste_valori(n):
valori = []
for i in range(n):
valoare = input("Introduceti o valoare: ")
while True:
try:
cifre = nrcifre(int(valoare))
if cifre <= 4:
print("Datele sunt corecte.")
valori.append(int(valoare))
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar valori cu mai putin de 9 cifre.")
exit()
return valori

def numere_minime(valori):

valori.sort()
return valori[0], valori[1], valori[2]

if __name__ == '__main__':
n = citeste_n()
valori = citeste_valori(n)
mini1, mini2, mini3 = numere_minime(valori)
print("Cele mai mari numere sunt:",mini3,mini2,mini1)
</syntaxhighlight>
== Explicații ==
Acest cod definește patru funcții în Python care au ca scop citirea unui număr de valori și găsirea celor mai mici trei numere dintre acestea.

Funcția citeste_n() citește numărul de valori n și verifică dacă acesta se află în intervalul specificat (de la 3 la 100). Dacă numărul introdus nu respectă aceste restricții, se afișează un mesaj de eroare și se cere reîncercarea introducerii valorii.

Funcția nrcifre(nr) primește un număr nr și returnează numărul de cifre ale sale.

Funcția citeste_valori(n) citește n valori și le verifică dacă au maxim 4 cifre. Dacă valorile nu respectă această condiție, se afișează un mesaj de eroare și se cere reîncercarea introducerii valorii.

Funcția numere_minime(valori) primește o listă valori de numere și returnează cele mai mici trei numere dintre acestea.

În funcția _main_(), se apelează cele patru funcții și se afișează cele mai mici trei numere între valorile introduse.

2781 - Wildfire

2023-03-30T14:08:14Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/2781/wildfire]
== Enunț ==
Se consideră o pădure ce conține '''n•m''' copaci aranjați pe '''n''' linii și '''m''' coloane în care s-a produs un incendiu. Pădurarii cunosc coordonatele '''x''' și '''y''' ale copacului de la care a izbucnit focul și modalitatea prin care acesta se extinde. Astfel, dacă un copac se aprinde într-o anumită zi, în ziua următoare se vor aprind copacii vecini cu acesta pe linie sau coloană care nu sunt încă afectați de incendiu.
== Cerință ==
Știind '''x''' și '''y''', coordonatele inițiale ale focului și '''n''' și '''m''', dimensiunile pădurii, ajutați pădurarii să determine numărul minim de zile după care întreaga pădure va fi afectată.
== Date de intrare ==
Programul citește de la tastatură numerele '''x y n m''', cu semnificația de mai sus.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.".Programul va afișa pe ecran numărul '''Z''', reprezentând numărul de zile după care va fi afectată întreaga pădure. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ x ≤ n ≤ 1.000.000.000'''
* '''1 ≤ y ≤ m ≤ 1.000.000.000'''
== Exemple ==
=== Exemplu 1 ===
În funcție de numărul de zile, fiecare zonă va fi distrusă în numărul de zile corespunzător figurii de mai jos:
; Intrare
: 2 2 4 5
; Ieșire
: 6
=== Exemplu 2 ===
; Intrare
: 2 2 0 6
; Ieșire
: Datele nu sunt comform restricțiilor impuse
=== Exemplu 3 ===
; Intrare
: 2 -2 0 5
; Ieșire
: Datele nu sunt comform restricțiilor impuse
== Explicație ==
În funcție de numărul de zile, fiecare zonă va fi distrusă în numărul de zile corespunzător figurii de mai jos:
== Exemplu 2 ==
; Intrare
: 3 3 9 9
; Ieșire
: 13
== Explicație ==
În funcție de numărul de zile, fiecare zonă va fi distrusă în numărul de zile corespunzător figurii de mai jos:
: 5 4 3 4 5 6 7 8 9
: 4 3 2 3 4 5 6 7 8
: 3 2 1 2 3 4 5 6 7
: 4 3 2 3 4 5 6 7 8
: 5 4 3 4 5 6 7 8 9
: 6 5 4 5 6 7 8 9 10
: 7 6 5 6 7 8 9 10 11
: 8 7 6 7 8 9 10 11 12
: 9 8 7 8 9 10 11 12 13
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_valori():
valori = []
for i in range(4):
while True:
try:
valoare = int(input("Introduceti o valoare: "))
if valoare >= 1 and valoare <= 1000000000:
print("Datele sunt corecte.")
valori.append(valoare)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori naturale cu mai putin de 10 cifre.")
return valori

def numar_zile(valori):
x, y, n, m = valori
lc1 = x + y - 2
lc2 = x - 1 + m - y
lc3 = y - 1 + n - x
lc4 = m - y + n - x
return max(lc1, lc2, lc3, lc4) + 1

if __name__ == '__main__':
valori = citeste_valori()
Z = numar_zile(valori)
print("Numărul de zile după care va fi afectată întreaga pădure este:", Z)
</syntaxhighlight>
== Explicații ==
citeste_valori(): Această funcție citește de la tastatură patru valori întregi și le validează astfel încât să se încadreze în anumite restricții. Dacă valorile nu se încadrează în aceste restricții, utilizatorul este notificat și trebuie să introducă din nou valorile până când acestea sunt corecte. Funcția returnează lista valorilor corecte.

numar_zile(): Această funcție primește o listă de patru valori întregi și calculează numărul de zile după care va fi afectată întreaga pădure. Acest calcul este realizat folosind patru formule matematice, care iau în considerare poziția arborelui inițial (x, y) și a celui final (n, m). Funcția returnează numărul de zile calculat.

La final, programul apelează cele două funcții și afișează numărul de zile obținut.

0119 - 2 Maxim

2023-03-30T13:53:04Z

Andor Giulia:

Sursă: [https://www.pbinfo.ro/probleme/119/2maxim]
== Cerință ==
Să se scrie un program care citește un șir de '''n''' numere naturale şi determină cele mai mari două numere din şir.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale nenule.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.".Programul afișează pe ecran numerele '''x y''', reprezentând valorile cerute, separate prin exact un spaţiu.În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''2 ≤ n ≤ 1000'''
* cele n numere citite vor fi mai mici decât '''2.000.000.000'''
* valorile afişate respectă relaţia '''x ≥ y'''
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 5
: 72 30 12 15 17
; Ieșire
: 75 72
=== Exemplu 2 ===
; Intrare
: 1
: 7 10 2 15 17
; Ieșire
: Datele nu sunt comform restricțiilor impuse
=== Exemplu 3 ===
; Intrare
: a
: b f c d g
; Ieșire
: Datele nu sunt comform restricțiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
n = int(input("Introduceti numarul de valori: "))
if n >= 2 and n <= 1000:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_valori(n):
valori = []
for i in range(n):
while True:
try:
valoare = int(input("Introduceti o valoare: "))
if valoare <= 2000000000:
print("Datele sunt corecte.")
valori.append(valoare)
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori naturale cu mai putin de 10 cifre.")

return valori

def numere_maxime(valori):
# Sortarea valorilor in ordine descrescatoare
valori.sort(reverse=True)
# Returnarea celor doua valori maxime
return valori[0], valori[1]

if __name__ == '__main__':
n = citeste_n()
valori = citeste_valori(n)
x, y = numere_maxime(valori)
print("Cele mai mari numere sunt:", x, "și", y)
</syntaxhighlight>
== Explicații ==
Acest cod constă dintr-o funcție pentru a citi un număr de valori, o funcție pentru a citi acele valori, o funcție pentru a sorta valorile în ordine descrescătoare, și o funcție pentru a găsi cele două numere maxime.

Funcția citeste_n() citește un număr întreg de la tastatură și îl verifică să fie între 2 și 1000. Dacă numărul este corect, acesta este returnat, altfel se afișează un mesaj de eroare și se începe din nou citirea.

Funcția citeste_valori(n) citește n valori întregi de la tastatură și le stochează într-o listă. Fiecare valoare este verificată să fie mai mică sau egală cu 2000000000. Dacă valoarea este corectă, aceasta este adăugată la lista de valori. Dacă nu, se afișează un mesaj de eroare și se cere o nouă valoare.

Funcția sortare(n, v) sortează lista v de valori în ordine descrescătoare utilizând algoritmul de sortare a bulelor. Lista sortată este returnată.

Funcția numere_maxime(valori) primește lista de valori și găsește cele două valori maxime utilizând funcția sortare(n, v) pentru a sorta lista în ordine descrescătoare. După sortare, primele două valori din lista sortată sunt returnate.

În funcția principală (_main_), se citesc numărul de valori și valorile într-o listă folosind funcțiile citeste_n() și citeste_valori(n). Apoi, cele două numere maxime sunt găsite utilizând funcția numere_maxime(valori) și sunt afișate pe ecran.