Bitnami MediaWiki - User contributions [en]

1424 - Smartphone

2023-04-29T10:56:22Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1424/smartphone] == Enunt == Andrei este elev în clasa a V-a și își dorește mult un smartphone. Tatăl său știe de acest lucru și s-a gândit să-i facă o bucurie de ziua lui. Așa că a hotărât să-l ducă într-un magazin de telefoane să-și aleagă unul. Fiecare telefon este inscripţionat cu un număr ce reprezintă performanţa acestuia. Cu cât numărul este mai mare, cu atât telefonul este mai bun. Andrei l-a dorit p...

Sursă: [https://www.pbinfo.ro/probleme/1424/smartphone]
== Enunt ==
Andrei este elev în clasa a V-a și își dorește mult un smartphone. Tatăl său știe de acest lucru și s-a gândit să-i facă o bucurie de ziua lui. Așa că a hotărât să-l ducă într-un magazin de telefoane să-și aleagă unul.
Fiecare telefon este inscripţionat cu un număr ce reprezintă performanţa acestuia. Cu cât numărul este mai mare, cu atât telefonul este mai bun. Andrei l-a dorit pe cel mai performant (cu numărul cel mai mare) dar tatăl lui i l-a cumpărat pe al doilea ca performanță.
== Cerință ==
Dându-se numărul '''n''' de smatphone-uri și performanța fiecăruia, să se determine:
: 1. Numărul cu care este inscripționat telefonul dorit de Andrei;
: 2. Numărul cu care este inscripționat telefonul pe care l-a primit Andrei.
== Date de intrare ==
Fișierul de intrare '''smartphone.in''' conține pe prima linie un număr natural '''c''' ('''1''' sau '''2''') reprezentând numărul cerinței ce trebuie rezolvată.
A doua linie conține numărul natural '''n''' reprezentând numărul de telefoane din magazin.
A treia linie conține '''n''' valori naturale distincte, separate prin câte un spaţiu, reprezentând performanțele telefoanelor.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''smartphone.out''' va conține pe prima linie un singur număr reprezentând răspunsul la cerința citită din fișierul de intrare. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n ≤ 10000'''
* '''1 ≤ x ≤ 2000000000''' ('''x =''' numărul inscripționat pe telefon)
* '''Pentru c = 1 se va rezolva doar cerința 1. Pentru c = 2 se va rezolva doar cerința 2'''.
== Exemple ==
=== Exemplu 1 ===
; '''smartphone.in'''
: 1
: 5
: 12 345 231 29 100
; '''smartphone.out'''
: 345
==== Explicatie ====
Cerința este 1. Numărul inscripționat pe telefonul dorit de Andrei este '''345'''.
=== Exemplu 2 ===
; '''smartphone.in'''
: 2
: 5
: 12 345 231 29 100
; '''smartphone.out'''
: 231
==== Explicatie ====
Cerința este 2. Numărul inscripționat pe telefonul primit de Andrei este '''231'''.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_valori():
while True:
try:
with open('smartphone.in') as fin:
n = int(fin.readline())
x = list(map(int, fin.readline().split()))
if 1 <= n <= 10000 and all(1 <= xi <= 2000000000 for xi in x):
print("Datele sunt corecte.")
with open('smartphone.out', 'a') as fout:
fout.write("Datele sunt corecte.\n")
return n,x
else:
print("Datele nu sunt conform restricțiilor impuse.")
with open('smartphone.out', 'a') as fout:
fout.write("Datele nu sunt conform restricțiilor impuse.\n")
except ValueError:
print("Trebuie introduse doar numere întregi.")
with open('smartphone.out', 'a') as fout:
fout.write("Trebuie introduse doar numere întregi.\n")

def smartphone(n, x):
with open('smartphone.out', 'a') as fout:
fout.write("Numarul cu care este inscriptionat telefonul dorit de Andrei este: " + str(max(x)) + "\n")
if len(x) >= 2:
fout.write("Numarul cu care este inscriptionat telefonul pe care l-a primit Andrei este: " + str(sorted(x, reverse=True)[1]) + "\n")
else:
fout.write("Nu exista un al doilea numar inscriptat pe un smartphone.\n")

if _name_ == '_main_':
n, x = citeste_valori()
smartphone(n, x)
</syntaxhighlight>
== Explicatie ==
Acest cod implementează două funcții, citeste_valori() și smartphone(n, x). Funcția citeste_valori() deschide fișierul "smartphone.in" și încearcă să citească două linii din el: prima linie conține un număr întreg n, iar a doua linie conține n numere întregi separate prin spațiu, stocate într-o listă x. Această funcție validează dacă datele citite sunt conforme cu restricțiile impuse (n trebuie să fie între 1 și 10000, iar fiecare element din lista x trebuie să fie între 1 și 2000000000), și afișează un mesaj corespunzător în cazul în care datele nu sunt conforme. Dacă datele sunt conforme, funcția returnează n și x.

Funcția smartphone(n, x) primește n și x ca argumente și deschide fișierul "smartphone.out". Funcția scrie în acest fișier numărul cel mai mare din lista x (reprezentând numărul cu care este inscripționat telefonul dorit de Andrei), și, dacă lista x are cel puțin două elemente, al doilea cel mai mare număr din listă (reprezentând numărul cu care este inscripționat telefonul pe care l-a primit Andrei). Dacă lista x are un singur element, funcția afișează un mesaj corespunzător în fișierul de ieșire.

În blocul if _name_ == '_main_':, se apelează funcția citeste_valori() pentru a citi datele din fișierul "smartphone.in", apoi se apelează funcția smartphone(n, x) pentru a scrie rezultatele în fișierul "smartphone.out".

0953 - DeeDee

2023-04-29T10:49:35Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/953/deedee] == Enunt == Deedee a descoperit în parc un şotron triunghiular construit din '''N*(N+1)/2''' dale de piatră dintre care '''K''' au culoarea gri iar restul sunt albe. Dalele sunt numerotate cu numerele distincte de la '''1''' la '''N*(N+1)/2''' şi sunt dispuse pe '''N''' rânduri, una lângă alta, ca în desenul de mai jos realizat pentru un şotron cu '''N=6''' şi '''K=5''', astfel: : -pe rândul '''1''', dala cu numă...

Sursă: [https://www.pbinfo.ro/probleme/953/deedee]
== Enunt ==
Deedee a descoperit în parc un şotron triunghiular construit din '''N*(N+1)/2''' dale de piatră dintre care '''K''' au culoarea gri iar restul sunt albe. Dalele sunt numerotate cu numerele distincte de la '''1''' la '''N*(N+1)/2''' şi sunt dispuse pe '''N''' rânduri, una lângă alta, ca în desenul de mai jos realizat pentru un şotron cu '''N=6''' şi '''K=5''', astfel:
: -pe rândul '''1''', dala cu numărul '''1'''
: -pe rândul '''2''', dalele cu numerele: '''2''' şi '''3'''
: -pe rândul '''3, dalele cu numerele: '''4''', '''5''' şi '''6'''
: …………..
: -pe rândul '''N''', dalele cu numerele: '''N*(N-1)/2+1, N*(N-1)/2+2 , … , N*(N+1)/2'''
Pornind de pe dala iniţială, adică dala cu numărul '''1''', sărind din dală în dală, Deedee trebuie să ajungă pe dala finală, adică dala cu numărul '''N*(N+1)/2''', respectând regula următoare: de pe dala curentă, numerotată cu '''X''' şi situată pe rândul '''Y''', ea poate să sară doar pe o dală albă situată pe rândul '''Y''' şi numerotată cu '''X+1''' (dacă aceasta există) sau pe rândul '''Y+1''' pe aceeaşi coloană cu dala curentă.
Nefiind o bună sportivă, Deedee vrea să descopere mai întâi dalele pe care ar trebui să sară pornind de la dala iniţială astfel încât să execute un număr minim de sărituri până la dala finală, respectând la fiecare săritură regula.
== Cerință ==
Scrieţi un program care să determine:
: a) numărul '''R''' al rândului care conţine cele mai multe dale gri, iar dacă sunt mai multe rânduri cu această proprietate atunci '''R''' va fi egal cu numărul cel mai mic al unui astfel de rând;
: b) numărul minim '''D''' de dale pe care trebuie să sară Deedee pornind de la dala iniţială astfel încât să ajungă pe dala finală, respectând la fiecare săritură regula din enunţ.
== Date de intrare ==
Programul citește de la tastatură numerele naturale '''N''' şi '''K''', cu semnificaţia din enunţ, apoi '''K''' numere naturale nenule, ordonate strict crescător, reprezentând numerele dalelor de culoare gri din şotron.
== 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 '''R''' și '''D''', în această ordine. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''3 ≤ N ≤ 100000; 1 ≤ K < 100000''';
* dalele au formă pătratică, cu latura de aceeaşi lungime
* dala iniţială şi dala finală sunt de culoare albă
* pentru datele de test există întotdeauna soluţie
* pentru rezolvarea corectă a cerinţei a) se acordă '''60%''' din punctaj, iar pentru rezolvarea corectă a ambelor cerinţe se acordă '''100%''' din punctaj
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 6 5
: 4 6 7 18 19
; Date de ieșire
: 3
: 10
==== Explicatie ====
Rândurile '''3''' şi '''6''' au numărul maxim de dale gri ('''2'''), deci '''R=3'''.

Deedee poate ajunge pe dala finală efectuând minimum '''D=10''' sărituri. De exemplu, poate urma traseul:
'''1 → 2 → 3 → 5 → 8 → 9 → 13 → 14 → 15 → 20 → 21'''.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
import math

def citeste_n_k():
while True:
try:
n = int(input("Introduceti numarul n: "))
k = int(input("Introduceti numarul de valori: "))
if 3 <= n <= 100000 and 1 <= k <= 100000:
print("Datele sunt corecte.")
return n, k
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_valori(k):
valori = []
for i in range(k):
while True:
try:
valoare = int(input("Introduceti o valoare: "))
if 1 <= 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 intregi cu cel mult 10 cifre.")
return valori

def deedee(valori, n):
r = 0
d = 0
ultimul_gri = 0
gri_in_rand = 0
for i in range(len(valori)):
row = math.ceil((math.sqrt(8*valori[i] + 1) - 1)/2)
if row > r:
r = row
gri_in_rand = 1
elif row == r:
gri_in_rand += 1
if valori[i] == 1:
ultimul_gri = 1
else:
if valori[i] == ultimul_gri + 1 or valori[i] == ultimul_gri + r + 1:
ultimul_gri = valori[i]
else:
salturi = math.ceil((valori[i] - ultimul_gri) / r)
ultimul_gri += salturi * r
if valori[i] == ultimul_gri + 1 or valori[i] == ultimul_gri + r + 1:
ultimul_gri = valori[i]
else: ultimul_gri+= r
d += salturi + 1
d += math.ceil((n*(n+1)//2 - ultimul_gri) / r)
return r, d

if _name_ == '_main_':
n, k = citeste_n_k()
valori = citeste_valori(k)
x, y = deedee(valori, n)
print("Valorile cerute sunt:", x, "și", y)
</syntaxhighlight>
== Explicatie ==
Acesta este un program Python care primește două numere de la utilizator - n și k - și o listă de k valori, apoi calculează două valori - r și d - și le afișează.
Valoarea r reprezintă numărul de griuri necesare pentru a acoperi toată grilă de dimensiune n x n, iar d reprezintă numărul de salturi necesare pentru a trece de la un gri la altul în ordinea dată de valorile introduse în listă.

Funcția "citeste_n_k()" primește de la utilizator valorile n și k și le validează, astfel încât n să fie între 3 și 100000, iar k între 1 și 100000. Dacă valorile nu sunt valide, se va cere reintroducerea lor până la introducerea unor valori valide.

Funcția "citeste_valori(k)" primește o valoare k și cere utilizatorului să introducă k valori, pe care le validează. Fiecare valoare trebuie să fie între 1 și 1000000000 și să aibă cel mult 10 cifre. Dacă valorile nu sunt valide, se va cere reintroducerea lor până la introducerea unor valori valide.

Funcția "deedee(valori, n)" primește o listă de valori și o valoare n și calculează r și d. Pentru fiecare valoare din listă, se calculează pe ce rând din grilă se află griul cu acea valoare (utilizând formula pentru calculul rândului unui gri dat în funcție de valoarea acestuia). Pe măsură ce se calculează rândurile, se actualizează valoarea lui r și numărul de griuri în același rând. Se calculează apoi numărul de salturi necesare pentru a ajunge la următorul gri în ordinea dată de valorile din listă. Dacă se găsește un salt către un gri care nu urmează în mod corect după ultimul gri, atunci se adaugă încă un salt pentru a ajunge la următorul gri corect. În cele din urmă, se calculează numărul de salturi necesare pentru a ajunge la toate griurile care nu au fost deja parcurse în lista de valori introdusă.

Funcția "main" apelează celelalte funcții pentru a obține valorile r și d și le afișează utilizatorului.

2269 - Maxim Par

2023-04-28T13:11:06Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/2269/maximpar]
== Cerință ==
Se dau n numere naturale. Determinați cel mai mare număr par introdus și numărul său de apariții.
== Date de intrare ==
Fișierul de intrare '''maximpar.in''' conține pe prima linie numărul n, iar pe a doua linie n numere naturale separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''maximpar.out''' va conține pe prima linie numerele '''maxim''' si '''apare''', reprezentând maximul par dintre numerele de pe a doua linie a fișierului de intrare și aparițiile acestuia, dacă fișierul de intrare conține cel puțin un număr par, respectiv '''-1''', în caz contrar.
== Restricții și precizări ==
* 1 ≤ '''n''' ≤ 200
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1.000'''
== Exemplu ==
; '''maximpar.in'''
: 6
: 9 6 9 8 9 8
; '''maximpar.out'''
: 8 2
== Explicație ==
În fișierul de intrare sunt '''6''' numere, cel mai mare număr par este '''8''' și apare de '''2''' ori.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
with open("maximpar.in") as fin:
n = int(fin.readline())
if n >= 1 and n <= 200:
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 = []
with open("maximpar.in") as fin:
fin.readline() # skip first line
for i in range(n):
while True:
try:
valoare = int(fin.readline())
if valoare <= 1000:
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.")

return valori

def numere_maxime(valori):
maxi, apare = -1, 0
for valoare in valori:
if valoare % 2 == 0:
if valoare > maxi:
maxi = valoare
apare = 1
elif valoare == maxi:
apare += 1
return maxi, apare

def scrie_rezultat(maxi, apare):
with open("maximpar.out", "w") as fout:
if apare != 0:
fout.write(f"{maxi} {apare}")
else:
fout.write("-1")

if _name_ == '_main_':
n = citeste_n()
valori = citeste_valori(n)
x, y = numere_maxime(valori)
print("Cele mai mari numere sunt:", x, "și apare de", y, "ori")
scrie_rezultat(x, y)
</syntaxhighlight>
== Explicatie ==
Acest cod este o implementare în Python a unei probleme de programare. Scopul problemei este de a citi un număr n și o listă de n numere dintr-un fișier de intrare și de a găsi cel mai mare număr par din listă și numărul său de apariții. Apoi, cele două valori găsite trebuie scrise într-un fișier de ieșire.

Funcția citeste_n() citește primul număr din fișierul de intrare, care este numărul n de numere care urmează.
Dacă acesta se încadrează în limitele cerute, funcția returnează n, altfel afișează un mesaj de eroare și încearcă din nou să citească n. Această funcție este apelată în funcția principală (if _name_ == '_main_':) pentru a obține numărul de elemente din listă.

Funcția citeste_valori(n) citește cele n numere din fișierul de intrare și verifică dacă fiecare valoare este mai mică sau egală cu 1000. Dacă o valoare este validă, aceasta este adăugată la lista valori, iar dacă nu, se afișează un mesaj de eroare. Funcția returnează lista de valori citite.

Funcția numere_maxime(valori) găsește cel mai mare număr par din lista valori și numărul său de apariții.
Variabilele maxi și apare sunt inițializate cu -1 și 0, respectiv. Pentru fiecare valoare din lista valori, dacă aceasta este un număr par și mai mare decât valoarea curentă a lui maxi, atunci maxi este actualizat cu această valoare și apare este resetat la 1. Dacă valoarea este egală cu maxi, apare este incrementat cu 1. La final, funcția returnează cele două valori găsite.

Funcția scrie_rezultat(maxi, apare) scrie cele două valori în fișierul de ieșire "maximpar.out". Dacă valoarea apare este diferită de 0, atunci se scriu cele două valori separate printr-un spațiu. Altfel, se scrie -1.

În funcția principală (if _name_ == '_main_':), se apelează mai întâi citeste_n() pentru a obține numărul de elemente din listă și citeste_valori(n) pentru a citi lista de valori. Apoi, se apelează numere_maxime(valori) pentru a găsi cele mai mari numere și se afișează pe ecran. În final, se apelează funcția scrie_rezultat(maxi, apare) pentru a scrie cele două valori în fișierul de ieșire.

3736 - Sir 15

2023-04-28T13:08:29Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/3736/sir15] == Enunt == Se dă un șir format din '''N''' numere naturale nenule. Elementele șirului sunt numerotate de la stânga la dreapta începând cu poziția '''1'''. == Cerință == Scrieți un program care să determine răspunsul pentru întrebări de următoarele tipuri: 1. Care este cea mai din stânga poziție care conține o valoare strict mai mare decât toate cele din dreapta sa? – întrebare de tipul 1 2. Care sunt p...

