Bitnami MediaWiki - User contributions [en]

1748 - Cursa

2023-04-29T11:31:40Z

AndorGiulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1748/cursa] == Cerință == Costică este alergător la un maraton. El parcurge un traseu sub forma unei matrice cu '''n''' linii şi '''m''' coloane linie cu linie şi pe fiecare linie, de la stânga la dreapta. Matricea conţine numere naturale. Dacă Costică întâlneşte un număr prim, el este penalizat, fiind trimis pe linia şi coloana anterioară, iar dacă acesta întâlneşte un număr perfect, poate avansa pe linia şi coloa...

Sursă: [https://www.pbinfo.ro/probleme/1748/cursa]
== Cerință ==
Costică este alergător la un maraton. El parcurge un traseu sub forma unei matrice cu '''n''' linii şi '''m''' coloane linie cu linie şi pe fiecare linie, de la stânga la dreapta. Matricea conţine numere naturale.
Dacă Costică întâlneşte un număr prim, el este penalizat, fiind trimis pe linia şi coloana anterioară, iar dacă acesta întâlneşte un număr perfect, poate avansa pe linia şi coloana următoare. Dacă mişcarea pe linie şi pe coloană depăşeşte limitele matricei, atunci se va efectua numai mişcarea care nu trece de aceste limite sau nu se va efectua nici o mişcare.
Afişaţi timpul '''t''' în care parcurge Costică traseul, ştiind că deplasarea dintr-un element al matricei în oricare altul durează o secundă, iar fiecare penalizare sau avansare durează o secundă.
Un număr este perfect dacă suma cifrelor lui este un număr prim.
Dacă un număr este şi prim şi perfect, atunci el va fi considerat prim.
După penalizare sau avansare, numerele prime sau perfecte îşi pierd proprietățile.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi ''''n*m''' numere naturale, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul va afișa pe ecran numărul '''t''', reprezentând timpul în care Costică parcurge traseul. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n,m ≤ 500'''
* cele n numere citite vor fi mai mici decât '''1.000.000'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 4 5
: 6 9 3 2 1
: 8 3 12 4 0
: 1 1 34 8 7
: 5 3 5 9 8
; Date de ieșire
: 28
==== Explicatie ====
'''2 3 5 7''' sunt numere prime, iar '''2 3 5 7 12 34''' sunt numere perfecte.
== 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 <= 500 and 2 <= m <= 500:
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**6:
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 este_prim(numar):
if numar < 2:
return False
for i in range(2, int(numar**0.5)+1):
if numar % i == 0:
return False
return True

def este_perfect(numar):
suma_cifre = sum(int(cifra) for cifra in str(numar))
return este_prim(suma_cifre)

def Cursa(matrice):
n = len(matrice)
m = len(matrice[0])
timp = 0
linie = 0
coloana = 0
while True:
if linie < 0 or linie >= n or coloana < 0 or coloana >= m:
break
valoare = matrice[linie][coloana]
if este_prim(valoare) or (este_perfect(valoare) and este_prim(sum(int(cifra) for cifra in str(valoare)))): # adăugare verificare pentru suma cifrelor
timp += 1
if linie == 0 and coloana == 0:
break
else:
linie, coloana = linie - 1, coloana - 1
if linie < 0 or coloana < 0: # adăugare verificare pentru depășirea matricei
break
valoare = matrice[linie][coloana]
este_prim(valoare)
este_perfect(valoare)
else:
timp += 1
if este_perfect(valoare):
linie, coloana = linie + 1, coloana + 1
if linie >= n or coloana >= m: # adăugare verificare pentru depășirea matricei
break
valoare = matrice[linie][coloana]
este_prim(valoare)
este_perfect(valoare)
else:
coloana += 1
return timp

if _name_ == "_main_":
matrice = citire_matrice()
t = Cursa(matrice)
print(f"Costica a parcurs traseul in {t} secunde.")
</syntaxhighlight>
== Explicatie ==
Acest cod începe prin definirea a trei funcții: citire_matrice(), este_prim(numar) și este_perfect(numar), urmate de funcția Cursa(matrice) care este apelată în if _name_ == "_main_":.

Funcția citire_matrice() citeste numarul de linii și coloane ale matricei de la tastatură, verifică dacă acestea respectă condițiile impuse și apoi citeste elementele matricei de la tastatură. Pentru fiecare element introdus, se verifică dacă îndeplinește condițiile impuse și se reia citirea de la tastatură până când se introduce un număr valid. Matricea este stocată într-o listă de liste și este returnată la sfârșitul funcției.

Funcția este_prim(numar) primește un număr întreg și verifică dacă este prim sau nu. Verificarea se face prin împărțirea numărului la toate numerele întregi de la 2 la rădăcina pătrată a numărului. Dacă numărul se divide fără rest la unul dintre aceste numere, atunci nu este prim.

Funcția este_perfect(numar) primește un număr întreg și verifică dacă suma cifrelor sale este un număr prim. În interiorul funcției, mai întâi se calculează suma cifrelor numărului, apoi se verifică dacă aceasta este primă, folosind funcția este_prim(numar).

Funcția Cursa(matrice) primește o matrice și calculează timpul necesar pentru a parcurge traseul descris în enunțul problemei. Se începe de la primul element al primei linii și se deplasează în sus și în stânga, la fiecare pas verificându-se dacă elementul curent îndeplinește condițiile impuse. Dacă da, se incrementează timpul și se deplasează în sus și în stânga, altfel se incrementează timpul și se deplasează în dreapta. Se continuă acest proces până când se ajunge la primul element al primei linii sau se depășește limita matricei. Timpul total este returnat la sfârșitul funcției.

În blocul if _name_ == "_main_":, se citește matricea de la tastatură, se calculează timpul necesar pentru a parcurge traseul folosind funcția Cursa(matrice) și se afișează rezultatul.

0231 - Exista

2023-04-29T11:27:09Z

AndorGiulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/231/exista] == Cerință == Scrieţi un program care citeşte un tablou bidimensional cu '''m''' linii şi '''n''' coloane şi un număr '''k''' şi determină suma indicilor coloanelor care conţin valoarea '''k'''. == Date de intrare == Fişierul de intrare '''exista.in''' conţine pe prima linie numerele '''k, m''' şi '''n''', iar pe următoarele '''m''' linii câte '''nv numere naturale separate prin spaţii, reprezentând elemente...

Sursă: [https://www.pbinfo.ro/probleme/231/exista]
== Cerință ==
Scrieţi un program care citeşte un tablou bidimensional cu '''m''' linii şi '''n''' coloane şi un număr '''k''' şi determină suma indicilor coloanelor care conţin valoarea '''k'''.
== Date de intrare ==
Fişierul de intrare '''exista.in''' conţine pe prima linie numerele '''k, m''' şi '''n''', iar pe următoarele '''m''' linii câte '''nv 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 '''exista.out''' va conţine pe prima linie suma cerută. Dacă nu există în matrice valoarea '''k''', se va afişa mesajul '''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≤10''';
* valoarea lui '''k''' şi elementele matricei sunt numere întregi cu cel mult '''4''' cifre;
* liniile sunt numerotate de la '''1''' la '''m''', iar coloanele de la '''1''' la '''n'''.
== Exemple ==
=== Exemplu 1 ===
; '''exista.in'''
: 3 5 4
: 2 4 5 -8
: 1 3 7 9
: -2 3 10
: 5 4 2 37
: 6 7 3 13
; '''exista.in'''
: 5
==== Explicatie ====
Coloana '''2''' şi coloana '''3''' conţin valoarea '''3''', iar suma lor este '''5'''.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
# Deschide fișierul de intrare și citește k, m și n
with open("exista.in", "r") as fin:
line = fin.readline().split()
if len(line) != 3:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
k = float(line[0])
m, n = map(int, line[1:])
if not (2 <= m <= 10 and 2 <= n <= 10):
print("Datele nu sunt conform restrictiilor impuse.")
exit()
matrice = []
# Citește matricea din fișierul de intrare
for i in range(m):
row = list(map(float, fin.readline().split()))
# Verifică dacă elementele matricei sunt conform cerințelor
if not all(isinstance(x, float) for x in row):
print("Datele nu sunt conform restrictiilor impuse.")
exit()
matrice.append(row)
return k, m, n, matrice