Sursă: [https://www.pbinfo.ro/probleme/3736/sir15]
== Enunt ==
Se dă un șir format din '''N''' numere naturale nenule. Elementele șirului sunt numerotate de la stânga la dreapta începând cu poziția '''1'''.
== Cerință ==
Scrieți un program care să determine răspunsul pentru întrebări de următoarele tipuri:
1. Care este cea mai din stânga poziție care conține o valoare strict mai mare decât toate cele din dreapta sa? – întrebare de tipul 1
2. Care sunt pozițiile care conțin valori strict mai mari decât toate cele din stânga lor? – întrebare de tipul 2
3. Dacă fiecărui element aflat între prima și ultima apariție a maximului i-am mări valoarea pentru a ajunge egal cu maximul, care este suma totală a valorilor adăugate? – întrebare de tipul 3
== Date de intrare ==
Fișierul de intrare '''sir.in''' conține pe prima linie un număr '''C''' (care poate fi '''1, 2 sau 3'''), indicând tipul întrebării. Pe linia a doua se află un număr natural '''N''', reprezentând numărul de elemente din șir. Pe a treia linie a fișierului de intrare se află '''N''' numere naturale, reprezentând elementele șirului, date de la stânga la dreapta (cel mai din stânga are poziția '''1''' și cel mai din dreapta are poziția '''N'''). Numerele de pe această linie sunt separate prin câte un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Dacă '''C = 1''', fișierul de ieșire '''sir.out''' trebuie să conțină un număr natural ce reprezintă răspunsul la o întrebare de tipul '''1'''. Dacă '''C = 2''', fișierul de ieșire trebuie să conțină, separați prin câte un spațiu și în ordine crescătoare, indicii determinați ca răspuns la o întrebare de tipul '''2'''. Dacă '''C = 3''', fișierul de ieșire trebuie să conțină un număr ce reprezintă răspunsul la o întrebare de tipul '''3'''. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ C ≤ 3'''
* '''1 ≤ N ≤ 100.000'''
* Numerele din șirul dat sunt cuprinse între 1 și 10.000, inclusiv.
* Pentru teste în valoare de 24 de puncte avem '''C = 1'''.
* Pentru teste în valoare de 32 de puncte avem '''C = 2'''.
* Pentru teste în valoare de 44 de puncte avem '''C = 3'''.
== Exemple ==
=== Exemplu 1 ===
; '''sir.in'''
: 1
: 7
: 3 2 2 5 3 5 4
; '''sir.out'''
: 6
==== Explicatie ====
Cea mai din stânga poziție a unei valori care este mai mare decât toate cele din dreapta sa este '''6''' (acolo unde se află valoarea '''5''')
=== Exemplu 2 ===
; '''sir.in'''
: 2
: 7
: 3 2 2 5 3 5 4
; '''sir.out'''
: 1 4
==== Explicatie ====
'''1''' și '''4''' sunt pozițiile unde se află valori mai mari decât toate cele din stânga lor.
=== Exemplu 3 ===
; '''sir.in'''
: 3
: 8
: 3 2 2 5 3 1 5 4
; '''sir.out'''
: 6
==== Explicatie ====
Maximul fiind '''5''', conform explicației de la întrebarea de tipul '''3''', trebuie mărite două elemente pentru a ajunge egale cu '''5'''. Acestea sunt cel aflat pe poziția '''5''' (de mărit cu '''2''') precum și cel de pe poziția '''6''' (de mărit cu'''4'''). Suma valorilor cu care avem de mărit este '''2 + 4 = 6'''.
=== Exemplu 4 ===
; '''sir.in'''
: 3
: 5
: 3 2 7 5 3
; '''sir.out'''
: 0
==== Explicatie ====
Maximul este '''7''' și apare o singură dată, deci nu se mai mărește nicio valoare.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
with open("sir.in") as fin:
c = int(fin.readline().strip())
n = int(fin.readline().strip())
if 1 <= c <= 3 and 1 <= n <= 100000:
print("Datele sunt corecte.")
return c, n
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_valori(n):
valori = []
with open("sir.in") as fin:
fin.readline()
fin.readline()
for line in fin:
for valoare in line.split():
try:
valoare = int(valoare)
if valoare > 1 and valoare <= 10000:
print("Datele sunt corecte.")
valori.append(valoare)
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori naturale cu mai putin de 9 cifre.")
return valori

def sir(c, n, valori):
# Cerinta 1
if c == 1:
max_val = valori[0]
max_pos = 0
ans = -1
for i in range(1, n):
if valori[i] > max_val:
max_val = valori[i]
max_pos = i
elif valori[i] < max_val and i > max_pos:
ans = max_pos + 1
break
with open("sir.out", "w") as fout:
fout.write(str(ans))

# Cerinta 2
elif c == 2:
max_val = valori[0]
ans = []
for i in range(1, n):
if valori[i] > max_val:
max_val = valori[i]
elif valori[i] < max_val and i > 1:
ans.append(str(i))
with open("sir.out", "w") as fout:
fout.write(" ".join(ans))

# Cerinta 3
elif c == 3:
max_val = max(valori)
max_pos = [i for i, j in enumerate(valori) if j == max_val]
ans = 0
for i in range(max_pos[0]+1, max_pos[-1]):
ans += max_val - valori[i]
with open("sir.out", "w") as fout:
fout.write(str(ans))

if _name_ == "_main_":
c, n = citeste_n()
valori = citeste_valori(n)
sir(c, n, valori)
</syntaxhighlight>
== Explicatie ==
Acest cod este o implementare Python a unui algoritm pentru rezolvarea unei probleme matematice, descrisă în enunțul pe care l-ai furnizat anterior.

Funcția citeste_n este utilizată pentru a citi valorile necesare din fișierul de intrare, respectiv tipul întrebării c și lungimea șirului n. Această funcție verifică dacă valorile citite sunt valide în conformitate cu restricțiile impuse de cerințe și returnează valorile citite.

Funcția citeste_valori este utilizată pentru a citi valorile din fișierul de intrare și verifica dacă sunt valide. Aceasta construiește o listă de valori valori și o returnează.

Funcția sir primește lista de valori valori și implementează algoritmii necesari pentru a determina răspunsurile la întrebările specifice. În funcție de tipul întrebării c, se aplică o strategie diferită pentru a obține rezultatul corect. Rezultatele sunt scrise în fișierul de ieșire "sir.out".

În final, se citește tipul întrebării și lista de valori din fișierul de intrare și se apelează funcția sir pentru a obține rezultatul.

2935 - Robot 5

2023-04-28T12:57:05Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/2935/robot5] == Cerință == Pe un cerc se află '''N''' poziții, consecutiv așezate și notate cu '''1,2,3,...,N'''. Distanțele între oricare două poziții vecine sunt egale cu un pas. Un robot se află inițial la poziția '''1'''. În una dintre poziții se află un depozit cu cantitatea '''X''' de energie, de la care robotul se poate alimenta. Robotul se poate deplasa pe cerc numai în sensul acelor de ceas. Robotul poate păst...

Sursă: [https://www.pbinfo.ro/probleme/2935/robot5]
== Cerință ==
Pe un cerc se află '''N''' poziții, consecutiv așezate și notate cu '''1,2,3,...,N'''. Distanțele între oricare două poziții vecine sunt egale cu un pas. Un robot se află inițial la poziția '''1'''. În una dintre poziții se află un depozit cu cantitatea '''X''' de energie, de la care robotul se poate alimenta. Robotul se poate deplasa pe cerc numai în sensul acelor de ceas. Robotul poate păstra o cantitate maximă '''W''' de energie, iar inițial este alimentat la capacitate maximă. Pentru fiecare pas robotul cheltuiește o unitate de energie.
1) Precizându-se numărul de poziții '''N''', energia inițială a robotului '''W''', poziția '''P''' a depozitului și cantitatea '''X''' de energie existentă inițial în depozit, se cere să se precizeze numărul de pași pe care îi poate efectua robotul.
2) Precizându-se numărul de poziții '''N''', energia inițială a robotului '''W''' și cantitatea '''X''' de energie existentă inițial în depozit, se vor determina și afișa numărul maxim de pași pe care îi poate efectua robotul și cea mai mică poziție, convenabil aleasă, unde se poate instala depozitul pentru obținerea numărului maxim de pași.
== Date de intrare ==
Pe primul rând al fișierului text '''robot5.in''' se află numărul natural '''C''' reprezentând cerința.
Dacă '''C=1''', atunci pe al doilea rând și separate prin câte un spațiu se vor afla scrise numerele naturale '''N, W, X și P'''.
Dacă '''C=2''', atunci pe al doilea rând și separate prin câte un spațiu se vor afla scrise numerele naturale '''N, W și X'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Dacă '''C=1''', atunci în fișierul de ieșire '''robot5.out''' se va scrie un număr natural reprezentând numărul de pași pe care îi poate efectua robotul, iar dacă '''C=2''', atunci în fișierul text '''robot5.out''' se vor scrie două numere naturale separate prin spațiu reprezentând numărul maxim de pași pe care îi poate efectua robotul și cea mai mică poziție a depozitului, convenabil aleasă pentru obținerea numărului maxim de pași. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* Când ajunge la depozit robotul se alimentează cu maximul de energie posibil, iar cantitatea de energie din depozit scade corespunzător.
* '''2 ≤ N ≤ 10.000'''
* '''1 ≤ W ≤ 1.000.000.000'''
* '''1 ≤ X ≤ 1.000.000.000'''
* '''1 ≤ P ≤ N'''
== Exemple ==
=== Exemplu 1 ===
;'''robot5.in'''
: 1
: 6 3 3 3
; '''robot5.out'''
: 5
==== Explicatie ====
Avem cerința '''1''', câți pași va putea face robotul. El are inițial '''3''' unități de energie și se află la poziția '''1''' și deci va putea ajunge la poziția '''3''' din '''2''' pași folosind '''2''' unități de energie. Când ajunge la poziția '''3''' mai are '''1''' unitate de energie și se alimentează din depozit cu '''2''' unități, refăcând cele '''3''' unități de energie maxim posibile. Mai poate face '''3''' pași și astfel ajunge la poziția '''6''' cu '''0''' unități de energie și se oprește. În total a efectuat '''5''' pași.
=== Exemplu 2 ===
;'''robot5.in'''
: 2
: 6 3 3
; '''robot5.out'''
: 6 4
==== Explicatie ====
Depozitul se va instala la poziția '''4''' și robotul va putea efectua '''6''' pași, care este maxim.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
import sys
def citeste_n():
while True:
try:
with open("robot5.in") as fin:
c = int(fin.readline().strip())
if c >= 1 and c <= 2:
print("Datele sunt corecte.")
return c
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_perechi(c):
valori = []
with open("robot5.in") as fin:
next(fin)
for i in range(1):
try:
line = fin.readline().strip()
if not line:
raise ValueError("Linia este goala.")
if c == 1:
N, W, X, P = map(int, line.split())
if 2 <= N <= 100000 and 1 <= W <= 1000000000 and 1 <= X <= 1000000000 and 1 <= P <= N:
print("Datele sunt corecte.")
valori.append((N, W, X, P))
else:
print("Datele nu sunt conform restrictiilor impuse.")
else:
N, W, X = map(int, line.split())
if 2 <= N <= 100000 and 1 <= W <= 1000000000 and 1 <= X <= 1000000000:
print("Datele sunt corecte.")
valori.append((N, W, X))
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError as e:
print(f"Linia {i+2}: {e}")
valori.append(None)

return [v for v in valori if v is not None]

def robot5(valori):
rezultate = []
for valoare in valori:
N, W, X = valoare[:3]
if len(valoare) == 4:
P = valoare[3]
distanta = min(N - P + 1, P) - 1
pasi = min(distanta, W // X)
else:
pasi = W // X

rezultate.append(pasi)

with open("robot5.out", "w") as fout:
for rezultat in rezultate:
fout.write(str(rezultat) + "\n")
if len(valoare) == 3:
pozitie = -1
max_pasi = 0
for i in range(1, N + 1):
distanta = min(N - i + 1, i) - 1
pasi = min(distanta, W // X)
if pasi > max_pasi:
max_pasi = pasi
pozitie = i
fout.write(str(max_pasi) + " " + str(pozitie) + "\n")

if _name_ == '_main_':
n = citeste_n()
valori = citeste_perechi(n)
robot5(valori)
</syntaxhighlight>
== Explicatie ==
Acest cod are ca scop citirea datelor dintr-un fișier de intrare și apoi procesarea acestora pentru a obține un rezultat, care este scris într-un fișier de ieșire.

Funcția citeste_n() deschide fișierul "robot5.in" și citește prima linie, care ar trebui să conțină un număr întreg c. Aceasta verifică dacă c este în intervalul [1, 2]. Dacă este, funcția returnează valoarea c, în caz contrar afișează un mesaj de eroare și cere introducerea unui alt număr.

Funcția citeste_perechi(c) deschide fișierul "robot5.in" și citește linia a doua, apoi procesează fiecare linie pentru a verifica dacă datele sunt conforme cu cerințele problemei. Aceasta verifică dacă valorile citite sunt întregi și se încadrează în intervalele specificate. Dacă valorile sunt conforme, ele sunt adăugate la lista de valori de returnat, altfel este afișat un mesaj de eroare.

Funcția robot5(valori) primește lista de valori prelucrate și apoi calculează pentru fiecare valoare numărul de pași pe care îi poate face robotul, având în vedere restricțiile din enunțul problemei. Aceasta adaugă rezultatul obținut într-o listă de rezultate.

În cele din urmă, funcția robot5(valori) scrie fiecare rezultat într-un fișier de ieșire "robot5.out". Pentru datele care nu conțin parametrul P, se calculează distanța maximă și poziția corespunzătoare acesteia, care sunt scrise și în fișierul de ieșire.

2916 - Triviador

2023-04-28T12:47:47Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/2916/triviador] == Enunt == Elevii clasei a V-a au fost provocați de către colegii lor de la alte școli să participe la concursul TRIVIADOR. Într-o echipă participă exact trei elevi care trebuie să răspundă la întrebări de cultură generală, obținând punctaje individuale. Punctajul unei echipe este suma punctajelor obținute de către membrii acesteia. == Cerință == Date '''n''', numărul de echipe și punctajele indivi...

Sursă: [https://www.pbinfo.ro/probleme/2916/triviador]
== Enunt ==
Elevii clasei a V-a au fost provocați de către colegii lor de la alte școli să participe la concursul TRIVIADOR. Într-o echipă participă exact trei elevi care trebuie să răspundă la întrebări de cultură generală, obținând punctaje individuale. Punctajul unei echipe este suma punctajelor obținute de către membrii acesteia.
== Cerință ==
Date '''n''', numărul de echipe și punctajele individuale ale membrilor fiecăreia, să se determine cele mai mari două punctaje diferite, obținute de către echipele participante. Dacă nu există două punctaje diferite, se va afișa mesajul '''TOTI SUNT CASTIGATORI'''
== Date de intrare ==
Fișierul de intrare '''triviador.in''' conține pe prima linie '''n''', numărul de echipe și pe următoarele '''n''' linii, câte trei numere separate printr-un spațiu, reprezentând punctajele celor trei membri ai fiecărei echipe.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''triviador.out''' va conţine pe prima linie două valori, în ordine descrescătoare, reprezentând cele mai mari două punctaje diferite obținute de către echipele participante sau mesajul '''TOTI SUNT CASTIGATORI''' dacă nu sunt două valori maxime diferite. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''2 ≤ n ≤ 10.000'''
* '''0 ≤ punctaj ≤ 100.000'''
== Exemple ==
=== Exemplu 1 ===
; '''triviador.in'''
: 5
: 7 2 5
: 1 4 2
: 3 3 7
: 0 9 5
: 6 2 2
; '''triviador.out'''
: 14 13
==== Explicatie ====
Echipele obțin următoarele punctaje: '''14=7+2+5''', '''7=1+4+2''', '''13=3+3+7''', '''14=0+9+5''', '''10=6+2+2'''. Cele două punctaje maxime diferite sunt '''14 13'''.
=== Exemplu 2 ===
; '''triviador.in'''
: 3
: 2 2 3
: 1 0 6
: 4 1 2
; '''triviador.out'''
: TOTI SUNT CASTIGATORI
==== Explicatie ====
Echipele obțin punctaje egale cu '''7''' și se va afișa '''TOTI SUNT CASTIGATORI'''.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
with open("triviador.in") as fin:
n = int(fin.readline().strip())
if n >= 2 and n <= 100000:
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 = []
with open("triviador.in") as fin:
next(fin)
for i in range(n):
while True:
try:
valoare1, valoare2, valoare3 = map(int, fin.readline().strip().split())
if 0 <= valoare1 <= 100000 and 0 <= valoare2 <= 100000 and 0 <= valoare3 <= 100000:
print("Datele sunt corecte.")
valori.append((valoare1, valoare2, valoare3))
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori numerice.")

return valori

def triviador(valori):
s = []
for i in range(len(valori)):
x, y, z = valori[i]
s.append(x + y + z)
s.sort()
if len(set(s)) == 1:
with open("triviador.out", "w") as fout:
fout.write("TOTI SUNT CASTIGATORI")
else:
max1, max2 = 0, 0
for i in range(len(s) - 1, -1, -1):
if max1 == 0 and max2 == 0:
max1 = s[i]
elif max1 != 0 and max2 == 0:
if s[i] > max2 and s[i] != max1:
max2 = s[i]
with open("triviador.out", "w") as fout:
fout.write(str(max1) + " " + str(max2))

if _name_ == '_main_':
try:
c, n, k = 1, 0, 0
n = citeste_n()
valori = citeste_perechi(n)
triviador(valori)
except (ValueError, IndexError):
print("Eroare: formatul fișierului 'triviador.in' este incorect!")
</syntaxhighlight>
== Explicatie ==
Acest cod este o implementare a unei soluții pentru o problemă numită "Triviador". Mai exact, soluția începe prin citirea unui număr întreg dintr-un fișier numit "triviador.in", reprezentând numărul de perechi de numere ce urmează să fie citite. În cazul în care numărul citit nu se încadrează în intervalul [2, 100000], se va afișa un mesaj de eroare și se va cere introducerea unui nou număr. În caz contrar, se va afișa un mesaj de confirmare și se va continua cu citirea perechilor de numere.

Pentru citirea perechilor de numere, funcția "citeste_perechi" va itera prin fiecare pereche și va verifica dacă valorile se încadrează în intervalul [0, 100000]. În caz contrar, se va afișa un mesaj de eroare și se va cere introducerea unor noi valori. În cazul în care valorile sunt corecte, se va afișa un mesaj de confirmare și se vor adăuga valorile într-o listă "valori".

Funcția "triviador" primește lista "valori" și calculează suma fiecărei perechi de numere. Aceste sume sunt adăugate într-o listă "s", sortate și verificate dacă toate sunt egale. În caz afirmativ, se va scrie mesajul "TOTI SUNT CASTIGATORI" în fișierul "triviador.out". În caz contrar, se vor identifica cele două cele mai mari valori din lista "s" și se vor scrie în fișierul "triviador.out".

În "if name == 'main':" se apelează funcțiile "citeste_n", "citeste_perechi" și "triviador" în ordine, iar în cazul în care apare o excepție de tipul ValueError sau IndexError se va afișa un mesaj de eroare. În final, se va scrie rezultatul în fișierul "triviador.out".

1753 - Concurs 2

2023-04-27T18:30:23Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1753/concurs2] == Cerinţa == La un concurs de programare s-au înscris n elevi. Concursul se desfăşoară pe două secţiuni, secţiunea 1 pentru începători şi secţiunea 2 avansaţi. Proba de concurs se desfăşoară pe parcursul a 3 ore şi elevii au de rezolvat 2 probleme. Fiecare problemă poate avea punctajul minim de 0 puncte şi punctajul maxim de 100 de puncte. Punctajul final al concurentului este format din suma punctajel...

Sursă: [https://www.pbinfo.ro/probleme/1753/concurs2]
== Cerinţa ==
La un concurs de programare s-au înscris n elevi. Concursul se desfăşoară pe două secţiuni, secţiunea 1 pentru începători şi secţiunea 2 avansaţi. Proba de concurs se desfăşoară pe parcursul a 3 ore şi elevii au de rezolvat 2 probleme.
Fiecare problemă poate avea punctajul minim de 0 puncte şi punctajul maxim de 100 de puncte. Punctajul final al concurentului este format din suma punctajelor celor două probleme. Să se scrie un program care citeşte numărul de elevi înscrişi şi apoi date despre fiecare elev înscris (secţiunea la care s-a înscris, punctajul obţinut pentru prima problema şi punctajul obţinut pentru a două problemă) și rezolvă următoarele cerinţe:
1. Afișează mesajul DA dacă toţi cei N elevi înscrişi au reuşit să obţină un punctaj nenul la ambele probleme propuse, respectiv NU” în caz contrar.
2. Afişează pentru fiecare secţiune numărul de elevi înscrişi. Afişarea se va face în ordinea crescătoare a numărului secţiunii, prin perechi de numere de forma '''nr_secţiune nr_elevi'''.
3. Afişaţi pentru fiecare secţiune punctajul maxim obţinut şi numărul de elevi care au obţinut acest punctaj. Afişarea se va face în ordinea crescătoare a numărului secţiunii, prin triplete de numere de forma '''nr_secţiune punctaj_maxim nr_elevi'''. Ştiind ca premiile se acordă doar celor care au luat punctaj maxim, afişaţi şi numărul de premii care vor fi acordate.
== Date de intrare ==
Fişierul de intrare '''concurs2.in''' conţine pe prima linie un număr natural '''C'''. Pentru toate testele de intrare, numărul '''C''' are una din valorile '''1, 2 sau 3'''. Pe linia a doua a fișierului se găseşte numărul natural '''N''' – numărul de elevi înscrişi iar pe următoarele '''N''' linii, separate prin spaţiu,trei numere S '''P1 P2''' cu semnificaţia: '''S''' secţiunea la care participă elevul, '''P1''' punctajul obţinut la prima problemă şi '''P2''' punctajul obţinut la a doua problemă.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.".Dacă C=1, se va rezolva numai punctul 1). În acest caz, în fişierul de ieşire concurs2.out se va scrie un singur mesaj DA sau NU.
Dacă C=2, se va rezolva numai punctul 2). În acest caz, în fişierul de ieşire
concurs2.out se vor scrie 2 linii, pe fiecare linie o pereche de numere, separate prin spaţiu reprezentând valorile cerinţei 2.
Dacă C=3, se va rezolva numai punctul 3). În acest caz, în fişierul de ieşire
concurs2.out se vor scrie 3 linii, pe primele două linii câte un triplet de numere separate prin spaţiu reprezentând valorile cerinţei 3 iar pe ultima linie numărul de premii. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 <= C <= 3,'''
* '''1 <= S <= 2'''
* '''0 < n <= 300'''
* '''0 <= P1,P2 <= 100'''
== Exemple ==
=== Exemplu 1 ===
; '''concurs2.in'''
: 1
: 7
: 1 100 100
: 2 100 100
: 1 50 0
: 1 100 100
: 2 0 40
: 1 100 100
: 2 30 70
; '''concurs2.out'''
: NU
==== Explicatie ====
Există elevi care au punctajul 0 la probleme.
=== Exemplu 2 ===
; '''concurs2.in'''
: 2
: 7
: 1 100 100
: 2 100 100
: 1 50 0
: 1 100 100
: 2 0 40
: 1 100 100
: 2 30 70
; '''concurs2.out'''
: 1 4
: 2 3
==== Explicatie ====
La secțiunea 1 sunt 4 înscriși iar la secțiunea 2 sunt 3 înscriși.
=== Exemplu 3 ===
; '''concurs2.in'''
: 3
: 7
: 1 100 100
: 2 100 100
: 1 50 0
: 1 100 100
: 2 0 40
: 1 100 100
: 2 30 70
; '''concurs2.out'''
: 1 200 3
: 2 200 1
: 4
==== Explicatie ====
La secţiunea 1 punctajul maxim (200) a fost obţinut de 3 elevi. La secţiunea 2 punctajul maxim (200) a fost obţinut de 1 elev. Număr de premii 4.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def verifica_punctaje(n, elevi):
for elev in elevi:
if elev[1] < 5 or elev[2] < 5:
print("Datele sunt conform restrictiilor impuse.")
else:
print("Datele sunt conform restrictiilor impuse.")
return

def verifica_date(elevi):
for elev in elevi:
if elev[1] == 0 or elev[2] == 0:
print("Datele sunt conform restrictiilor impuse.")
else:
print("Datele sunt conform restrictiilor impuse.")
return

def numar_elevi_pe_sectiuni(n, elevi):
sectiuni = [0, 0]
for elev in elevi:
sectiuni[elev[0]-1] += 1
return sectiuni

def max_punctaj_pe_sectiuni(n, elevi):
max_punctaje = [0, 0]
nr_max_punctaje = [0, 0]
for elev in elevi:
sectiune = elev[0]-1
punctaj = elev[1] + elev[2]
if punctaj > max_punctaje[sectiune]:
max_punctaje[sectiune] = punctaj
nr_max_punctaje[sectiune] = 1
elif punctaj == max_punctaje[sectiune]:
nr_max_punctaje[sectiune] += 1

with open("concurs2.out", "w") as f:
if verifica_punctaje(n, elevi):
f.write("DA\n")
else:
f.write("NU\n")

nr_elevi = numar_elevi_pe_sectiuni(n, elevi)
f.write(f"{1} {nr_elevi[0]}\n{2} {nr_elevi[1]}\n")

for i in range(2):
f.write(f"{i+1} {max_punctaje[i]} {nr_max_punctaje[i]}\n")

nr_premii = nr_max_punctaje.count(1)
f.write(str(nr_premii))

def rezolva_concursul(n, elevi):
verifica_date(elevi)
max_punctaj_pe_sectiuni(n, elevi)
</syntaxhighlight>
== Explicație ==
Acest cod este o implementare a unei funcții care primește o listă de elevi, fiecare cu sectiunea sa (1 sau 2), punctajul la prima problemă și punctajul la a doua problemă. Scopul funcției este de a determina și afișa într-un fișier următoarele informații:

Dacă toți elevii au obținut punctaje pozitive la ambele probleme, se va scrie "DA" în fișier. În caz contrar, se va scrie "NU".
Numărul de elevi din fiecare sectiune.
Cel mai mare punctaj obținut la fiecare dintre cele două secțiuni, precum și numărul de elevi care au obținut acel punctaj.
Numărul de elevi care au obținut cel mai mare punctaj din fiecare sectiune și care primesc un premiu.
Codul începe prin a defini o funcție auxiliară "verifica_punctaje" care verifică dacă toți elevii au obținut punctaje pozitive la ambele probleme.

Următoarele două funcții, "numar_elevi_pe_sectiuni" și "max_punctaj_pe_sectiuni", sunt folosite pentru a calcula numărul de elevi din fiecare sectiune și cel mai mare punctaj obținut în fiecare sectiune.

Funcția "max_punctaj_pe_sectiuni" utilizează o listă pentru a păstra cel mai mare punctaj obținut în fiecare sectiune și o altă listă pentru a număra câți elevi au obținut acel punctaj.

Codul finalizează prin deschiderea unui fișier "concurs2.out" în modul de scriere și apelarea funcțiilor auxiliare pentru a obține datele necesare, pe care le scrie în fișierul respectiv.

1051 - Bete 1

2023-04-27T17:54:20Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1051/bete1] == Enunt == Ana şi Bogdan au găsit la bunicul lor o cutie cu '''N''' beţe de aceeaşi lungime. După câteva minute de joacă urmează cearta. Bunicul le-a propus să rupă cele '''N''' beţe și apoi Ana să primească fragmentele din mâna stângă, iar Bogdan fragmentele din mâna dreaptă. Zis şi făcut. Copiii au luat fragmentele, le-au numerotat fiecare cu numere de la '''1''' la '''N''', le-au măsurat şi acum î...

Sursă: [https://www.pbinfo.ro/probleme/1051/bete1]
== Enunt ==
Ana şi Bogdan au găsit la bunicul lor o cutie cu '''N''' beţe de aceeaşi lungime. După câteva minute de joacă urmează cearta. Bunicul le-a propus să rupă cele '''N''' beţe și apoi Ana să primească fragmentele din mâna stângă, iar Bogdan fragmentele din mâna dreaptă. Zis şi făcut. Copiii au luat fragmentele, le-au numerotat fiecare cu numere de la '''1''' la '''N''', le-au măsurat şi acum îşi doresc să lipească fragmentele primite, dar mai au nevoie de câteva informaţii.
== Cerință ==
Cunoscând '''N''' numărul de beţe, '''a1, a2,…, aN''' lungimile fragmentelor primite de Ana şi '''b1, b2,…, bN''' lungimile fragmentelor primite de Bogdan, să se scrie un program care să determine:

a) lungimea iniţială a beţelor;
b) lungimea celui mai lung băţ care se poate obţine prin lipirea unui fragment aparţinând Anei cu un fragment care aparţine lui Bogdan;
c) numărul beţelor de lungime maximă care se pot obţine prin lipirea unui fragment aparţinând Anei cu un fragment care aparţine lui Bogdan.
== Date de intrare ==
Fișierul de intrare '''bete1.in''' conține pe prima linie numărul natural '''N''' reprezentând numărul de beţe. Pe a doua linie sunt '''N''' numere naturale'''a1, a2,…, aN''' reprezentând lungimile fragmentelor primite de Ana şi pe a treia linie sunt '''N''' numere naturale '''b1, b2,…, bN''' reprezentând lungimile fragmentelor primite de Bogdan.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''bete1.out''' va conține trei linii. Pe prima linie se va scrie numărul natural '''L''' reprezentând lungimea iniţială a beţelor, pe a doua linie se va scrie numărul natural '''K''' reprezentând lungimea celui mai lung băţ care se poate obţine prin lipirea unui fragment aparţinând Anei cu un fragment care aparţine lui Bogdan, iar pe a treia linie se va scrie numărul natural '''P''' reprezentând numărul beţelor de lungime maximă care se pot obţine prin lipirea unui fragment aparţinând Anei cu un fragment care aparţine lui Bogdan. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ N ≤ 1000'''
* '''1 ≤ ai ≤ 10.000, (1 ≤ i ≤ N)'''
* '''1 ≤ bi ≤ 10.000, (1 ≤ i ≤ N)'''
* '''1 ≤ L ≤ 20.000'''
* '''1 ≤ K ≤ 20.000'''
* '''1 ≤ P ≤ 1000'''
== Exemple ==
=== Exemplu 1 ===
; '''bete1.in'''
: 6
: 2 6 7 1 3 5
: 5 4 7 8 9 3
; '''bete1.out'''
: 10
: 16
: 1
==== Explicatie ====
Lungimea iniţială este '''10''', lungimea maximă este '''16''' și se poate forma un singur băţ de lungime '''16'''.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def verificare_restrictii(n, a, b):
try:
if 1 <= n <= 1000:
print("n este conform restrictiilor impuse.")
else:
print("n nu este conform restrictiilor impuse.")
exit()

for lungime in a:
if 1 <= lungime <= 10000:
print(f"Lungimea {lungime} este conform restrictiilor impuse.")
else:
print(f"Lungimea {lungime} nu este conform restrictiilor impuse.")
exit()

for lungime in b:
if 1 <= lungime <= 10000:
print(f"Lungimea {lungime} este conform restrictiilor impuse.")
else:
print(f"Lungimea {lungime} nu este conform restrictiilor impuse.")
exit()

except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def bete1():
with open("bete1.in") as fin, open("bete1.out", "w") as fout:
n = int(fin.readline())
a = list(map(int, fin.readline().split()))
b = list(map(int, fin.readline().split()))

verificare_restrictii(n, a, b)

lungime_initiala = sum(a) + sum(b)
k = max([x+y for x in a for y in b])
p = sum([1 for x in a for y in b if x+y == k])

fout.write(str(lungime_initiala) + "\n")
fout.write(str(k) + "\n")
fout.write(str(p))

return n, a, b

if _name_ == "_main_":
n, a, b = bete1()
print("Lungimea initiala a betelor:", sum(a) + sum(b))
print("Lungimea celui mai lung bat:", max([x+y for x in a for y in b]))
print("Numarul betelor de lungime maxima:", sum([1 for x in a for y in b if x+y == max([x+y for x in a for y in b])]))
</syntaxhighlight>
== Explicatie ==

2874 - Sort Matrix Col

2023-04-27T17:45:41Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/2874/sortmatrixcol] == Cerință == Se dă o matrice cu '''n''' linii și '''m''' coloane și un caracter '''c''' care poate fi '''+''' sau '''-'''. Să se sorteze, după linii, matricea crescător dacă semnul este '''+''' sau descrescător dacă semnul este '''-'''. Sortarea matricei după coloane este rearanjarea elementelor astfel încât, parcurgând matricea pe coloane, de la stânga la dreapta și de sus în jos, elementele sunt...

Sursă: [https://www.pbinfo.ro/probleme/2874/sortmatrixcol]
== Cerință ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și un caracter '''c''' care poate fi '''+''' sau '''-'''. Să se sorteze, după linii, matricea crescător dacă semnul este '''+''' sau descrescător dacă semnul este '''-'''.
Sortarea matricei după coloane este rearanjarea elementelor astfel încât, parcurgând matricea pe coloane, de la stânga la dreapta și de sus în jos, elementele sunt în ordine crescătoare/descrescătoare.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' și '''m''' și caracterul '''c''', iar apoi '''n''' linii cu '''m''' numere naturale. Fiecare linie pe câte un rând, toate numerele de pe fiecare linie separate prin spații unul de celălalt.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul va afișa pe ecran matricea sortată conform cerinței, câte o linie a matricei pe o linie a ecranului, elementele fiecărei linii 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 ≤ n ≤ m ≤ 100'''
* elementele matricei vor fi mai mici sau egale cu ''''1.000'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 5 4 +
: 2 4 1 3
: 9 8 7 6
: 20 19 18 16
: 30 29 124 12
: 59 21 0 3
; Date de ieșire
: 0 4 12 21
: 1 6 16 29
: 2 7 18 30
: 3 8 19 59
: 3 9 20 124
=== Exemplu 2 ===
; Date de intrare
: 5 4 -
: 2 4 1 3
: 9 8 7 6
: 20 19 18 16
: 30 29 124 12
: 59 21 0 3
; Date de ieșire
: 124 20 9 3
: 59 19 8 3
: 30 18 7 2
: 29 16 6 1
: 21 12 4 0
== 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):
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 SortMatrixCol(n, m, matrice):
semn = input("Introduceti caracterul + sau -: ")

# transforma matricea intr-o lista unidimensionala
lista_unidimensionala = []
for j in range(m):
for i in range(n):
lista_unidimensionala.append(matrice[i][j])

# sorteaza lista unidimensionala
if semn == '+':
lista_unidimensionala.sort()
elif semn == '-':
lista_unidimensionala.sort(reverse=True)
else:
print("Semnul trebuie să fie + sau -.")
return

# retransforma lista unidimensionala in matrice cu coloane
matrice_sortata = []
for j in range(m):
coloana_matrice = []
for i in range(n):
coloana_matrice.append(lista_unidimensionala.pop(0))
matrice_sortata.append(coloana_matrice)

# afiseaza matricea sortata
for i in range(n):
for j in range(m):
print(matrice_sortata[j][i], end=" ")
print()

if _name_ == "_main_":
n, m, matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Matricea modificata:")
SortMatrixCol(n,m,matrice)
</syntaxhighlight>
== Explicatie ==
Acest cod implementează două funcții. Funcția citire_matrice() primește input de la utilizator pentru a crea o matrice cu dimensiunile specificate și apoi citește valorile pentru fiecare element din matrice. Funcția asigură că datele introduse sunt corecte și se încadrează în limitele stabilite pentru dimensiunile matricei și valorile elementelor.

Funcția SortMatrixCol(n, m, matrice) primește matricea creată de funcția citire_matrice() și sortează coloanele în ordine crescătoare sau descrescătoare în funcție de semnul specificat de utilizator. Această funcție transformă matricea într-o listă unidimensională, sortază lista și apoi retransformă lista într-o matrice cu coloane, pe care o afișează.

Funcția main citește matricea folosind funcția citire_matrice(), afișează matricea inițială, apoi sortează matricea folosind funcția SortMatrixCol() și afișează matricea sortată.

4281 - Min 2 Cif

2023-04-26T09:38:44Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/4281/min2cif]
== Cerință ==
Se citesc de la tastatură numere naturale până la apariția lui zero. Să se determine cel mic număr citit care are două cifre.
== Date de intrare ==
Programul citește de la tastatură numere naturale. Citirea se încheie la introducerea valorii '''0'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul afișează pe ecran '''M''', cel mai mic număr citit care are două cifre. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* numerele citite vor fi mai mici decât '''10000'''
* dacă niciun număr citit nu are două cifre, se va afișa '''NU EXISTA'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
:105 63 20 4 0
; Date de ieșire
: 20
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def verificare():
numere = []
while True:
numar = input("Introduceti o valoare: ")
try:
numar = int(numar)
if numar == 0:
break
elif 10 <= numar <= 99:
print("Datele sunt corecte.")
numere.append(numar)
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie respectate cerintele.")
return numere

def Min2Cif(numere):
if len(numere) == 0:
return None
numar_min = numere[0]
for n in numere:
if n < numar_min:
numar_min = n
return numar_min

if _name_ == '_main_':
n = verificare()
MIN = Min2Cif(n)
if MIN is None:
print("NU EXISTA.")
else:
print("Cel mai mic număr cu două cifre este:", MIN)
</syntaxhighlight>
== Explicatie ==
Acest cod are ca scop găsirea celui mai mic număr cu două cifre dintr-o listă de numere întregi citite de la tastatură.

Funcția verificare inițializează o listă goală numere și utilizează o buclă while infinită pentru a citi de la tastatură valori până când se introduce valoarea zero. În interiorul buclei, se verifică dacă valoarea introdusă este un număr întreg prin încercarea conversiei la tipul int. Dacă conversia nu este posibilă, se afișează un mesaj de eroare și se continuă bucla. Dacă conversia este posibilă, se verifică dacă numărul respectă cerințele impuse, respectiv să fie un număr cu două cifre (între 10 și 99). Dacă nu respectă cerințele, se afișează un mesaj de eroare și se continuă bucla. În caz contrar, se afișează un mesaj de confirmare și se adaugă numărul la lista numere.

Funcția Min2Cif primește ca argument lista numere și parcurge fiecare element din listă pentru a găsi cel mai mic număr cu două cifre. Dacă lista este goală, se returnează None.

Blocul if _name_ == '_main_': este folosit pentru a rula codul din funcția main doar atunci când acesta este executat ca program și nu ca modul importat în alt cod. Se apelează funcția verificare pentru a citi valori de la tastatură și se salvează rezultatul în variabila n. Se apelează apoi funcția Min2Cif cu argumentul n și se salvează rezultatul în variabila MIN. Dacă MIN este None, se afișează un mesaj că "NU EXISTA." Altfel, se afișează un mesaj care indică cel mai mic număr cu două cifre găsit.

4280 - Max Div K

2023-04-26T09:34:12Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/4280/maxdivk]
== Cerință ==
Se citesc de la tastatură numerele '''n k''', apoi un șir de '''n''' numere naturale. Să se determine cel mai mare număr din șir care se divide cu '''k'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''n k''', 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 prima ecran '''M''', cel mai mare număr din șir care se divide cu '''k'''. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''n ≤ 50'''
* numerele citite vor fi mai mici decât '''10000'''
* '''k > 0'''
* dacă șirul nu conține niciun număr divizibil cu '''k''', se va afișa mesajul '''NU EXISTA'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 4 3
: 104 63 24 5
; Date de ieșire
: 63
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n_k():
while True:
try:
n = int(input("Introduceti numarul de elemente: "))
k = int(input("Introduceti numarul k: "))
if n <= 50 and k > 0:
print("Datele sunt corecte.")
return n, k
else:
print("Datele nu sunt conform restrictiilor 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(f"Introduceti valoarea {i+1}: "))
if valoare < 10000:
print("Datele sunt corecte.")
valori.append(valoare)
break
else:
print("Valoarea trebuie sa fie mai mica decat 10000.")
except ValueError:
print("Trebuie introduse doar valori naturale.")

return valori

def Max_Div_K(valori, k):
max_divisible = -1
for num in valori:
if num % k == 0 and num > max_divisible:
max_divisible = num

if max_divisible == -1:
print("NU EXISTA")
else:
print("Cel mai mare numar din sir care se divide cu k este:", max_divisible)

if _name_ == '_main_':
n, k = citeste_n_k()
valori = citeste_valori(n)
</syntaxhighlight>
== Explicatie ==
Acest cod este o implementare Python a unui program care citeste un numar n si un numar k, apoi citeste o lista de n numere si afiseaza cel mai mare numar din lista care se divide exact cu k. Programul este impartit in trei functii:

citeste_n_k() - Aceasta functie primeste de la utilizator numerele n si k si verifica daca acestea respecta anumite restrictii impuse. Daca valorile introduse sunt corecte, functia returneaza valorile n si k.

citeste_valori(n) - Aceasta functie citeste n numere de la utilizator si verifica daca fiecare numar introdus este mai mic decat 10000. Daca numarul introdus este corect, acesta este adaugat intr-o lista. Lista cu valorile introduse este returnata la sfarsitul functiei.

Max_Div_K(valori, k) - Aceasta functie primeste lista cu valorile introduse si numarul k. Functia itereaza prin lista de numere si gaseste cel mai mare numar care se divide exact cu k. Daca un astfel de numar nu exista in lista, functia afiseaza "NU EXISTA". Daca un astfel de numar exista in lista, functia afiseaza numarul respectiv.

Functiile sunt apelate in if _name_ == '_main_': pentru a porni programul. Mai intai, sunt citite numerele n si k folosind citeste_n_k(). Apoi, valorile introduse de utilizator sunt citite folosind citeste_valori(n), si apoi functia Max_Div_

3999 - Sum Min 9

2023-04-26T09:24:53Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/3999/sum-min9]
== Cerință ==
Se dau n perechi de numere naturale '''a''', '''b'''. Să se determine cea mai mică sumă care se poate obține adunând câte un singur număr din fiecare pereche de numere citite '''a''' şi '''b'''.
== Date de intrare ==
Programul citeşte de la tastatură numărul '''n''', apoi '''n''' perechi de numere '''a''', '''b'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul pe ecranului suma minimă obținută. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n ≤ 10.000'''
* fiecare dintre numerele '''a''' şi '''b''' au cel mult '''9''' cifre.
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 3
: 2 69
: 20 10
: 19 30
; Date de ieșire
: 31
==== Explicatie ====
Se aleg numerele '''2''', '''10''' și '''19'''. Suma lor este '''31'''.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
n = int(input("Introduceti numarul de perechi: "))
if n >= 1 and n <= 10000:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restrictiilor 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_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())
cifre1 = nrcifre(valoare1)
cifre2 = nrcifre(valoare2)
if cifre1 <= 9 and cifre2 <= 9:
print("Datele sunt corecte.")
valori.append((valoare1, valoare2))
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori cu mai putin de 9 cifre.")
return valori