def calculeaza_suma(k, m, n, matrice):
suma = 0.0
coloane_cu_k = []
for j in range(n):
coloana_j = [matrice[i][j] for i in range(m)]
if k in coloana_j:
suma += j + 1
coloane_cu_k.append(j + 1)
if not coloane_cu_k:
print("NU EXISTA")
exit()
return suma

if _name_ == "_main_":
k, m, n, matrice = citire_matrice()
suma = calculeaza_suma(k, m, n, matrice)
with open("exista.out", "w") as fout:
fout.write(str(suma) + "\n")
print("Suma indicilor coloanelor care contin valoarea k este:", suma)
</syntaxhighlight>
== Explicatie ==
Acest cod rezolvă problema de a calcula suma indicilor coloanelor care conțin o anumită valoare k într-o matrice bidimensională dată.

Funcția citire_matrice deschide fișierul de intrare exista.in și citește valoarea k, dimensiunile matricei (m și n), și matricea în sine. Dacă datele de intrare nu respectă condițiile impuse (de exemplu, dimensiunile matricei sunt în afara intervalului [2,10]), se afișează un mesaj de eroare și programul se încheie cu exit(). Funcția returnează k, m, n și matricea.

Funcția calculeaza_suma primește k, m, n și matricea, și calculează suma indicilor coloanelor care conțin valoarea k. Pentru fiecare coloană, extrage toate elementele acelei coloane și verifică dacă k se află printre acele elemente. Dacă da, adaugă indicele coloanei (indexul începe de la 1, nu de la 0) la lista coloane_cu_k și adaugă indicele la variabila suma. Dacă nu există nicio coloană care să conțină valoarea k, afișează mesajul "NU EXISTA" și programul se încheie cu exit(). Funcția returnează suma.

În blocul principal, se apelează funcțiile citire_matrice și calculeaza_suma pentru a obține suma și se scrie aceasta în fișierul de ieșire exista.out. Se afișează, de asemenea, valoarea sumei în consolă.

3389 - Colturi DR

2023-04-29T11:20:48Z

AndorGiulia:

Sursă: [https://www.pbinfo.ro/probleme/3389/colturi-dr]
== Cerință ==
Se dă o matrice cu '''n''' linii și '''m''' coloane cu valori de '''0''' și '''1'''. Numim '''dreptunghi de extrem''' un dreptunghi ale cărui vârfuri au valori egale. Determinați numărul acestor dreptunghiuri, aria dreptunghiului de arie maximă și câte dreptunghiuri au aceeași valoare a vârfurilor ca și dreptunghiul de arie maximă.
== Date de intrare ==
Fișierul de intrare '''colturi_dr.in''' conține pe prima linie numărul '''n''' de linii, numărul '''m''' de coloane, iar pe următoarele linii se află cele '''n * m''' numere naturale.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''colturi_dr.out''' va conține pe prima linie numerele '''nr, A si cnt''' reprezentând cele trei numere specificate în cerință. Î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'''
* numărul de dreptunghiuri de extrem cu vârfuri de '''1''' este diferit de numărul de dreptunghiuri de extrem cu vârfuri de '''0'''.
* un '''dreptunghi de extrem''' are cel puțin două linii și două coloane
== Exemple ==
=== Exemplu 1 ===
; '''colturi_dr.in'''
: 5 5
: 1 1 1 1 0
: 0 1 1 0 1
: 0 1 0 0 1
: 1 0 1 0 1
; '''colturi_dr.out'''
: 11 25 9
==== Explicatie ====
Sunt '''9''' dreptunghiuri de extrem a cărui vârfuri sunt '''1''', respectiv '''2''' ale cărui vârfuri sunt '''0'''. Dreptunghiul de extrem de arie maximă are colțul stânga sus la '''(0,0)''' și colțul dreapta jos la '''(5,5)'''.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
# Deschide fișierul de intrare și citește n, m și p
with open("colturi_dr.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 in [0, 1] for x in row):
print("Datele nu sunt conform restrictiilor impuse.")
exit()
matrice.append(row)
return n, m, matrice

def colturi_dr(n, m, matrice):
nr = 0 # Numărul dreptunghiurilor de extrem
max_area = 0 # Aria maximă a dreptunghiului de extrem
max_cnt = 0 # Numărul dreptunghiurilor cu aceeași arie maximă
for i in range(n - 1):
for j in range(m - 1):
if matrice[i][j] == matrice[i][j + 1] == matrice[i + 1][j] == matrice[i + 1][j + 1]:
nr += 1
area = (i + 2) * (j + 2)
if area > max_area:
max_area = area
max_cnt = 1
elif area == max_area:
max_cnt += 1
return nr, max_area, max_cnt

if _name_ == "_main_":
n, m, matrice = citire_matrice()
nr, max_area, cnt = colturi_dr(n, m, matrice)
with open("colturi_dr.out", "w") as fout:
fout.write(str(nr) + " " + str(max_area) + " " + str(cnt) + "\n")
print("Numărul de dreptunghiuri de extrem este:", nr)
print("Aria maximă a unui dreptunghi de extrem este:", max_area)
print("Numărul de dreptunghiuri cu aceeași arie maximă este:", cnt)
</syntaxhighlight>
== Explicatie ==
Acest cod implementează o funcție numită citire_matrice() care citește datele de intrare dintr-un fișier colturi_dr.in. Datele de intrare conțin trei valori: n și m, reprezentând dimensiunile unei matrici de dimensiune nxm, și o matrice binară cu n linii și m coloane. Matricea este formată din 0-uri și 1-uri, și reprezintă un tip special de matrice numit "matrice de extrem" (dreptunghiurile de extrem), care conține doar dreptunghiuri cu colțurile de aceeași valoare.

Funcția citire_matrice() validează datele de intrare și returnează o tuplă formată din n, m și matricea citită.

Funcția colturi_dr() primește dimensiunile matricei și matricea în sine și calculează numărul de dreptunghiuri de extrem, aria maximă a unui dreptunghi de extrem și numărul de dreptunghiuri cu aceeași arie maximă.

În final, programul scrie datele de ieșire în fișierul colturi_dr.out și le afișează pe ecran.

3389 - Colturi DR

2023-04-29T11:20:11Z

AndorGiulia: Pagină nouă: Sursă: [pbinfo.ro/probleme/3389/colturi-dr] == Cerință == Se dă o matrice cu '''n''' linii și '''m''' coloane cu valori de '''0''' și '''1'''. Numim '''dreptunghi de extrem''' un dreptunghi ale cărui vârfuri au valori egale. Determinați numărul acestor dreptunghiuri, aria dreptunghiului de arie maximă și câte dreptunghiuri au aceeași valoare a vârfurilor ca și dreptunghiul de arie maximă. == Date de intrare == Fișierul de intrare '''colturi_dr.in''' conține...

Sursă: [pbinfo.ro/probleme/3389/colturi-dr]
== Cerință ==
Se dă o matrice cu '''n''' linii și '''m''' coloane cu valori de '''0''' și '''1'''. Numim '''dreptunghi de extrem''' un dreptunghi ale cărui vârfuri au valori egale. Determinați numărul acestor dreptunghiuri, aria dreptunghiului de arie maximă și câte dreptunghiuri au aceeași valoare a vârfurilor ca și dreptunghiul de arie maximă.
== Date de intrare ==
Fișierul de intrare '''colturi_dr.in''' conține pe prima linie numărul '''n''' de linii, numărul '''m''' de coloane, iar pe următoarele linii se află cele '''n * m''' numere naturale.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''colturi_dr.out''' va conține pe prima linie numerele '''nr, A si cnt''' reprezentând cele trei numere specificate în cerință. Î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'''
* numărul de dreptunghiuri de extrem cu vârfuri de '''1''' este diferit de numărul de dreptunghiuri de extrem cu vârfuri de '''0'''.
* un '''dreptunghi de extrem''' are cel puțin două linii și două coloane
== Exemple ==
=== Exemplu 1 ===
; '''colturi_dr.in'''
: 5 5
: 1 1 1 1 0
: 0 1 1 0 1
: 0 1 0 0 1
: 1 0 1 0 1
; '''colturi_dr.out'''
: 11 25 9
==== Explicatie ====
Sunt '''9''' dreptunghiuri de extrem a cărui vârfuri sunt '''1''', respectiv '''2''' ale cărui vârfuri sunt '''0'''. Dreptunghiul de extrem de arie maximă are colțul stânga sus la '''(0,0)''' și colțul dreapta jos la '''(5,5)'''.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citire_matrice():
# Deschide fișierul de intrare și citește n, m și p
with open("colturi_dr.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 in [0, 1] for x in row):
print("Datele nu sunt conform restrictiilor impuse.")
exit()
matrice.append(row)
return n, m, matrice

def colturi_dr(n, m, matrice):
nr = 0 # Numărul dreptunghiurilor de extrem
max_area = 0 # Aria maximă a dreptunghiului de extrem
max_cnt = 0 # Numărul dreptunghiurilor cu aceeași arie maximă
for i in range(n - 1):
for j in range(m - 1):
if matrice[i][j] == matrice[i][j + 1] == matrice[i + 1][j] == matrice[i + 1][j + 1]:
nr += 1
area = (i + 2) * (j + 2)
if area > max_area:
max_area = area
max_cnt = 1
elif area == max_area:
max_cnt += 1
return nr, max_area, max_cnt

if _name_ == "_main_":
n, m, matrice = citire_matrice()
nr, max_area, cnt = colturi_dr(n, m, matrice)
with open("colturi_dr.out", "w") as fout:
fout.write(str(nr) + " " + str(max_area) + " " + str(cnt) + "\n")
print("Numărul de dreptunghiuri de extrem este:", nr)
print("Aria maximă a unui dreptunghi de extrem este:", max_area)
print("Numărul de dreptunghiuri cu aceeași arie maximă este:", cnt)
</syntaxhighlight>
== Explicatie ==
Acest cod implementează o funcție numită citire_matrice() care citește datele de intrare dintr-un fișier colturi_dr.in. Datele de intrare conțin trei valori: n și m, reprezentând dimensiunile unei matrici de dimensiune nxm, și o matrice binară cu n linii și m coloane. Matricea este formată din 0-uri și 1-uri, și reprezintă un tip special de matrice numit "matrice de extrem" (dreptunghiurile de extrem), care conține doar dreptunghiuri cu colțurile de aceeași valoare.

Funcția citire_matrice() validează datele de intrare și returnează o tuplă formată din n, m și matricea citită.

Funcția colturi_dr() primește dimensiunile matricei și matricea în sine și calculează numărul de dreptunghiuri de extrem, aria maximă a unui dreptunghi de extrem și numărul de dreptunghiuri cu aceeași arie maximă.

În final, programul scrie datele de ieșire în fișierul colturi_dr.out și le afișează pe ecran.

0667 - Nr Prime 1

2023-04-29T11:09:24Z

AndorGiulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/667/nrprime1] == Cerință == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Să se determine câte dintre elementele situate pe coloane cu indici impari sunt prime. == 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 ecr...

Sursă: [https://www.pbinfo.ro/probleme/667/nrprime1]
== Cerință ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Să se determine câte dintre elementele situate pe coloane cu indici impari sunt prime.
== 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 '''C''', reprezentând valoarea căutată. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n , m ≤ 600'''
* 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'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 4 3
: 5 2 10
: 3 9 1
: 7 10 1
: 10 19 3
; Date de ieșire
: 4
==== Explicatie ====
Cele '''4''' valori prime determinate sunt cele evidențiate mai jos:

: '''5''' 2 10
: '''3''' 9 1
: '''7''' 10 1
: 10 19 '''3'''
Observăm că matricea conține și alte elemente prime, dar ele nu sunt situate pe coloane cu indici impari.
== 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 <= 600 and 1 <= m <= 600:
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):
try:
n = int(input(f"Introduceti un numar pentru linia {linie+1}, coloana {coloana+1}: "))
if n <= 1000000:
print("Datele sunt corecte.")
matrice[linie].append(n)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()
return matrice

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

def NrPrime1(n, m, a):
cnt = 0
for i in range(n):
for j in range(m):
if j % 2 == 0 and prim(a[i][j]):
cnt += 1
print(cnt)

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
NrPrime1(n, m, matrice)
</syntaxhighlight>
== Explicatie ==
Acest cod implementează o funcție numită "NrPrime1" care primește trei argumente: n (numărul de linii al matricei), m (numărul de coloane al matricei) și a (matricea însăși). Funcția calculează și afișează numărul de numere prime din matrice care se află pe poziții pare de coloană.

Pentru a face asta, mai întâi sunt definite următoarele funcții:

"citire_lin_col" care citește de la utilizator numărul de linii și de coloane și verifică dacă valorile introduse sunt în intervalul permis (1-600). Dacă valorile sunt corecte, ele sunt returnate. În caz contrar, programul se termină.

"citeste_valori_matrice" care primește numărul de linii și coloane și citește de la utilizator valorile matricei. În timp ce valorile sunt citite, funcția verifică dacă fiecare valoare este mai mică sau egală cu 1000000. Dacă nu este cazul, programul se termină. Matricea este returnată la final.

"prim" care primește un număr și returnează adevărat dacă numărul este prim sau fals altfel. Această funcție este folosită de funcția "NrPrime1".

Funcția "NrPrime1" iterază prin fiecare element al matricei și verifică dacă numărul este prim și dacă coloana este număr par. Dacă da, numărătorul este crescut cu 1. La final, numărătorul este afișat.

0565 - Acoperire

2023-04-29T11:04:16Z

AndorGiulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/565/acoperire] == Cerință == Gigel deține un teren de formă dreptunghiulară, împărțite în '''n•m''' sectoare, dispuse pe '''n''' linii și '''m''' coloane. În anumite sectoare sunt instalate camere de luat vederi. Fiecare cameră acoperă anumite sectoare ale terenului, pe diagonală și are o anumită putere '''k''' reprezentând numărul de sectoare pe care le acoperă pe fiecare din cele '''4''' direcții, inclusiv sector...

Sursă: [https://www.pbinfo.ro/probleme/565/acoperire]
== Cerință ==
Gigel deține un teren de formă dreptunghiulară, împărțite în '''n•m''' sectoare, dispuse pe '''n''' linii și '''m''' coloane. În anumite sectoare sunt instalate camere de luat vederi. Fiecare cameră acoperă anumite sectoare ale terenului, pe diagonală și are o anumită putere '''k''' reprezentând numărul de sectoare pe care le acoperă pe fiecare din cele '''4''' direcții, inclusiv sectorul în care se află camera.
Determinați câte sectoare ale terenului nu sunt acoperite de nici o cameră.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m k''', reprezentând dimensiunile terenului și numărul de camere, apoi '''k''' triplete '''i j p''', reprezentând coordonatele fiecărei camere șî puterea ei.
== 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''', reprezentând numărul de sectoare neacoperite. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n , m ≤ 1000'''
* '''1 ≤ p ≤ 1000'''
* '''1 ≤ j ≤ m'''
* '''1 ≤ p ≤ min(n,m)'''
* o cameră poate acoperi un sector în care se află o altă cameră
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 1 7 2
: 4 2 3
: 4 5 4
; Date de ieșire
: 16
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n_m_k():
while True:
try:
n = int(input("Introduceti numarul n: "))
m = int(input("Introduceti numarul m: "))
k = int(input("Introduceti numarul k: "))
if 1 <= n <= 1000 and 1 <= m <= 1000 and 1 <= k <= 1000:
print("Datele sunt corecte.")
return n,m,k
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

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

return valori

def Acoperire(valori, n, m):
a = [[-1 for j in range(m+1)] for i in range(n+1)]
cnt = 0
for i,j,p in valori:
a[i][j] = p
for l in range(1, p+1):
if i + l <= n and j + l <= m:
a[i+l][j+l] = p
if i + l <= n and j - l > 0:
a[i+l][j-l] = p
if i - l > 0 and j + l <= m:
a[i-l][j+l] = p
if i - l > 0 and j - l > 0:
a[i-l][j-l] = p
for i in range(1, n+1):
for j in range(1, m+1):
if a[i][j] == -1:
cnt += 1
return cnt

if _name_ == '_main_':
n, m, k = citeste_n_m_k()
valori = citeste_triplet(k, m)
cnt = Acoperire(valori, n, m)
print("Numarul de sectoare neacoperite este:", cnt)
</syntaxhighlight>
== Explicatie ==
Acest cod este o implementare a unui algoritm care calculează numărul de sectoare neacoperite de o matrice dată, folosind informații despre un set de triplete formate din trei valori întregi (i, j, p) care semnifică: linia i, coloana j și raza de acoperire p a unui sector circular centrare în (i,j).

Funcția citeste_n_m_k() citește de la tastatură valorile pentru n, m și k, reprezentând dimensiunile matricei și numărul de triplete, iar apoi verifică dacă valorile sunt conforme cu restricțiile impuse: n, m și k trebuie să fie între 1 și 1000. Dacă valorile sunt corecte, funcția le returnează.

Funcția citeste_triplet(n, m) primește numărul de triplete k și dimensiunea m și citește de la tastatură k triplete (i, j, p), reprezentând coordonatele centrului sectorului circular și raza de acoperire a acestuia. După citire, funcția verifică dacă tripletele sunt conforme cu restricțiile impuse: i și j trebuie să fie între 1 și n și respectiv între 1 și m, iar p trebuie să fie între 1 și min(n,m). Tripletele valide sunt adăugate la o listă de valori și apoi returnate.

Funcția Acoperire(valori, n, m) primește lista de valori citite anterior și dimensiunile matricei și calculează numărul de sectoare neacoperite. Înainte de a începe procesul de acoperire, se creează o matrice a de dimensiuni n+1 x m+1, inițializată cu valoarea -1 pentru toate elementele, pentru a putea verifica mai ușor dacă un sector a fost acoperit sau nu. Apoi, pentru fiecare triplet de valori citite, se actualizează matricea a, setând valoarea razei p pentru fiecare element de pe cercul centrat în (i,j). Se actualizează de asemenea și elementele din interiorul cercului, mărind raza de la 1 la p. La final, se numără câte elemente din matricea a au valoarea -1, semnificând sectoarele neacoperite, și se returnează acest număr.

Funcția main() apelează funcțiile citeste_n_m_k(), citeste_triplet(k, m) și Acoperire(valori, n, m) și afișează numărul de sectoare neacoperite.

4183 - Bac Eroziune

2023-04-29T10:38:03Z

AndorGiulia: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/4183/bac-eroziune] == Enunt == Pentru prevenirea eroziunii la Marea Neagră, autoritățile au hotărât înnisiparea unei plaje. Plaja a fost împărțită în parcele de formă pătrată cu latura de 1 metru, dispuse ca elementele unui tablou bidimensional, reținându-se nivelul fiecărei parcele, măsurat în metri, de la nivelul mării. Înnisiparea se realizează doar pe acele parcele care au nivelul strict mai mic decât al celei...

Sursă: [https://www.pbinfo.ro/probleme/4183/bac-eroziune]
== Enunt ==
Pentru prevenirea eroziunii la Marea Neagră, autoritățile au hotărât înnisiparea unei plaje. Plaja a fost împărțită în parcele de formă pătrată cu latura de 1 metru, dispuse ca elementele unui tablou bidimensional, reținându-se nivelul fiecărei parcele, măsurat în metri, de la nivelul mării. Înnisiparea se realizează doar pe acele parcele care au nivelul strict mai mic decât al celei mai joase dintre parcelele vecine cu ea, adăugând nisip, astfel încât cele două să aibă același nivel. Două parcele sunt vecine dacă au o latură comună.
== Cerință ==
Scrieți un program C/C++ care citește de la tastatură două numere naturale '''L''' și '''C''', apoi elementele unui tablou bidimensional cu '''L''' linii şi '''C''' coloane reprezentând nivelurile parcelelor, în ordinea dispunerii acestora pe plajă și determină cantitatea totală de nisip adăugată, măsurată în metri cubi.
== Date de intrare ==
Programul citește de la tastatură două numere naturale '''L''' și '''C''', apoi elementele unui tablou bidimensional cu '''L''' linii şi '''C''' coloane reprezentând nivelurile parcelelor.
== 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 '''S''', reprezentând cantitatea totală de nisip adăugată, măsurată în metri cubi. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ L, C ≤ 100'''
* Elementele tabloului bidimensional sunt numere naturale cuprinse între '''1''' și '''10'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 5 4
: 5 3 4 6
: 7 5 9 3
: 6 8 3 9
: 4 5 2 3
: 3 1 4 4
; Date de ieșire
: 7
==== Explicatie ====
Se vor înnisipa parcelele de la pozițiile '''(1,2)''', '''(2,4)''', '''(4,3)''', '''(5,2)''' pentru a fi aduse la nivelul parcelelor vecine corespunzătoare și se va afișa valoarea '''7 (1 + 3 + 1 + 2)'''.
== 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 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):
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 valoare <= 1000000:
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 n, m, matrice

def bac_eroziune(valori, n):
nisip_total = 0
for i in range(n):
for j in range(len(valori[i])):
vecini = []
nivel = valori[i][j]
if i > 0:
vecini.append(valori[i-1][j])
if j > 0:
vecini.append(valori[i][j-1])
if i < n-1:
vecini.append(valori[i+1][j])
if j < len(valori[i])-1:
vecini.append(valori[i][j+1])
vecini.sort()
if nivel < vecini[0]:
nisip = vecini[0] - nivel
valori[i][j] += nisip
nisip_total += nisip
return nisip_total

if _name_ == '_main_':
n, m, matrice = citire_matrice()
print("Cantitatea totala de nisip adaugata: ", bac_eroziune(matrice, n))
</syntaxhighlight>
== Explicatie ==
Acest cod este scris in limbajul Python si contine doua functii: citire_matrice() si bac_eroziune(). De asemenea, se verifica si se afiseaza rezultatul.

Functia citire_matrice() solicita de la utilizator numarul de linii si coloane ale matricei, apoi verifica daca valorile introduse se incadreaza in intervalul permis (1-100). Daca valorile sunt valide, se solicita utilizatorului sa introduca valorile matricei. De asemenea, se verifica daca valorile introduse se incadreaza in intervalul permis (<= 1000000). Daca valorile sunt valide, acestea sunt stocate intr-o matrice si returnate impreuna cu dimensiunile matricei.

Functia bac_eroziune() primeste ca argumente matricea si dimensiunea acesteia. Aceasta parcurge matricea si pentru fiecare element verifica daca este mai mic decat cel mai mic vecin. Daca este indeplinita aceasta conditie, se aduna o cantitate de nisip egala cu diferenta dintre valoarea celui mai mic vecin si valoarea curenta si se actualizeaza valoarea curenta. Cantitatea totala de nisip adaugata este returnata la sfarsit.

In if _name_ == '_main_':, se apeleaza functia citire_matrice() pentru a citi matricea de la utilizator si se afiseaza cantitatea totala de nisip adaugata prin apelarea functiei bac_eroziune().

2810 - Inserare 1

2023-04-27T18:52:38Z

AndorGiulia: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/2810/inserare1] ---- == Cerinţa == Scrieți un program care citește de la tastatură un număr natural par '''n (n∈[2,50])''' și elementele unui tablou bidimensional cu '''n''' linii și '''n''' coloane, numere reale, apoi transformă tabloul în memorie, inserând o linie nouă, la mijlocul său, valoarea fiecărui element al acesteia fiind egală cu media aritmetică a elementelor aflate pe coloana corespunzătoare lui în tabloul...

Sursa: [https://www.pbinfo.ro/probleme/2810/inserare1]
----
== Cerinţa ==
Scrieți un program care citește de la tastatură un număr natural par '''n (n∈[2,50])''' și elementele unui tablou bidimensional cu '''n''' linii și '''n''' coloane, numere reale, apoi transformă tabloul în memorie, inserând o linie nouă, la mijlocul său, valoarea fiecărui element al acesteia fiind egală cu media aritmetică a elementelor aflate pe coloana corespunzătoare lui în tabloul citit. Tabloul obținut se afișează pe ecran, 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ă numărul '''n''', iar apoi cele '''n • n''' elemente ale tabloului.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."/ Programul va afișa pe ecran elementele tabloului modificat, conform cerinței. Î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 ==
* valorile afișate sunt considerate corecte dacă diferența în valoare absolută dintre fiecare element afișat și cel corect este mai mică decât '''0.001'''
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 4
: 1.5 0.75 3 1.2
: 2.75 1.25 2.25 1.5
: 4.5 1.15 3 4.5
: 0.25 0.85 1.75 3
; Ieșire
: 1.5 0.75 3 1.2
: 2.75 1.25 2.25 1.5
: 2.25 1 2.5 2.55
: 4.5 1.15 3 4.5
: 0.25 0.85 1.75 3
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_lin_col():
try:
n = int(input("Introduceti numarul: "))
if 2 <= n <= 50:
print("Datele sunt corecte.")
return n
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 = float(input(f"Introduceti un numar pentru linia {linie+1}, coloana {coloana+1}: "))
print("Datele sunt corecte.")
matrice[linie].append(n)
break
except ValueError:
print("Trebuie introduse doar numere reale.")
else:
print("Prea multe incercari esuate.")
exit()
return matrice

def Inserare1(matrice, n):
v = [0] * 51
for i in range(1, n + 1):
for j in range(1, n + 1):
v[j] += (matrice[i-1][j-1] * 100000)
for i in range(1, n + 1):
v[i] /= (n * 100000)

for i in range(1, n // 2 + 1):
print(*matrice[i-1][0:n])

print(*v[1:n + 1])

for i in range(n // 2 + 1, n + 1):
print(*matrice[i-1][0:n])

if _name_ == "_main_":
n = citire_lin_col()
matrice = citeste_valori_matrice(n, n)
Inserare1(matrice, n)
</syntaxhighlight>
== Explicații ==
Acest cod Python citeste dimensiunea unei matrici (linii si coloane) de la utilizator, apoi citeste valorile matricei ca numere reale si le stocheaza intr-o lista bidimensionala. Dupa aceea, calculeaza o lista de valori medii pe coloana, dupa care afiseaza matricea originala cu primele jumatate de linii, lista de valori medii si restul matricei. Funcția citire_lin_col() se asigură că dimensiunile introduse de utilizator respectă cerințele (numere între 2 și 50), în timp ce funcția citeste_valori_matrice() primește dimensiunile matricei și cere utilizatorului să introducă valorile matricei. Dacă utilizatorul introduce o valoare invalidă, i se vor oferi trei încercări de a introduce o valoare corectă. Dacă utilizatorul depășește numărul de încercări, programul se va încheia cu un mesaj de eroare. Funcția Inserare1() primește matricea și dimensiunea acesteia și calculează lista de valori medii pe coloană folosind o variabilă auxiliară v. După aceea, afișează matricea originală împărțită în trei părți: primele jumătate de linii, lista de valori medii și restul matricei.

1007 - Matrice 7

2023-04-27T18:48:40Z

AndorGiulia: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/1007/matrice7] ---- == Cerinţa == Se consideră o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se modifice matricea în felul următor: toate elementele egale cu valoarea maximă din matrice se înlocuiesc cu valoarea minimă de pe coloana lor. == Date de intrare == Fișierul de intrare '''matrice7.in''' conține pe prima linie numerele '''n m''', iar următoarele '''n''' linii câte '''m''' numere natu...

Sursa: [https://www.pbinfo.ro/probleme/1007/matrice7]
----
== Cerinţa ==
Se consideră o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se modifice matricea în felul următor: toate elementele egale cu valoarea maximă din matrice se înlocuiesc cu valoarea minimă de pe coloana lor.
== Date de intrare ==
Fișierul de intrare '''matrice7.in''' conține pe prima linie numerele '''n m''', iar următoarele '''n''' linii câte '''m''' numere naturale, reprezentând elementele matricei.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.". Fișierul de ieșire '''matrice7.out''' va conține matricea modificată, câte o linie a matricei pe o linie a fişierului, elementele fiecărei linii fiind separate prin exact un spaţiu. Î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'''
* elementele matricei vor fi mai mici decât '''1 000 000 000'''
== Exemple ==
=== Exemplu 1 ===
; '''matrice7.in'''
: 3 4
: 2 6 7 3
: 7 1 7 1
: 5 3 1 2
; '''matrice7.out'''
: 2 6 1 3
: 2 1 1 1
: 5 3 1 2
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def citire_matrice():
try:
with open("matrice7.in", "r") as fin:
n, m = map(int, fin.readline().split())
if 1 <= n <= 100 and 1 <= m <= 100:
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 <= 1000000000:
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 matrice7.in nu exista.")
exit()

def matrice7(n, m, matrix):
max_val = -1
for i in range(n):
for j in range(m):
if matrix[i][j] > max_val:
max_val = matrix[i][j]

min_col = [math.inf] * m
for j in range(m):
for i in range(n):
if matrix[i][j] < min_col[j]:
min_col[j] = matrix[i][j]

for i in range(n):
for j in range(m):
if matrix[i][j] == max_val:
matrix[i][j] = min_col[j]

with open("matrice7.out", "w") as fout:
for i in range(n):
for j in range(m):
fout.write(str(matrix[i][j]) + " ")
fout.write("\n")

if _name_ == "_main_":
n, m, matrix = citire_matrice()
matrice7(n, m, matrix)
print("Procesul s-a incheiat cu succes!")
</syntaxhighlight>
== Explicații ==
Funcția citire_matrice()
Descriere: Această funcție se ocupă de citirea datelor din fișierul "matrice7.in" și construirea matricei corespunzătoare. În cazul în care fișierul nu există sau datele nu sunt conforme cu restricțiile impuse, se va afișa un mesaj de eroare corespunzător.
Parametri: Funcția nu primește parametri.
Return: Funcția returnează trei valori: n (numărul de linii al matricei), m (numărul de coloane al matricei) și matrix (matricea propriu-zisă, reprezentată sub formă de listă de liste).
Funcția matrice7(n, m, matrix)
Descriere: Această funcție primește ca parametri dimensiunile matricei și matricea propriu-zisă și se ocupă de efectuarea operațiilor specifice cerinței și de scrierea matricei rezultate în fișierul "matrice7.out".
Parametri: Funcția primește trei parametri: n (numărul de linii al matricei), m (numărul de coloane al matricei) și matrix (matricea propriu-zisă, reprezentată sub formă de listă de liste).
Return: Funcția nu returnează niciun rezultat.
Funcția main()
Descriere: Această funcție reprezintă punctul de pornire al programului. Se apelează funcția citire_matrice() pentru a obține matricea de intrare și se apelează apoi funcția matrice7() pentru a obține matricea rezultată.
De asemenea, se afișează un mesaj de confirmare a terminării programului.
Parametri: Funcția nu primește parametri.
Return: Funcția nu returnează niciun rezultat.

0751 - MCautare

2023-04-27T18:43:46Z

AndorGiulia: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/751/mcautare] ---- == Cerinţa == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale și '''k''' valori naturale. Determinați pentru fiecare dintre cele '''k''' valori dacă apare pe fiecare linie a matricei. == Date de intrare == Programul citește de la tastatură numerele '''n m''', apoi cele '''n''' linii ale matricei, fiecare cu câte '''m''' valori. Apoi citește valoarea '''k''', apoi '''k''' valor...

Sursa: [https://www.pbinfo.ro/probleme/751/mcautare]
----
== Cerinţa ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale și '''k''' valori naturale. Determinați pentru fiecare dintre cele '''k''' valori dacă apare pe fiecare linie a matricei.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m''', apoi cele '''n''' linii ale matricei, fiecare cu câte '''m''' valori. Apoi citește valoarea '''k''', apoi '''k''' valori '''x'''.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.". Programul va afișa pe ecran, pentru fiecare dintre cele'''k''' valori '''x''', mesajul '''DA''', dacă '''x''' apare pe fiecare dintre liniile matricei, respectiv '''NU''' în caz contrar. Fiecare mesaj va fi afișat pe câte o linie a ecranului. Î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 ≤ 1000'''
* elementele matricei și cele '''k''' valori '''x''' sunt mai mici decât '''1.000.000.000'''
== Exemple ==
=== Exemplu 1 ===
; Intrare
: 4 5
: 3 7 9 9 7
: 3 7 8 10 9
: 3 5 4 7 9
: 6
: 9 4 7 8 10 7
; Ieșire
: DA
: DA
: NU
: NU
: DA
==== Explicatie ====
Dintre cele 6 valori citite, doar prima, a treia și a șasea apar pe toate liniile matricei.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citeste_valoare_intrega(mesaj):
while True:
try:
valoare = int(input(mesaj))
return valoare
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_matrice(n, m):
matrice = []
for linie in range(n):
matrice.append([])
for coloana in range(m):
valoare_corecta = False
incercari = 0
while not valoare_corecta and incercari < 3:
valoare = citeste_valoare_intrega(f"Introduceti un numar pentru linia {linie+1}, coloana {coloana+1}: ")
if valoare <= 1000000:
matrice[linie].append(valoare)
valoare_corecta = True
else:
print("Datele nu sunt conforme cu restrictiile impuse.")
incercari += 1
if not valoare_corecta:
print("Prea multe incercari esuate.")
exit()
return matrice

def citire_matrice():
try:
n = citeste_valoare_intrega("Introduceti numarul de linii: ")
m = citeste_valoare_intrega("Introduceti numarul de coloane: ")
if not (1 <= n <= 100 and 1 <= m <= 100):
print("Datele nu sunt conforme cu restrictiile impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

matrice = citeste_matrice(n, m)
k = citeste_valoare_intrega("Introduceti numarul de valori cautate: ")
valori = []
for i in range(k):
valoare = citeste_valoare_intrega(f"Introduceti valoarea {i+1}: ")
if valoare <= 1000000:
valori.append(valoare)
else:
print("Datele nu sunt conforme cu restrictiile impuse.")
exit()

return matrice, valori

def MCautare(matrice, valori):
n = len(matrice)
m = len(matrice[0])
for valoare in valori:
apare_pe_toate_linii = True
for linie in range(n):
if valoare not in matrice[linie]:
apare_pe_toate_linii = False
break
if apare_pe_toate_linii:
print("DA")
else:
print("NU")

if _name_ == "_main_":
matrice, valori = citire_matrice()
MCautare(matrice, valori)
</syntaxhighlight>
== Explicații ==
Acest cod Python definește mai multe funcții pentru a căuta anumite valori într-o matrice și a determina dacă acestea apar pe toate liniile matricei.

Funcția citeste_valoare_intrega(mesaj) primește un mesaj și citește o valoare întreagă de la tastatură folosind funcția input(). Această funcție este apoi utilizată în funcția citeste_matrice(n, m) pentru a citi valorile pentru matricea de dimensiuni n x m. Pentru a asigura că valorile introduse sunt corecte, acestea sunt verificate dacă sunt numere întregi și mai mici sau egale cu 1.000.000. Dacă utilizatorul introduce o valoare incorectă, acesta primește un mesaj de eroare și are maximum 3 încercări de a introduce o valoare corectă.

Funcția citire_matrice() este utilizată pentru a citi dimensiunile matricei și pentru a apela funcția citeste_matrice(n, m) pentru a citi valorile matricei și o listă de valori pentru căutare. Dacă valorile introduse pentru dimensiunile matricei nu sunt conforme cu restricțiile impuse (1 <= n <= 100 și 1 <= m <= 100), programul se va opri cu un mesaj de eroare.

Funcția MCautare(matrice, valori) primește matricea și lista de valori pentru căutare și verifică dacă fiecare valoare apare pe toate liniile matricei. Pentru fiecare valoare din lista de căutare, se parcurg toate liniile matricei pentru a verifica dacă valoarea respectivă apare pe toate acestea. Dacă valoarea apare pe toate liniile, se afișează mesajul "DA". Altfel, se afișează mesajul "NU".

Codul verifică în plus dacă utilizatorul introduce valori care depășesc limitele specificate, caz în care programul se va opri cu un mesaj de eroare.

0769 - Ord Col

2023-04-27T18:36:41Z

AndorGiulia: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/769/ordcol] ---- == Cerinţa == Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se ordoneze coloanele matricei astfel încât elementele de pe prima linie să fie ordonate crescător. == 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...

Sursa: [https://www.pbinfo.ro/probleme/769/ordcol]
----
== Cerinţa ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se ordoneze coloanele matricei astfel încât elementele de pe prima linie să fie ordonate crescător.
== 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 ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.". 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 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 ≤ m,n ≤ 100'''
* elementele matricei vor fi mai mici decât '''1000000'''
== 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
: 4 9 15 18 20 23
: 1 18 23 14 8 22
: 17 15 13 12 15 18
: 3 5 8 12 18 20
== 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):
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 valoare <= 1000000:
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 OrdCol(matrice):
n = len(matrice)
m = len(matrice[0])
v = sorted(matrice[0])
b = [[0 for j in range(m)] for i in range(n)]
for i in range(m):
for j in range(m):
if v[i] == matrice[0][j]:
for l in range(n):
b[l][i] = matrice[l][j]
print("Matricea initiala:")
for i in range(n):
for j in range(m):
print(matrice[i][j], end=' ')
print()
print("Matricea transpusa:")
for i in range(n):
for j in range(m):
print(b[i][j], end=' ')
print()

if _name_ == "_main_":
matrice = citire_matrice()
OrdCol(matrice)
</syntaxhighlight>
== Explicații ==
Acest cod implementează două funcții Python, citire_matrice() și OrdCol(matrice), pentru a citi o matrice de numere întregi de la tastatură și a afișa matricea transpusă sortată în ordine crescătoare a primului rând.

Funcția citire_matrice() citește numărul de linii și de coloane ale matricei de la tastatură și verifică dacă acestea se încadrează în intervalul [1,100]. Apoi, primește de la utilizator elementele matricei și le adaugă într-o listă bidimensională matrice. În timpul introducerii valorilor, funcția verifică dacă acestea sunt numere întregi și dacă se încadrează în intervalul [1,1000000]. Dacă se produc erori în timpul introducerii valorilor, funcția afișează mesaje corespunzătoare și oprește programul cu ajutorul funcției exit(). În final, funcția returnează matricea.

Funcția OrdCol(matrice) primește matricea returnată de funcția citire_matrice() și creează o nouă matrice b cu aceleași dimensiuni ca matricea inițială. Se sortează primul rând al matricei inițiale în ordine crescătoare și se stochează rezultatul în lista v. Apoi, se parcurg coloanele matricei inițiale și se caută pentru fiecare element din primul rând valoarea corespunzătoare din coloana respectivă. Dacă se găsește o astfel de valoare, elementul din noua matrice b de pe aceeași poziție este setat la valoarea respectivă. În final, sunt afișate matricea inițială și matricea transpusă sortată în ordine crescătoare a primului rând.

Instrucțiunea if _name_ == "_main_": asigură faptul că codul de mai sus va fi executat doar dacă acest fișier este rulat ca program, nu dacă este importat ca modul într-un alt program.

4001 - Min Max K 9

2023-04-27T18:31:17Z

AndorGiulia:

Sursă: [https://www.pbinfo.ro/probleme/4001/minmaxk9]
== Cerinţa ==
Se citește o cifră '''k''' și apoi se citesc numere naturale distincte de la tastatură până la apariția lui zero. Afișați câte dintre numerele citite după '''k''' sunt cuprinse între cel mai mic și cel mai mare număr cu proprietatea că are ultima cifră egală cu '''k'''. Dacă niciunul dintre numerele citite nu are ultima cifră egală cu '''k''', atunci se va afișa '''NU EXISTA'''.
== Date de intrare ==
Programul citește de la tastatură numărul k și apoi numere naturale distincte. Citirea se încheie la introducerea valorii '''0''', care nu se prelucrează.
== 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 numere citite între numărul minim și cel maxim (inclusiv acestea) cu proprietatea cerută. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* numerele citite aparțin intervalului '''[0,1.000.000]''' și sunt distincte (diferite două câte două).
* '''0<=k<=9'''.
* în total se citesc cel mult '''200000''' de numere.
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 5 45 44 5505 7884 15 75 530 0
; Date de iesire
: 3
=== Exemplu 2 ===
; Date de intrare
:4
: 1 2 3 4
; Date de iesire
:Datele sunt corecte. Rezultat: 4
=== Exemplu 3 ===
; Date de intrare
: 3
: 76968635425 456 6
; Date de iesire
:Datele introduse nu corespund cerinței.

== Rezolvare ==
<syntaxhighlight lang="python" line>
def citeste_k():
while True:
try:
k = int(input("Introduceti cifra k: "))
if 0 <= k <= 9:
print("Datele sunt corecte.")
return k
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_valori():
numere = []
while True:
try:
n = int(input("Introduceti un numar: "))
if 0 <= n <= 1000000:
numere.append(n)
if n == 0:
break
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori cu mai putin de 9 cifre.")
return numere

def numere_cu_ultima_cifra_k(numere, k):
numere_cu_k = [nr for nr in numere if nr % 10 == k]
if len(numere_cu_k) == 0:
print("NU EXISTA")
else:
min_nr_cu_k = min(numere_cu_k)
max_nr_cu_k = max(numere_cu_k)
numere_intre = [nr for nr in numere if min_nr_cu_k <= nr <= max_nr_cu_k and nr % 10 == k]
print(len(numere_intre))

if _name_ == '_main_':
k = citeste_k()
valori = citeste_valori()
numere_cu_ultima_cifra_k(valori, k)
</syntaxhighlight>
== Explicație ==
Acest cod are ca scop rezolvarea problemei de a număra câte dintre numerele citite după o cifră k sunt cuprinse între cel mai mic și cel mai mare număr cu proprietatea că are ultima cifră egală cu k. Programul citește de la tastatură cifra k și apoi numere naturale distincte până la apariția lui zero, stocate într-o listă. În funcția citeste_k(), cifra k este citită și verificată dacă este între 0 și 9. În caz contrar, se afișează un mesaj de eroare. În funcția citeste_valori(), numerele sunt citite și verificate dacă sunt între 0 și 1000000 și adăugate în listă. În cazul în care se introduce 0, citirea se încheie și nu se adaugă în listă. Dacă se introduce o valoare care nu respectă restricțiile, se afișează un mesaj de eroare.

În funcția numere_cu_ultima_cifra_k(), lista de numere este parcursă și se generează o altă listă care conține doar numerele cu ultima cifră egală cu cifra k. Dacă nu există niciun număr cu această proprietate, se afișează "NU EXISTA". Altfel, se găsesc cel mai mic și cel mai mare număr din lista numere_cu_k și se numără câte dintre numerele inițiale se încadrează între aceste valori și au ultima cifră egală cu k. Rezultatul este afișat la consolă.