def Sum_Min_9(valori):
suma_min = 0
for a, b in valori:
suma_min += min(a, b)

print("Suma minima este:", suma_min)

if _name_ == '_main_':
n = citeste_n()
valori = citeste_perechi(n)
Sum_Min_9(valori)
</syntaxhighlight>
== Explicatie ==

3998 - Sum Max 9

2023-04-26T09:17:34Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/3998/sum-max9]
== Cerință ==
Se dau '''n''' perechi de numere naturale '''a''','''b'''. Să se determine cea mai mare sumă care se poate obține adunând câte un singur număr din fiecare pereche de numere citite '''a''' şi '''b'''.
== Date de intrare ==
Programul citeşte de la tastatură numărul '''n''', apoi n perechi de numere'''a''', '''b'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul pe ecranului suma maximă obținută. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n ≤ 10.000'''
* fiecare dintre numerele '''a''' şi '''b''' au cel mult '''9''' cifre.
* cele '''n''' numere citite vor avea cel mult '''9''' cifre
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 3
: 2 69
: 20 10
: 19 30
; Date de ieșire
: 119
==== Explicatie ====
Se aleg numerele '''69''', '''20''' și '''30'''. Suma lor este '''119'''.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
n = int(input("Introduceti numarul de perechi: "))
if n >= 1 and n <= 10000:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restrictiilor 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_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())
cifre1 = nrcifre(valoare1)
cifre2 = nrcifre(valoare2)
if cifre1 <= 9 and cifre2 <= 9:
print("Datele sunt corecte.")
valori.append((valoare1, valoare2))
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori cu mai putin de 9 cifre.")
return valori

def pereche(valori):
suma_maxima = 0
for a, b in valori:
suma_maxima += max(a, b)
print(f"Suma maxima este: {suma_maxima}")
return

if _name_ == '_main_':
n = citeste_n()
valori = citeste_perechi(n)
pereche(valori)
</syntaxhighlight>
== Explicatie ==
Acest cod implementează o soluție pentru o problemă care cere să se determine cea mai mare sumă care se poate obține adunând câte un singur număr din fiecare pereche de numere citite a şi b. Programul primește de la tastatură numărul de perechi și valorile acestora, și verifică dacă acestea respectă restricțiile problemei: numărul de perechi trebuie să fie între 1 și 10000, iar numerele a și b trebuie să aibă cel mult 9 cifre. Dacă datele sunt corecte, programul afișează pe ecran suma maximă obținută.

Funcția citeste_n() citește de la tastatură numărul de perechi și verifică dacă acesta respectă restricțiile impuse de problema dată. Funcția nrcifre(nr) primește un număr și returnează numărul de cifre al acestuia.

Funcția citeste_perechi(n) primește numărul de perechi și citește de la tastatură aceste perechi de numere.
Funcția verifică dacă numerele a și b respectă restricțiile problemei, adică să aibă cel mult 9 cifre. Dacă datele sunt corecte, funcția adaugă perechea de numere în lista valori.

Funcția pereche(valori) primește lista de perechi de numere citite de la tastatură și calculează suma maximă obținută adunând câte un singur număr din fiecare pereche de numere citite. Suma maximă este afișată pe ecran.

În funcția principală main(), se citește numărul de perechi și valorile acestora folosind funcțiile citeste_n() și citeste_perechi(), și se calculează suma maximă apelând funcția pereche().

3391 - Sir Maxim

2023-04-26T09:11:29Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/3391/sirmaxim] == Cerință == Se citește un număr '''n''' și apoi '''n''' numere naturale cu maxim '''9''' cifre. Știind că '''n''' este dat par, să se determine de câte ori maximul din prima jumătate apare în șir în a doua jumătate. == Date de intrare == Programul citeşte din fișierul '''sirmaxim.in''' un număr n, apoi n numere narurale. == Date de ieșire == Dacă datele sunt introduse corect, pe ecran se va afișa: "...

Sursă: [https://www.pbinfo.ro/probleme/3391/sirmaxim]
== Cerință ==
Se citește un număr '''n''' și apoi '''n''' numere naturale cu maxim '''9''' cifre. Știind că '''n''' este dat par, să se determine de câte ori maximul din prima jumătate apare în șir în a doua jumătate.
== Date de intrare ==
Programul citeşte din fișierul '''sirmaxim.in''' un număr n, apoi n numere narurale.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul va scrie în fisierul sirmaxim.out un număr natural, 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 ≤ 20'''
* '''n''' par
== Exemple ==
=== Exemplu 1 ===
; '''sirmaxim.in'''
: 6
: 1 5 2 13 5 5
; '''sirmaxim.out'''
: 2
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
with open("sirmaxim.in", "r") as fin:
n = int(fin.readline())
if not (1 <= n <= 20 and n % 2 == 0):
print("Datele nu sunt conform restricțiilor impuse.")
exit()
print("Datele sunt corecte.")
return n

def citeste_valori(n):
with open("sirmaxim.in", "r") as fin:
fin.readline() # skip first line
valori = []
for i in range(n):
linie = fin.readline().strip().split()
while len(linie) < n:
linie += fin.readline().strip().split()
try:
for j in range(n):
x = int(linie[j])
if x < 0:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
valori.append(x)
except ValueError:
print("Trebuie introduse doar numere naturale.")
exit()
return valori

def sirmaxim(valori):
n = len(valori)
first_half = valori[:n//2]
second_half = valori[n//2:]
max_first_half = max(first_half)
count = second_half.count(max_first_half)
with open("sirmaxim.out", "w") as fout:
fout.write(str(count))
print(f"Maximul din prima jumătate a apărut de {count} ori în a doua jumătate.")

if _name_ == '_main_':
n = citeste_n()
valori = citeste_valori(n)
sirmaxim(valori)
</syntaxhighlight>

== Explicații ==
Acest cod implementează o soluție pentru problema "sirmaxim". Problema cere ca programul să citească un număr n și apoi n numere naturale cu maxim 9 cifre. De asemenea, se știe că n este dat par. Scopul este să se determine de câte ori maximul din prima jumătate a șirului apare în a doua jumătate.

Funcția citeste_n() deschide fișierul "sirmaxim.in" și citește prima linie, care conține numărul n. Se verifică dacă n se încadrează în restricțiile impuse (1 ≤ n ≤ 20 și n par). Dacă nu, se afișează un mesaj de eroare și programul se termină prin apelul funcției exit(). Dacă numărul este corect, se afișează un mesaj corespunzător și se returnează n.

Funcția citeste_valori(n) citește cele n linii următoare din fișierul "sirmaxim.in", care conțin n numere naturale separate prin spații. Fiecare linie este citită și apoi prelucrată astfel încât să conțină exact n numere (dacă în linie nu sunt suficiente numere, se citesc și se adaugă linii suplimentare până se ajunge la n numere). Se verifică dacă fiecare număr citit este un număr natural și se adaugă într-o listă valori. Dacă se întâlnește un număr negativ, se afișează un mesaj de eroare și programul se termină prin apelul funcției exit().
Dacă se întâlnește un număr care nu este natural (de exemplu, un număr cu virgulă), se afișează un mesaj de eroare și programul se termină prin apelul funcției exit(). La final, funcția returnează lista de numere valori.

Funcția sirmaxim(valori) primește ca parametru lista de numere valori și implementează algoritmul descris în enunțul problemei. Mai precis, se obține prima jumătate a listei și se găsește maximul acestei jumătăți. Apoi, se numără de câte ori acest maxim apare în a doua jumătate a listei. Rezultatul este scris în fișierul "sirmaxim.out".

În funcția main, se apelează funcțiile citeste_n(), citeste_valori(n) și sirmaxim(valori) pentru a citi datele din fișier și a determina rezultatul cerut.

2729 - SAO

2023-04-22T19:27:35Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/2729/sao]
== Enunt ==
Te afli în universul SAO (Sword Art Online pentru necunoscători). Ai la dispoziție o sumă mică de bani și '''m''' oferte. Fiecare ofertă constă într-o armură de o anumită rezistență și o sabie de o anumită putere. Tu trebuie să învingi '''n''' monștrii ale căror rezistențe și puteri sunt cunoscute. După ce ai învins un monstru, armura ta va pierde din rezistență o valoare egală cu valoarea puterii monstrului, iar sabia va pierde valoarea rezistenței monstrului. Tu vei avea nevoie de setul armură/sabie de o valoare minimă care poate să învingă toți cei '''n''' monștri.
== Cerinţa ==
Știind '''n''' – numărul de monștri, rezistența și puterea fiecăruia și '''m''' – numărul de oferte, cu rezistența armurii, puterea sabiei și prețul, să se determine costul cel mai mic pentru a învinge toți cei '''n''' monștri.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' perechi de numere naturale reprezentând rezistența respectiv puterea fiecărui monstru. Apoi se va citi numărul '''m''' și '''m''' triplete de numere naturale reprezentând rezistența, puterea și prețul echipamentelor.
== 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 '''V''', reprezentând costul cel mai mic pentru a învinge toți cei n monștrii. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n,m ≤ 10.000'''
* cele '''2*n+3*m''' numere citite vor fi mai mici sau egale cu '''2*63'''.
* în cazul în care nu poate învinge toți monștrii, se va afișa '''-1'''.
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 1
: 10 10
: 2
: 9 9 2
: 11 11 7
; Date de iesire
: 7
==== Explicație ====
Doar cea de-a doua ofertă garantează victoria.
=== Exemplu 2 ===
; Date de intrare
: 1
: 10 10
: 2
: 9 9 2
: 5 5 7
; Date de iesire
: -1
==== Explicație ====
Niciuna dintre oferte nu garantează victoria.

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
n = int(input("Introduceti numarul de monștri: "))
if n >= 1 and n <= 10000:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_monstri(n):
monstri = []
for i in range(n):
while True:
try:
rezistenta, putere = map(int, input(
"Introduceti rezistența și puterea monștrilor separate prin spatiu: ").split())
if 1 <= rezistenta <= 2 * 63 and 1 <= putere <= 2 * 63:
print("Datele sunt corecte.")
monstri.append((rezistenta, putere))
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori numerice.")
return monstri

def citeste_m():
while True:
try:
m = int(input("Introduceti numarul de oferte: "))
if m >= 1 and m <= 10000:
print("Datele sunt corecte.")
return m
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere intregi.")

def citeste_oferte(m):
oferte = []
for i in range(m):
while True:
try:
rezistenta_armura, putere_sabie, pret = map(int, input(
"Introduceti rezistența armurii, puterea săbiei și prețul separate prin spatiu: ").split())
if 1 <= rezistenta_armura <= 2 * 63 and 1 <= putere_sabie <= 2 * 63 and 1 <= pret <= 2 ** 63:
print("Datele sunt corecte.")
oferte.append((rezistenta_armura, putere_sabie, pret))
break
else:
print("Datele nu sunt conform restrictiilor impuse.")
except ValueError:
print("Trebuie introduse doar valori numerice.")
return oferte

def Sao(monstri, oferte):
# Sortam ofertele in ordine crescatoare dupa pret
oferte = sorted(oferte, key=lambda x: x[2])

# Pentru fiecare montru, cautam cea mai ieftina oferta care il poate invinge
cost_minim = 0
for i in range(len(monstri)):
rez_monstru, putere_monstru = monstri[i]
oferta_potrivita = False
for j in range(len(oferte)):
rez_armura, putere_sabie, pret = oferte[j]
if rez_armura >= putere_monstru and putere_sabie >= rez_monstru:
cost_minim += pret
oferta_potrivita = True
break
if not oferta_potrivita:
print(-1)
return

print(cost_minim)

if _name_ == '_main_':
n = citeste_n()
numere = citeste_monstri(n)
m = citeste_m()
numere2 = citeste_oferte(m)
Sao(numere,numere2)
</syntaxhighlight>
== Explicații ==
Acest cod implementează algoritmul Sao dintr-un joc de strategie, care constă în găsirea celei mai bune oferte pentru a invinge un set de monștri.

Funcția citeste_n() primește de la utilizator numărul de monștri pe care trebuie să îi învingă jucătorul și îl validează. În cazul în care numărul introdus este valid, funcția întoarce acest număr.

Funcția citeste_monstri(n) primește numărul de monștri n și primește de la utilizator caracteristicile fiecărui monstru: rezistența și puterea. Caracteristicile sunt validate, iar în cazul în care datele introduse sunt valide, acestea sunt adăugate într-o listă de monștri, care este returnată la final.

Funcția citeste_m() primește de la utilizator numărul de oferte disponibile și îl validează. În cazul în care numărul introdus este valid, funcția întoarce acest număr.

Funcția citeste_oferte(m) primește numărul de oferte m și primește de la utilizator caracteristicile fiecărei oferte: rezistența armurii, puterea săbiei și prețul. Caracteristicile sunt validate, iar în cazul în care datele introduse sunt valide, acestea sunt adăugate într-o listă de oferte, care este returnată la final.

Funcția Sao(monstri, oferte) primește listele de monștri și oferte, sortează ofertele în ordine crescătoare după preț și pentru fiecare monstru caută cea mai ieftină ofertă care îl poate învinge. Costul minim este calculat prin adunarea prețurilor celor mai bune oferte. Dacă nu există o ofertă potrivită pentru un anumit monstru, se afișează -1. La final, funcția afișează costul minim pentru a învinge toți monștrii.

În funcția principală (if _name_ == '_main_':) sunt apelate funcțiile de citire a datelor (citeste_n(), citeste_monstri(n), citeste_m() și citeste_oferte(m)) și funcția Sao(monstri, oferte) care primește datele citite și afișează rezultatul.

3284 - Calc Par Impar

2023-04-22T17:06:48Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/3284/calcparimpar]
== Cerință ==
Se dau '''n''' numere naturale. Considerăm poziţiile lor numerotate de la '''1''' la '''n'''.
Să se determine cea mai mare valoare memorată pe o poziţie pară şi cea mai mică valoare de două cifre aflată pe o poziţie impară.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Programul va afișa pe ecran numerele '''x''' şi '''y''', pe același rând și separate prin spațiu, reprezentând, în ordine, cele două valori calculate.
În cazul în care nu sunt valori de două cifre pe poziții impare se va afișa '''-1''' în contul valorii '''y'''.
== Restricții și precizări ==
* '''2 ≤ n ≤ 20'''
* cele '''n''' numere citite vor fi mai mici decât '''1.000.000.000'''
== Exemplu ==
; Intrare
: 5
: 1 3 3 4 8
; Ieșire
: 4 -1
== 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("Numarul de valori trebuie sa fie intre 2 si 20.")
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 >= 1 and valoare <= 1000000000 :
print("Datele sunt corecte.")
valori.append(valoare)
break
else:
print("Valoarea trebuie sa fie intre 1 si 1.000.000.000.")
except ValueError:
print("Trebuie introduse doar valori naturale.")

return valori

def calcParImpar(valori):
max_par = -1
min_impar = 100
for i in range(1, len(valori) + 1):
x = valori[i - 1]
if i % 2 == 0:
if x > max_par:
max_par = x
else:
if nrcif(x) == 2 and x < min_impar:
min_impar = x

if max_par == -1:
print("-1", end=" ")
else:
print(max_par, end=" ")
if min_impar == 100:
print("-1")
else:
print(min_impar)

def nrcif(n):
cnt = 0
while n:
n //= 10
cnt += 1
return cnt

if _name_ == '_main_':
n = citeste_n()
valori = citeste_valori(n)
calcParImpar(valori)

</syntaxhighlight>
== Explicații ==
Acest cod este o implementare a unei probleme care primește un număr n de valori și apoi n valori naturale. Scopul este să se calculeze valoarea maximă pară dintre toate pozițiile pare și valoarea minimă impară care are exact două cifre în reprezentarea sa.

Funcția citeste_n() primește numărul de valori de la utilizator și se asigură că această valoare este între 2 și 20. Funcția returnează această valoare n.

Funcția citeste_valori(n) citește n valori de la utilizator și se asigură că fiecare valoare este între 1 și 1.000.000.000. Aceste valori sunt adăugate într-o listă și această listă este returnată.

Funcția calcParImpar(valori) calculează valoarea maximă pară dintre toate pozițiile pare și valoarea minimă impară care are exact două cifre în reprezentarea sa. Pentru a face acest lucru, funcția parcurge toate valorile din lista și verifică dacă poziția este pară sau impară. Dacă poziția este pară, atunci valoarea este verificată și, dacă este pară și mai mare decât valoarea maximă pară curentă, atunci valoarea devine noua valoare maximă pară. Dacă poziția este impară, atunci valoarea este verificată și, dacă are exact două cifre și este mai mică decât valoarea minimă impară curentă, atunci valoarea devine noua valoare minimă impară.

Funcția nrcif(n) primește o valoare întreagă și returnează numărul de cifre din reprezentarea acelei valori.

În funcția principală, citeste_n() și citeste_valori(n) sunt apelate pentru a citi valorile de la utilizator, apoi calcParImpar(valori) este apelată pentru a calcula valorile dorite.

1875 - Platou 1

2023-04-22T17:05:54Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1875/platou1] == Cerinţa == Se consideră un șir de cifre. Să se determine lungimea maximală a unei secvențe din șir formată din cifre egale. == Date de intrare == Fișierul de intrare '''platou1.in''' conține pe prima linie cifrele reprezentând termenii șirului, separate prin câte un spațiu. == Date de ieșire == Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''plato...

Sursă: [https://www.pbinfo.ro/probleme/1875/platou1]
== Cerinţa ==
Se consideră un șir de cifre. Să se determine lungimea maximală a unei secvențe din șir formată din cifre egale.
== Date de intrare ==
Fișierul de intrare '''platou1.in''' conține pe prima linie cifrele reprezentând termenii șirului, separate prin câte un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''platou1.out''' va conține pe prima linie două numere naturale '''k x''', separate printr-un singur spațiu, '''k''' reprezentând lungimea secvenței determinate, iar '''x''' reprezentând termenul șirului din care este formată secvența. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* fișierul de intrare conține cel mult '''1.000''' de cifre, separate prin câte un spațiu, reprezentând termenii șirului dat;
* dacă șirul conține mai multe secvențe cu lungimea maximală, se va afișa cel mai mic termen ce formează o astfel de secvență.
== Exemple ==
=== Exemplu 1 ===
; '''platou1.in'''
: 3 8 8 8 8 9 9 9 2 5 5 5 5 7 6 6 6 6 8 8
; '''platou1.out''
: 4 5
==== Explicatie ====
În fișierul de intrare sunt 3 secvențe cu lungimea maximă k=4, termenul cel mai mic fiind x=5.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def verificare():
numere = []
with open('platou1.in', 'r') as fin:
while True:
numar = fin.readline().strip()
if not numar:
break
try:
numar = int(numar)
if numar == 0:
break
elif numar > 0 and numar < 1000:
print("Datele sunt corecte.")
numere.append(numar)
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie respectate cerintele.")
return numere

def platou1(numere):
with open('platou1.out', 'w') as fout:
xmin = 10
k = 0
lg = 1
x = numere[0]
for y in numere[1:]:
if x == y:
lg += 1
else:
if k < lg:
k = lg
xmin = x
elif k == lg and xmin > x:
xmin = x
lg = 1
x = y
with open('platou1.out', 'w') as fout:
fout.write(f"{k} {xmin}\n")

if _name_ == '_main_':
numere = verificare()
platou1(numere)
</syntaxhighlight>

== Explicații ==
Acest cod este scris în limbajul Python și constă din două funcții, verificare() și platou1(), și o secțiune if _name_ == '_main_'. Scopul programului este de a găsi cea mai lungă secvență consecutivă de numere identice dintr-o listă de numere citită dintr-un fișier și de a afișa lungimea acelei secvențe și cel mai mic număr din acea secvență.

Funcția verificare() primește datele de intrare din fișierul "platou1.in". Fiecare linie este citită și verificată dacă poate fi convertită într-un număr întreg. Numerele întregi pozitive mai mici decât 1000 sunt adăugate într-o listă numere, în timp ce numerele care nu îndeplinesc această cerință sunt ignorate. Dacă se întâlnește numărul zero, citirea se oprește și lista numere este returnată.

Funcția platou1() primește lista numere și deschide fișierul "platou1.out" pentru a scrie rezultatul. Folosind o buclă for, funcția compară fiecare element din listă cu elementul anterior. Dacă cele două elemente sunt identice, variabila lg este incrementată. Dacă nu sunt identice, variabila k este actualizată cu lungimea maximă de până acum a secvenței și variabila xmin este actualizată cu cel mai mic număr din secvența curentă dacă aceasta are aceeași lungime ca și secvența maximă până în acel moment. Lungimea secvenței curente este resetată la 1 și se trece la următorul număr din listă.

La final, funcția deschide fișierul "platou1.out" și scrie rezultatul sub formă de linie unică, care conține lungimea secvenței maxime și cel mai mic număr din acea secvență.

Secțiunea if _name_ == '_main_' verifică dacă acest script este rulat direct sau este importat ca modul în altă parte. Dacă este rulat direct, funcția verificare() este apelată pentru a citi datele din fișier și a construi lista de numere, iar apoi funcția platou1() este apelată cu această listă pentru a calcula și scrie rezultatul în fișierul "platou1.out".

0561 - Rafaelo

2023-04-22T16:59:27Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/561/rafaelo]
== Enunț ==
Alina dispune de o sumă '''S''' de bani. Apropiindu-se ziua ei de naștere, vrea să cumpere cât mai multe cutii cu bomboane Rafaelo. Alina are la dispoziție '''N''' magazine din care poate face această alegere. Cunoscând prețul unei cutii de bomboane Rafaelo în fiecare magazin și faptul că va cumpăra toate cutiile cu bomboane din același magazin, ajutați-o pe Alina să facă această alegere astfel încât să nu depășească suma '''S''' de care dispune.
== Cerință ==
Cunoscând suma '''S''' de bani, numărul '''N''' de magazine și '''p1''', '''p2''', '''p3''',… , '''pN''' prețul unei cutii de bomboane Rafaelo în fiecare magazin, stabiliți numărul maxim de cutii de bomboane ce poate fi cumpărat și magazinul din care pot fi cumpărate. Dacă sunt mai multe astfel de magazine se va afișa primul dintre ele în ordinea în care au fost date.
== Date de intrare ==
Programul citește de la tastatură separate prin spații suma '''S''', '''N''' numărul de magazine și apoi '''N''' numere naturale nenule separate prin spații, reprezentând prețul unei cutii cu bomboane Rafaelo în fiecare magazin.
== Date de ieșire ==
Programul afișează pe ecran două numere naturale '''x''' și '''y''', separate prin exact un spațiu, reprezentând numărul maxim de cutii cu bomboane Rafaelo ce pot fi cumpărate, respectiv magazinul din care pot fi cumpărate.
== Restricții și precizări ==
* '''1 ≤ N ≤ 100'''
* '''1 ≤ S ≤ 10000'''
* Prețul unei cutii cu bomboane este un număr natural nenul mai mic sau egal cu '''1000'''.
* Cel puțin un magazin are prețul unei cutii cu bomboane mai mic sau egal cu '''S'''.
== Exemplu ==
; Intrare
: 20 5
: 9 3 4 8 3
; Ieșire
: 6 2
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
n = int(input("Introduceti numarul de valori: "))
s = int(input("Introduceti suma de bani: "))
if 1<= n <= 100 and 1<= s <= 10000:
print("Datele sunt corecte.")
return n
else:
print("Numarul de valori trebuie sa fie intre 2 si 20.")
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 >= 1 and valoare <= 1000000000 :
print("Datele sunt corecte.")
valori.append(valoare)
break
else:
print("Valoarea trebuie sa fie intre 1 si 1.000.000.000.")
except ValueError:
print("Trebuie introduse doar valori naturale.")

return valori

def rafaelo(s, valori):
max_cutii = 0
magazin = 0
for i in range(len(valori)):
if s // valori[i] > max_cutii:
max_cutii = s // valori[i]
magazin = i + 1

print("Se pot cumpara maxim", max_cutii, "cutii de bomboane de la magazinul", magazin)

if _name_ == '_main_':
n = citeste_n()
valori = citeste_valori(n)
s = int(input("Introduceti suma de bani: "))
rafaelo(s, valori)
</syntaxhighlight>
== Explicatie ==
Acest cod este o implementare a algoritmului de rezolvare a problemei "Rafaelo", care are ca scop determinarea numărului maxim de cutii de bomboane ce pot fi cumpărate cu o anumită sumă de bani, dintr-un set de prețuri de la mai multe magazine.

Funcția citeste_n() primește de la utilizator numărul de valori și suma de bani, verificând dacă valorile introduse respectă condițiile din enunțul problemei. În cazul în care valorile sunt corecte, funcția returnează numărul de valori introduse.

Funcția citeste_valori(n) primește numărul de valori și returnează o listă de valori introduse de utilizator. Această funcție verifică dacă valorile introduse sunt corecte și le adaugă în listă.

Funcția rafaelo(s, valori) primește suma de bani și lista de prețuri, iar apoi utilizează o buclă for pentru a verifica fiecare preț din listă. Dacă suma de bani împărțită la preț este mai mare decât numărul maxim de cutii până acum, se actualizează valoarea maximă și se memorează numărul magazinului de unde trebuie achiziționate cutiile de bomboane.

În cele din urmă, funcția afișează rezultatul obținut, adică numărul maxim de cutii de bomboane care pot fi cumpărate și magazinul de unde trebuie achiziționate cutiile de bomboane.

3284 - Calc Par Impar

2023-04-22T16:57:42Z

MiclausIoana:

1878 - Nr Asoc

2023-04-22T08:05:47Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1878/nrasoc] == Cerinţa == Se consideră un șir ai cărui termeni sunt numere naturale nenule, de o singură cifră. Numim '''număr asociat''' al acestui șir un număr natural format cu termenii șirului, în ordinea în care aceștia apar în șir. Se cere determinarea unui șir obținut prin eliminarea a doi termeni situați pe poziții consecutive în șirului dat, astfel încât numărul asociat șirului obținut să fie maxim....

Sursă: [https://www.pbinfo.ro/probleme/1878/nrasoc]
== Cerinţa ==
Se consideră un șir ai cărui termeni sunt numere naturale nenule, de o singură cifră. Numim '''număr asociat''' al acestui șir un număr natural format cu termenii șirului, în ordinea în care aceștia apar în șir.
Se cere determinarea unui șir obținut prin eliminarea a doi termeni situați pe poziții consecutive în șirului dat, astfel încât numărul asociat șirului obținut să fie maxim.
== Date de intrare ==
Fișierul de intrare '''nrasoc.in''' conține pe prima linie o succesiune de cifre, separate prin câte un spațiu, reprezentând termenii șirului dat.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''nrasoc.out''' va conține pe prima linie un șir de cifre, separate prin câte un spațiu, reprezentând șirul corespunzător numărului asociat maxim. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* fișierul de intrare conține cel mult '''80''' de cifre.
== Exemple ==
=== Exemplu 1 ===
; '''nrasoc.in'''
: 9 8 5 7 6 2 3 4
; '''nrasoc.out'''
: 9 8 6 2 3 4
==== Explicatie ====
Numerele asociate șirurilor care se pot obține sunt '''576234''', '''976234''', '''986234''', '''2985234''', '''985734''', '''985764''', '''985762'''. Fișierul de ieșire va conține:
'''9 8 6 2 3 4'''
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citeste_șir():
while True:
try:
with open('nrasoc.in') as fin:
a = [int(x) for x in fin.read().split()]
if len(a) <= 80:
print("Datele sunt corecte.")
return a
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere întregi.")

def nrasoc():
a = citeste_șir()
n = len(a)
max_numar = -1
for i in range(1, n - 1):
numar = int(str(a[i - 1]) + str(a[i + 1]))
if numar > max_numar:
max_numar = numar
poz = i
rezultat = [str(x) for i, x in enumerate(a) if i != poz and i != poz + 1]
with open('nrasoc.out', 'w') as fout:
fout.write(' '.join(rezultat))

if _name_ == '_main_':
nrasoc()
</syntaxhighlight>

== Explicații ==
Acest cod este o implementare în Python a problemei "Numărul asociat" (nrasoc). În esență, problema cere să se elimine două elemente consecutive dintr-un șir de cifre, astfel încât numărul format din restul cifrelor să fie maxim.

În primul rând, există două funcții definite în cod: citeste_k() și nrasoc().

Funcția citeste_k() este utilizată pentru a citi valoarea cifrei k din consolă și pentru a verifica dacă aceasta respectă restricțiile impuse (să fie între 0 și 9). Funcția returnează k doar dacă acesta este valid.

Funcția nrasoc() este funcția principală a programului și se ocupă de citirea datelor din fișierul de intrare (nrasoc.in), prelucrarea lor și scrierea rezultatelor în fișierul de ieșire (nrasoc.out).

În interiorul acestei funcții, se deschid fișierele de intrare și de ieșire utilizând o clauză with, ceea ce înseamnă că acestea vor fi automat închise la finalul blocului de cod. Datele din fișierul de intrare sunt citite și stocate într-un array numit a.

Apoi, se aplică algoritmul descris în enunț pentru a găsi șirul corespunzător numărului asociat maxim. Se parcurge șirul de la primul element până la penultimul și se calculează două numere p și q format din câte două cifre, începând de la elementul curent și următorul. Dacă p este mai mic decât q și acesta este primul astfel de caz întâlnit, se trece peste elementul următor și se memorează acest lucru în variabila cnt. În caz contrar, elementul curent este scris în fișierul de ieșire.

La final, se verifică dacă s-a ajuns la ultimele două elemente din șir (penultimul și ultimul). Dacă da și cnt este încă 0, atunci se scrie ultimul element în fișierul de ieșire.

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

În general, acest cod respectă bunele practici de programare, cum ar fi folosirea de variabile cu denumiri sugestive, comentarea codului acolo unde este necesar, respectarea indentării și utilizarea unor funcții separate pentru a împărți sarcinile în codul mai mic.

2781 - Wildfire

2023-04-22T07:48:53Z

MiclausIoana:

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 3 ===
; 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.

0347 - Suma Max Min

2023-04-22T07:44:47Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/347/summaxmin]
== Cerință ==
Se dau '''n''' numere naturale. Calculaţi suma dintre cel mai mare și cel mai mic număr dat.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.", programul afișează pe ecran numărul '''S''', reprezentând suma dintre cel mai mare și cel mai mic număr dat. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* 1 ≤ '''n''' ≤ 100
* cele '''n''' numere citite vor avea cel mult '''6''' cifre
== Exemple ===
=== Exemplu 1 ===
; Date de intrare
: 5
: 7 2 8 4 8
; Date de ieșire
: Datele sunt corecte. Rezultat: 10
=== Exemplu 2 ===
; Date de intrare
: 6
: 8 6 5 4 7 8
; Date de ieșire
: Datele sunt corecte. Rezultat:12
=== Exemplu 3 ===
; Date de intrare
: 4
: 1 86547458968 3 4
; Date de ieșire
: Datele nu sunt conform restricțiilor impuse.
==== Explicație ====
; '''8 + 2 = 10.'''
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
n = int(input("Introduceti numarul de valori: "))
if n >= 1 and n <= 1000:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

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 <= 9:
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 gaseste_suma(valori):
numar_minim = 100
numar_maxim = 0
for x in valori:
if numar_maxim is None or x > numar_maxim:
numar_maxim = x
if numar_minim is None or x < numar_minim:
numar_minim = x
suma = numar_maxim + numar_minim
return suma

if __name__ == '__main__':
n = citeste_n()
valori = citeste_valori(n)
sum = gaseste_suma(valori)
print("Suma dintre numarul minim și maxim este:", sum)
</syntaxhighlight>

== Explicații ==
Acest cod reprezintă o aplicație simplă care citește un număr specificat de valori de la tastatură, verifică dacă acestea respectă anumite restricții, găsește valoarea maximă dintre acestea și o afișează la final.
Funcția citeste_n() primește numărul de valori de la utilizator și verifică dacă acesta respectă restricțiile impuse (număr întreg între 1 și 1000). Dacă valorile introduse de utilizator nu respectă restricțiile sau nu sunt un număr întreg, funcția afișează un mesaj de eroare și încheie programul.
Funcția nrcifre(nr) primește un număr și returnează numărul de cifre ale acestuia.
Funcția citeste_valori(n) primește ca parametru un număr întreg n și citește n valori de la utilizator. În timpul citirii, acesta verifică dacă valorile introduse de utilizator au mai puțin de 9 cifre și dacă nu, cere introducerea altor valori.Dacă valorile introduse de utilizator sunt conforme cu restricțiile impuse, acestea sunt adăugate într-o listă valori, care este returnată de subprogram.
În programul principal, se citește un număr întreg n, se apelează subprogramul citeste_valori(n) pentru a citi n valori, se găsește cel mai mic și cel mai mare număr din lista de valori, se face suma lor folosind subprogramul gaseste_suma(valori) și o afișează.

1881 - Platou 4

2023-04-22T07:04:09Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1881/platou4] == Cerinţa == Se consideră un şir '''s''' format din numere întregi. Să se determine numărul de termeni ai şirului obţinut prin eliminarea din cele două extremităţi ale lui '''s''' a unui număr minim de termeni, astfel încât şirul rezultat să înceapă şi să se termine cu câte un număr par. == Date de intrare == Fișierul de intrare '''platou4.in''' conține numere întregi separate prin spații. == Dat...

Sursă: [https://www.pbinfo.ro/probleme/1881/platou4]
== Cerinţa ==
Se consideră un şir '''s''' format din numere întregi. Să se determine numărul de termeni ai şirului obţinut prin eliminarea din cele două extremităţi ale lui '''s''' a unui număr minim de termeni, astfel încât şirul rezultat să înceapă şi să se termine cu câte un număr par.
== Date de intrare ==
Fișierul de intrare '''platou4.in''' conține numere întregi separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''platou4.out''' va conține pe prima linie numărul '''k''', reprezentând lungimea șirului obținut. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* fișierul de intrare conține cel mult '''1000''' de numere întregi
* numerele din fișier de intrare vor fi din intervalul '''[-99,99]'''
* fișierul de intrare conține cel puțin un număr par.
== Exemple ==
=== Exemplu 1 ===
; '''platou4.in'''
: 7 -22 -13 10 31 41 -6 2 101 83
; '''platou4.out'''
: 7
==== Explicatie ====
Sunt eliminate din șirul s numerele 7 101 83.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citeste_sir():
while True:
try:
with open('platou4.in') as fin:
n = int(fin.readline())
a = [int(x) for x in fin.readline().split()]
if len(a) == n and all(-99 <= x <= 99 for x in a):
print("Datele sunt corecte.")
return a
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere întregi.")

def platou4():
with open('platou4.in') as fin, open('platou4.out', 'w') as fout:
a = list(map(int, fin.readline().split()))
while a[0] % 2 != 0:
a.pop(0)
while a[-1] % 2 != 0:
a.pop(-1)
fout.write(str(len(a)) + '\n')

if _name_ == '_main_':
platou4()
</syntaxhighlight>

== Explicații ==
Acest cod rezolvă problema de la cerința pentru șiruri de numere întregi din fișierul de intrare platou4.in.

Funcția citeste_sir() primește ca intrare un fișier text și returnează lista de numere întregi citite din fișier, după ce a verificat dacă sunt conform restricțiilor impuse.

Funcția platou4() deschide fișierul de intrare și fișierul de ieșire și citește prima linie din fișierul de intrare, care conține numărul de elemente din șir. Acest număr nu este folosit în restul codului. În continuare, se citește linia cu numerele întregi și se creează o listă a prin aplicarea funcției map(int, fin.readline().split()).

Se elimină elementele de la începutul listei a care nu sunt numere pare prin parcurgerea listei și eliminarea elementelor până când primul element rămas este un număr par. Se elimină și elementele de la finalul listei a care nu sunt numere pare prin parcurgerea listei în ordine inversă și eliminarea elementelor până când ultimul element rămas este un număr par.

Se scrie în fișierul de ieșire lungimea listei a rămase după eliminarea elementelor nedorite, adică numărul de termeni ai șirului obținut prin eliminarea din cele două extremități ale lui s a unui număr minim de termeni, astfel încât șirul rezultat să înceapă și să se termine cu câte un număr par.

1880 - Platou 3

2023-04-22T06:58:53Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1880/platou3] == Cerinţa == Se consideră un şir format din '''n''' numere întregi. Șirul conține cel puțin un număr pozitiv. Să se determine lungimea maximă a unei secvenţe din şir care are proprietatea că este formată doar din valori strict pozitive. == Date de intrare == Fișierul de intrare '''platou3.in''' conține pe prima linie numărul '''n''', iar pe a doua linie n numere întregi separate prin spații. == Date de...

Sursă: [https://www.pbinfo.ro/probleme/1880/platou3]
== Cerinţa ==
Se consideră un şir format din '''n''' numere întregi. Șirul conține cel puțin un număr pozitiv. Să se determine lungimea maximă a unei secvenţe din şir care are proprietatea că este formată doar din valori strict pozitive.
== Date de intrare ==
Fișierul de intrare '''platou3.in''' conține pe prima linie numărul '''n''', iar pe a doua linie n numere întregi separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''platou3.out''' va conține pe prima linie numărul '''k''', reprezentând lungimea maximă a secvenței determinate. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n ≤ 1000'''
* numerele de pe a doua linie a fișierului de intrare vor fi din intervalul '''[-99,99]'''
* O secvenţă a unui şir constă în elemente aflate pe poziţii consecutive în şirul considerat.
== Exemple ==
=== Exemplu 1 ===
; '''platou3.in'''
: 10
: 7 -22 -13 10 31 41 -6 2 10 8
; '''platou3.out'''
: 3
==== Explicatie ====
În fișierul de intrare, secvențele de lungime maximă (k=3) sunt: 10 31 41 și 2 10 8.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citeste_sir():
while True:
try:
with open('platou3.in') as fin:
n = int(fin.readline())
a = [int(x) for x in fin.readline().split()]
if len(a) == n and all(-99 <= x <= 99 for x in a):
print("Datele sunt corecte.")
return a
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere întregi.")

def platou3():
with open("platou3.in") as fin, open("platou3.out", "w") as fout:
n = int(fin.readline())
a = [-1] + list(map(int, fin.readline().split()))
l = 0
lmax = 0
for i in range(1, n + 1):
if a[i] > 0 and a[i - 1] > 0:
l += 1
if l > lmax:
lmax = l
else:
l = 0
fout.write(str(lmax + 1))

if _name_ == '_main_':
platou3()
</syntaxhighlight>

== Explicații ==
Acest cod rezolvă problema de determinare a lungimii maxime a unei secvențe formate doar din valori strict pozitive într-un șir de întregi dat.

Funcția citeste_sir() citește datele de intrare din fișierul "platou3.in", verifică dacă acestea sunt valide și le returnează sub formă de listă de întregi.

Funcția platou3() deschide fișierul de intrare și fișierul de ieșire și citește datele de intrare, reprezentând un șir de întregi cu cel puțin un element pozitiv. Apoi, calculează lungimea maximă a unei secvențe din șir care are proprietatea că este formată doar din valori strict pozitive și o scrie în fișierul de ieșire.

Dacă fișierul este executat direct, atunci funcția platou3() este apelată.

1879 - Platou 2

2023-04-22T06:53:29Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/1879/platou2] == Cerinţa == Se consideră un şir format din '''n''' numere naturale nenule. Să se determine lungimea maximă a unei secvenţe strict crescătoare din şirul dat. == Date de intrare == Fișierul de intrare '''platou2.in''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații. == Date de ieșire == Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele s...

Sursă: [https://www.pbinfo.ro/probleme/1879/platou2]
== Cerinţa ==
Se consideră un şir format din '''n''' numere naturale nenule. Să se determine lungimea maximă a unei secvenţe strict crescătoare din şirul dat.
== Date de intrare ==
Fișierul de intrare '''platou2.in''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fișierul de ieșire '''platou2.out''' va conține pe prima linie numărul '''k''', reprezentând lungimea maximă a secvenței determinate. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n ≤ 1000'''
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''100'''
* O secvenţă a unui şir constă în elemente aflate pe poziţii consecutive în şirul considerat.
=== Exemplu 1 ===
; '''platou2.in'''
: 10
: 7 22 13 10 31 41 6 7 10 8
; '''platou2.out'''
: 3
==== Explicatie ====
În fișierul de intrare, secvențele de lungime maximă (k=3) sunt: 10 31 41 și 6 7 10.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citeste_sir():
while True:
try:
with open('platou2.in') as fin:
n = int(fin.readline())
a = [int(x) for x in fin.readline().split()]
if len(a) == n and all(1 <= x <= 100 for x in a):
print("Datele sunt corecte.")
return a
else:
print("Datele nu sunt conform restricțiilor impuse.")
except ValueError:
print("Trebuie introduse doar numere întregi.")

def platou2():
a = citeste_sir()
n = len(a)
k = 1
maxi = 1
for i in range(1, n):
if a[i-1] < a[i]:
k += 1
if k > maxi:
maxi = k
else:
k = 1
with open("platou2.out", "w") as fout:
fout.write(str(maxi))

if _name_ == '_main_':
platou2()
</syntaxhighlight>

== Explicații ==
Acest cod este scris in Python si contine doua functii: "citeste_sir()" si "platou2()".

Functia "citeste_sir()" citeste datele de intrare din fisierul "platou2.in" si verifica daca acestea respecta anumite restrictii impuse. Mai precis, functia verifica daca primul element din fisierul de intrare este un numar intreg, iar al doilea element este o lista de n numere intregi intre 1 si 100. Daca datele de intrare sunt corecte, functia returneaza aceasta lista de numere intregi. In caz contrar, se afiseaza un mesaj corespunzator erorii si se reia citirea datelor de intrare.

Functia "platou2()" apeleaza functia "citeste_sir()" pentru a obtine lista de numere intregi reprezentand datele de intrare. Apoi, se determina lungimea acestei liste si se initializeaza doua variabile, "k" si "maxi", cu valorile 1. In urmatoarea bucla, se parcurge lista de numere intregi si se compara fiecare element cu predecesorul sau. Daca elementul curent este mai mare decat predecesorul sau, atunci se incrementeaza valoarea lui "k". Daca valoarea lui "k" este mai mare decat valoarea lui "maxi", atunci se actualizeaza valoarea lui "maxi" cu valoarea lui "k". Daca elementul curent nu este mai mare decat predecesorul sau, atunci valoarea lui "k" este resetata la 1. La final, functia scrie valoarea variabilei "maxi" in fisierul "platou2.out".

Partea finala a codului verifica daca fisierul a fost executat ca program principal si, in caz afirmativ, apeleaza functia "platou2()".

0282 - Poz Max

2023-04-20T15:20:12Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/282/pozmax] == Cerinţa == Se dă un şir cu '''n''' elemente, numere reale, numerotate de la '''1''' la '''n'''. Determinaţi numărul de ordine al primei şi al ultimei apariţii a valorii maxime din şir. == Date de intrare == Fişierul de intrare '''pozmax.in''' conţine pe prima linie numărul '''n'''; urmează '''n''' numere reale, dispuse pe mai multe linii şi separate prin spaţii. == Date de ieșire == Dacă datele sunt introd...

Sursă: [https://www.pbinfo.ro/probleme/282/pozmax]
== Cerinţa ==
Se dă un şir cu '''n''' elemente, numere reale, numerotate de la '''1''' la '''n'''. Determinaţi numărul de ordine al primei şi al ultimei apariţii a valorii maxime din şir.
== Date de intrare ==
Fişierul de intrare '''pozmax.in''' conţine pe prima linie numărul '''n'''; urmează '''n''' numere reale, dispuse pe mai multe linii şi separate prin spaţii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fişierul de ieşire '''pozmax.out''' va conţine pe prima linie două numere '''p''' şi '''u''', reprezentând valorile cerute. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''n''' este un număr natural cu cel mult '''9''' cifre;
== Exemple ==
=== Exemplu 1 ===
; '''pozmax.in'''
: 8
: 3.5 7 -4 7 2 7 6.3 5
; '''pozmax.out'''
: 2 6
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
with open("pozmax.in", "r") as fin:
n = int(fin.readline())
if n >= 1 and n <= 1000000000:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori(n):
valori = []
with open("pozmax.in", "r") as fin:
fin.readline()
for i in range(n):
linie = fin.readline().strip().split()
while len(linie) != n:
linie += fin.readline().strip().split()
try:
for j in range(n):
if float(linie[j]) <= 10**9:
valori.append(float(linie[j]))
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere reale.")
exit()
return valori

def pozitii_max(valori):
max_val = max(valori)
p = valori.index(max_val) + 1
u = len(valori) - valori[::-1].index(max_val)
return p, u

if _name_ == '_main_':
n = citeste_n()
valori = citeste_valori(n)
p, u = pozitii_max(valori)
with open("pozmax.out", 'w') as f:
f.write(str(p) + " " + str(u))
</syntaxhighlight>

== Explicații ==
Acest cod implementează o soluție pentru problema de găsire a pozițiilor primei și ultimei apariții a valorii maxime dintr-un șir de numere reale.

Funcția citeste_n() este folosită pentru a citi valoarea n din fișierul de intrare "pozmax.in" și verifică dacă se încadrează în restricțiile impuse (între 1 și 1 miliard).

Funcția citeste_valori(n) este utilizată pentru a citi șirul de n numere reale din fișierul de intrare "pozmax.in". Aceasta verifică dacă numerele sunt conforme cu restricțiile impuse (valori între -1 miliard și 1 miliard) și, în caz contrar, iese din program cu un mesaj de eroare.

Funcția pozitii_max(valori) primește șirul de numere reale și găsește valoarea maximă din șir folosind funcția max(). Folosind metoda index(), aceasta determină poziția primei apariții a valorii maxime și adaugă 1 pentru a obține poziția în numerotare de la 1. De asemenea, calculează poziția ultimei apariții a valorii maxime folosind metoda index() combinată cu o inversare a șirului și adaugă lungimea șirului pentru a obține poziția în numerotare de la 1.

În funcția main(), se apelează cele trei funcții pentru a citi datele de intrare, a determina pozițiile valorii maxime și a scrie rezultatul în fișierul de ieșire "pozmax.out".

2275 - Minim Doua

2023-04-20T15:07:13Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/2275/minimdoua] == Cerinţa == Se dau '''n''' numere naturale. Determinați cele mai mici două numere dintre cele introduse care au ultimele două cifre egale. Dacă nu există cel puțin două astfel de numere se va afișa '''numere insuficiente'''. == Date de intrare == Fișierul de intrare '''minimdoua.in''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații. == Date de ieșir...

Sursă: [https://www.pbinfo.ro/probleme/2275/minimdoua]
== Cerinţa ==
Se dau '''n''' numere naturale. Determinați cele mai mici două numere dintre cele introduse care au ultimele două cifre egale. Dacă nu există cel puțin două astfel de numere se va afișa '''numere insuficiente'''.
== Date de intrare ==
Fișierul de intrare '''minimdoua.in''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte." Fișierul de ieșire '''minimdoua.out''' va conține pe prima linie numerele '''minim1''' si '''minim2''', reprezentând minimele cerute, în ordine crescătoare, dacă fișierul de intrare conține cel puțin două astfel de numere, respectiv '''numere insuficiente''', în caz contrar. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''1 ≤ n ≤ 200'''
* pentru fiecare număr x de pe a doua linie a fișierului de intrare este îndeplinită relația '''0 ≤ x ≤ 1.000.000'''
* minimele cerute vor avea cel puțin două cifre
== Exemple ==
=== Exemplu 1 ===
; '''minimdoua.in'''
: 7
: 12 55 112 322 477 115 7
; '''minimdoua.out'''
: 55 322
=== Exemplu 2 ===
; '''minimdoua.in'''
: 6
: 12 55 112 3 4774 115
; '''minimdoua.out'''
: numere insuficiente
==== Explicație ====
În fișierul de intrare este doar un singur număr cu proprietatea cerută.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def citeste_n():
while True:
try:
with open("minimdoua.in", "r") as fin:
n = int(fin.readline())
if n >= 2 and n <= 1000:
print("Datele sunt corecte.")
return n
else:
print("Datele nu sunt conform restricțiilor impuse.")
exit()
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

def citeste_valori(n):
valori = []
for i in range(n):
with open("minimdoua.in", "r") as fin:
fin.readline()
linie = fin.readline().strip().split()
while len(linie) != n:
linie += fin.readline().strip().split()
try:
if len(linie[i]) <= 9:
print("Datele sunt corecte.")
valori.append(int(linie[i]))
else:
print("Trebuie introduse doar valori cu mai putin de 9 cifre.")
exit()
except ValueError:
print("Trebuie introduse doar valori cu mai putin de 9 cifre.")
exit()
return valori

def minim_doua(valori):
a = []
v = []
for i in range(len(valori)):
if valori[i] % 10 == (valori[i] // 10) % 10 and valori[i] > 9:
v.append(valori[i])
v.sort()
if len(v) >= 2:
return v[0], v[1]
else:
return "numere insuficiente"

if _name_ == '_main_':
n = citeste_n()
valori = citeste_valori(n)
minim1, minim2 = minim_doua(valori)
with open("minimdoua.out", 'w') as f:
if isinstance(minim1, str):
f.write(minim1)
else:
f.write(str(minim1) + ' ' + str(minim2))
</syntaxhighlight>

== Explicații ==
Acesta este un cod Python care rezolvă o problemă de găsire a celor mai mici două numere întregi pozitive cu aceeași cifră zecimală de unitate.

Funcția citeste_n() deschide fișierul "minimdoua.in" și încearcă să citească un singur număr întreg de pe prima linie. Dacă numărul îndeplinește condițiile de a fi între 2 și 1000, atunci funcția va returna acest număr. În caz contrar, se va afișa un mesaj de eroare și se va ieși din program.

Funcția citeste_valori(n) primește ca argument numărul de valori pe care trebuie să le citească. Apoi, pentru fiecare linie din fișier, funcția va citi o linie, va elimina caracterele de tip newline și apoi va împărți acea linie în cuvinte. Dacă numărul de cuvinte împărțite nu este egal cu n, atunci vor fi citite noi linii până când numărul de cuvinte va fi egal cu n. În continuare, funcția va verifica fiecare cuvânt și dacă lungimea sa este mai mică sau egală cu 9, va adăuga numărul într-o listă. Altfel, se va afișa un mesaj de eroare și se va ieși din program. Funcția va returna lista de numere citite.

Funcția minim_doua(valori) primește lista de numere și va adăuga numerele care îndeplinesc condiția specificată într-o altă listă, v. Această listă va fi sortată în ordine crescătoare, iar dacă are cel puțin două elemente, atunci primele două elemente vor fi cele două numere cu cifra zecimală de unitate identică și mai mici. Altfel, funcția va returna un mesaj care indică faptul că lista de numere nu are suficiente elemente.

În funcția principală _main_, se vor apela funcțiile citeste_n(), citeste_valori(n) și minim_doua(valori) pentru a obține cele mai mici două numere întregi pozitive cu aceeași cifră zecimală de unitate. Apoi, rezultatele vor fi scrise în fișierul "minimdoua.out" în funcție de rezultatul returnat de minim_doua(valori). Dacă funcția returnează un mesaj de eroare, atunci mesajul va fi scris în fișier.

0281 - Maxim 5

2023-04-20T14:57:29Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/281/maxim5] == Cerinţa == Se dă un fişier text care conţine mai multe linii, pe fiecare linie existând câte un şir de numere naturale nenule, despărţite prin câte un spaţiu; fiecare linie se termină cu numarul '''0''' (care se consideră că nu face parte din şirul aflat pe linia respectivă) şi conţine cel puţin două valori. Se cere să se afişeze valoarea maximă din şirul care conţine cele mai puţine numere. În...

Sursă: [https://www.pbinfo.ro/probleme/281/maxim5]
== Cerinţa ==
Se dă un fişier text care conţine mai multe linii, pe fiecare linie existând câte un şir de numere naturale nenule, despărţite prin câte un spaţiu; fiecare linie se termină cu numarul '''0''' (care se consideră că nu face parte din şirul aflat pe linia respectivă) şi conţine cel puţin două valori.
Se cere să se afişeze valoarea maximă din şirul care conţine cele mai puţine numere. În cazul în care există mai multe şiruri cu acelaşi număr minim de numere, se va afişa cea mai mare valoare care apare în unul dintre aceste şiruri.
== Date de intrare ==
Fişierul de intrare '''maxim5.in''' conţine şirurile de numere, aşa cu a fost descris mai sus.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Fişierul de ieşire '''maxim5.out''' va conţine pe prima linie numărul M, reprezentând valoarea maximă din şirul care conţine cele mai puţine numere. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* numerele din şirurile date au cel mult 9 cifre
== Exemple ==
=== Exemplu 1 ===
; '''maxim5.in'''
: 2 253 34 3 0
: 6 88 9 3 0
: 4 54 88 12345 98 234 546 0
; '''maxim5.out'''
: 253
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def nrcifre(nr):
nrcif = 0
while nr != 0:
nrcif += 1
nr //= 10
return nrcif

def citeste_valori():
valori = []
with open("maxim5.in", 'r') as f:
for linie in f:
nums = linie.strip().split()
if nums[-1] != "0" or len(nums) < 2:
raise ValueError("Linia nu se termina cu 0 sau contine mai putin de 2 valori.")
valoare = [int(num) for num in nums[:-1]]
if any(nrcifre(num) > 9 for num in valoare):
raise ValueError("Datele nu sunt conform restricțiilor impuse.")
valori.append(valoare)
return valori

def valoare_maxima_si_lungimea_minima(valori):
lmax = float('inf') # initializam cu infinit
st, dr = -1, -1
for i in range(len(valori)):
l = len(valori[i])
if l < lmax:
lmax = l
st, dr = i, i
elif l == lmax:
dr = i
max_val = 0
for i in range(st, dr+1):
for val in valori[i]:
if val > max_val:
max_val = val
return max_val

if _name_ == '_main_':
valori = citeste_valori()
max_val = valoare_maxima_si_lungimea_minima(valori)
with open("maxim5.out", 'w') as f:
f.write(str(max_val))
</syntaxhighlight>

== Explicații ==
Acest cod citeste date dintr-un fisier "maxim5.in" care contine o lista de liste de numere intregi si gaseste valoarea maxima dintre aceste numere intregi, care se afla in sub-listele cu lungimea minima.

Functia "nrcifre" calculeaza numarul de cifre al unui numar intreg.

Functia "citeste_valori" citeste datele din fisierul "maxim5.in" si verifica daca fiecare linie se termina cu "0" si contine cel putin 2 valori. De asemenea, verifica daca fiecare valoare din sub-liste are cel mult 9 cifre. Daca datele nu sunt conforme cu aceste reguli, functia arunca o exceptie de tipul ValueError. In final, functia returneaza lista de liste de numere intregi citite din fisier.

Functia "valoare_maxima_si_lungimea_minima" gaseste lungimea minima a sub-listelor din lista de liste de numere intregi si gaseste valoarea maxima dintre numerele intregi din sub-listele cu aceasta lungime minima.

In main, se citesc valorile din fisier, se gaseste valoarea maxima, si se scrie aceasta valoare in fisierul "maxim5.out".

4001 - Min Max K 9

2023-04-20T14:50:02Z

MiclausIoana:

ursă: [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ă.

2873 - Sort Matrix Lin

2023-04-19T15:26:30Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/2873/sortmatrixlin] == Cerinţa == Se dă o matrice cu '''n''' linii și '''m''' coloane și un caracter '''c''' care poate fi '''+''' sau '''-'''. Să se sorteze, după linii, matricea crescător dacă semnul este '''+''' sau descrescător dacă semnul este '''-'''. Sortarea matricei după linii este rearanjarea elementelor astfel încât, parcurgând matricea pe linii, de sus în jos și de la stânga la dreapta, elementele sunt în o...

Sursă: [https://www.pbinfo.ro/probleme/2873/sortmatrixlin]
== Cerinţa ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și un caracter '''c''' care poate fi '''+''' sau '''-'''. Să se sorteze, după linii, matricea crescător dacă semnul este '''+''' sau descrescător dacă semnul este '''-'''.
Sortarea matricei după linii este rearanjarea elementelor astfel încât, parcurgând matricea pe linii, de sus în jos și de la stânga la dreapta, elementele sunt în ordine crescătoare/descrescătoare.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m''' și caracterul '''c''', iar apoi '''n''' linii cu '''m''' numere naturale. Fiecare linie pe câte un rând, toate numerele de pe fiecare linie separate prin câte un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte." Programul va afișa pe ecran matricea sortată conform cerinței, câte o linie a matricei pe o linie a ecranului, elementele fiecărei linii 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 ≤ n ≤ m ≤ 100'''
* elementele matricei vor fi mai mici sau egale cu '''1.000'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 5 4 +
: 2 4 1 3
: 9 8 7 6
: 20 19 18 16
: 30 29 124 12
: 59 21 0 3
; Date de iesire
: 0 1 2 3
:3 4 6 7
: 8 9 12 16
: 18 19 20 21
: 29 30 59 124
==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):
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 SortMatrixLin(n, m, matrice):
semn = input("Introduceti caracterul + sau -: ")

# transforma matricea intr-o lista unidimensionala
lista_unidimensionala = []
for i in range(n):
for j in range(m):
lista_unidimensionala.append(matrice[i][j])

# sorteaza lista unidimensionala
if semn == '+':
lista_unidimensionala.sort()
elif semn == '-':
lista_unidimensionala.sort(reverse=True)
else:
print("Semnul trebuie să fie + sau -.")
return

# retransforma lista unidimensionala in matrice
matrice_sortata = []
for i in range(n):
linie_matrice = []
for j in range(m):
linie_matrice.append(lista_unidimensionala.pop(0))
matrice_sortata.append(linie_matrice)

# afiseaza matricea sortata
for i in range(n):
for j in range(m):
print(matrice_sortata[i][j], end=" ")
print()

if _name_ == "_main_":
n, m, matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Matricea modificata:")
SortMatrixLin(n, m, matrice)
</syntaxhighlight>
== Explicații ==
Acest cod definește două funcții: citire_matrice() și SortMatrixLin(n, m, matrice).

Funcția citire_matrice() primește de la utilizator numărul de linii și de coloane ale unei matrice și apoi primește de la utilizator elementele matricei, verificând dacă acestea respectă anumite condiții și returnează dimensiunile matricei și matricea însăși.

Funcția SortMatrixLin(n, m, matrice) primește dimensiunile și matricea, apoi transformă matricea într-o listă unidimensională și sortează lista, utilizând semnul introdus de utilizator. Ulterior, funcția transformă lista unidimensională sortată înapoi în matrice și o afișează.

În funcția main, programul apelează funcția citire_matrice() și afișează matricea inițială. Apoi, programul apelează funcția SortMatrixLin(n, m, matrice) și afișează matricea sortată.

0620 - Sort Col

2023-04-19T15:20:57Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/620/sortcol] == Cerinţa == Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Ordonați descrescător elementele de pe fiecare coloană a matricei și apoi afișați matricea. == 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ă date...

Sursă: [https://www.pbinfo.ro/probleme/620/sortcol]
== Cerinţa ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Ordonați descrescător elementele de pe fiecare coloană a matricei și apoi afișați matricea.
== 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 matricea modificată, câte o linie a matricei pe câte o linie a ecranului, elementele fiecărei linii 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 '''10000'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 4 6
: 4 20 15 23 18 9
: 1 8 23 22 14 18
: 17 18 13 18 12 15
: 3 18 8 20 12 5
; Date de iesire
: 17 20 23 23 18 18
: 4 18 15 22 14 15
: 3 18 13 20 12 9
: 1 8 8 18 12 5
==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):
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 SortCol(n, m, matrice):
def sort(col):
for i in range(n):
for j in range(i + 1, n):
if matrice[i][col] < matrice[j][col]:
matrice[i][col], matrice[j][col] = matrice[j][col], matrice[i][col]

for j in range(m):
sort(j)

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

if _name_ == "_main_":
n, m, matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Matricea modificata:")
SortCol(n, m, matrice)
</syntaxhighlight>

== Explicații ==
Acest cod definește două funcții: citire_matrice() și SortCol(), și conține blocul principal care citește matricea de la tastatură, o afișează și apoi o sortează descrescător pe coloane, afișând matricea modificată.

Funcția citire_matrice() citește numărul de linii și coloane ale matricei de la tastatură, și apoi citește elementele matricei, verificând dacă acestea sunt numere întregi și mai mici decât 10000. Funcția returnează numărul de linii, coloane și matricea în sine.

Funcția SortCol() primește ca parametri numărul de linii, numărul de coloane și matricea, și definește o funcție internă numită sort(), care sortează matricea descrescător pe o anumită coloană dată ca argument. În bucla principală, această funcție este apelată pentru fiecare coloană a matricei, iar apoi matricea modificată este afișată pe ecran. Blocul principal apelează funcția citire_matrice() pentru a citi matricea, o afișează pe ecran, apoi apelează funcția SortCol() pentru a o sorta și a o afișa pe ecran.

Mai trebuie menționat că în ultima linie din cod, if _name_ == "_main_": este o construcție care se asigură că codul care urmează va fi executat doar dacă acest script este rulat direct, și nu importat ca un modul într-un alt script.

0619 - Sort Lin

2023-04-19T15:16:24Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/619/sortlin] == Cerinţa == Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Ordonați crescător elementele de pe fiecare linie a matricei și apoi afişați matricea. == 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 sun...

Sursă: [https://www.pbinfo.ro/probleme/619/sortlin]
== Cerinţa ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Ordonați crescător elementele de pe fiecare linie a matricei și apoi afişați matricea.
== 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 matricea modificată, câte o linie a matricei pe câte o linie a ecranului, elementele fiecărei linii 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 '''10000'''
=== Exemplu 1 ===
; Date de intrare
: 4 6
: 4 20 15 23 18 9
: 1 8 23 22 14 18
: 17 18 13 18 12 15
: 3 18 8 20 12 5
; Date de iesire
: 4 9 15 18 20 23
: 1 8 14 18 22 23
: 12 13 15 17 18 18
: 3 5 8 12 18 20
==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):
linie_matrice = []
try:
row = list(map(int, input("Introduceti elementele liniei:").split()))
if len(row) != m:
print(f"Linia {linie+1} nu are {m} elemente.")
exit()
for valoare in row:
if valoare <= 10000:
linie_matrice.append(valoare)
else:
print("Datele nu sunt conform restrictiilor impuse.")
exit()
linie_matrice.sort()
matrice.append(linie_matrice)
except ValueError:
print("Trebuie introduse doar numere intregi.")
exit()

return n, m, matrice

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

if _name_ == "_main_":
n, m, matrice = citire_matrice()
print("Matricea initiala:")
afisare_matrice(n, m, matrice)
print("Matricea sortata:")
afisare_matrice(n, m, matrice)
</syntaxhighlight>
== Explicații ==
Codul dat primește o matrice cu n linii și m coloane și elemente numere naturale. Scopul este de a sorta elementele de pe fiecare linie a matricei în ordine crescătoare și de a afișa matricea sortată.

Funcția citire_matrice primește numărul de linii și coloane ale matricei și apoi citește elementele matricei linie cu linie de la tastatură. Verifică dacă datele de intrare sunt valide și în caz contrar afișează un mesaj corespunzător și iese din program. De asemenea, funcția sortează elementele de pe fiecare linie a matricei în ordine crescătoare și returnează matricea sortată.

Funcția afisare_matrice primește matricea sortată și afișează elementele sale pe ecran, linie cu linie, separate prin spații.

În blocul principal, se apelează funcția citire_matrice pentru a citi matricea de la tastatură, se afișează matricea inițială cu ajutorul funcției afisare_matrice, se sortează și se afișează matricea sortată cu ajutorul aceleiași funcții.

În general, codul este structurat bine și respectă cerințele problemei. Au fost adăugate verificări suplimentare pentru a gestiona cazurile de date invalide și a oferi o interfață mai bună pentru utilizator.

0762 - Identice 2

2023-04-19T15:07:20Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/762/identice2] == Cerinţa == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Să se determine câte perechi de linii din matrice sunt identice. == 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: "Datel...

Sursă: [https://www.pbinfo.ro/probleme/762/identice2]
== Cerinţa ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Să se determine câte perechi de linii din matrice sunt identice.
== 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 valoare 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'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 6 3
: 10 2 5
: 2 1 4
: 10 2 5
: 7 10 9
: 10 2 5
: 2 1 4
; Date de iesire
: 4
==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 m % 2 == 0:
print("Numarul de coloane trebuie sa fie impar.")
exit()
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 <= 1000000:
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 identice2(n, m, matrice):
cnt = 0
for i in range(n - 1):
for k in range(i + 1, n):
ok = all(matrice[i][j] == matrice[k][j] for j in range(m))
if ok:
cnt += 1

print(cnt)

if _name_ == "_main_":
n, m, matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Numarul de perechi de linii consecutive identice:")
identice2(n, m, matrice)
</syntaxhighlight>

== Explicații ==
Acest cod reprezintă o soluție pentru problema de a determina câte perechi de linii consecutive identice există într-o matrice dată.

Funcția citire_matrice() se ocupă de citirea datelor de intrare de la tastatură și returnează numărul de linii și coloane ale matricei, precum și matricea propriu-zisă. Mai întâi se verifică dacă numărul de coloane este impar (conform cerințelor problemei) și se validează datele de intrare (numerele de linii și coloane trebuie să fie cuprinse între 1 și 100, iar elementele matricei să fie numere naturale mai mici decât 1.000.000).

Funcția identice2() primește ca parametri numărul de linii și coloane ale matricei și matricea însăși. Apoi, folosind două bucle for, se compară fiecare pereche de linii din matrice (exceptând cele cu aceeași poziție) și se verifică dacă sunt identice. Pentru a verifica acest lucru, se folosește funcția all() împreună cu o expresie generatoare, care verifică dacă elementele de pe fiecare poziție a celor două linii sunt egale. Dacă da, se incrementează un contor cnt. La final, funcția afișează valoarea acestui contor.

În funcția main(), se apelează mai întâi funcția citire_matrice() pentru a obține datele de intrare. Apoi, se afișează matricea inițială și se apelează funcția identice2() pentru a determina numărul de perechi de linii consecutive identice

0668 - Identice 1

2023-04-19T15:00:45Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/668/identice1] == Cerinţa == Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Să se determine câte perechi de linii consecutive din matrice sunt identice. == 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 af...

Sursă: [https://www.pbinfo.ro/probleme/668/identice1]
== Cerinţa ==
Se dă o matrice cu '''n''' linii și '''m''' coloane și elemente numere naturale. Să se determine câte perechi de linii consecutive din matrice sunt identice.
== 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 numere, reprezentând valoare 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'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 5 3
: 10 2 5
: 2 1 4
: 2 1 4
: 7 10 9
: 7 10 9
; Date de iesire
: 2
==== Explicatie ====
Sunt identice a doua și a treia linie, respectiv a patra și a cincea.

=== 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 m % 2 == 0:
print("Numarul de coloane trebuie sa fie impar.")
exit()
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 <= 1000000:
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 identice(n, m, matrice):
cnt = 0
for i in range(n-1):
if matrice[i] == matrice[i+1]:
cnt += 1

print(cnt)

if _name_ == "_main_":
n, m, matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Numarul de perechi de linii consecutive identice:")
identice(n, m, matrice)
</syntaxhighlight>

=== Explicatie ===
Acest program citeste de la tastatura numerele n si m, apoi citeste o matrice cu n linii si m coloane, formata din numere intregi mai mici decat 1.000.000, verificand in acelasi timp daca datele introduse sunt valide. Dupa ce matricea este citita, programul afiseaza matricea initiala si numarul de perechi de linii consecutive identice din matricea data.

Functia citire_matrice primeste input-ul de la tastatura si creeaza si returneaza matricea corespunzatoare. Verifica daca numarul de coloane este impar si daca valorile introduse se incadreaza in intervalul permis. Dupa ce matricea este citita, aceasta este returnata impreuna cu dimensiunile sale.

Functia identice primeste dimensiunile si matricea si calculeaza numarul de perechi de linii consecutive identice. Parcurge matricea linie cu linie si verifica daca linia curenta si cea urmatoare sunt identice, daca da, adauga unu la numarul de perechi identice. La final afiseaza numarul de perechi identice gasite

3120 - Simetrica Bac

2023-04-19T14:48:24Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/3120/simetrica-bac] == Cerinţa == Un tablou bidimensional cu număr impar de coloane este numit simetric faţă de coloana din mijloc dacă, pe fiecare linie a tabloului, elementele dispuse simetric faţă de elementul din mijloc al liniei respective au valori egale. Scrieţi un program care citește de la tastatură două numere naturale, '''m''' și '''n''' ('''n''' impar), și elementele unui tablou bidimensional cu '''m''' linii ș...

Sursă: [https://www.pbinfo.ro/probleme/3120/simetrica-bac]
== Cerinţa ==
Un tablou bidimensional cu număr impar de coloane este numit simetric faţă de coloana din mijloc dacă, pe fiecare linie a tabloului, elementele dispuse simetric faţă de elementul din mijloc al liniei respective au valori egale.
Scrieţi un program care citește de la tastatură două numere naturale, '''m''' și '''n''' ('''n''' impar), și elementele unui tablou bidimensional cu '''m''' linii și '''n''' coloane, numere naturale. Programul afișează pe ecran mesajul '''DA''', dacă tabloul este simetric față de coloana din mijloc, sau mesajul '''NU''' în caz contrar.
== Date de intrare ==
Programul citește de la tastatură numerele '''m''' și '''n''', iar apoi cele n*m elemente ale 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 mesajul DA sau NU, conform eununțului. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''3 ≤ n, m ≤ 21'''
* numerele citite din matrice vor fi mai mici decât '''10.000'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 4 5
: 1 2 4 2 1
: 3 5 5 5 3
: 2 4 1 4 2
: 1 1 1 1 1
; Date de iesire
: DA
=== Exemplu 2 ===
; Date de intrare
: 2 4
: 2 3 1 3
: 1 1 1 5
; Date de iesire
: NU, Datele nu sunt comform restirctiilor impuse
== 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 m % 2 == 0:
print("Numarul de coloane trebuie sa fie impar.")
exit()
if 3 <= n <= 21 and 3 <= m <= 21:
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 <= 10000:
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 simetrie(n, m, matrice):
mijl = m // 2
for i in range(n):
for j in range(mijl):
if matrice[i][j] != matrice[i][m-j-1]:
print("NU")
return
print("DA")

if _name_ == "_main_":
n, m, matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Matricea transformata:")
simetrie(n, m, matrice)
</syntaxhighlight>
== Explicații ==
Acest cod reprezintă o implementare a unui program care citeste o matrice de dimensiuni date de utilizator, verifica daca matricea respecta anumite restrictii (numarul de linii si coloane trebuie sa fie intre 3 si 21, numarul de coloane trebuie sa fie impar, valorile din matrice trebuie sa fie mai mici sau egale cu 10000), si verifica daca matricea este simetrica fata de mijlocul ei.

Functia citire_matrice() citeste numarul de linii si coloane ale matricei si verifica daca sunt conforme cu restrictiile, iar apoi citeste elementele matricei, verificand daca sunt numere intregi si sunt conforme cu restrictiile. Daca aceste conditii nu sunt respectate, programul se opreste prin intermediul functiei exit(). Aceasta functie returneaza dimensiunile si matricea citite.

Functia simetrie(n, m, matrice) verifica daca matricea primita ca parametru este simetrica fata de mijlocul ei. Acest lucru este realizat prin compararea fiecarui element din matrice cu elementul corespunzator de pe partea opusa. Daca exista cel putin o pereche de elemente care nu sunt simetrice, programul afiseaza "NU". Daca toate elementele sunt simetrice, programul afiseaza "DA".

In final, programul citeste si afiseaza matricea initiala, apoi verifica daca matricea este simetrica si afiseaza matricea transformata.

0788 - Oglindire

2023-04-19T14:35:34Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/788/oglindire] == Cerinţa == Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se oglindească toate liniile matricei care încep cu un număr prim și apoi să se afișeze matricea. == 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 =...

Sursă: [https://www.pbinfo.ro/probleme/788/oglindire]
== Cerinţa ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se oglindească toate liniile matricei care încep cu un număr prim și apoi să se afișeze matricea.
== 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
: 17 15 13 18 12 1
: 15 8 23 23 14 18
: 3 18 8 23 12 15
; Date de iesire
: 4 20 15 23 18 9
: 1 12 18 13 15 17
: 15 8 23 23 14 18
: 15 12 23 8 18 3
== 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 oglindit(n, m, matrice):
for i in range(n):
if prim(matrice[i][0]):
for j in range(m - 1, -1, -1):
print(matrice[i][j], end=' ')
else:
for j in range(m):
print(matrice[i][j], end=' ')
print()

if _name_ == "_main_":
n, m, matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Matricea transformata:")
oglindit(n, m, matrice)
</syntaxhighlight>
== Explicatii ==
Acest cod definește două funcții: "citire_matrice()" și "oglindit()".

Funcția "citire_matrice()" cere utilizatorului să introducă numărul de linii și de coloane ale matricei și validează datele introduse pentru a se asigura că sunt corecte. Apoi, se introduce matricea element cu element, pentru fiecare linie și coloană, și se validează valoarea introdusă. Dacă datele nu sunt valide, se afișează un mesaj corespunzător și se iese din program.

Funcția "oglindit()" primește numărul de linii și coloane ale matricei, împreună cu matricea în sine. Aceasta verifică dacă primul element al fiecărei linii este prim sau nu, și dacă este prim, afișează elementele acelei linii în ordine inversă, altfel le afișează în ordine directă.

În programul principal, se apelează funcția "citire_matrice()" pentru a citi matricea de intrare, se afișează matricea de intrare și apoi se apelează funcția "oglindit()" pentru a afișa matricea transformată.

0796 - Eliminare 3

2023-04-19T14:29:08Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/796/eliminare3]
== Cerinţa ==
Se dă o matrice cu '''m''' linii și '''n''' coloane și elemente numere naturale cu cel mult patru cifre. Să se modifice matricea, eliminând penultima linie și penultima coloană.
== Date de intrare ==
Programul citește de la tastatură numerele '''m n''', iar apoi '''m*n''' 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 matricea obținută fiecare linie a matricei pe câte o linie a ecranului, elementele de pe aceeași 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 ==
* '''3 ≤ m,n ≤ 50'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 4 5
: 5 1 2 3 4
: 8 2 2 5 3
: 2 1 7 3 9
: 3 0 9 8 5
; Date de iesire
: 5 1 2 4
: 8 2 2 3
: 3 0 9 5
=== Exemplu 2 ===
; Date de intrare
: 2 3
; Date de iesire
: Datele nu sunt comform restrictiilor impuse
== 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 3 <= n <= 50 and 3 <= 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 valoare >= 0:
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 eliminare_penultima_linie_si_coloana(matrice):
n = len(matrice)
m = len(matrice[0])
for i in range(n):
for j in range(m):
if i != n - 2 and j != m - 2:
print(matrice[i][j], end=' ')
if i != n - 2:
print()

if _name_ == "_main_":
matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Matricea transformata:")
eliminare_penultima_linie_si_coloana(matrice)
</syntaxhighlight>

== Explicatii ==
Acest cod definește două funcții și apoi apelează funcțiile respective în funcția principală, care este protejată de instrucțiunea if _name_ == "_main_":.

Funcția citire_matrice() primește input-ul de la utilizator pentru dimensiunile matricei și valorile pentru fiecare element din matrice. În primul rând, funcția cere numărul de linii și de coloane ale matricei și verifică dacă numerele introduse sunt în intervalul [3, 50]. Dacă nu sunt, funcția afișează un mesaj corespunzător și se termină. Dacă input-ul este corect, funcția continuă să ceară valori pentru fiecare element al matricei și să le stocheze într-o listă bidimensională matrice. Dacă valoarea introdusă nu este un număr întreg, funcția afișează un mesaj corespunzător și se termină. Dacă numărul introdus este mai mic decât zero, funcția afișează un mesaj corespunzător și încearcă din nou să ceară o valoare de la utilizator până când aceasta este validă. Funcția returnează matricea.

Funcția eliminare_penultima_linie_si_coloana(matrice) primește matricea ca argument și afișează matricea fără a doua linie și a doua coloană. Pentru fiecare element din matrice, funcția verifică dacă linia și coloana curentă sunt penultimele și, dacă da, afișează elementul următor. În caz contrar, afișează elementul curent. După afișarea tuturor elementelor dintr-o linie, funcția afișează o linie goală.

Funcția principală apelează citire_matrice() și afișează matricea inițială. Apoi, apelează eliminare_penultima_linie_si_coloana(matrice) și afișează matricea transformată.

0785 - Elim Min Max

2023-04-19T14:18:48Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/785/elimminmax]
== Cerinţa ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale distincte două câte două. Să se elimine din matrice linia și coloana pe care se află elementul maxim și linia și coloana pe care se află elementul minim.
== 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
: 45 49 28 43 19 30
: 24 12 9 55 52 39
: 7 13 48 15 3 51
: 37 4 25 8 20 34
; Date de iesire
: 45 49 28 30
: 37 4 25 34
==== Explicatie ====
S-au eliminat liniile 2 și 3, respectiv coloanele 4 și 5.

== 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 matrice

def eliminare_linie(matrice):
# gasirea pozitiei elementului maxim
max_val = matrice[0][0]
max_i, max_j = 0, 0
for i in range(len(matrice)):
for j in range(len(matrice[0])):
if matrice[i][j] > max_val:
max_val = matrice[i][j]
max_i, max_j = i, j

# gasirea pozitiei elementului minim
min_val = matrice[0][0]
min_i, min_j = 0, 0
for i in range(len(matrice)):
for j in range(len(matrice[0])):
if matrice[i][j] < min_val:
min_val = matrice[i][j]
min_i, min_j = i, j

# eliminarea liniilor si coloanelor
new_matrice = []
for i in range(len(matrice)):
if i == max_i or i == min_i:
continue
new_row = []
for j in range(len(matrice[0])):
if j == max_j or j == min_j:
continue
new_row.append(matrice[i][j])
new_matrice.append(new_row)

# afisarea matricei transformate
for row in new_matrice:
print(*row)

if _name_ == "_main_":
matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Matricea transformata:")
eliminare_linie(matrice)
</syntaxhighlight>

== Explicati ==
citire_matrice() - această funcție primește de la utilizator numărul de linii și coloane ale matricei și apoi îl solicită să introducă valorile matricei. Dacă valorile introduse sunt în intervalul [1, 100] și sunt numere întregi, atunci funcția returnează matricea creată.

eliminare_linie(matrice) - această funcție primește o matrice și urmărește două obiective: să găsească pozițiile elementului maxim și minim din matrice și să elimine liniile și coloanele care conțin aceste elemente. Apoi, funcția afișează matricea modificată.

main() - această funcție este punctul de intrare în program. Ea inițializează matricea cu ajutorul funcției citire_matrice(), afișează matricea inițială și apoi aplică funcția eliminare_linie() pentru a obține matricea modificată.

0774 - Elim Linii

2023-04-19T14:09:26Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/774/elimlinii]
== Cerinţa ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se elimine din matrice toate liniile care încep cu un număr prim și apoi să se afișeze matricea.
== 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
:17 15 13 18 12 1
:15 8 23 23 14 18
:3 18 8 23 12 15
; Date de iesire
: 4 20 15 23 18 9
: 15 8 23 23 14 18
=== Exemplu 2 ===
; Date de intrare
: 0 2
; Date de iesire
: Datele nu sunt comform restrictiilor impuse
==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 matrice

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

def eliminare_linii(matrice):
n = len(matrice)
m = len(matrice[0])
k = 0
while k < n:
if is_prime(matrice[k][0]):
for i in range(k, n - 1):
for j in range(m):
matrice[i][j] = matrice[i + 1][j]
n -= 1
else:
k += 1

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

if _name_ == "_main_":
matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
eliminare_linii(matrice)
</syntaxhighlight>

== Explicații ==
citire_matrice(): Această funcție cere utilizatorului să introducă dimensiunile matricei și valorile fiecărui element al matricei. Dacă valorile introduse nu respectă condițiile, funcția se încheie cu un mesaj de eroare. Funcția returnează matricea introdusă.

is_prime(n): Această funcție primește un număr întreg n și returnează True dacă n este prim și False în caz contrar.

eliminare_linii(matrice): Această funcție primește matricea introdusă și elimină liniile care au primul element prim, conform descrierii de mai sus. Matricea rezultată este afișată pe ecran.

În partea de jos a codului se citește matricea introdusă de utilizator și se afișează pe ecran. Apoi, funcția eliminare_linii() este apelată cu matricea introdusă ca argument.

0796 - Eliminare 3

2023-04-19T14:00:31Z

MiclausIoana: Pagină nouă: == Rezolvare == def citire_matrice(): try: n = int(input("Introduceti numarul de linii: ")) m = int(input("Introduceti numarul de coloane: ")) if 3 <= n <= 50 and 3 <= 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...

== Rezolvare ==
def citire_matrice():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if 3 <= n <= 50 and 3 <= 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 valoare >= 0:
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 eliminare_penultima_linie_si_coloana(matrice):
n = len(matrice)
m = len(matrice[0])
for i in range(n):
for j in range(m):
if i != n - 2 and j != m - 2:
print(matrice[i][j], end=' ')
if i != n - 2:
print()

if _name_ == "_main_":
matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Matricea transformata:")
eliminare_penultima_linie_si_coloana(matrice)
== Explicatii ==
Acest cod definește două funcții și apoi apelează funcțiile respective în funcția principală, care este protejată de instrucțiunea if _name_ == "_main_":.

Funcția citire_matrice() primește input-ul de la utilizator pentru dimensiunile matricei și valorile pentru fiecare element din matrice. În primul rând, funcția cere numărul de linii și de coloane ale matricei și verifică dacă numerele introduse sunt în intervalul [3, 50]. Dacă nu sunt, funcția afișează un mesaj corespunzător și se termină. Dacă input-ul este corect, funcția continuă să ceară valori pentru fiecare element al matricei și să le stocheze într-o listă bidimensională matrice. Dacă valoarea introdusă nu este un număr întreg, funcția afișează un mesaj corespunzător și se termină. Dacă numărul introdus este mai mic decât zero, funcția afișează un mesaj corespunzător și încearcă din nou să ceară o valoare de la utilizator până când aceasta este validă. Funcția returnează matricea.

Funcția eliminare_penultima_linie_si_coloana(matrice) primește matricea ca argument și afișează matricea fără a doua linie și a doua coloană. Pentru fiecare element din matrice, funcția verifică dacă linia și coloana curentă sunt penultimele și, dacă da, afișează elementul următor. În caz contrar, afișează elementul curent. După afișarea tuturor elementelor dintr-o linie, funcția afișează o linie goală.

Funcția principală apelează citire_matrice() și afișează matricea inițială. Apoi, apelează eliminare_penultima_linie_si_coloana(matrice) și afișează matricea transformată.

0785 - Elim Min Max

2023-04-19T13:58:35Z

MiclausIoana: Pagină nouă: == Rezolvare == 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 ran...

== Rezolvare ==
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 eliminare_linie(matrice):
# gasirea pozitiei elementului maxim
max_val = matrice[0][0]
max_i, max_j = 0, 0
for i in range(len(matrice)):
for j in range(len(matrice[0])):
if matrice[i][j] > max_val:
max_val = matrice[i][j]
max_i, max_j = i, j

# gasirea pozitiei elementului minim
min_val = matrice[0][0]
min_i, min_j = 0, 0
for i in range(len(matrice)):
for j in range(len(matrice[0])):
if matrice[i][j] < min_val:
min_val = matrice[i][j]
min_i, min_j = i, j

# eliminarea liniilor si coloanelor
new_matrice = []
for i in range(len(matrice)):
if i == max_i or i == min_i:
continue
new_row = []
for j in range(len(matrice[0])):
if j == max_j or j == min_j:
continue
new_row.append(matrice[i][j])
new_matrice.append(new_row)

# afisarea matricei transformate
for row in new_matrice:
print(*row)

if _name_ == "_main_":
matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
print("Matricea transformata:")
eliminare_linie(matrice)

== Explicati ==
citire_matrice() - această funcție primește de la utilizator numărul de linii și coloane ale matricei și apoi îl solicită să introducă valorile matricei. Dacă valorile introduse sunt în intervalul [1, 100] și sunt numere întregi, atunci funcția returnează matricea creată.

eliminare_linie(matrice) - această funcție primește o matrice și urmărește două obiective: să găsească pozițiile elementului maxim și minim din matrice și să elimine liniile și coloanele care conțin aceste elemente. Apoi, funcția afișează matricea modificată.

main() - această funcție este punctul de intrare în program. Ea inițializează matricea cu ajutorul funcției citire_matrice(), afișează matricea inițială și apoi aplică funcția eliminare_linie() pentru a obține matricea modificată.

0774 - Elim Linii

2023-04-19T13:47:06Z

MiclausIoana: Pagină nouă: Sursă: [] == Cerinţa == == Date de intrare == == 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 '''MAX''', reprezentând cel mai mare dintre cele '''n''' numere date,. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.". == Restricții și precizări == * 1 ≤ n ≤ 1.000 * cele '''n''' numere citite vor avea cel mult '''9''' cifre == Exemple...

Sursă: []
== Cerinţa ==

== Date de intrare ==

== 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 '''MAX''', reprezentând cel mai mare dintre cele '''n''' numere date,. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* 1 ≤ n ≤ 1.000
* cele '''n''' numere citite vor avea cel mult '''9''' cifre
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 5
: 7 6 9 6 8
; Date de iesire
:Datele sunt corecte. Rezultat: 9
=== Exemplu 2 ===
; Date de intrare
: 4
: 1 2 3 4
; Date de iesire
:Datele sunt corecte. Rezultat: 4
==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 matrice

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

def eliminare_linii(matrice):
n = len(matrice)
m = len(matrice[0])
k = 0
while k < n:
if is_prime(matrice[k][0]):
for i in range(k, n - 1):
for j in range(m):
matrice[i][j] = matrice[i + 1][j]
n -= 1
else:
k += 1

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

if _name_ == "_main_":
matrice = citire_matrice()
print("Matricea initiala:")
for linie in matrice:
print(linie)
eliminare_linii(matrice)
</syntaxhighlight>

== Explicații ==
citire_matrice(): Această funcție cere utilizatorului să introducă dimensiunile matricei și valorile fiecărui element al matricei. Dacă valorile introduse nu respectă condițiile, funcția se încheie cu un mesaj de eroare. Funcția returnează matricea introdusă.

is_prime(n): Această funcție primește un număr întreg n și returnează True dacă n este prim și False în caz contrar.

eliminare_linii(matrice): Această funcție primește matricea introdusă și elimină liniile care au primul element prim, conform descrierii de mai sus. Matricea rezultată este afișată pe ecran.

În partea de jos a codului se citește matricea introdusă de utilizator și se afișează pe ecran. Apoi, funcția eliminare_linii() este apelată cu matricea introdusă ca argument.

0775 - Elim Coloane

2023-04-19T13:29:25Z

MiclausIoana: Pagină nouă: Sursă: [https://www.pbinfo.ro/probleme/775/elimcoloane] == Cerinţa == Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se elimine din matrice toate coloanele care conțin elemente nule și apoi să se afișeze matricea. == 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 ==...

Sursă: [https://www.pbinfo.ro/probleme/775/elimcoloane]
== Cerinţa ==
Se dă o matrice cu '''n''' linii şi '''m''' coloane şi elemente numere naturale. Să se elimine din matrice toate coloanele care conțin elemente nule și apoi să se afișeze matricea.
== 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 0 9
: 17 0 13 18 12 1
: 15 8 23 23 14 18
: 3 0 8 23 12 15
; Date de iesire
: 4 15 23 9
: 17 13 18 1
: 15 23 23 18
: 3 8 23 15
=== Exemplu 2 ===
; Date de intrare
: 4 0
; Date de iesire
:Datele nu sunt comform restrictiilor impuse
==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 matrice

def eliminare_coloane(matrice):
n = len(matrice)
m = len(matrice[0])
j = m
while j >= 1:
ok = False
for i in range(n):
if matrice[i][j - 1] == 0:
ok = True
break
if ok:
for k in range(j - 1, m - 1):
for i in range(n):
matrice[i][k] = matrice[i][k + 1]
m -= 1
else:
j -= 1

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

if _name_ == "_main_":
matrice = citire_matrice()
eliminare_coloane(matrice)
</syntaxhighlight>
== Explicații ==
Acest cod este scris in Python si consta din 4 functii:

citire_lin_col(): Aceasta functie citeste de la utilizator numarul de linii si de coloane pentru matrice si verifica daca valorile respecta restrictiile impuse. Daca valorile sunt corecte, acestea sunt returnate. Daca valorile nu sunt corecte, programul se va inchide.

citeste_valori_matrice(lin, col): Aceasta functie citeste valorile matricei de la utilizator si le valideaza, asigurandu-se ca fiecare valoare introdusa este un numar intreg si nu depaseste o anumita valoare maxima. Daca valorile sunt valide, acestea sunt adaugate la matrice si matricea este returnata.

eliminare_coloane(matrice, n, m): Aceasta functie primeste matricea citita anterior si dimensiunile acesteia si elimina toate coloanele care contin cel putin o valoare 0. Pentru a face acest lucru, functia parcurge matricea de la dreapta la stanga si verifica fiecare coloana daca contine cel putin o valoare 0. Daca o coloana contine o astfel de valoare, functia elimina acea coloana din matrice si actualizeaza numarul de coloane. Daca o coloana nu contine valoarea 0, functia trece la urmatoarea coloana pana ajunge la prima coloana a matricei. La final, functia afiseaza matricea actualizata fara coloanele eliminate.

if _name_ == "_main_": : Aceasta instructiune verifica daca fisierul curent este fisierul principal care este executat, nu este importat ca un modul in alt program. Daca acesta este fisierul principal, atunci se vor apela functiile in ordine pentru a citi datele de intrare, pentru a elimina coloanele si pentru a afisa rezultatul.

0316 - Min Cols 2

2023-04-19T13:15:52Z

MiclausIoana:

Sursă: [https://www.pbinfo.ro/probleme/316/mincols2]
== Cerinţa ==
Se dă o matrice cu '''m''' linii şi '''n''' coloane şi elemente numere naturale. Înlocuiţi cu valoarea minimă din matrice toate elementele de pe coloanele care conţin valoarea minimă.
== 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 matricea modificată, câte o linie a matricei pe câte o linie a ecranului, elementele fiecărei linii 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 ≤ 20'''
* elementele matricei vor fi mai mici decât '''10000'''
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 4 4
:8 3 3 7
:2 1 6 5
:8 7 3 1
:9 8 7 1
; Date de iesire
:8 1 3 1
:2 1 6 1
:8 1 3 1
:9 1 7 1
=== Exemplu 2 ===
; Date de intrare
: 0
; Date de iesire
: Datele nu sunt comform restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line>
def citire_lin_col():
try:
n = int(input("Introduceti numarul de linii: "))
m = int(input("Introduceti numarul de coloane: "))
if 1 <= n <= 20 and 1 <= m <= 20:
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 valoare_minima(matrice, n, m):
# determinarea valorii minime din matrice
min_val = min(min(matrice))

# determinarea coloanelor care contin valoarea minima
coloane_min = []
for j in range(m):
for i in range(n):
if matrice[i][j] == min_val:
coloane_min.append(j)
break

# inlocuirea elementelor de pe coloanele care contin valoarea minima
for j in coloane_min:
for i in range(n):
matrice[i][j] = min_val

# afisarea matricei finale
print("Matricea finala:")
for linie in matrice:
print(*linie)

if _name_ == "_main_":
n, m = citire_lin_col()
matrice = citeste_valori_matrice(n, m)
valoare_minima(matrice, n, m)
</syntaxhighlight>
== Explicati ==
citire_lin_col(): aceasta functie citeste numarul de linii si coloane ale matricei de la utilizator si verifica daca acestea sunt valide. Daca valorile introduse sunt valide, functia returneaza cele doua valori. Daca nu, functia va afisa un mesaj de eroare si va iesi din program.

citeste_valori_matrice(lin, col): aceasta functie citeste elementele matricei de la utilizator, linie cu linie, si le valideaza. Aceasta returneaza o lista bidimensionala care reprezinta matricea.

valoare_minima(matrice, n, m): aceasta functie determina valoarea minima din matrice, coloanele care contin aceasta valoare si inlocuieste elementele din aceste coloane cu valoarea minima.

afisare_matrice(matrice, n, m): aceasta functie afiseaza matricea sub forma de tabel, cu valorile aliniate corespunzator.

main(): aceasta functie ruleaza toate celelalte functii, in ordinea corespunzatoare, pentru a citi matricea de la utilizator, a modifica elementele matricei si a afisa matricea rezultata.

0779 - Vecini Pari

2023-04-03T19:26:52Z

MiclausIoana: 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) count = 0 for i in range(n): for j in range(m): if i > 0 and matrix[i-1][j] % 2 == 1: # verificăm vecinul de sus continue if i < n-1 and matrix[i+1][j] % 2 == 1: # verificăm vecinul de jos continue if j > 0 and matrix[i][j-1] % 2 == 1:...

== 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)

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

print(count)
</syntaxhighlight>

0778 - MChenar

2023-04-03T19:06:59Z

MiclausIoana: Pagină nouă: == Rezolvare == <syntaxhighlight lang="python" line="1"> n, m = map(int, input().split()) # Inițializăm matricea cu zero-uri matrix = [[0 for j in range(m)] for i in range(n)] # Citim elementele matricei de la tastatură for i in range(n): row = list(map(int, input().split())) for j in range(m): matrix[i][j] = row[j] # Parcurgem chenarul și adăugăm elementele distincte într-un set distinct_elements = set() for j in range(m): distinct_elements.add(...

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

# Inițializăm matricea cu zero-uri
matrix = [[0 for j in range(m)] for i in range(n)]

# Citim elementele matricei de la tastatură
for i in range(n):
row = list(map(int, input().split()))
for j in range(m):
matrix[i][j] = row[j]

# Parcurgem chenarul și adăugăm elementele distincte într-un set
distinct_elements = set()
for j in range(m):
distinct_elements.add(matrix[0][j])
distinct_elements.add(matrix[n-1][j])

for i in range(1, n-1):
distinct_elements.add(matrix[i][0])
distinct_elements.add(matrix[i][m-1])

# Sortăm setul și afișăm elementele în ordine crescătoare
distinct_elements = sorted(distinct_elements)
for element in distinct_elements:
print(element, end=' ')
</syntaxhighlight>

2825 - Chenar 2

2023-04-03T18:53:58Z

MiclausIoana: Pagină nouă: == Rezolvare == <syntaxhighlight lang="python" line="1"> n, m = map(int, input().split()) a = [list(map(int, input().split())) for _ in range(n)] x = int(input()) 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 a[i][j] == x: print("DA") exit() print("NU") </syntaxhighlight>

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

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 a[i][j] == x:
print("DA")
exit()

print("NU")
</syntaxhighlight>

0777 - Cnt Coloane

2023-04-03T18:45:57Z

MiclausIoana: 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) count = 0 for j in range(m): column = [matrix[i][j] for i in range(n)] if len(set(column)) == n: count += 1 print(count) </syntaxhighlight>

== 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)

count = 0
for j in range(m):
column = [matrix[i][j] for i in range(n)]
if len(set(column)) == n:
count += 1

print(count)
</syntaxhighlight>

0776 - Cnt Linii

2023-04-03T18:42:53Z

MiclausIoana: Pagină nouă: == Rezolvare == <syntaxhighlight lang="python" line="1"> n, m = map(int, input().split()) # citim elementele matricei matrix = [] for i in range(n): row = list(map(int, input().split())) matrix.append(row) # determinăm numărul de linii cu toate elementele egale count = 0 for row in matrix: if all(elem == row[0] for elem in row): count += 1 # afișăm rezultatul print(count) </syntaxhighlight>

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

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

# determinăm numărul de linii cu toate elementele egale
count = 0
for row in matrix:
if all(elem == row[0] for elem in row):
count += 1

# afișăm rezultatul
print(count)
</syntaxhighlight>

2807 - Matrice 10

2023-04-03T18:38:47Z

MiclausIoana: Pagină nouă: == Rezolvare == <syntaxhighlight lang="python" line="1"> # citim dimensiunile matricei n, m = map(int, input().split()) # citim elementele matricei matrix = [] for i in range(n): row = list(map(int, input().split())) matrix.append(row) # găsim minimul din prima și ultima coloană min_first_col = matrix[0][0] min_last_col = matrix[0][-1] for i in range(n): if matrix[i][0] < min_first_col: min_first_col = matrix[i][0] if matrix[i][-1] < min_last_col...

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

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

# găsim minimul din prima și ultima coloană
min_first_col = matrix[0][0]
min_last_col = matrix[0][-1]

for i in range(n):
if matrix[i][0] < min_first_col:
min_first_col = matrix[i][0]
if matrix[i][-1] < min_last_col:
min_last_col = matrix[i][-1]

# înlocuim elementul minim din ultima coloană cu elementul minim din prima coloană
for i in range(n):
if matrix[i][-1] == min_last_col:
matrix[i][-1] = min_first_col
elif matrix[i][0] == min_first_col:
matrix[i][0] = min_last_col

# afișăm matricea modificată
for i in range(n):
for j in range(m):
print(matrix[i][j], end=" ")
print()
</syntaxhighlight>