Bitnami MediaWiki - User contributions [en]

Gazeta Matematică

2023-11-08T09:08:07Z

Csatari Mălina:

Această pagină conține o listă cu numerele revistei ''[https://gmb.ssmr.ro/ Gazeta Matematică]'' care conțin articole/probleme cu autori membri ai [https://ssmr.cunbm.utcluj.ro/ Filialei Maramureș] a [https://ssmr.ro/ Societății de Științe Matematice din România].
{| class="wikitable mw-collapsible"
|+
!Anul
!Numărul
!Numărul problemei
!Clasa
!Domeniu
|-
|rowspan="5" |2022
|rowspan="2"|1
| [[28247]]
|11
|Matrice
|-
| [[28250]]
|12
|integrala Riemann
limită
|-
|4 - [[Gazeta Matematică nr 4 2022|link]]
| [[28315]]
|10
|numere complexe
|-
|rowspan="2"|11
| [[E:16407]]
|5
|cub perfect
|-
| [[28450]]
|
|progresii aritmetice
|-
|rowspan = "4" |2021
|rowspan= "1" | 12 - [[28208|link]]
|[[28208]]
|9
|
|-
|rowspan = "3" |678 - [[Gazeta Matematică nr 678 2021|link]]
|[[E:15990]]
|5
|
|-
| [[E:15991]]
|5
|
|-
| [[E:15992]]
|5
|
|-
|rowspan="3" |2018
|rowspan="3" |4 - [[Gazeta Matematică nr 4 2018|link]]
| [[S:E18.128]]
|
|
|-
|[[S:E18.131]]
|
|
|-
| [[S:E18.131]]
|
|
|-
|rowspan="2" |2015
|1 - [[Gazeta Matematică nr 1 2015|link]]
|[[27020]]
|10
|coeficienți binomiali
|-
|2 - [[Gazeta Matematică nr 2 2015|link]]
|[[27036]]
|11
|ecuații funcționale
|-
| rowspan="2"| 2011
|rowspan="2"|7-8-9 - [[Gazeta Matematică nr 789 2011|link]]
|[[E:14223]]
|7
|rezolvarea triunghiului
|-
|[[E:14228]]
|7
|radicali
|}

28208

2023-11-08T08:45:14Z

Csatari Mălina: Pagină nouă: '''28208 (Dana Heuberger, Baia Mare)''' ''Considerăm pentagonul convex ABCDE înscris într-un cerc și <math>H_1, H_2, H_3, H_4, H_5</math> ortocentrele triunghiurilor ACD, BDE, CEA, DAB, respectiv EBC. Arătați că, dacă <math>H_1H_2 \parallel AB</math>, <math>H_2H_3 \parallel BC</math>, <math>H_3H_4 \parallel CD</math> și <math>H_4H_5 \parallel DE</math>, atunci ABCDE și <math>H_1H_2H_3H_4H_5</math> sunt pentagoane regulate.'' '''Soluție:''' Fie ''O'' centrul cercu...

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

''Considerăm pentagonul convex ABCDE înscris într-un cerc și <math>H_1, H_2, H_3, H_4, H_5</math> ortocentrele triunghiurilor ACD, BDE, CEA, DAB, respectiv EBC. Arătați că, dacă <math>H_1H_2 \parallel AB</math>, <math>H_2H_3 \parallel BC</math>, <math>H_3H_4 \parallel CD</math> și <math>H_4H_5 \parallel DE</math>, atunci ABCDE și <math>H_1H_2H_3H_4H_5</math> sunt pentagoane regulate.''

'''Soluție:'''
Fie ''O'' centrul cercului circumscris pentagonului ''ABCDE''. Folosind relația lui Sylvester, obținem <math>\overrightarrow{O H_1}=\overrightarrow{O A}+\overrightarrow{O C}+\overrightarrow{O D}</math> și <math>\overrightarrow{O H_2}=\overrightarrow{O B}+\overrightarrow{O D}+\overrightarrow{O E}.</math> Avem <math>\overrightarrow{H_1 H_2}=\overrightarrow{O H_2}-\overrightarrow{O H_1}=\overrightarrow{A B}+\overrightarrow{C E}</math> și, cum <math>H_1H_2 \parallel AB,</math> rezultă că <math>AB \parallel CE</math>, deci <math>AE=BC</math> și <math>H_1H_2 = |CE-AB|.</math>

Analog, din <math>H_2H_3 \parallel BC,</math> obținem <math>AB=CD</math> și <math>H_2H_3=|AD-BC|</math>, din <math>H_3H_4 \parallel CD</math> deducem că <math>BC=DE</math> și <math>H_3H_4=|BE-CD|</math>, iar din <math>H_4H_5 \parallel DE</math> rezultă că <math>CD=AE</math> și <math>H_4H_5=|AC-DE|.</math>

Avem <math>AB=BC=CD=DE=EA</math>, prin urmare și arcele de cerc subîntinse de laturile pentagonului sunt congruente, deci și unghiurile lui ABCDE sunt congruente. În concluzie, pentagonul ABCDE este regulat.

Din <math>AE \parallel BD</math> și <math>\overrightarrow{H_1 H_5}=\overrightarrow{A E}+\overrightarrow{D B}</math>, obținem <math>H_1H_5=DB-AE</math> și <math>H_5H_1 \parallel AE.</math> Deducem că <math>H_1H_2=H_2H_3=H_3H_4=H_4H_5=H_5H_1</math> și că unghiurile lui <math>H_1H_2H_3H_4H_5</math> sunt congruente cu cele ale pentagonului regulat ABCDE, deci <math>H_1H_2H_3H_4H_5</math> este un pentagon regulat.

0270 - Unice1

2023-06-02T10:45:44Z

Csatari Mălina: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/270/unice1 0270 - Unice1] ---- == Cerinţa == Se dau '''n''' numere întregi. Determinaţi câte dintre numerele date apar o singură dată. == Date de intrare == Fişierul de intrare '''unice1.in''' conţine pe prima linie numărul n; urmează n numere întregi, dispuse pe mai multe linii, separate prin spaţii. == Date de ieșire == Dacă datele din fișier sunt introduse corect, pe ecran se va afișa: '''"Datele din fișier sunt int...

Sursa: [https://www.pbinfo.ro/probleme/270/unice1 0270 - Unice1]
----
== Cerinţa ==
Se dau '''n''' numere întregi. Determinaţi câte dintre numerele date apar o singură dată.
== Date de intrare ==
Fişierul de intrare '''unice1.in''' conţine pe prima linie numărul n; urmează n numere întregi, dispuse pe mai multe linii, separate prin spaţii.
== Date de ieșire ==
Dacă datele din fișier sunt introduse corect, pe ecran se va afișa:
'''"Datele din fișier sunt introduse corect."''', apoi, fişierul de ieşire unice1.out va conţine pe prima linie C, numărul cerut. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele din fișier nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''1 ≤ n ≤ 1000'''
* cele '''n''' valori citite sunt cuprinse între '''-1.000.000''' şi '''1.000.000'''

== Exemple ==
===Exemplul 1===
; unice1.in
: 7
: 4 -2 3 4
: 5 -2 4
; Ecran
: Datele din fișier sunt introduse corect.
; unice1.out
: 2
===Exemplul 2===
; pozitie.in
: 7
: 4 -21000000 3 4
: 5 -2 4
; Ecran
: Datele din fișier nu corespund restricțiilor impuse.
 

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

def numere_unice():
frecvente = [0] * 2000001 # Inițializăm un vector de frecvențe cu valori de 0

for numar in numere:
index = numar + 1000000 # Folosim un offset pentru a nu avea numere negative în vector
frecvente[index] += 1

numere_unice = 0
for frecventa in frecvente:
if frecventa == 1:
numere_unice += 1

with open('unice1.out', 'w') as f:
f.write(str(numere_unice))

def citire_conform_restrictiilor(numere, n):
if n < 1 or n > 1000:
print("Datele din fișier nu corespund restricțiilor impuse.")
exit()
for numar in numere:
if numar < -1000000 or numar > 1000000:
print("Datele din fișier nu corespund restricțiilor impuse.")
exit()
print("Datele din fișier sunt introduse corect.")

if __name__ == '__main__':
with open('unice1.in', 'r') as f:
n = int(f.readline())
numere = []
for _ in range(n):
numere.extend(map(int, f.readline().split()))
citire_conform_restrictiilor(numere, n)
numere_unice()

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține '''trei secțiuni''': 1. Secțiunea '''if __name__ == '__main__' ''': În această secțiune, codul este responsabil pentru citirea datelor din fișier (with open('unice1.in', 'r') as f:) și apelarea funcțiilor citire_conform_restrictiilor() și numere_unice(). 2. Secțiunea '''citire_conform_restrictiilor''': Această secțiune definește funcția citire_conform_restrictiilor, care primește lista numere și numărul n ca argumente. Funcția verifică restricțiile impuse în enunțul problemei: că n trebuie să fie între 1 și 1000, iar numerele trebuie să fie cuprinse între -1.000.000 și 1.000.000. Dacă una dintre restricții nu este respectată, se afișează un mesaj de eroare și se utilizează exit() pentru a opri execuția programului. Altfel, afișează mesajul de confirmare că datele din fișier sunt corecte și se continuă programul. 3. Secțiunea '''numere_unice''': Această secțiune definește '''funcția numere_unice''', care implementează logica pentru determinarea numărului de numere unice. În această funcție, se inițializează un vector de frecvențe cu valori de 0, se parcurge lista numere și se incrementează frecvența corespunzătoare fiecărui număr. Apoi, se numără câte elemente au o frecvență de 1 și se scrie rezultatul (din variabila numere_unice) în fișierul de ieșire "unice1.out", astfel rezolvând problema conform cerințelor impuse!

0551 - Elevi

2023-04-26T12:04:13Z

Csatari Mălina:

Sursa: https://www.pbinfo.ro/probleme/551/elevi 0551- Elevi]
----
== Cerinţa ==
La liceul nostru sunt '''m''' clase, fiecare având '''n''' elevi. Pentru fiecare elev se cunoaşte talentul artistic, exprimat printr-un număr natural. Să se determine cea mai mare valoare pe care o are talentul artistic al elevilor, notată cu '''MAX''' şi numărul '''CNT''' de clase din liceu în care există elevi care au talent maxim.
== Date de intrare ==
Programul citește de la tastatură numerele '''m n''', iar apoi '''m''' şiruri cu câte '''n''' numere naturale, reprezentând talentul fiecărui elev din fiecare clasă.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa numerele MAX CNT, separate prin exact un spaţiu, cu semnificaţia precizată. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n''' &les; '''1000'''
* '''1''' &les; '''m''' &les; '''100'''
* talentul artistic al unui elev este un număr natural mai mic decât '''1.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 5 4
: 1 5 3 5
: 4 4 6 1
: 6 3 6 2
: 1 4 1 4
: 6 5 6 2
; Ieșire
: Datele sunt introduse corect.
: 6 3
===Exemplul 2===
; Intrare
: -1 12
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0551

def citire_cu_restrictii_m_n(m, n):
if n < 1 or n > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if m < 1 or m > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()

def verificare_vectori_conform_restrictiilor(vector):
for element in vector:
if element > 1000000 or element < 1:
print("Datele nu corespund restricțiilor impuse.")
exit()

def prelucrare_max_cnt(m, n):
vector = [0] * 1001
MAX, CNT = -1, 0
for k in range(1, n+1):
vector = list(map(int, input().split()))

cmaxim = vector[0]

for i in range(m):
if vector[i] > cmaxim:
cmaxim = vector[i]

if cmaxim > MAX:
MAX = cmaxim
CNT = 1
elif cmaxim == MAX:
CNT += 1
print("Datele sunt introduse corect.")
print(MAX, CNT)

if __name__ == '__main__':
n, m = map(int, input().split())
citire_cu_restrictii_m_n(m, n)
prelucrare_max_cnt(m, n)

</syntaxhighlight>
== Explicație rezolvare==
Acest cod definește trei funcții și o secțiune '''if __name__ == '__main__':'''(linia 40) care apelează aceste funcții după citirea numerelor n și m cu ajutorul comenzii de citire input() și cea de conversie în număr int() (linia 41). Funcția '''citire_cu_restrictii_m_n(m, n)''' primește doi parametri, m și n, și verifică dacă aceștia îndeplinesc restricțiile impuse. Dacă n nu este între 1 și 1000 sau m nu este între 1 și 100, se afișează "Datele nu corespund restricțiilor impuse." și se încheie programul prin apelul funcției exit(). Funcția '''verificare_vectori_conform_restrictiilor(vector)''' primește un vector de numere și verifică dacă acestea îndeplinesc restricțiile impuse. Dacă un element din vector este mai mare decât 1000000 sau mai mic decât 1, se afișează "Datele nu corespund restricțiilor impuse." și se încheie programul prin apelul funcției exit(). Funcția '''prelucrare_max_cnt(m, n)''' primește doi parametri, m și n, și efectuează o prelucrare de date. Se creează un vector gol de lungime 1001 cu vector = [0] * 1001. Apoi se citește n linii de input, fiecare conținând m numere separate prin spațiu, și se stochează în vector. Pentru fiecare linie, se găsește cel mai mare element din acea linie și se compară cu maximul global (MAX). Dacă acesta este mai mare decât maximul global curent, se actualizează maximul global și se resetează contorul (CNT) la 1. Dacă este egal cu maximul global curent, se incrementează contorul. La final, se afișează "Datele sunt introduse corect." și pe un rând nou MAX și CNT, conform problemei.

0189 - NumarMunte

2023-04-26T11:53:51Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/189/numarmunte 0189- NumarMunte]
----
== Cerinţa ==
Se dau '''n''' numere naturale. Determinați, pentru fiecare dintre ele, dacă este de tip “munte”. Un număr este de tip “munte” dacă cifrele sale formează inițial un șir strict crescător, apoi un șir strict descrescător.
== 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 introduse corect."''', apoi pe un rând nou pentru fiecare dintre cele n numere citite, pe câte o linie a ecranului '''valoarea 1''', dacă numărul corespunzător este de tip “munte”, respectiv '''valoarea 0''' în caz contrar. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n''' &les; '''10'''
* cele n numere vor fi cuprinse între '''100''' și '''2.000.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 4
: 15965 156 121 753
; Ieșire
: Datele sunt introduse corect.
: 1
: 0
: 1
: 0
===Exemplul 2===
; Intrare
: 3
: 123 3 145
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0189

def afisare_if_munte(vector):
for element in vector:
if verificare_munte(element):
print(1)
if not verificare_munte(element):
print(0)

def verificare_munte(numar):
nr_cifre = len(str(numar))
cifre = []
while numar:
cifre.append(numar % 10)
numar //= 10
cifre.reverse()
poz = 0
while poz < nr_cifre - 1 and cifre[poz] < cifre[poz + 1]:
poz += 1
if poz == 0 or poz == nr_cifre - 1:
return False
while poz < nr_cifre - 1 and cifre[poz] > cifre[poz + 1]:
poz += 1
return poz == nr_cifre - 1

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 10:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 100 or x > 2000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
afisare_if_munte(vector)

</syntaxhighlight>
== Explicație rezolvare==
Acest cod implementează o soluție pentru problema de a determina dacă un număr dat este de tip "munte". Mai exact, în secțiunea '''if __name__ == '__main__':''' se citește de la tastatură un număr natural n, urmat de n numere naturale pe care le punem în vectorul "vector", apoi apelăm cele două funcții definite mai sus citire_conform_restrictiilor(vector, n) și afisare_if_munte(vector). Funcția '''verificare_munte(num)''' primește ca argument un număr natural num și returnează True dacă acesta este de tip "munte" și False în caz contrar. Algoritmul folosit în această funcție constă în parcurgerea cifrelor numărului, în ordine inversă față de poziția lor, și verificarea dacă există o poziție în care cifrele cresc și apoi scad. Dacă se găsește o astfel de poziție, se returnează True. Altfel, se returnează False. 
Funcția '''afisare_if_munte(vector)''' primește ca argument un vector de numere naturale și afișează rezultatul verificării pentru fiecare element din vector, folosind funcția '''verificare_munte(num)''' (dacă rezultatul returnat de funcție este diferit de 0 afișăm 1, adică este munte, iar dacă rezultatul returnat de funcție este 0 afișăm 0, adică nu este munte). 
Funcția '''citire_conform_restrictiilor()''' verifică dacă datele introduse corespund restricțiilor impuse de problemă (n trebuie să fie între 1 și 10, iar numerele din vector trebuie să fie între 100 și 2000000000, n este lungimea vectorului "vector"). Dacă datele sunt introduse corect se afișează "Datele sunt introduse corect." și se poate continua programul. Dacă nu, programul afișează "Datele nu corespund restricțiilor impuse." și se oprește cu ajutorul comenzii exit().

1893 - MerryChristmas

2023-04-26T11:45:39Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/1893/merrychristmas 1893- MerryChristmas]
----
== Cerinţa ==
Moş Crăciun s-a dus la Polul Nord Shopping City să cumpere '''n''' cadouri pentru copiii din întreaga lume. Fiecare cadou avea un cod de bare pentru identificarea produsului, corespunzător unui număr format din nouă cifre, prima cifră fiind nenulă. La plecare şi-a amintit că-i promisese unui copil isteţ un cadou special, care să fie diferit de toate celelalte. Moş Crăciun vă roagă să găsiţi un cadou care să aibă codul de bare diferit de toate celelalte.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale de nouă cifre, separate prin spații, reprezentând codurile cadourilor cumpărate.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa codul unui cadou special, care este diferit de codurile cadourilor cumpărate. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n''' &les; '''500.000'''
* cele '''n''' numere citite vor avea câte nouă cifre

== Exemple ==
===Exemplul 1===
; Intrare
: 4
: 123456789 987654321 112345567 200000001
; Ieșire (orice variantă de cod e corectă atât timp cât e diferită de celelalte din vector)
: Datele sunt introduse corect.
: 286867248
===Exemplul 2===
; Intrare
: 4
: 12 2 3 4
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1893

import random

def generare_cod():
nr_pt_produs1 = random.randint(10000, 31622)
nr_pt_produs2 = random.randint(10000, 31622)
cod_generat_random_de_9_cifre = nr_pt_produs1 * nr_pt_produs2
return cod_generat_random_de_9_cifre

def verificare_cod_unic(coduri):
cod_generat_random_de_9_cifre = generare_cod()
if cod_generat_random_de_9_cifre not in coduri:
print(cod_generat_random_de_9_cifre)
else:
verificare_cod_unic(coduri)

def citire_conform_restrictiilor(n, coduri):
if n < 1 or n > 500000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in coduri:
if x < 100000000 or x > 999999999:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(coduri):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
coduri = list(map(int, input().split()))
citire_conform_restrictiilor(n, coduri)
verificare_cod_unic(coduri)

</syntaxhighlight>
== Explicație rezolvare==
În secțiunea '''if __name__ == '__main__':''', programul citește numărul n și cele n coduri pe care le vom pune în vectorul "coduri", apoi apelează funcția citire_conform_restrictiilor(n, coduri) și funcția verificare_cod_unic(coduri) pentru a genera un cod unic de bare și a-l afișa pe ecran. Funcția '''citire_conform_restrictiilor()''' primește ca parametrii numărul n și un vector "coduri". Funcția verifică dacă datele de intrare corespund cerințelor: n trebuie să fie între 1 și 500.000 inclusiv, fiecare cod trebuie să fie un număr întreg de nouă cifre și numărul de coduri introduse trebuie să fie egal cu n. Dacă oricare dintre restricții este încălcată, se va afișa "Datele nu corespund restricțiilor impuse." și se va încheia programul cu ajutorul comenzii exit(). Dacă datele respectă condițiile, se va afișa "Datele sunt introduse corect." și se poate continua programul.
Funcția '''generare_cod()''' generează un cod unic de bare, folosind funcția randint() din modulul Python random pentru a genera două numere întregi aleatoare între 10.000 și 31.622 inclusiv (variabilele nr_pt_produs1, nr_pt_produs2). Produsul celor două numere întregi nr_pt_produs1 * nr_pt_produs2 este mereu un număr cu nouă cifre, care reprezintă codul de bare și este calculat în variabila cod_generat_random_de_9_cifre, care va fi returnat de această funcție.
Funcția '''verificare_cod_unic(coduri)''' verifică dacă un cod generat de funcția generare_cod() este unic în lista dată ca parametru (printr-un if ... not in ..., care verifică dacă numărul nu este în listă). Dacă codul generat este în listă, funcția generează un nou cod unic prin apelarea recursivă a sa. Dacă codul generat este unic, acesta este afișat pe ecran.

0383 - inlocuireK

2023-04-26T11:34:40Z

Csatari Mălina: /* Exemplul 2 */

Sursa: [https://www.pbinfo.ro/probleme/383/inlocuirek 0383- inlocuireK]
----
== Cerinţa ==
Se dă un număr natural nenul '''k''' și vector cu '''n''' numere naturale. Să se înlocuiască fiecare element cu multiplul lui '''k''' cel mai apropiat de el și să se afișeze elementele astfel obținute în ordine inversă.
== Date de intrare ==
Programul citește de la tastatură numerele '''k''' și '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa elementele vectorului, după înlocuire, în ordine inversă, separate prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n''' &les; '''200'''
* '''1''' &les; '''k''' &les; '''100'''
* elementele vectorului vor fi cuprinse între '''1''' și '''1.000.000'''
* dacă pentru un element al vectorului există mai multi cei mai apropiați multipli ai lui k, elementul va fi înlocui cu cel mai mic dintre aceștia

== Exemple ==
===Exemplul 1===
; Intrare
: 5 4
: 17 14 24 25
; Ieșire
: Datele sunt introduse corect.
: 25 25 15 15
===Exemplul 2===
; Intrare
: 101 2
: 1 2
; Ieșire
: Datele nu corespund restricțiilor impuse.
 

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

def inloc_elem_cu_multiplu_k_cel_mai_apropiat(vector, n, k):
for i in range(n):
multiplu_k_inferior = vector[i] // k * k
multiplu_k_superior = multiplu_k_inferior + k
if abs(vector[i] - multiplu_k_inferior) <= abs(multiplu_k_superior - vector[i]):
vector[i] = multiplu_k_inferior
else:
vector[i] = multiplu_k_superior

for i in range(n-1, -1, -1):
print(vector[i], end=' ')

def citire_conform_restrictiilor(k, n, vector):
if n < 1 or n > 200 or k < 1 or k > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 1 or x > 1000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
k, n = map(int, input().split())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(k, n, vector)
inloc_elem_cu_multiplu_k_cel_mai_apropiat(vector, n, k)

</syntaxhighlight>
== Explicație rezolvare==
Programul de mai sus conține două funcții, funcția inloc_elem_cu_multiplu_k_cel_mai_apropiat(vector, n, k) și funcția citire_conform_restrictiilor(k, n, vector), care sunt apelate în secțiunea '''if __name__ == '__main__':''' (linia 30) după citirea numerelor k și n, respectiv cele n numere pe care le punem în vectorul "vector" (liniile 31, 32).
Funcția '''citire_conform_restrictiilor''' verifică dacă datele de intrare respectă restricțiile impuse în enunțul problemei (n este cuprins între 1 și 200, k este cuprins între 1 și 200, elementele vectorului sunt cuprinse între 1 și 1000000, n este lungimea vectorului "vector). Dacă datele respectă nu respectă oricare dintre restricții se afișează "Datele nu corespund restricțiilor impuse." și oprește programul prin apelul funcției exit(), iar dacă datele corespund restricțiilor se afișează "Datele sunt introduse corect." și se poate continua programul.
Funcția '''inloc_elem_cu_multiplu_k_cel_mai_apropiat''' primește ca parametrii vectorul "vector" și numărul de elemente n din vector, precum și numărul natural k și efectuează următoarele operații: -> pentru fiecare element din vector, găsește cel mai apropiat multiplu al lui k, prin împărțirea elementului la k și înmulțirea rezultatului cu k; -> determină dacă cel mai apropiat multiplu este a sau b, unde b este multiplul lui k imediat mai mare decât a; -> înlocuiește elementul din vector cu cel mai apropiat multiplu găsit; -> afișează elementele vectorului, după înlocuire, în ordine inversă.

0383 - inlocuireK

2023-04-26T11:34:22Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/383/inlocuirek 0383- inlocuireK]
----
== Cerinţa ==
Se dă un număr natural nenul '''k''' și vector cu '''n''' numere naturale. Să se înlocuiască fiecare element cu multiplul lui '''k''' cel mai apropiat de el și să se afișeze elementele astfel obținute în ordine inversă.
== Date de intrare ==
Programul citește de la tastatură numerele '''k''' și '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa elementele vectorului, după înlocuire, în ordine inversă, separate prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n''' &les; '''200'''
* '''1''' &les; '''k''' &les; '''100'''
* elementele vectorului vor fi cuprinse între '''1''' și '''1.000.000'''
* dacă pentru un element al vectorului există mai multi cei mai apropiați multipli ai lui k, elementul va fi înlocui cu cel mai mic dintre aceștia

== Exemple ==
===Exemplul 1===
; Intrare
: 5 4
: 17 14 24 25
; Ieșire
: Datele sunt introduse corect.
: 25 25 15 15
===Exemplul 2===
; Intrare
: 101 2
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0383

def inloc_elem_cu_multiplu_k_cel_mai_apropiat(vector, n, k):
for i in range(n):
multiplu_k_inferior = vector[i] // k * k
multiplu_k_superior = multiplu_k_inferior + k
if abs(vector[i] - multiplu_k_inferior) <= abs(multiplu_k_superior - vector[i]):
vector[i] = multiplu_k_inferior
else:
vector[i] = multiplu_k_superior

for i in range(n-1, -1, -1):
print(vector[i], end=' ')

def citire_conform_restrictiilor(k, n, vector):
if n < 1 or n > 200 or k < 1 or k > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 1 or x > 1000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
k, n = map(int, input().split())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(k, n, vector)
inloc_elem_cu_multiplu_k_cel_mai_apropiat(vector, n, k)

</syntaxhighlight>
== Explicație rezolvare==
Programul de mai sus conține două funcții, funcția inloc_elem_cu_multiplu_k_cel_mai_apropiat(vector, n, k) și funcția citire_conform_restrictiilor(k, n, vector), care sunt apelate în secțiunea '''if __name__ == '__main__':''' (linia 30) după citirea numerelor k și n, respectiv cele n numere pe care le punem în vectorul "vector" (liniile 31, 32).
Funcția '''citire_conform_restrictiilor''' verifică dacă datele de intrare respectă restricțiile impuse în enunțul problemei (n este cuprins între 1 și 200, k este cuprins între 1 și 200, elementele vectorului sunt cuprinse între 1 și 1000000, n este lungimea vectorului "vector). Dacă datele respectă nu respectă oricare dintre restricții se afișează "Datele nu corespund restricțiilor impuse." și oprește programul prin apelul funcției exit(), iar dacă datele corespund restricțiilor se afișează "Datele sunt introduse corect." și se poate continua programul.
Funcția '''inloc_elem_cu_multiplu_k_cel_mai_apropiat''' primește ca parametrii vectorul "vector" și numărul de elemente n din vector, precum și numărul natural k și efectuează următoarele operații: -> pentru fiecare element din vector, găsește cel mai apropiat multiplu al lui k, prin împărțirea elementului la k și înmulțirea rezultatului cu k; -> determină dacă cel mai apropiat multiplu este a sau b, unde b este multiplul lui k imediat mai mare decât a; -> înlocuiește elementul din vector cu cel mai apropiat multiplu găsit; -> afișează elementele vectorului, după înlocuire, în ordine inversă.

4109 - afisare22

2023-04-26T11:22:39Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/4109/afisare22 - afisare22]
----
== Cerinţa ==
Se dă un vector '''x''' cu '''n''' elemente numere întregi, și un vector '''y''' cu '''m''' elemente, de asemenea numere întregi. Să se afișeze toate elementele din vectorul '''x''' care sunt mai mari decât toate elementele din vectorul '''y'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi cele '''n''' elemente ale vectorului '''x'''. Apoi și citește '''m''' și cele '''m''' elemente ale lui '''y'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa elementele din vectorul x care sunt mai mari decât toate elementele din vectorul y, sau NU EXISTA dacă vectorul x nu conține astfel de elemente. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n, m''' &les; '''10.000'''
* elementele celor 2 vectori vor fi din intervalul '''[-1.000.000.000,1.000.000.000]'''

== Exemple ==
===Exemplul 1===
; Intrare
: 7
: 91 -6 5 141 2 1 10
: 8
: 8 14 9 14 16 15 4 6
; Ieșire
: Datele sunt introduse corect.
: 91 141
===Exemplul 2===
; Intrare
: -2
: 1 2 3 4
: -4
: 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 4109

def afis_el_din_vect_x_mai_mari_decat_toate_el_din_y(n, x, m, y):
maxim = -1000000000
exista = False
for i in range(m):
if y[i] > maxim:
maxim = y[i]
for i in range(n):
adevarat = True
if x[i] < maxim:
adevarat = False
if adevarat:
exista = True
print(x[i], end=" ")
if not exista:
print("NU EXISTA")

def citire_conform_restrictiilor(n, x, m, y):
if n != len(x):
print("Datele nu corespund restricțiilor impuse.")
exit()
if m != len(y):
print("Datele nu corespund restricțiilor impuse.1")
exit()
for element in x:
if element < -1000000000 or element > 1000000000:
print("Datele nu corespund restricțiilor impuse.3")
exit()
for element in y:
if element < -1000000000 or element > 1000000000:
print("Datele nu corespund restricțiilor impuse.4")
exit()
if n < 1 or n > 10000:
print("Datele nu corespund restricțiilor impuse.1")
exit()
if m < 1 or m > 10000:
print("Datele nu corespund restricțiilor impuse.1")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
x = list(map(int, input().split()))
m = int(input())
y = list(map(int, input().split()))
citire_conform_restrictiilor(n, x, m, y)
afis_el_din_vect_x_mai_mari_decat_toate_el_din_y(n, x, m, y)

</syntaxhighlight>
== Explicație rezolvare==
Acest cod conține două funcții, '''afis_el_din_vect_x_mai_mari_decat_toate_el_din_y''' și '''citire_conform_restrictiilor''', care se apelează în interiorul secțiunii '''if __name__ == '__main__':''' (linia 44) după citirea numărului n, vectorului x, numărului m, respectiv vectorului x (liniile 45-48, se folosește comanda input() pentru citire și int() pentru convertire în numere). Funcția '''afis_el_din_vect_x_mai_mari_decat_toate_el_din_y''' primește patru argumente: n, x, m și y (n și m sunt lungimile vectorilor x, respectiv y). Funcția afișează elementele din lista x care sunt mai mari decât toate elementele din lista y. Mai exact, funcția găsește cel mai mare element din lista y, folosind o buclă for și variabila maxim. Apoi, parcurge lista x cu o altă buclă for și verifică dacă fiecare element din x este mai mare decât maxim. Dacă da, funcția afișează elementul. Dacă niciun element din x nu este mai mare decât maxim, funcția afișează mesajul "NU EXISTA". Funcția '''citire_conform_restrictiilor''' primește datele de intrare și le verifică dacă ele corespund restricțiilor impuse. Funcția primește ca parametrii numărul n, vectorul x, numărul m și vectorul y. Funcția verifică dacă lungimile listelor x și y corespund numerelor n și m, respectiv. De asemenea, funcția verifică dacă toate numerele din x și y sunt întregi între -1000000000 și 1000000000 și dacă n și m sunt întregi între 1 și 10000. Dacă datele introduse corespund acestor restricții, funcția afișează mesajul "Datele sunt introduse corect.", respectiv mesajul "Datele nu corespund restricțiilor impuse." dacă nu respectă oricare dintre restricții.

4104 - afisare21

2023-04-26T11:11:56Z

Csatari Mălina: /* Exemplul 2 */

Sursa: [https://www.pbinfo.ro/probleme/4104/afisare21 - afisare21]
----
== Cerinţa ==
Se dă un vector '''x''' cu '''n''' elemente numere întregi, și un vector '''y''' cu '''m''' elemente, de asemenea numere întregi. Să se afișeze toate elementele din vectorul '''x''' care sunt mai mici decât toate elementele din vectorul '''y'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi cele '''n''' elemente ale vectorului '''x'''. Apoi și citește '''m''' și cele '''m''' elemente ale lui '''y'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa elementele din vectorul x care sunt mai mici decât toate elementele din vectorul y, sau NU EXISTA dacă vectorul x nu conține astfel de elemente. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n, m''' &les; '''10.000'''
* elementele celor 2 vectori vor fi din intervalul '''[-1.000.000.000,1.000.000.000]'''

== Exemple ==
===Exemplul 1===
; Intrare
: 7
: 9 -6 5 14 2 1 10
: 8
: 8 14 9 14 16 15 4 6
; Ieșire
: Datele sunt introduse corect.
: -6 2 1
===Exemplul 2===
; Intrare
:-2
: 1 2 3
: -4
: 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.
 

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

def afis_el_din_vect_x_mai_mici_decat_toate_el_din_y(n, x, m, y):
minim = 1000000001
exista = False
for i in range(m):
if y[i] < minim:
minim = y[i]
for i in range(n):
advevarat = True
if x[i] > minim:
advevarat = False
if advevarat:
exista = True
print(x[i], end=" ")
if not exista:
print("NU EXISTA")

def citire_conform_restrictiilor(n, x, m, y):
if n != len(x):
print("Datele nu corespund restricțiilor impuse.")
exit()
if m != len(y):
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in x:
if element < -1000000000 or element > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in y:
if element < -1000000000 or element > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n < 1 or n > 10000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if m < 1 or m > 10000:
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
x = list(map(int, input().split()))
m = int(input())
y = list(map(int, input().split()))
citire_conform_restrictiilor(n, x, m, y)
afis_el_din_vect_x_mai_mici_decat_toate_el_din_y(n, x, m, y)

</syntaxhighlight>
== Explicație rezolvare==
Acest cod conține două funcții: afis_el_din_vect_x_mai_mici_decat_toate_el_din_y și citire_conform_restrictiilor(), care vor fi apelate în interiorul secțiunii '''if __name__ == '__main__':''' (linia 44) după citirea numărului n, vectorului x, m și vectorului y (se folosește comanda input() pentru citire și int() pentru a converti în numere). Funcția '''citire_conform_restrictiilor''' primește ca parametrii numărul n, vectorul x, numărul m, respectiv vectorul y, și verifică dacă datele introduse respectă restricțiile (n, m să fie lungimile vectorilor x, respectiv y, elementele celor doi vectori să fie cuprinse între -1000000000 și 1000000000, n și m să fie cuprinse între 1 și 10000). Dacă datele nu corespund restricțiilor impuse, afișează "Datele nu corespund restricțiilor impuse." și se oprește execuția programului prin apelarea funcției exit(), iar dacă ele respectă restricțiile se afișează "Datele sunt introduse corect." și se poate continua programul. Funcția '''afis_el_din_vect_x_mai_mici_decat_toate_el_din_y''' primește patru parametri: -> n: numărul de elemente din vectorul x -> x: vectorul x -> m: numărul de elemente din vectorul y -> y: vectorul y Funcția '''afis_el_din_vect_x_mai_mici_decat_toate_el_din_y(n, x, m, y)''' are următorul comportament: -> Inițializează variabila minim cu o valoare mare și variabila exista cu valoarea False. -> Parcurge vectorul y și găsește valoarea minimă din acesta. Valoarea minimă o stochează în variabila minim. -> Parcurge vectorul x și afișează elementele din acesta care sunt mai mici decât minim. Dacă există cel puțin un astfel de element, variabila exista devine True. -> Dacă nu există niciun element din vectorul x mai mic decât toate elementele din vectorul y, se afișează mesajul "NU EXISTA".

4104 - afisare21

2023-04-26T11:11:08Z

Csatari Mălina: /* Exemplul 2 */

Sursa: [https://www.pbinfo.ro/probleme/4104/afisare21 - afisare21]
----
== Cerinţa ==
Se dă un vector '''x''' cu '''n''' elemente numere întregi, și un vector '''y''' cu '''m''' elemente, de asemenea numere întregi. Să se afișeze toate elementele din vectorul '''x''' care sunt mai mici decât toate elementele din vectorul '''y'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi cele '''n''' elemente ale vectorului '''x'''. Apoi și citește '''m''' și cele '''m''' elemente ale lui '''y'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa elementele din vectorul x care sunt mai mici decât toate elementele din vectorul y, sau NU EXISTA dacă vectorul x nu conține astfel de elemente. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n, m''' &les; '''10.000'''
* elementele celor 2 vectori vor fi din intervalul '''[-1.000.000.000,1.000.000.000]'''

== Exemple ==
===Exemplul 1===
; Intrare
: 7
: 9 -6 5 14 2 1 10
: 8
: 8 14 9 14 16 15 4 6
; Ieșire
: Datele sunt introduse corect.
: -6 2 1
===Exemplul 2===
; Intrare
: 7
: 1 2 3 4
: 8
: 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.
 

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

def afis_el_din_vect_x_mai_mici_decat_toate_el_din_y(n, x, m, y):
minim = 1000000001
exista = False
for i in range(m):
if y[i] < minim:
minim = y[i]
for i in range(n):
advevarat = True
if x[i] > minim:
advevarat = False
if advevarat:
exista = True
print(x[i], end=" ")
if not exista:
print("NU EXISTA")

def citire_conform_restrictiilor(n, x, m, y):
if n != len(x):
print("Datele nu corespund restricțiilor impuse.")
exit()
if m != len(y):
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in x:
if element < -1000000000 or element > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in y:
if element < -1000000000 or element > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n < 1 or n > 10000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if m < 1 or m > 10000:
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
x = list(map(int, input().split()))
m = int(input())
y = list(map(int, input().split()))
citire_conform_restrictiilor(n, x, m, y)
afis_el_din_vect_x_mai_mici_decat_toate_el_din_y(n, x, m, y)

</syntaxhighlight>
== Explicație rezolvare==
Acest cod conține două funcții: afis_el_din_vect_x_mai_mici_decat_toate_el_din_y și citire_conform_restrictiilor(), care vor fi apelate în interiorul secțiunii '''if __name__ == '__main__':''' (linia 44) după citirea numărului n, vectorului x, m și vectorului y (se folosește comanda input() pentru citire și int() pentru a converti în numere). Funcția '''citire_conform_restrictiilor''' primește ca parametrii numărul n, vectorul x, numărul m, respectiv vectorul y, și verifică dacă datele introduse respectă restricțiile (n, m să fie lungimile vectorilor x, respectiv y, elementele celor doi vectori să fie cuprinse între -1000000000 și 1000000000, n și m să fie cuprinse între 1 și 10000). Dacă datele nu corespund restricțiilor impuse, afișează "Datele nu corespund restricțiilor impuse." și se oprește execuția programului prin apelarea funcției exit(), iar dacă ele respectă restricțiile se afișează "Datele sunt introduse corect." și se poate continua programul. Funcția '''afis_el_din_vect_x_mai_mici_decat_toate_el_din_y''' primește patru parametri: -> n: numărul de elemente din vectorul x -> x: vectorul x -> m: numărul de elemente din vectorul y -> y: vectorul y Funcția '''afis_el_din_vect_x_mai_mici_decat_toate_el_din_y(n, x, m, y)''' are următorul comportament: -> Inițializează variabila minim cu o valoare mare și variabila exista cu valoarea False. -> Parcurge vectorul y și găsește valoarea minimă din acesta. Valoarea minimă o stochează în variabila minim. -> Parcurge vectorul x și afișează elementele din acesta care sunt mai mici decât minim. Dacă există cel puțin un astfel de element, variabila exista devine True. -> Dacă nu există niciun element din vectorul x mai mic decât toate elementele din vectorul y, se afișează mesajul "NU EXISTA".

4104 - afisare21

2023-04-26T11:10:35Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/4104/afisare21 - afisare21]
----
== Cerinţa ==
Se dă un vector '''x''' cu '''n''' elemente numere întregi, și un vector '''y''' cu '''m''' elemente, de asemenea numere întregi. Să se afișeze toate elementele din vectorul '''x''' care sunt mai mici decât toate elementele din vectorul '''y'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi cele '''n''' elemente ale vectorului '''x'''. Apoi și citește '''m''' și cele '''m''' elemente ale lui '''y'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa elementele din vectorul x care sunt mai mici decât toate elementele din vectorul y, sau NU EXISTA dacă vectorul x nu conține astfel de elemente. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n, m''' &les; '''10.000'''
* elementele celor 2 vectori vor fi din intervalul '''[-1.000.000.000,1.000.000.000]'''

== Exemple ==
===Exemplul 1===
; Intrare
: 7
: 9 -6 5 14 2 1 10
: 8
: 8 14 9 14 16 15 4 6
; Ieșire
: Datele sunt introduse corect.
: -6 2 1
===Exemplul 2===
; Intrare
: 7
: 1 2 3 4
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 4104

def afis_el_din_vect_x_mai_mici_decat_toate_el_din_y(n, x, m, y):
minim = 1000000001
exista = False
for i in range(m):
if y[i] < minim:
minim = y[i]
for i in range(n):
advevarat = True
if x[i] > minim:
advevarat = False
if advevarat:
exista = True
print(x[i], end=" ")
if not exista:
print("NU EXISTA")

def citire_conform_restrictiilor(n, x, m, y):
if n != len(x):
print("Datele nu corespund restricțiilor impuse.")
exit()
if m != len(y):
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in x:
if element < -1000000000 or element > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in y:
if element < -1000000000 or element > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n < 1 or n > 10000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if m < 1 or m > 10000:
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
x = list(map(int, input().split()))
m = int(input())
y = list(map(int, input().split()))
citire_conform_restrictiilor(n, x, m, y)
afis_el_din_vect_x_mai_mici_decat_toate_el_din_y(n, x, m, y)

</syntaxhighlight>
== Explicație rezolvare==
Acest cod conține două funcții: afis_el_din_vect_x_mai_mici_decat_toate_el_din_y și citire_conform_restrictiilor(), care vor fi apelate în interiorul secțiunii '''if __name__ == '__main__':''' (linia 44) după citirea numărului n, vectorului x, m și vectorului y (se folosește comanda input() pentru citire și int() pentru a converti în numere). Funcția '''citire_conform_restrictiilor''' primește ca parametrii numărul n, vectorul x, numărul m, respectiv vectorul y, și verifică dacă datele introduse respectă restricțiile (n, m să fie lungimile vectorilor x, respectiv y, elementele celor doi vectori să fie cuprinse între -1000000000 și 1000000000, n și m să fie cuprinse între 1 și 10000). Dacă datele nu corespund restricțiilor impuse, afișează "Datele nu corespund restricțiilor impuse." și se oprește execuția programului prin apelarea funcției exit(), iar dacă ele respectă restricțiile se afișează "Datele sunt introduse corect." și se poate continua programul. Funcția '''afis_el_din_vect_x_mai_mici_decat_toate_el_din_y''' primește patru parametri: -> n: numărul de elemente din vectorul x -> x: vectorul x -> m: numărul de elemente din vectorul y -> y: vectorul y Funcția '''afis_el_din_vect_x_mai_mici_decat_toate_el_din_y(n, x, m, y)''' are următorul comportament: -> Inițializează variabila minim cu o valoare mare și variabila exista cu valoarea False. -> Parcurge vectorul y și găsește valoarea minimă din acesta. Valoarea minimă o stochează în variabila minim. -> Parcurge vectorul x și afișează elementele din acesta care sunt mai mici decât minim. Dacă există cel puțin un astfel de element, variabila exista devine True. -> Dacă nu există niciun element din vectorul x mai mic decât toate elementele din vectorul y, se afișează mesajul "NU EXISTA".

29192 - Groups

2023-04-26T10:58:47Z

Csatari Mălina: /* Exemplul 2 */

Sursa: [https://www.pbinfo.ro/probleme/2919/2groups 2919 - 2Groups]
----
== Cerinţa ==
Se dă numărul natural '''n'''. Să se împartă numerele naturale de la 1 la n în două grupuri astfel încât diferența absolută dintre sumele numerelor din cele două grupuri să fie minimă.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează numerele din primul grup și pe al următorul rând numerele din al doilea grup, separate prin câte un spațiu. Ordinea afișării nu contează. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''2''' &les; '''n''' &les; '''100.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 5
; Ieșire variantă 1 (există mai multe modalității de așezare a acestor grupuri, ordinea afișării nu contează. Ceea ce contează e diferența absolută dintre sumele numerelor din cele două grupuri să fie 1.)
: Datele sunt introduse corect.
: 1 2 5
: 3 4
; Ieșire variantă 2
: Datele sunt introduse corect.
: 5 2
: 4 3 1
===Exemplul 2===
; Intrare
: 1234567
: 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.
 

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

def construire_grupuri(n):
vector1, vector2 = [], []
lungime_vector_1, lungime_vector_2 = 0, 0
for i in range(1, n + 1):
if i % 2 == 1:
vector1.append(i)
lungime_vector_1 += 1
else:
vector2.append(i)
lungime_vector_2 += 1
if n % 2 == 1:
for i in range(0, lungime_vector_1, 2):
if i != lungime_vector_1 - 1:
print(vector1[i], vector2[i], end=" ")
else:
print(vector1[i], end=" ")
print()
for i in range(1, lungime_vector_2, 2):
print(vector1[i], vector2[i], end=" ")
else:
for i in range(0, lungime_vector_1):
if i % 2 == 0:
print(vector1[i], end=" ")
else:
print(vector2[i], end=" ")
print()
for i in range(0, lungime_vector_1):
if i % 2 == 1:
print(vector1[i], end=" ")
else:
print(vector2[i], end=" ")

def citire_conform_restrictiilor(n):
if n < 2 or n > 100000:
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
citire_conform_restrictiilor(n)
construire_grupuri(n)

</syntaxhighlight>
== Explicație rezolvare==
Acest cod definește două funcții: "construire_grupuri(n)" și "citire_conform_restrictiilor()" care vor fi apelate în main-ul programului '''if __name__ == '__main__':''' (linia 43) după citirea numărului n (linia 44) care se face cu ajutorul comenzii input() și int() pentru a îl converti în număr întreg. Funcția '''citire_conform_restrictiilor()''' verifică dacă n se încadrează în intervalul [2, 100000]. Dacă nu, afișează "Datele nu corespund restricțiilor impuse." și oprește programul prin apelarea funcției exit(). În caz contrar, afișează "Datele sunt introduse corect.". Pentru a crea două grupuri astfel încât diferența absolută dintre sumele numerelor din cele două să fie minimă folosim doi vectori în funcția '''construire_grupuri(n)''' vector1 și vector 2. Mai întâi, se inițializează cei doi vectori goi, vector1 și vector2, care vor conține numerele până la n împărțite în două subliste separate. De asemenea, se inițializează două variabile, lungime_vector_1 și lungime_vector_2, care vor reprezenta lungimile celor două subliste. Apoi, într-o buclă for care parcurge numerele de la 1 la n, fiecare număr impar este adăugat la vector1, iar fiecare număr par este adăugat la vector2. În același timp, variabilele lungime_vector_1 și lungime_vector_2 sunt actualizate pentru a reflecta noile lungimi ale celor două liste. Dacă n este impar, atunci bucla for ulterioră va parcurge doar elementele din vector1 și vector2 pentru a le grupa în perechi. Se folosește o buclă for care parcurge elementele din vector1 și vector2 începând cu primul element din vector1 și fiecare al doilea element din fiecare listă este afișat ca un grup de două elemente, până la ultimul element din vector1, care va fi afișat separat, în afara grupului de două elemente. După aceea, o altă buclă for este folosită pentru a afișa restul grupurilor de câte două elemente din vector1 și vector2. 
Dacă n este par, bucla for ulterioară va afișa elementele din vector1 și vector2 într-un mod specific. Mai întâi, se afișează primele grupuri de două elemente formată din vector1 și vector2 în ordine alternativă, astfel încât primul element din vector1 este afișat primul. Apoi, o altă buclă for este utilizată pentru a afișa restul grupurilor de câte două elemente din vector1 și vector2, în ordine inversă, astfel încât primul element din vector2 este afișat primul. În final, funcția '''construire_grupuri(n)''' afișează pe două linii separate de grupuri de numere, după ce grupurile de numere au fost construite în ordinea specificată mai sus.

0161 - inlocuire

2023-04-26T10:58:19Z

Csatari Mălina: /* Exemplul 2 */

Sursa: [https://www.pbinfo.ro/probleme/161/inlocuire 0161 - inlocuire]
----
== Cerinţa ==
Se dă un vector cu '''n''' elemente, numere naturale. Să se înlocuiască toate elementele nule din vector cu partea întreagă a mediei aritmetice a elementelor nenule din vector.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează elementele vectorului, după înlocuire, separate prin câte un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n''' &les; '''200'''
* elementele vectorului vor fi mai mici decât '''1000'''
* vectorul va conține cel puțin un element nenul

== Exemple ==
===Exemplul 1===
; Intrare
: 5
: 0 2 0 4 5
; Ieșire
: Datele sunt introduse corect.
: 3 2 3 4 5
===Exemplul 2===
; Intrare
: 1234
: 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.
 

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

def inlocuire_el_nule_cu_media_el_nenule(vector, n):
suma = 0
nr_nenule = 0
for i in range(n):
if vector[i]:
suma += vector[i]
nr_nenule += 1
media_el_nenule = suma // nr_nenule

for i in range(n):
if not vector[i]:
vector[i] = media_el_nenule

for i in range(n):
print(vector[i], end=' ')

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
nr_nule = 0
for element in vector:
if element == 0:
nr_nule += 1
if nr_nule == 0:
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
inlocuire_el_nule_cu_media_el_nenule(vector, n)

</syntaxhighlight>
== Explicație rezolvare==
Programul de mai sus definește două funcții, funcția inlocuire_el_nule_cu_media_el_nenule(vector, n) și citire_conform_restrictiilor(vector, n), care sunt apelate în interiorul secțiunii '''if __name__ == '__main__':''' (linia 41) după citirea numărului n (linia 42, cu comanda input() și int() pentru a converti în număr) și celor n numere pe care le punem în vectorul "vector" (linia 43). Funcția '''citire_conform_restrictiilor(vector, n)''' are ca parametrii numărul n și vectorul "vector" și verifică dacă acestea îndeplinesc anumite restricții, precum: -> numărul n trebuie să fie între 1 și 200 -> fiecare element al vectorului trebuie să fie mai mic decât 1000 -> dimensiunea vectorului n trebuie să fie egală cu numărul de elemente introduse de la tastatură -> vectorul trebuie să conțină cel puțin un element nul (avem o variabilă nr_nule pe care o inițializăm cu 0 și parcurgem tot vectorul și dacă elementul este nul, creștem cu 1 această variabilă, iar dacă ea este 0 după terminarea buclei, înseamnă că vectorul nu are niciun element nul, adică nu respectă condițiile). -> dacă oricare restricție nu este respectată, programul afișează "Datele nu corespund restricțiilor impuse." și se termină prin apelarea funcției exit(). În caz contrar, programul afișează "Datele sunt introduse corect." și programul poate continua. Funcția '''inlocuire_el_nule_cu_media_el_nenule(vector, n)''' primește ca argumente un vector și dimensiunea sa și face următoarele acțiuni: -> calculează suma și numărul de elemente nenule din vector, folosind o buclă for și o structură condițională if; -> calculează media aritmetică a elementelor nenule din vector pe care o punem în variabila media_el_nenule; -> înlocuiește toate elementele nule din vector cu media aritmetică a elementelor nenule din vector prin a parcurge vectorul cu un for loop și verificarea elementelor dacă sunt nule și înlocuirea acestora cu variabila media_el_nenule; -> afișează vectorul inlocuit cu ajutorul unui for loop, separate printr-un spațiu, conform problemei.

0161 - inlocuire

2023-04-26T10:58:03Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/161/inlocuire 0161 - inlocuire]
----
== Cerinţa ==
Se dă un vector cu '''n''' elemente, numere naturale. Să se înlocuiască toate elementele nule din vector cu partea întreagă a mediei aritmetice a elementelor nenule din vector.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează elementele vectorului, după înlocuire, separate prin câte un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''1''' &les; '''n''' &les; '''200'''
* elementele vectorului vor fi mai mici decât '''1000'''
* vectorul va conține cel puțin un element nenul

== Exemple ==
===Exemplul 1===
; Intrare
: 5
: 0 2 0 4 5
; Ieșire
: Datele sunt introduse corect.
: 3 2 3 4 5
===Exemplul 2===
; Intrare
: 1234
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0161

def inlocuire_el_nule_cu_media_el_nenule(vector, n):
suma = 0
nr_nenule = 0
for i in range(n):
if vector[i]:
suma += vector[i]
nr_nenule += 1
media_el_nenule = suma // nr_nenule

for i in range(n):
if not vector[i]:
vector[i] = media_el_nenule

for i in range(n):
print(vector[i], end=' ')

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
nr_nule = 0
for element in vector:
if element == 0:
nr_nule += 1
if nr_nule == 0:
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
inlocuire_el_nule_cu_media_el_nenule(vector, n)

</syntaxhighlight>
== Explicație rezolvare==
Programul de mai sus definește două funcții, funcția inlocuire_el_nule_cu_media_el_nenule(vector, n) și citire_conform_restrictiilor(vector, n), care sunt apelate în interiorul secțiunii '''if __name__ == '__main__':''' (linia 41) după citirea numărului n (linia 42, cu comanda input() și int() pentru a converti în număr) și celor n numere pe care le punem în vectorul "vector" (linia 43). Funcția '''citire_conform_restrictiilor(vector, n)''' are ca parametrii numărul n și vectorul "vector" și verifică dacă acestea îndeplinesc anumite restricții, precum: -> numărul n trebuie să fie între 1 și 200 -> fiecare element al vectorului trebuie să fie mai mic decât 1000 -> dimensiunea vectorului n trebuie să fie egală cu numărul de elemente introduse de la tastatură -> vectorul trebuie să conțină cel puțin un element nul (avem o variabilă nr_nule pe care o inițializăm cu 0 și parcurgem tot vectorul și dacă elementul este nul, creștem cu 1 această variabilă, iar dacă ea este 0 după terminarea buclei, înseamnă că vectorul nu are niciun element nul, adică nu respectă condițiile). -> dacă oricare restricție nu este respectată, programul afișează "Datele nu corespund restricțiilor impuse." și se termină prin apelarea funcției exit(). În caz contrar, programul afișează "Datele sunt introduse corect." și programul poate continua. Funcția '''inlocuire_el_nule_cu_media_el_nenule(vector, n)''' primește ca argumente un vector și dimensiunea sa și face următoarele acțiuni: -> calculează suma și numărul de elemente nenule din vector, folosind o buclă for și o structură condițională if; -> calculează media aritmetică a elementelor nenule din vector pe care o punem în variabila media_el_nenule; -> înlocuiește toate elementele nule din vector cu media aritmetică a elementelor nenule din vector prin a parcurge vectorul cu un for loop și verificarea elementelor dacă sunt nule și înlocuirea acestora cu variabila media_el_nenule; -> afișează vectorul inlocuit cu ajutorul unui for loop, separate printr-un spațiu, conform problemei.

29192 - Groups

2023-04-26T10:42:55Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/2919/2groups 2919 - 2Groups]
----
== Cerinţa ==
Se dă numărul natural '''n'''. Să se împartă numerele naturale de la 1 la n în două grupuri astfel încât diferența absolută dintre sumele numerelor din cele două grupuri să fie minimă.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează numerele din primul grup și pe al următorul rând numerele din al doilea grup, separate prin câte un spațiu. Ordinea afișării nu contează. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* '''2''' &les; '''n''' &les; '''100.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 5
; Ieșire variantă 1 (există mai multe modalității de așezare a acestor grupuri, ordinea afișării nu contează. Ceea ce contează e diferența absolută dintre sumele numerelor din cele două grupuri să fie 1.)
: Datele sunt introduse corect.
: 1 2 5
: 3 4
; Ieșire variantă 2
: Datele sunt introduse corect.
: 5 2
: 4 3 1
===Exemplul 2===
; Intrare
: 1234567
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2919

def construire_grupuri(n):
vector1, vector2 = [], []
lungime_vector_1, lungime_vector_2 = 0, 0
for i in range(1, n + 1):
if i % 2 == 1:
vector1.append(i)
lungime_vector_1 += 1
else:
vector2.append(i)
lungime_vector_2 += 1
if n % 2 == 1:
for i in range(0, lungime_vector_1, 2):
if i != lungime_vector_1 - 1:
print(vector1[i], vector2[i], end=" ")
else:
print(vector1[i], end=" ")
print()
for i in range(1, lungime_vector_2, 2):
print(vector1[i], vector2[i], end=" ")
else:
for i in range(0, lungime_vector_1):
if i % 2 == 0:
print(vector1[i], end=" ")
else:
print(vector2[i], end=" ")
print()
for i in range(0, lungime_vector_1):
if i % 2 == 1:
print(vector1[i], end=" ")
else:
print(vector2[i], end=" ")

def citire_conform_restrictiilor(n):
if n < 2 or n > 100000:
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
citire_conform_restrictiilor(n)
construire_grupuri(n)

</syntaxhighlight>
== Explicație rezolvare==
Acest cod definește două funcții: "construire_grupuri(n)" și "citire_conform_restrictiilor()" care vor fi apelate în main-ul programului '''if __name__ == '__main__':''' (linia 43) după citirea numărului n (linia 44) care se face cu ajutorul comenzii input() și int() pentru a îl converti în număr întreg. Funcția '''citire_conform_restrictiilor()''' verifică dacă n se încadrează în intervalul [2, 100000]. Dacă nu, afișează "Datele nu corespund restricțiilor impuse." și oprește programul prin apelarea funcției exit(). În caz contrar, afișează "Datele sunt introduse corect.". Pentru a crea două grupuri astfel încât diferența absolută dintre sumele numerelor din cele două să fie minimă folosim doi vectori în funcția '''construire_grupuri(n)''' vector1 și vector 2. Mai întâi, se inițializează cei doi vectori goi, vector1 și vector2, care vor conține numerele până la n împărțite în două subliste separate. De asemenea, se inițializează două variabile, lungime_vector_1 și lungime_vector_2, care vor reprezenta lungimile celor două subliste. Apoi, într-o buclă for care parcurge numerele de la 1 la n, fiecare număr impar este adăugat la vector1, iar fiecare număr par este adăugat la vector2. În același timp, variabilele lungime_vector_1 și lungime_vector_2 sunt actualizate pentru a reflecta noile lungimi ale celor două liste. Dacă n este impar, atunci bucla for ulterioră va parcurge doar elementele din vector1 și vector2 pentru a le grupa în perechi. Se folosește o buclă for care parcurge elementele din vector1 și vector2 începând cu primul element din vector1 și fiecare al doilea element din fiecare listă este afișat ca un grup de două elemente, până la ultimul element din vector1, care va fi afișat separat, în afara grupului de două elemente. După aceea, o altă buclă for este folosită pentru a afișa restul grupurilor de câte două elemente din vector1 și vector2. 
Dacă n este par, bucla for ulterioară va afișa elementele din vector1 și vector2 într-un mod specific. Mai întâi, se afișează primele grupuri de două elemente formată din vector1 și vector2 în ordine alternativă, astfel încât primul element din vector1 este afișat primul. Apoi, o altă buclă for este utilizată pentru a afișa restul grupurilor de câte două elemente din vector1 și vector2, în ordine inversă, astfel încât primul element din vector2 este afișat primul. În final, funcția '''construire_grupuri(n)''' afișează pe două linii separate de grupuri de numere, după ce grupurile de numere au fost construite în ordinea specificată mai sus.

0496 - Numarare4

2023-04-26T10:37:36Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/496/numarare4 0496 - Numarare4]
----
== Cerinţa ==
Se dă un vector cu '''n''' numere naturale. Să se determine câte dintre elementele vectorului sunt prime cu ultimul element.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează pe ecran numărul C, reprezentând valoarea cerută.. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 50 64 15 28 35 75
; Ieșire
: Datele sunt introduse corect.
: 2
=== Explicație exemplu 1===
Elementele din vector prime cu '''75''' sunt '''64''' și '''28'''.
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0496

def nr_elem_prime_cu_ultimul(vector, n):
ultimul_element = vector[n-1]
numar_elemente_prime = 0
for element in vector:
limita_superioara = int(element**0.5) + 1
nr_divizori_comuni = 0
for divizor in range(3, limita_superioara, 2):
if element % divizor == 0:
nr_divizori_comuni += 1
if nr_divizori_comuni == 0:
numar_elemente_prime += 1
print(numar_elemente_prime)

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
nr_elem_prime_cu_ultimul(vector, n)

</syntaxhighlight>
== Explicație rezolvare==
În programul de mai sus se definesc două funcții, funcția nr_elem_prime_cu_ultimul(vector, n) și funcția citire_conform_restrictiilor(vector, n), care vor fi apelate în interiorul secțiunii '''if __name__ == '__main__':'''(liniile 34, 35), după citirea numărului n și celor n numere pe care le vom pune în vectorul "vector" (liniile 32, 33). În funcția numită '''citire_conform_restrictiilor(vector, n)''' se asigură că input-ul îndeplinește restricțiile (numărul de elemente n este între 1 și 200, iar elementele vectorului sunt între 0 și 1000) și că numărul de elemente este egal cu n. Dacă oricare dintre condiții nu este respectată, atunci se afișează mesajul "Datele nu corespund restricțiilor impuse." și programul se oprește prin apelul funcției "exit()". Funcția '''nr_elem_prime_cu_ultimul(vector, n)''' primește vectorul și lungimea acestuia și apoi parcurge fiecare element din vector cu un for loop. Pentru fiecare element, se calculează limita superioară, adică rădăcina pătrată a elementului, plus 1 (avem nevoie de limita superioară pentru a verifica în mod eficient divizorii numerelor, fără a verifica toate numerele până la numărul respectiv). Apoi se parcurg toate numerele impare de la 3 până la limita superioară și se verifică dacă elementul este divizibil cu ele. Dacă nu este divizibil cu niciunul dintre acești divizori, atunci numărul este considerat prim și se incrementează numărul de elemente prime găsite, dar dacă ultimul element este 1, toate elementele din vector nu vor fi prime între ele, așadar numar_elemente_prime va fi 0. În cele din urmă, programul afișează numărul de elemente prime găsite.

4286 - Constr3

2023-04-26T10:30:21Z

Csatari Mălina: /* Explicație rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4286/constr3 4286 - Constr3]
----
== Cerinţa ==
Se dă un vector '''x''' cu '''n''' elemente, '''numere naturale'''. Să se construiască un alt vector, '''y''', care să conțină '''elementele impare din x''', în '''ordine inversă'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează '''elementele vectorului y''', separate prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1.000.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 50 5 15 29 13 40
; Ieșire
: Datele sunt introduse corect.
: 13 29 15 5
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 4286

def construirea_vect_y(vector, n):
vector_impare = []
contor = 0
for i in range(n - 1, -1, -1):
impar = True
if vector[i] % 2 == 0:
impar = False
elif vector[i] % 2 != 0:
impar = True
if impar:
vector_impare.append(vector[i])
contor += 1
for i in range(0, contor):
print(vector_impare[i], end=' ')

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
construirea_vect_y(vector, n)

</syntaxhighlight>
== Explicație rezolvare==
Să luăm '''main-ul programului if __name__ == '__main__':''' (linia 33). Începem prin a citi datele de intrare, vector și n (liniile 34, 35, folosim int pentru a converti datele în numere întregi) și apelează funcțiile citire_conform_restrictiilor() și construire_vect_y() (liniile 36, 37). În funcția '''citire_conform_restricțiilor()''' verifică dacă n este între 1 și 200, dacă elemente dacă sunt între 1 și 1.000.000.000 și dacă numărul n dat anterior corespunde cu numărul de elemente al vectorului introdus. În caz contrar, se afișează mesajul "Datele nu corespund restricțiilor impuse" și se iese din program cu comanda exit(). Dacă datele respectă restricțiile, afișăm mesajul "Datele sunt introduse corect." și se continuă programul. În funcția '''construire_vect_y()''', construim un vector cu numele vector_impare care este inițial gol, și inițializăm o variabilă contor cu 0, care va fi lungimea vectorului vector_impare. Apoi, luăm pe rând elementele din vectorul dat în ordine inversă pentru a le introduce în ordinea cerută în problema noastră cu ajutorul unui for. Folosim variabila impar de tip boolean, inițializată cu True, care dacă elementul este impar este True, iar dacă nu, False. După această verificare (liniile 8-11), mai facem o altă verificare care adaugă in vector_impare elementele impare și adaugă + 1 în variabila contor (care reține lungimea vector_impare). Și, în finalul acestei funcții, după acest for, afișăm vector_impare cu ajutorul unui for loop și lăsăm un spațiu între fiecare element (liniile 15-16).

4286 - Constr3

2023-04-26T10:27:57Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/4286/constr3 4286 - Constr3]
----
== Cerinţa ==
Se dă un vector '''x''' cu '''n''' elemente, '''numere naturale'''. Să se construiască un alt vector, '''y''', care să conțină '''elementele impare din x''', în '''ordine inversă'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează '''elementele vectorului y''', separate prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1.000.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 50 5 15 29 13 40
; Ieșire
: Datele sunt introduse corect.
: 13 29 15 5
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 4286

def construirea_vect_y(vector, n):
vector_impare = []
contor = 0
for i in range(n - 1, -1, -1):
impar = True
if vector[i] % 2 == 0:
impar = False
elif vector[i] % 2 != 0:
impar = True
if impar:
vector_impare.append(vector[i])
contor += 1
for i in range(0, contor):
print(vector_impare[i], end=' ')

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
construirea_vect_y(vector, n)

</syntaxhighlight>
== Explicație rezolvare==
Să luăm '''main-ul programului if __name__ == '__main__':''' (linia 33). Începem prin a citi datele de intrare, vector și n (liniile 34, 35, folosim int pentru a converti datele în numere întregi) și apelează funcțiile citire_conform_restrictiilor() și construire_vect_y() (liniile 36, 37). În funcția '''citire_conform_restricțiilor()''' verifică dacă n este între 1 și 200, dacă elemente dacă sunt între 1 și 1.000.000.000 și dacă numărul n dat anterior corespunde cu numărul de elemente al vectorului introdus. În caz contrar, se afișează mesajul "Datele nu corespund restricțiilor impuse" și se iese din program cu comanda exit(). Dacă datele respectă restricțiile, afișăm mesajul "Datele sunt introduse corect." și '''returnăm vector și n''' pentru a le prelucra conform problemei. În funcția '''construire_vect_y()''', construim un vector cu numele vector_impare care este inițial gol, și inițializăm o variabilă contor cu 0, care va fi lungimea vectorului vector_impare. Apoi, luăm pe rând elementele din vectorul dat în ordine inversă pentru a le introduce în ordinea cerută în problema noastră cu ajutorul unui for. Folosim variabila impar de tip boolean, inițializată cu True, care dacă elementul este impar este True, iar dacă nu, False. După această verificare (liniile 8-11), mai facem o altă verificare care adaugă in vector_impare elementele impare și adaugă + 1 în variabila contor (care reține lungimea vector_impare). Și, în finalul acestei funcții, după acest for, afișăm vector_impare cu ajutorul unui for loop și lăsăm un spațiu între fiecare element (liniile 15-16).

0495 - Constr2

2023-04-26T09:48:39Z

Csatari Mălina: /* Rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/495/constr2 0495 - Constr2]
----
== Cerinţa ==
Se dă un vector '''x''' cu '''n''' elemente, numere naturale. Să se construiască un alt vector, '''y''', care să conțină elementele prime din '''x''', în ordine inversă.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează '''elementele vectorului y''', separate prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1.000.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 50 5 15 29 13 40
; Ieșire
: Datele sunt introduse corect.
: 13 29 5
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0495

def construirea_vect_y(vector, n):
vector_prime = []
contor = 0
for i in range(n - 1, -1, -1):
prim = True
if vector[i] < 2:
prim = False
elif vector[i] % 2 == 0 and vector[i] > 2:
prim = False
else:
for d in range(3, int(vector[i] ** 0.5) + 1, 2):
if vector[i] % d == 0:
prim = False
break
if prim:
vector_prime.append(vector[i])
contor += 1
for i in range(0, contor):
print(vector_prime[i], end=' ')

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
construirea_vect_y(vector, n)

</syntaxhighlight>

== Explicație rezolvare ==
Secțiunea '''if name == 'main':''' reprezintă punctul de intrare în program, adică funcția principală "main()". În interiorul acestei secțiuni, se citește de la tastatură valoarea lui "n" utilizând funcția "input()" și se stochează în variabila "n" ca un întreg utilizând funcția "int()". Apoi, se citește de la tastatură elementele vectorului "vector" utilizând funcția "input()", care sunt separate prin spații și convertite într-un vector de întregi utilizând funcția "split()" și funcția "map()" împreună. Apoi, se apelează funcția "citire_conform_restrictiilor(vector, n)" pentru a verifica dacă valorile citite respectă restricțiile impuse. Dacă această verificare este trecută cu succes, se apelează funcția "construirea_vect_y(vector, n)" pentru a construi vectorul "vector_prime" și a afișa valorile primelor din acest vector. Funcția '''citire_conform_restrictiilor(vector, n)''' primește doi parametri: "vector" și "n". Aceasta verifică dacă valorile lui "n" și elementele din "vector" respectă restricțiile impuse. Restricțiile impuse sunt următoarele: "n" trebuie să fie între 1 și 200, elementele din "vector" trebuie să fie între 0 și 1000000000, și numărul de elemente din "vector" trebuie să fie egal cu "n". Verificarea se face utilizând statement-uri "if". Dacă una dintre aceste restricții nu este îndeplinită, se afișează "Datele nu corespund restricțiilor impuse." utilizând funcția "print()" și se folosește funcția "exit()" pentru a încheia execuția programului. Dacă restricțiile sunt respectate, se afișează "Datele sunt introduse corect." și se continuă programul. Funcția '''construirea_vect_y(vector, n)''' primește doi parametri: "vector" și "n", reprezentând un vector de numere întregi și dimensiunea acestuia. Scopul acestei funcții este să construiască un alt vector, vector_prime, care să conțină doar valorile prime din vectorul inițial, în ordine inversă. Acest lucru se realizează astfel: -> se declară o listă "vector_prime" care va fi utilizată pentru a stoca valorile prime din "vector"; -> se declară o variabilă "contor" inițializată cu valoarea 0, care va fi utilizată pentru a număra câte valori prime sunt adăugate în "vector_prime"; -> se parcurge vectorul "vector" cu ajutorul unui for loop de la indexul "n-1" până la indexul 0, utilizând un ciclu "for" cu o iterație inversă, adică de la "n-1" până la 0, cu un pas de -1 (începem vectorul de pe poziția 0); -> pentru fiecare element din "vector", la fiecare iterație; se inițializează o variabilă prim cu valoarea booleană True (care va fi la început True pentru fiecare element din vector deoarece se inițializează la începutul for loop-ului); -> dacă elementul din "vector" este mai mare sau egal cu 2 și este un număr par, atunci acesta nu poate fi prim, și se setează variabila "prim" la False; -> în caz contrar, se parcurge un alt ciclu "for" de la 3 până la radicalul pătrat al valorii din "vector" + 1, cu un pas de 2 (deoarece numerele pare mai mari decât 2 nu pot fi prime, iar numerele prime sunt întotdeauna impare, cu excepția valorii 2). În interiorul acestul for loop, se verifică dacă valoarea din "vector" este divizibilă cu un număr din intervalul [3, radical pătrat al valorii din "vector"] (exclusiv). Dacă este divizibilă, atunci nu este primă, iar variabila "prim" este setată la False și se iese din ciclul "for" utilizând instrucțiunea "break"; -> dacă nu a fost găsită nicio valoare cu care să fie divizibilă valoarea din "vector", atunci aceasta este primă, iar variabila "prim" rămâne de la început True; dacă variabila "prim" este True, adică valoarea din "vector" este primă, atunci aceasta este adăugată în "vector_prime" utilizând funcția "append()", și "contor" este incrementat (contor este lungimea vectorului vector_prime); după ce am terminat cu acest for loop, adăugăm încă unul care parcurge vector_prime și afișează toate elementele din acesta, ele fiind ceea ce problema noastră ne cere.

0495 - Constr2

2023-04-26T09:46:46Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/495/constr2 0495 - Constr2]
----
== Cerinţa ==
Se dă un vector '''x''' cu '''n''' elemente, numere naturale. Să se construiască un alt vector, '''y''', care să conțină elementele prime din '''x''', în ordine inversă.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează '''elementele vectorului y''', separate prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1.000.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 50 5 15 29 13 40
; Ieșire
: Datele sunt introduse corect.
: 13 29 5
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0495

def construirea_vect_y(vector, n):
vector_prime = []
contor = 0
for i in range(n - 1, -1, -1):
prim = True
if vector[i] < 2:
prim = False
elif vector[i] % 2 == 0 and vector[i] > 2:
prim = False
else:
for d in range(3, int(vector[i] ** 0.5) + 1, 2):
if vector[i] % d == 0:
prim = False
break
if prim:
vector_prime.append(vector[i])
contor += 1
for i in range(0, contor):
print(vector_prime[i], end=' ')

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
construirea_vect_y(vector, n)

if __name__ == '__main__':
vector, n = citire_conform_restrictiilor()
construirea_vect_y(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
Secțiunea '''if name == 'main':''' reprezintă punctul de intrare în program, adică funcția principală "main()". În interiorul acestei secțiuni, se citește de la tastatură valoarea lui "n" utilizând funcția "input()" și se stochează în variabila "n" ca un întreg utilizând funcția "int()". Apoi, se citește de la tastatură elementele vectorului "vector" utilizând funcția "input()", care sunt separate prin spații și convertite într-un vector de întregi utilizând funcția "split()" și funcția "map()" împreună. Apoi, se apelează funcția "citire_conform_restrictiilor(vector, n)" pentru a verifica dacă valorile citite respectă restricțiile impuse. Dacă această verificare este trecută cu succes, se apelează funcția "construirea_vect_y(vector, n)" pentru a construi vectorul "vector_prime" și a afișa valorile primelor din acest vector. Funcția '''citire_conform_restrictiilor(vector, n)''' primește doi parametri: "vector" și "n". Aceasta verifică dacă valorile lui "n" și elementele din "vector" respectă restricțiile impuse. Restricțiile impuse sunt următoarele: "n" trebuie să fie între 1 și 200, elementele din "vector" trebuie să fie între 0 și 1000000000, și numărul de elemente din "vector" trebuie să fie egal cu "n". Verificarea se face utilizând statement-uri "if". Dacă una dintre aceste restricții nu este îndeplinită, se afișează "Datele nu corespund restricțiilor impuse." utilizând funcția "print()" și se folosește funcția "exit()" pentru a încheia execuția programului. Dacă restricțiile sunt respectate, se afișează "Datele sunt introduse corect." și se continuă programul. Funcția '''construirea_vect_y(vector, n)''' primește doi parametri: "vector" și "n", reprezentând un vector de numere întregi și dimensiunea acestuia. Scopul acestei funcții este să construiască un alt vector, vector_prime, care să conțină doar valorile prime din vectorul inițial, în ordine inversă. Acest lucru se realizează astfel: -> se declară o listă "vector_prime" care va fi utilizată pentru a stoca valorile prime din "vector"; -> se declară o variabilă "contor" inițializată cu valoarea 0, care va fi utilizată pentru a număra câte valori prime sunt adăugate în "vector_prime"; -> se parcurge vectorul "vector" cu ajutorul unui for loop de la indexul "n-1" până la indexul 0, utilizând un ciclu "for" cu o iterație inversă, adică de la "n-1" până la 0, cu un pas de -1 (începem vectorul de pe poziția 0); -> pentru fiecare element din "vector", la fiecare iterație; se inițializează o variabilă prim cu valoarea booleană True (care va fi la început True pentru fiecare element din vector deoarece se inițializează la începutul for loop-ului); -> dacă elementul din "vector" este mai mare sau egal cu 2 și este un număr par, atunci acesta nu poate fi prim, și se setează variabila "prim" la False; -> în caz contrar, se parcurge un alt ciclu "for" de la 3 până la radicalul pătrat al valorii din "vector" + 1, cu un pas de 2 (deoarece numerele pare mai mari decât 2 nu pot fi prime, iar numerele prime sunt întotdeauna impare, cu excepția valorii 2). În interiorul acestul for loop, se verifică dacă valoarea din "vector" este divizibilă cu un număr din intervalul [3, radical pătrat al valorii din "vector"] (exclusiv). Dacă este divizibilă, atunci nu este primă, iar variabila "prim" este setată la False și se iese din ciclul "for" utilizând instrucțiunea "break"; -> dacă nu a fost găsită nicio valoare cu care să fie divizibilă valoarea din "vector", atunci aceasta este primă, iar variabila "prim" rămâne de la început True; dacă variabila "prim" este True, adică valoarea din "vector" este primă, atunci aceasta este adăugată în "vector_prime" utilizând funcția "append()", și "contor" este incrementat (contor este lungimea vectorului vector_prime); după ce am terminat cu acest for loop, adăugăm încă unul care parcurge vector_prime și afișează toate elementele din acesta, ele fiind ceea ce problema noastră ne cere.

0494 - Constr1

2023-04-26T09:26:48Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/494/constr1 0494 - Constr1]
----
== Cerinţa ==
Se dă un vector '''x''' cu '''n''' elemente, numere naturale. Să se construiască un alt vector, '''y''', cu '''n''' elemente, cu proprietatea că '''y[i]''' este egal cu suma elementelor din '''x''', cu excepția lui '''x[i]'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou cele '''n elemente ale vectorului y''', separate prin exact un spațiu. În caz contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 50 5 15 29 35 40
; Ieșire
: Datele sunt introduse corect.
: 124 169 159 145 139 134
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0494

def constr_vectorului_y(vector, n):
y = [0] * n
suma_elem_din_vector = sum(vector)
for i in range(n):
y[i] = suma_elem_din_vector - vector[i]
for i in range(n):
print(y[i], end=' ')

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
constr_vectorului_y(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
În programul de mai sus, sunt definite două funcții, '''constr_vectorului_y()''' și '''citire_conform_restrictiilor()''', și se folosește secțiunea '''if name == 'main':''' pentru a citi datele de intrare de la tastatură (numărul n și vectorul "vector"), a verifica restricțiile acestora utilizând funcția "citire_conform_restrictiilor()", și apoi a apela funcția "constr_vectorului_y()" pentru a construi și afișa vectorul y conform problemei. Funcția '''citire_conform_restrictiilor(vector, n)''' primește doi parametri: "vector" și "n". Ea verifică dacă valorile lui "n" și elementele din "vector" respectă restricțiile impuse, și anume: "n" trebuie să fie între 1 și 200, elementele din "vector" trebuie să fie între 0 și 1000, și numărul de elemente din "vector" trebuie să fie egal cu "n". Dacă aceste restricții nu sunt îndeplinite, funcția afișează mesajul "Datele nu corespund restricțiilor impuse." și folosește funcția "exit()" pentru a încheia execuția programului. Dacă restricțiile sunt respectate, se afișează "Datele sunt introduse corect." și se continuă programul. Funcția '''constr_vectorului_y(vector, n)''' primește doi parametri: "vector" și "n". Ea construiește un alt vector "y" cu aceeași dimensiune ca și "vector", în care fiecare element este suma tuturor elementelor din "vector" minus valoarea elementului corespunzător din "vector". Mai precis, pentru fiecare element din "vector" de la indexul 0 până la indexul "n-1", se calculează suma tuturor elementelor din "vector" utilizând funcția "sum()", și se scade din această sumă valoarea elementului "vector[i]" pentru a obține valoarea corespunzătoare din "y". Această valoare este atribuită elementului "y[i]" din vectorul "y". Funcția "constr_vectorului_y()" nu returnează nimic, ci doar afișează elementele vectorului "y" utilizând un ciclu "for" și funcția "print()" cu argumentul "end=' '" pentru a afișa toate elementele separate printr-un spațiu.

1860 - BlackFriday

2023-04-26T09:08:38Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/1860/blackfriday 1860 - BlackFriday]
----
== Cerinţa ==
Anul acesta unele magazine din România s-au hotărât să organizeze BlackFriday joia, altele de luni până joi, iar altele sâmbătă şi duminică. Ele au afişat '''n''' preţuri înainte de ieftinire şi cele n preţuri după ieftinire. Aflaţi ce produs s-a ieftinit cu cel mai mare procent.
== Date de intrare ==
Fișierul de intrare '''blackfriday.in''' conține pe prima linie numărul '''n''', pe a doua linie '''n''' numere naturale separate prin spații reprezentând preţurile înainte de ieftinire, iar pe a treia linie '''n''' numere naturale separate prin spații reprezentând preţurile corespunzătoare după ieftinire.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele din fișier sunt introduse corect."''', apoi în fișierul blackfriday.out se va afișa pe prima linie '''numărul k''', reprezentând numărul de ordine din şirul de preţuri dat al produsului care s-a ieftinit cu cel mai mare procent. În cazul în care datele din fișier nu respectă restricțiile, se va afișa pe ecran: '''"Datele din fișier nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 2 &les; '''n''' &les; 10
* elementele vectorului vor fi cuprinse între '''1''' și '''1.000.000.000'''
* dacă sunt mai multe preţuri care s-au ieftinit cu acelaşi procent se va afişa numărul de ordine mai mic
* preţurile după ieftinire sunt '''strict mai mici''' decât cele anterioare(evident).
Exemplu:
== Exemple ==
===Exemplul 1===
; blackfriday.in
: 3
: 8 15 200
: 4 6 160
; Ecran
: Datele din fișier sunt introduse corect.
; blackfriday.out
: 2
===Exemplul 2===
; blackfriday.in
: 4
: 8 15 200 12
: 4 6 160 16
; Ecran
: Datele din fișier nu corespund restricțiilor impuse.
; blackfriday.out
: 
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1860

def citire_conform_restrictiilor(n, pret_initial, pret_redus):
if n < 2 or n > 10:
print("Datele din fișier nu corespund restricțiilor impuse.")
exit()
for elem in pret_initial:
if elem < 1 or elem > 1000000000:
print("Datele din fișier nu corespund restricțiilor impuse.")
exit()
for elem in pret_redus:
if elem < 1 or elem > 1000000000:
print("Datele din fișier nu corespund restricțiilor impuse.")
exit()
for i in range(n):
if(pret_initial[i] < pret_redus[i]):
print("Datele din fișier nu corespund restricțiilor impuse.")
exit()
print("Datele din fișier sunt introduse corect.")

def afis_produsului_cu_reducerea_cea_mai_mare_in_blackfridayout(n, pret_initial, pret_redus):
max_reducere = -1
k = -1
for i in range(n):
reducere = (pret_initial[i] - pret_redus[i]) / pret_initial[i]
if reducere > max_reducere:
max_reducere = reducere
k = i + 1
with open("blackfriday.out", "w") as f:
f.write(str(k))

if __name__ == '__main__':
with open("blackfriday.in") as f:
n = int(f.readline())
pret_initial = list(map(int, f.readline().split()))
pret_redus = list(map(int, f.readline().split()))
citire_conform_restrictiilor(n, pret_initial, pret_redus)
afis_produsului_cu_reducerea_cea_mai_mare_in_blackfridayout(n, pret_initial, pret_redus)

</syntaxhighlight>
== Explicație rezolvare ==
Programul de mai sus definește două funcții: 1. Funcția '''citire_conform_restrictiilor(n, pret_initial, pret_redus)''', care verifică dacă datele de intrare respectă restricțiile impuse. Aceasta primește trei argumente: "n" - numărul de produse, "pret_initial" - o listă de prețuri inițiale ale produselor și "pret_redus" - o listă de prețuri reduse ale produselor. Funcția parcurge fiecare preț din listele "pret_initial" și "pret_redus" și verifică dacă respectă restricțiile impuse (n să fie între 2 și 10 inclusiv, iar prețurile să fie între 1 și 1000000000 inclusiv). Dacă una dintre restricții nu este respectată, se afișează "Datele din fișier nu corespund restricțiilor impuse." și programul se încheie prin apelul funcției "exit()". Dacă toate restricțiile sunt respectate, se afișează "Datele din fișier sunt introduse corect." și se continuă programul. 2. Funcția '''afis_produsului_cu_reducerea_cea_mai_mare_in_blackfridayout(n, pret_initial, pret_redus)''', care identifică produsul cu cea mai mare reducere în procent și scrie numărul său de ordine în fișierul de ieșire blackfriday.out. Se procedează astfel: -> se inițializează o variabilă "max_reducere" cu valoarea -1 și o variabilă "k" cu valoarea -1. Acestea vor fi utilizate pentru a urmări produsul cu cea mai mare reducere în procent și numărul său de ordine în listele de prețuri; -> parcurge fiecare produs cu un for loop în intervalul de la 0 la n-1 (deoarece indicii în listele de prețuri încep de la 0) folosind un ciclu "for" și variabila "i" ca indice; -> calculează reducerea în procent pentru fiecare produs utilizând formula reducere = (pret_initial[i] - pret_redus[i]) / pret_initial[i] (reducerea în procent este diferența dintre prețul inițial și prețul redus, împărțită la prețul inițial, exprimată ca valoare în intervalul [0, 1]); -> compară reducerea calculată pentru produsul curent cu valoarea maximă a reducerii în procent găsită până în acel moment (stocată în variabila "max_reducere"). Dacă reducerea curentă este mai mare decât valoarea maximă, actualizează valoarea maximă a reducerii cu reducerea curentă și actualizează variabila "k" cu indicele produsului curent i + 1 (deoarece numărul de ordine al produsului este indicele + 1 în listele de prețuri, vectorul nostru începe de la 0, dar poziția sa este + 1); -> după ce au fost parcurse toate produsele, variabila "k" va conține numărul de ordine al produsului cu cea mai mare reducere în procent; -> deschide fișierul de ieșire "blackfriday.out" în modul de scriere ("w") utilizând declarația "with open(...) as f. Apoi, scrie în fișier valoarea variabilei "k" convertită la șir de caractere folosind funcția "str()". Secțiunea '''if __name__ == '__main__':''' deschide inițial fișierul blackfriday.in cu ajutorul declarației with open(...) as f și citește numărul n, lista pret_initial și lista pret_redus. Apoi, apelează cele două funcții descrise mai sus citire_conform_restrictiilor(n, pret_initial, pret_redus) și afis_produsului_cu_reducerea_cea_mai_mare_in_blackfridayout(n, pret_initial, pret_redus) și finalizează programul, afișând rezultatele conform problemei.

0493 - Constr

2023-04-22T10:37:31Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/493/constr 0493 - Constr]
----
== Cerinţa ==
Se dă un vector '''x''' cu '''n''' elemente, numere naturale. Să se construiască un alt vector, '''y''', cu proprietatea că '''y[i]''' este egal cu restul împărțirii lui '''x[i]''' la suma cifrelor lui '''x[i]'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează '''elementele vectorului y''', separate prin exact un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''1''' și '''1.000.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 50 1815 15 289 35 40
; Ieșire
: Datele sunt introduse corect.
: 0 0 3 4 3 0
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0493

def construirea_vectorului_y(x, n):
y = []
for i in range(n):
a, s = x[i], 0
while a:
s += a % 10
a //= 10
y.append(x[i] % s)

for i in range(n):
print(y[i], end=" ")

def citire_conform_restrictiilor(x, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for elem in x:
if elem < 0 or elem > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(x):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
x = list(map(int, input().split()))
citire_conform_restrictiilor(x, n)
construirea_vectorului_y(x, n)

</syntaxhighlight>
== Explicație rezolvare ==
Programul începe prin definirea unei funcții numite '''construirea_vectorului_y(x, n)''', care primește două argumente: vectorul x și numărul n. În această funcție, se creează un vector gol y, în care vom adăuga ulterior elemente. Se parcurge vectorul x folosind un ciclu for. La fiecare iterație, se extrage elementul a de pe poziția i din vectorul x și se inițializează o variabilă s cu valoarea 0. Apoi, se parcurge cifrele din elementul a folosind un alt ciclu while. La fiecare iterație a acestui ciclu, se adaugă la variabila s ultima cifră a lui a, obținută prin operarea modulo 10, și se împarte a la 10, eliminându-se astfel ultima cifră. Aceasta se repetă până când a devine 0, moment în care suma cifrelor elementului a este acumulată în variabila s. Apoi, se adaugă la vectorul y valoarea a % s, care reprezintă restul împărțirii elementului a la suma cifrelor acestuia. Aceasta se realizează folosind metoda append() a listelor în Python. La final, se parcurge vectorul y și se afișează elementele pe ecran, separate prin spațiu, folosind un alt ciclu for și funcția print() cu argumentul end=" ", care specifică separatorul dintre elemente ca fiind spațiul. În continuare, programul definește o funcție numită '''citire_conform_restrictiilor(x, n)''', care primește două argumente: vectorul x și numărul n. Această funcție verifică dacă n și elementele din vectorul x respectă anumite restricții. Dacă n este mai mic decât 1 sau mai mare decât 200, sau dacă oricare dintre elementele din vectorul x este mai mic decât 0 sau mai mare decât 1000000000, sau dacă n nu este egal cu lungimea vectorului x, atunci se afișează "Datele nu corespund restricțiilor impuse." și programul se încheie folosind funcția exit(). Dacă toate restricțiile sunt respectate, se afișează "Datele sunt introduse corect." și se continuă programul. În secțiunea '''if __name__ == '__main__':''', se citește numărul n de la intrare folosind funcția input() și se convertește la tipul întreg folosind int(). Apoi, se citește vectorul x de la intrare, care conține n numere întregi separate prin spațiu, și se convertește într-o listă de întregi folosind funcția map() împreună cu int() pentru a aplica conversia la fiecare element din input-ul citit. Apoi, se apelează funcția citire_conform_restrictiilor(x, n) pentru a verifica restricțiile impuse asupra datelor citite. Dacă restricțiile sunt respectate, se apelează funcția construirea_vectorului_y(x, n) pentru a construi și afișa vectorul y, conform problemei.

4105 - NumarareDiv

2023-04-22T10:27:37Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/4105/numararediv 4105 - NumarareDiv]
----
== Cerinţa ==
Se dă un vector cu '''n''' numere naturale. Să se determine câte dintre perechile de elemente din vector au același număr de divizori.

== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează pe ecran '''numărul c''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 1000
* elementele vectorului vor fi cuprinse între '''1''' și '''1.000.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 13 3 8 7 9 25
; Ieșire
: Datele sunt introduse corect.
: 4
===Explicație exemplul 1===
Perechile de elemente cu același număr de divizori sunt: 
'''13 3''' – cu câte 2 divizori fiecare 
'''13 7''' – cu câte 2 divizori fiecare 
'''3 7''' – cu câte 2 divizori fiecare 
'''9 25''' – cu câte 3 divizori fiecare
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 4105

def numar_divizori(n):
divizori = 0
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divizori += 1
if i * i != n:
divizori += 1
return divizori

def cate_perechi_cu_acelasi_nr_divizori(vector, n):
s = [numar_divizori(x) for x in vector]
c = 0
for i in range(n):
for j in range(i+1, n):
if s[i] == s[j]:
c += 1
print(c)

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 1 or x > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
cate_perechi_cu_acelasi_nr_divizori(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
'''Funcția numar_divizori(n)''' primește un număr întreg n ca argument și returnează numărul de divizori ai acestuia. Pentru a determina acest număr, se utilizează o buclă for care parcurge toate valorile între 1 și rădăcina pătrată a lui n și se verifică dacă n este divizibil cu aceste valori folosind operatorul modulo (%). Dacă n este divizibil cu un anumit număr, atunci se incrementează un contor numit divizori. De asemenea, se adaugă încă un divizor pentru fiecare valoare găsită, cu excepția cazului în care valoarea găsită este chiar rădăcina pătrată a lui n, pentru a evita dublarea divizorului. La final, funcția returnează numărul total de divizori. '''Funcția cate_perechi_cu_acelasi_nr_divizori(vector, n)''' primește un vector de numere întregi vector și un număr întreg n reprezentând lungimea vectorului. Scopul acestei funcții este să numere câte perechi de numere din vector au același număr de divizori. Se folosește o buclă for dublă pentru a compara fiecare pereche posibilă de numere din vector. Dacă numărul de divizori al celor două numere este același, se incrementează un contor numit c. La final, se afișează valoarea contorului. '''Funcția citire_conform_restrictiilor(vector, n)''' primește un vector „vector” și un număr întreg n reprezentând lungimea vectorului și verifică dacă vectorul și lungimea acestuia respectă restricțiile problemei. Restricțiile impuse sunt: n trebuie să fie între 1 și 1000, fiecare element al vectorului trebuie să fie între 1 și 1000000000, iar lungimea vectorului trebuie să fie egală cu n. Dacă una dintre aceste restricții nu este respectată, se afișează „Datele nu corespund restricțiilor impuse.” și programul se încheie folosind funcția exit(). Dacă toate restricțiile sunt respectate, se afișează „Datele sunt introduse corect.”. La final, în '''blocul if __name__ == '__main__':''', programul citește de la intrare un număr n, apoi un vector „vector”, și apoi apelează funcțiile citire_conform_restrictiilor(vector, n) și cate_perechi_cu_acelasi_nr_divizori(vector, n) pentru a rezolva problema dată.

0499 - Numarare5

2023-04-22T10:20:55Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/499/numarare5 - Numarare5]
----
== Cerinţa ==
Se dă un vector cu '''n''' numere naturale. Să se determine câte dintre perechile de elemente din vector sunt formate din valori cu aceeași sumă a cifrelor.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează pe ecran '''numărul C''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1.000.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 51 842 15 28 77 132
; Ieșire
: Datele sunt introduse corect.
: 4
===Explicație exemplul 1===
Perechile de elemente cu aceeaşi sumă cifrelor sunt: 
'''51 15''' 
'''51 132''' 
'''842 77''' 
'''15 132'''
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0499

def suma_cifrelor(n):
suma = 0
while n:
suma += n % 10
n = n//10
return suma

def cate_perechi_cu_aceeasi_suma_cifrelor(vector, n):
s = [suma_cifrelor(x) for x in vector]
C = 0
for i in range(n):
for j in range(i+1, n):
if s[i] == s[j]:
C += 1
print(C)

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
cate_perechi_cu_aceeasi_suma_cifrelor(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
Programul de mai sus face: -> Definirea '''funcției suma_cifrelor(n)''' care primește un număr întreg n și calculează suma cifrelor acestuia. Funcția utilizează o buclă while care rulează până când n devine zero, la fiecare iterație extrăgând ultima cifră a lui n folosind operatorul modulo % și adăugând-o la suma suma. După aceea, n este împărțit la 10 folosind operatorul de divizare întreagă // pentru a se trece la următoarea cifră. Suma cifrelor este returnată la final. -> Definirea '''funcției cate_perechi_cu_aceeasi_suma_cifrelor(vector, n)''' care primește un vector de numere întregi vector și un număr întreg n reprezentând lungimea vectorului. Funcția calculează suma cifrelor pentru fiecare element din vector utilizând funcția suma_cifrelor() și stochează rezultatele într-un alt vector s. Apoi, folosește două bucle for pentru a compara suma cifrelor a fiecărui element din vectorul s cu suma cifrelor a celorlalte elemente din vector și numără câte perechi au aceeași sumă a cifrelor. Rezultatul este afișat la final cu ajutorul funcției print(). -> Definirea '''funcției citire_conform_restrictiilor(vector, n)''' care primește un vector vector și un număr n reprezentând lungimea vectorului și verifică dacă acestea respectă anumite restricții. Restricțiile impuse includ: n trebuie să fie între 1 și 200, fiecare element din vector trebuie să fie între 0 și 1000000000, iar lungimea vectorului vector trebuie să fie egală cu n. Dacă oricare dintre restricții nu este respectată, se afișează "Datele nu corespund restricțiilor impuse." și programul se încheie cu ajutorul funcției exit(). Dacă toate restricțiile sunt respectate, se afișează "Datele sunt introduse corect." și se continuă programul. În '''secțiunea if __name__ == '__main__':''' se citește de la tastatură numărul n și vectorul vector folosind funcția input() și list(map(int, input().split())). Apoi, se apelează funcția citire_conform_restrictiilor(vector, n) pentru a verifica dacă datele introduse respectă restricțiile impuse. În final, se apelează funcția cate_perechi_cu_aceeasi_suma_cifrelor(vector, n) pentru a afișa valoarea cerută în problemă.

4110 - NumarareSD

2023-04-22T10:10:03Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/4110/numararesd 4110 - NumarareSD]
----
== Cerinţa ==
Se dă un vector cu '''n''' numere naturale. Să se determine câte dintre perechile de elemente din vector au aceeași sumă a divizorilor.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează pe ecran '''numărul c''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 1000
* elementele vectorului vor fi cuprinse între '''1''' și '''1.000.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 10 3 6 17 9 11
; Ieșire
: Datele sunt introduse corect.
: 2
===Explicație exemplul 1===
Perechile de elemente cu aceeași sumă a divizorilor sunt: 
'''10 17''' – cu suma 18 
'''6 11''' – cu suma 12
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 4110

import math

def suma_divizorilor(n):
sumdiv = 0
for d in range(1, int(math.sqrt(n))+1):
if n % d == 0:
sumdiv += d
if d != n // d:
sumdiv += n // d
return sumdiv

def cate_perechi_cu_aceeasi_suma_diviz(vector, n):
s = [suma_divizorilor(x) for x in vector]
c = 0
for i in range(n):
for j in range(i+1, n):
if s[i] == s[j]:
c += 1
print(c)

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 1 or x > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
cate_perechi_cu_aceeasi_suma_diviz(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
'''Funcția suma_divizorilor(n)''' primește un număr întreg n ca argument și calculează suma divizorilor acestuia. Pentru a face acest lucru, se parcurge un interval de la 1 la radicalul pătrat din n (inclusiv), iar pentru fiecare divizor d al lui n, se adaugă la suma sumdiv valoarea lui d și valoarea lui n // d (dacă d nu este egal cu n // d). '''Funcția cate_perechi_cu_aceeasi_suma_diviz(vector, n)''' primește un vector de numere întregi vector și un număr întreg n reprezentând lungimea vectorului. Această funcție calculează numărul de perechi de indici distincte din vector (i, j), cu i < j, pentru care suma divizorilor elementelor de pe pozițiile i și j din vector este aceeași. Acest lucru se face prin calcularea sumelor divizorilor pentru fiecare element din vector utilizând funcția '''suma_divizorilor(n)''', și apoi compararea acestor sume pentru a identifica perechile cu aceeași sumă de divizori. '''Funcția citire_conform_restrictiilor(vector, n)''' primește un vector de numere vector și un număr n reprezentând lungimea vectorului. Această funcție verifică dacă valorile lui n și ale elementelor din vector respectă anumite restricții impuse (n trebuie să fie între 1 și 1000, iar elementele vectorului trebuie să fie între 1 și 1000000000, n trebuie să fie lungimea vectorului "vector"), și dacă aceste restricții nu sunt îndeplinite afișează "Datele nu corespund restricțiilor impuse." și încheie execuția programului cu ajutorul comenzii exit(), iar dacă ele sunt îndeplinite afișează "Datele sunt introduse corect." și se continuă programul. În '''blocul if __name__ == '__main__':''' se realizează citirea valorii lui n de la tastatură, citirea vectorului de numere întregi vector de la tastatură, apelul funcției citire_conform_restrictiilor(vector, n) pentru a verifica restricțiile impuse asupra datelor de intrare, și apelul funcției cate_perechi_cu_aceeasi_suma_diviz(vector, n) pentru a calcula și afișa numărul de perechi de indici cu aceeași sumă de divizori, număr ce reprezintă valoarea cerută în problemă.

4105 - NumarareDiv

2023-04-22T10:01:07Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/4105/numararediv 4105 - NumarareDiv]
----
== Cerinţa ==
Se dă un vector cu '''n''' numere naturale. Să se determine câte dintre perechile de elemente din vector au același număr de divizori.

== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează pe ecran '''numărul c''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 1000
* elementele vectorului vor fi cuprinse între '''1''' și '''1.000.000.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 13 3 8 7 9 25
; Ieșire
: Datele sunt introduse corect.
: 4
===Explicație exemplul 1===
Perechile de elemente cu același număr de divizori sunt: 
'''13 3''' – cu câte 2 divizori fiecare 
'''13 7''' – cu câte 2 divizori fiecare 
'''3 7''' – cu câte 2 divizori fiecare 
'''9 25''' – cu câte 3 divizori fiecare
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 4105

def numar_divizori(n):
divizori = 0
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divizori += 1
if i * i != n:
divizori += 1
return divizori

def cate_perechi_cu_acelasi_nr_divizori(vector, n):
s = [numar_divizori(x) for x in vector]
c = 0
for i in range(n):
for j in range(i+1, n):
if s[i] == s[j]:
c += 1
print(c)

def citire_conform_restrictiilor():
n = int(input())
if n < 1 or n > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
vector = list(map(int, input().split()))
for x in vector:
if x < 1 or x > 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")
return vector, n

if __name__ == '__main__':
vector, n = citire_conform_restrictiilor()
cate_perechi_cu_acelasi_nr_divizori(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
'''Funcția numar_divizori(n)''' primește un număr întreg n ca argument și returnează numărul de divizori ai acestuia. Pentru a determina acest număr, se utilizează o buclă for care parcurge toate valorile între 1 și rădăcina pătrată a lui n și se verifică dacă n este divizibil cu aceste valori folosind operatorul modulo (%). Dacă n este divizibil cu un anumit număr, atunci se incrementează un contor numit divizori. De asemenea, se adaugă încă un divizor pentru fiecare valoare găsită, cu excepția cazului în care valoarea găsită este chiar rădăcina pătrată a lui n, pentru a evita dublarea divizorului. La final, funcția returnează numărul total de divizori. '''Funcția cate_perechi_cu_acelasi_nr_divizori(vector, n)''' primește un vector de numere întregi vector și un număr întreg n reprezentând lungimea vectorului. Scopul acestei funcții este să numere câte perechi de numere din vector au același număr de divizori. Se folosește o buclă for dublă pentru a compara fiecare pereche posibilă de numere din vector. Dacă numărul de divizori al celor două numere este același, se incrementează un contor numit c. La final, se afișează valoarea contorului. '''Funcția citire_conform_restrictiilor(vector, n)''' primește un vector „vector” și un număr întreg n reprezentând lungimea vectorului și verifică dacă vectorul și lungimea acestuia respectă restricțiile problemei. Restricțiile impuse sunt: n trebuie să fie între 1 și 1000, fiecare element al vectorului trebuie să fie între 1 și 1000000000, iar lungimea vectorului trebuie să fie egală cu n. Dacă una dintre aceste restricții nu este respectată, se afișează „Datele nu corespund restricțiilor impuse.” și programul se încheie folosind funcția exit(). Dacă toate restricțiile sunt respectate, se afișează „Datele sunt introduse corect.”. La final, în '''blocul if __name__ == '__main__':''', programul citește de la intrare un număr n, apoi un vector „vector”, și apoi apelează funcțiile citire_conform_restrictiilor(vector, n) și cate_perechi_cu_acelasi_nr_divizori(vector, n) pentru a rezolva problema dată.

0498 - NumararePIE

2023-04-22T09:26:48Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/498/numararepie - NumararePIE]
----
== Cerinţe ==
Se dă un vector cu '''n''' numere naturale. Să se determine câte dintre perechile de elemente din vector sunt prime între ele.

== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou afișează pe ecran '''numărul C''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 51 18 15 28 77 121
; Ieșire
: Datele sunt introduse corect.
: 9

===Explicație exemplul 1===
Perechile de elemente prime între ele sunt: 
51 28 
51 77 
51 121 
18 77 
18 121 
15 28 
15 77 
15 121 
28 121
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0498

def verificare_prime_intre_ele(nr1, nr2):
while nr2 != 0:
a = nr1 % nr2
nr1 = nr2
nr2 = a
return nr1

def numarare_perechi_elem_prime_intre_ele(vector, n):
C = 0
for i in range(n):
for j in range(i + 1, n):
if verificare_prime_intre_ele(vector[i], vector[j]) == 1:
C += 1
print(C)

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
numarare_perechi_elem_prime_intre_ele(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
Programul de mai sus conține trei funcții, funcția '''verificare_prime_intre_ele(nr1, nr2)''', funcția numarare_perechi_elem_prime_intre_ele(vector, n) și funcția '''citire_conform_restrictiilor(vector, n)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 34) după citirea numărului n (linia 35) și celor n numere pe care le vom pune în șirul „vector” (linia 36). După ce am citit elementele, se va apela '''funcția citire_conform_restrictiilor(vector, n)''' care primește doi parametri: vectorul „vector” și lungimea sa, reprezentată de variabila „n”. Funcția verifică dacă n este între 1 și 200 (linia 21), dacă elementele vectorului sunt cuprinse între 0 și 1000 (liniile 24, 25) și dacă n este lungimea vectorului „vector” (linia 28). Dacă oricare dintre condiții este încălcată, se va afișa mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 31) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''numarare_perechi_elem_prime_intre_ele(vector, n)''' care primește ca parametrii vectorul „vector” și dimensiunea sa „n”. În această funcție se inițializează o variabilă C cu 0, care va fi utilizată pentru a număra perechile de elemente consecutive din vector care sunt prime între ele, apoi se parcurge vectorul utilizând o buclă for. În interiorul primei bucle for, se adaugă o buclă for imbricată care începe de la i + 1 (următorul element din vector după elementul curent) și se termină la n-1 (ultimul element din vector). Aceasta se face pentru a verifica toate perechile de elemente consecutive posibile din vector. Pentru fiecare pereche de elemente consecutive din vector, se apelează '''funcția verificare_prime_intre_ele(nr1, nr2)''' pentru a verifica dacă acestea sunt prime între ele. Funcția '''verificare_prime_intre_ele(nr1, nr2)''' calculează cel mai mare divizor comun al celor două numere folosind algoritmul lui Euclid (care începe prin a calcula restul împărțirii nr1 la nr2 și se atribuie rezultatul într-o variabilă a (adesea denumită și "restul"), apoi se actualizează valorile celor două numere astfel: nr1 devine nr2 și nr2 devine a. și se repetă acești pași până când a devine 0, și vom avea în final CMMD al celor două numere) și returnează rezultatul. Dacă rezultatul returnat de această funcție este 1 (adică cele două numere nu au niciun divizor comun în afara valorii 1), atunci se consideră că cele două numere sunt prime între ele. -> dacă cele două numere consecutive din vector sunt prime între ele, atunci variabila C este incrementată cu 1; -> la finalul buclei imbricate, se va obține numărul total de perechi de elemente consecutive din vector care sunt prime între ele, stocat în variabila C, pe care o afișăm, ea fiind valoarea cerută în problemă.

0498 - NumararePIE

2023-04-22T09:07:07Z

Csatari Mălina: /* Exemplul 1 */

0492 - Numarare3

2023-04-22T09:00:22Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/492/numarare3 - Numarare3]
----
== Cerinţa ==
Se dă un vector cu '''n''' numere naturale. Să se determine câte dintre perechile de elemente egal depărtate de capetele vectorului sunt prime între ele.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi șirul de '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou '''numărul c''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 50 18 15 28 35 40
; Ieșire
: Datele sunt introduse corect.
: 2
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0492

def cate_perechi_de_el_egal_departate_prime_intre_ele(vector, n):
c = 0
for i in range(n // 2):
a, b = vector[i], vector[n-i-1]
if b == 0:
b = a
else:
while a % b != 0:
r = a % b
a = b
b = r
if b == 1:
c += 1
print(c)

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
cate_perechi_de_el_egal_departate_prime_intre_ele(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''cate_perechi_de_el_egal_departate_prime_intre_ele(vector, n)''' și funcția '''citire_conform_restrictiilor(vector, n)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 33) după citirea numărului n (linia 34) și celor n numere pe care le vom pune în șirul „vector” (linia 35). După ce am citit elementele, se va apela '''funcția citire_conform_restrictiilor(vector, n)''' care primește doi parametri: vectorul „vector” și lungimea sa, reprezentată de variabila „n”. Funcția verifică dacă lungimea vectorului n este între 1 și 200 (linia 20), dacă elementele vectorului sunt cuprinse între 0 și 1000 (liniile 23, 24) și dacă n este lungimea vectorului „vector” (linia 27). Dacă oricare dintre condiții este încălcată, se va afișa mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 30) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''cate_perechi_de_el_egal_departate_prime_intre_ele(vector, n)''' care primește ca parametrii vectorul „vector” și dimensiunea sa „n”. În interiorul funcției: -> se initializează o variabilă c cu valoarea 0, care va fi folosită pentru a număra câte astfel de perechi sunt găsite în vector; -> se parcurge vectorul utilizând o buclă for care iterează de la 0 la jumătatea numărului total de elemente din vector (n // 2). Aceasta se face pentru a evita să se numere de două ori aceeași pereche de elemente; -> pentru fiecare pereche de elemente consecutive din vector, se extrag valorile celor două elemente în variabilele a și b utilizând indexarea vectorului; -> se verifică dacă b este egal cu 0. Dacă da, atunci b este actualizat cu valoarea lui a, pentru a evita împărțirea la zero ulterior; -> se aplică algoritmul pentru a determina cel mai mare divizor comun dintre a și b. Acesta constă în aplicarea succesivă a restului împărțirii până când restul devine 0. În timpul acestui proces, valorile lui a și b sunt actualizate în consecință; -> se verifică dacă b este egal cu 1. Dacă da, înseamnă că a și b sunt coprime (adică nu au niciun divizor comun în afara valorii 1) și deci numărul de elemente departate între ele este un număr prim. În acest caz, variabila c este incrementată cu 1; -> se afișează valoarea variabilei c la finalul funcției, care reprezintă numărul total de perechi de elemente consecutive din vector care îndeplinesc condițiile specificate în problemă.

2858 - pv

2023-04-22T08:43:00Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/2858/pv - 2858 - pv]
----
== Cerinţe ==
Se dă un șir cu '''n''' elemente, '''numere naturale'''.
* Să se afișeze '''elementele șirului de la dreapta la stânga'''.
* Să se calculeze '''suma valorilor pare din șir'''.
* Să se determine '''suma valorilor aflate pe poziții pare în șir'''.
* Să se determine '''numărul numerelor din șir care sunt divizibile cu 10'''.
* Să se determine '''suma numerelor divizibile cu 3 și aflate pe poziții impare'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi șirul de '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi:
 * pe un rând nou va afișa '''elementele șirului de la dreapta la stânga''';
 * pe un rând nou se va afișa '''un singur număr reprezentând suma valorilor pare''';
 * pe un rând nou se va afișa '''un singur număr reprezentând suma valorilor aflate pe poziții pare''' în șir;
 * pe un rând nou se va afișa '''un singur număr reprezentând numărul numerelor din șir care sunt divizibile cu 10''';
 * pe ultimul rând se va afișa '''un singur număr reprezentând suma numerelor divizibile cu 3 și aflate pe poziții impare'''.
 În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 100
* elementele vectorului vor fi cuprinse '''între 0 și 100'''

== Exemple ==
===Exemplul 1===
; Intrare
: 10
: 1 2 3 4 5 6 7 8 9 10
; Ieșire
: Datele sunt introduse corect.
: 10 9 8 7 6 5 4 3 2 1
: 30
: 30
: 1
: 12
===Exemplul 2===
; Intrare
: 5
: 10 2 -3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2858

def afisare_vector_invers(vector, n):
for i in range(n-1, -1, -1):
print(vector[i], end=" ")
print()

def afisare_suma_val_pare(vector, n):
suma_val_pare = 0
for i in range(n):
if vector[i] % 2 == 0:
suma_val_pare += vector[i]
print(suma_val_pare)

def afisare_suma_poz_pare(vector, n):
suma_poz_pare = 0
# vectorul începe de la 0, așadar pozițiile pare vor fi cele impare în cazul acesta
for i in range(n):
if i % 2 != 0:
suma_poz_pare += vector[i]
print(suma_poz_pare)

def afisare_nr_el_div_10(vector, n):
nr_el_div_10 = 0
for i in range(n):
if vector[i] % 10 == 0:
nr_el_div_10 += 1
print(nr_el_div_10)

def afisare_suma_poz_imp_div_3(vector, n):
suma_poz_imp_div_3 = 0
for i in range(n):
if vector[i] % 3 == 0 and i % 2 != 1:
suma_poz_imp_div_3 += vector[i]
print(suma_poz_imp_div_3)

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
afisare_vector_invers(vector, n)
afisare_suma_val_pare(vector, n)
afisare_suma_poz_pare(vector, n)
afisare_nr_el_div_10(vector, n)
afisare_suma_poz_imp_div_3(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
Programul de mai sus este împărțit în mai multe funcții care efectuează operațiile date în problemă asupra vectorului de numere. -> '''Funcția afisare_vector_invers(vector, n)''' primește ca parametri vectorul „vector” și numărul de elemente din vector (n) și afișează elementele vectorului în ordine inversă, de la ultimul element la primul, cu ajutorul unui for loop (linia 4); -> '''Funcția afisare_suma_val_pare(vector, n)''' primește ca parametri un vector „vector” și numărul de elemente din vector (n) și calculează și afișează suma tuturor valorilor pare din vector (parcurgem vectorul cu ajutorul unui for loop, linia 11, și verificăm dacă elementele sunt pare, iar dacă da, le adăugăm în variabila suma_val_pare, care a fost inițializată cu 0 înainte de for loop, linia 10) și la final afișăm suma_val_pare; -> '''Funcția afisare_suma_poz_pare(vector, n)''' primește ca parametri un vector „vector” și numărul de elemente din vector (n) și calculează și afișează suma valorilor din pozițiile pare (indexuri impare vor fi pare deoarece la noi vectorul începe de la 0, nu de la 1) din vector. Acest lucru se realizează prin parcurgerea vectorului și adunarea valorilor aflate pe poziții impare (care sunt pare dacă se începe de pe poziția 1), pe care le adunăm în variabila suma_poz_pare și o afișăm la final; -> '''Funcția afisare_nr_el_div_10(vector, n)''' primește ca parametri un vector „vector” și numărul de elemente din vector (n) și calculează și afișează numărul de elemente din vector care sunt divizibile cu 10 în variabila nr_el_div_10, inițializată cu 0 la început. Calcularea acestei valori se face prin a parcurge vectorul cu un for loop și se verifică dacă numărul este divizibil cu 10 cu ajutorul operatorului % (de exemplu, dacă element % 10 este diferit de 0, înseamnă cu numărul nu este divizibil cu 10) și adunăm 1 în variabila nr_el_div_10 de fiecare dată când descoperim un element divizibil cu 10, apoi după finalizarea parcurgerii, afișăm aceasta valoare; -> '''Funcția afisare_suma_poz_imp_div_3(vector, n)''' primește ca parametri un vector „vector” și numărul de elemente din vector (n) și calculează și afișează suma valorilor din pozițiile impare (la noi cele pare deoarece începem vectorul de la 0, nu 1) din vector care sunt divizibile cu 3. Acest număr va fi calculat în variabila suma_poz_imp_div_3 pe care o inițializăm cu 0 la început, apoi parcurgem vectorul și verificăm pentru fiecare element dacă este divizibil cu 3 cu ajutorul operatorului % și dacă poziția sa este pară (pentru a obține pozițiile impare, noi începem vectorul de la 0, așadar cele două vor fi inversate), iar dacă ambele condiții sunt îndeplinite se adaugă elementul respectiv în variabila suma_poz_imp_div_3, care după parcurgerea întregului vector va avea valoarea cerută; -> '''Funcția citire_conform_restrictiilor(vector, n)''' primește ca parametri un vector „vector” și numărul de elemente din vector (n) și verifică dacă vectorul și numărul de elemente din vector respectă restricțiile impuse. Aceste restricții includ ca numărul de elemente din vector să fie între 1 și 100, valorile din vector să fie între 0 și 100 și numărul de elemente din vector să fie egal cu n. Dacă restricțiile nu sunt respectate, programul afișează „Datele nu corespund restricțiilor impuse.” și se încheie prin apelul funcției exit(). Dacă restricțiile sunt respectate, se afișează un mesajul „Datele sunt introduse corect.” (linia 55); -> '''În secțiunea if __name__ == '__main__':''', programul începe prin citirea numărului de elemente din vector (n) de la tastatură folosind funcția input() și convertirea acestuia la un număr întreg utilizând funcția int() (linia 57). Apoi, vectorul este citit de la tastatură ca o listă de numere întregi utilizând funcția input() și funcția split() care separă valorile citite în funcție de spații și le transformă într-o listă de șiruri de caractere. Apoi, utilizând funcția map() împreună cu funcția int(), lista de șiruri de caractere este convertită într-o listă de numere întregi. Apoi, tot în main, se apelează toate funcțiile de mai sus și se va obține rezultatul conform problemei.

0986 - Numarare7

2023-04-22T07:57:31Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/986/numarare7 - Numarare7]
----
== Cerinţa ==
Se dă un șir cu '''n''' elemente, '''numere reale'''. Să se determine câte dintre elemente se află în afara intervalului închis determinat de primul și ultimul element.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere reale, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa numărul '''C''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între -1000 și 1000

== Exemple ==
===Exemplul 1===
; Intrare
: 6
: 2 0.5 4 -1 -8 -3
; Ieșire
: Datele sunt introduse corect.
: 2
===Explicație exemplul 1===
: Elementele șirului aflate în afara intervalului '''[-3,2]''' sunt: '''4''' și '''-8'''.
===Exemplul 2===
; Intrare
: 201
: 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0986 Numarare7

def nr_elem_aflate_inafara_interv_inchis_primul_ultimul(vector):
temp1 = vector[0]
temp2 = vector[-1]
if temp2 < temp1:
temp1, temp2 = temp2, temp1
C = sum(1 for elem in vector if elem > temp2 or elem < temp1)
print(C)

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < -1000 or x > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")
return vector

if __name__ == '__main__':
n = int(input())
vector = list(map(float, input().split()))
citire_conform_restrictiilor(vector, n)
nr_elem_aflate_inafara_interv_inchis_primul_ultimul(vector)

</syntaxhighlight>
== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''nr_elem_aflate_inafara_interv_inchis_primul_ultimul(vector)''' și funcția '''citire_conform_restrictiilor(vector, n)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 27) după citirea numărului n (linia 28) și celor n numere reale pe care le vom pune în șirul „vector” (linia 29). După ce am citit elementele, se va apela '''funcția citire_conform_restrictiilor(vector, n)''' care primește doi parametri: vectorul „vector” și lungimea sa, reprezentată de variabila „n”. Funcția verifică dacă lungimea vectorului n este între 1 și 200 (linia 13), dacă elementele vectorului sunt cuprinse între -1000 și 1000 (liniile 16, 17) și dacă n este lungimea vectorului „vector” (linia 20). Dacă oricare dintre condiții este încălcată, se va afișa mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 34) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''nr_elem_aflate_inafara_interv_inchis_primul_ultimul(vector)''' care primește ca parametrii vectorul „vector” și dimensiunea sa „n”, apoi: -> inițializează două variabile, temp1 și temp2, cu primul, respectiv ultimul element din vector (liniile 4, 5). Aceste variabile vor fi utilizate pentru a reține valorile primului și ultimului element din vector, astfel încât să se poată determina intervalul închis format de acestea; -> verifică dacă ultimul element din vector, reprezentat de temp2, este mai mic decât primul element din vector , reprezentat de temp1 (linia 6). Dacă da, inversează valorile celor două variabile temporare (linia 7), astfel încât temp1 să rețină valoarea ultimului element și temp2 să rețină valoarea primului element; -> utilizează o expresie generator (sum(1 for elem in vector if elem > temp2 or elem < temp1)) pentru a parcurge vectorul și pentru fiecare element din vector care este mai mare decât temp2 sau mai mic decât temp1, adaugă 1 la o variabilă C. Expresia generator calculează efectiv numărul de elemente care se află în afara intervalului închis definit de primul și ultimul element din vector; -> afișează valoarea lui C pe ecran, valoare cerută de problemă.

0491 - Suma2

2023-04-22T07:48:50Z

Csatari Mălina: /* Exemplul 4 */

Sursa: [https://www.pbinfo.ro/probleme/491/suma2 - Suma2]
----
== Cerinţa ==
Se citește un vector cu '''n''' elemente, numere naturale. Să se determine suma valorilor elementelor cuprinse între primul și ultimul element par al vectorului, inclusiv acestea.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa numărul '''S''', reprezentând suma calculată. Dacă în vector nu există niciun element par, '''în loc de suma S''' se va afișa '''"Nu există niciun număr par."'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 1.000
* elementele vectorului vor fi mai mici decât '''100.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 5
: 7 6 1 2 8
; Ieșire
: Datele sunt introduse corect.
: 17
===Explicație exemplul 1===
: 17 = 6 + 1 + 2 + 8
===Exemplul 2===
; Intrare
: 6
: 1 2 5 7 9 11
; Ieșire
: Datele sunt introduse corect.
: 2
===Explicație exemplul 2===
: Deși există doar un element par în vector, el este și primul și ultimul, așadar rezultatul va fi 2.
===Exemplul 3===
; Intrare
: 3
: 3 5 7
; Ieșire
: Datele sunt introduse corect.
: Nu există niciun număr par.
===Exemplul 4===
; Intrare
: 1234
: 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0491 - Suma2

def suma_elem_dintre_primul_elem_par_si_ultimul(vector, n):
a, b = -1, -1
for i in range(n):
if vector[i] % 2 == 0:
if a == -1:
a = i
b = i
if a != -1:
S = sum(vector[a:b + 1])
print(S)
else:
print("Nu există niciun număr par.")

def citire_conform_restrictiilor(n, vector):
if n < 1 or n > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x >= 100000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(n, vector)
suma_elem_dintre_primul_elem_par_si_ultimul(vector, n)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''suma_elem_dintre_primul_elem_par_si_ultimul(vector, n)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 31) după citirea numărului n (linia 32) și celor n numere pe care le vom pune în șirul „vector” (linia 33). După ce am citit elementele, se va apela '''funcția citire_conform_restrictiilor(n, vector)''' care primește doi parametri: numărul n și cele n numere pe care le punem în vectorul „vector”. Funcția verifică dacă n este între 1 și 1000 (linia 18), dacă elementele vectorului sunt mai mici decât 100000 (liniile 21, 22) și dacă n este lungimea vectorului „vector” (linia 25). Dacă oricare dintre condiții este încălcată, se va afișa mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 28) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''suma_elem_dintre_primul_elem_par_si_ultimul(vector, n)''' care primește ca parametrii vectorul „vector” și dimensiunea sa „n”. În această funcție se inițializează a și b, cu valoarea -1. Aceste variabile vor fi utilizate pentru a reține poziția primului și ultimului element par din vector. Apoi, parcurgem vectorul folosind un ciclu for (linia 5), iar pentru fiecare element verifică dacă este un număr par, folosind operatorul de modulo % care calculează restul împărțirii la 2. Dacă restul este 0, înseamnă că elementul este par. Dacă un element par este găsit, se verifică dacă a are valoarea -1, ceea ce indică faptul că este primul element par găsit. Dacă da, a va fi actualizat cu poziția acestui element. În mod similar, variabila b va fi actualizată la fiecare pas cu poziția ultimului element par găsit, astfel încât, la finalul parcurgerii vectorului, b va reține poziția ultimului element par din vector. După parcurgerea întregului vector, verificăm dacă s-au găsit cel puțin un element par în vector, verificând dacă a are o valoare diferită de -1. Dacă da, calculează suma elementelor din vector începând de la poziția a și până la poziția b + 1, folosind funcția predefinită sum() și o afișează pe ecran. Dacă nu există niciun element par în vector, afișează mesajul "Nu există niciun număr par."

0487 - Numarare2

2023-04-22T07:48:27Z

Csatari Mălina: /* Exemplul 2 */

Sursa: [https://www.pbinfo.ro/probleme/487/numarare2 - Numarare2]
----
== Cerinţa ==
Se dă un vector cu '''n''' numere naturale. Să se determine câte dintre elemente au valoarea strict mai mare decât media aritmetică a elementelor vectorului.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa numărul '''C''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 5
: 5 0 2 1 4
; Ieșire
: Datele sunt introduse corect.
: 2
===Explicație exemplul 1===
: Media aritmetică a elementelor este '''2.4'''. În vector sunt '''2''' elemente cu valoarea strict mai mare decât '''2.4''': '''5 4'''
===Exemplul 2===
; Intrare
: 1234
: 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 0487 Numarare2

def nr_elem_cu_val_strict_mai_mare_decat_media_aritm(vector, n):
suma = sum(vector)
medie = suma / n
C = sum(1 for x in vector if x > medie)
print(C)

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
nr_elem_cu_val_strict_mai_mare_decat_media_aritm(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''nr_elem_cu_val_strict_mai_mare_decat_media_aritm(vector, n)''' și funcția '''citire_conform_restrictiilor(vector, n)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 24) după citirea numărului n (linia 25) și celor n numere pe care le vom pune în șirul „vector” (linia 26). După ce am citit elementele, se va apela '''funcția citire_conform_restrictiilor(vector, n)''' care primește doi parametri: vectorul „vector” și lungimea sa, reprezentată de variabila „n”. Funcția verifică dacă lungimea vectorului n este între 1 și 200 (linia 11), dacă elementele vectorului sunt cuprinse între 0 și 1000 (liniile 14, 15) și dacă n este lungimea vectorului „vector” (linia 18). Dacă oricare dintre condiții este încălcată, se va afișa mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 21) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''nr_elem_cu_val_strict_mai_mare_decat_media_aritm(vector, n)''' care primește ca parametrii vectorul „vector” și dimensiunea sa „n”. Funcția începe prin a calcula suma tuturor elementelor din vector folosind funcția predefinită sum() (linia 4), și o stochează în variabila suma, apoi într-o altă variabilă medie calculează media aritmetică a elementelor din vector împărțind suma calculată anterior la lungimea vectorului (n) și o stochează în variabila medie. Folosind o expresie generator (sum(1 for x in vector if x > medie)), parcurgem vectorul și pentru fiecare element care are o valoare mai mare sau egală cu media aritmetică, adăugăm 1 la valoarea lui C (variabilă denumită conform problemei). Expresia generator calculează efectiv numărul de elemente care satisfac condiția dată, conform problemei, apoi afișează valoarea lui C pe ecran.

0487 - Numarare2

2023-04-22T07:45:56Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/487/numarare2 - Numarare2]
----
== Cerinţa ==
Se dă un vector cu '''n''' numere naturale. Să se determine câte dintre elemente au valoarea strict mai mare decât media aritmetică a elementelor vectorului.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa numărul '''C''', reprezentând valoarea cerută. În caz contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200
* elementele vectorului vor fi cuprinse între '''0''' și '''1.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 5
: 5 0 2 1 4
; Ieșire
: Datele sunt introduse corect.
: 2
===Explicație exemplul 1===
: Media aritmetică a elementelor este '''2.4'''. În vector sunt '''2''' elemente cu valoarea strict mai mare decât '''2.4''': '''5 4'''
===Exemplul 2===
; Intrare
: 1234
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 0487 Numarare2

def nr_elem_cu_val_strict_mai_mare_decat_media_aritm(vector, n):
suma = sum(vector)
medie = suma / n
C = sum(1 for x in vector if x > medie)
print(C)

def citire_conform_restrictiilor(vector, n):
if n < 1 or n > 200:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x < 0 or x > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(vector, n)
nr_elem_cu_val_strict_mai_mare_decat_media_aritm(vector, n)

</syntaxhighlight>
== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''nr_elem_cu_val_strict_mai_mare_decat_media_aritm(vector, n)''' și funcția '''citire_conform_restrictiilor(vector, n)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 24) după citirea numărului n (linia 25) și celor n numere pe care le vom pune în șirul „vector” (linia 26). După ce am citit elementele, se va apela '''funcția citire_conform_restrictiilor(vector, n)''' care primește doi parametri: vectorul „vector” și lungimea sa, reprezentată de variabila „n”. Funcția verifică dacă lungimea vectorului n este între 1 și 200 (linia 11), dacă elementele vectorului sunt cuprinse între 0 și 1000 (liniile 14, 15) și dacă n este lungimea vectorului „vector” (linia 18). Dacă oricare dintre condiții este încălcată, se va afișa mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 21) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''nr_elem_cu_val_strict_mai_mare_decat_media_aritm(vector, n)''' care primește ca parametrii vectorul „vector” și dimensiunea sa „n”. Funcția începe prin a calcula suma tuturor elementelor din vector folosind funcția predefinită sum() (linia 4), și o stochează în variabila suma, apoi într-o altă variabilă medie calculează media aritmetică a elementelor din vector împărțind suma calculată anterior la lungimea vectorului (n) și o stochează în variabila medie. Folosind o expresie generator (sum(1 for x in vector if x > medie)), parcurgem vectorul și pentru fiecare element care are o valoare mai mare sau egală cu media aritmetică, adăugăm 1 la valoarea lui C (variabilă denumită conform problemei). Expresia generator calculează efectiv numărul de elemente care satisfac condiția dată, conform problemei, apoi afișează valoarea lui C pe ecran.

0491 - Suma2

2023-04-22T07:33:16Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/491/suma2 - Suma2]
----
== Cerinţa ==
Se citește un vector cu '''n''' elemente, numere naturale. Să se determine suma valorilor elementelor cuprinse între primul și ultimul element par al vectorului, inclusiv acestea.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou va afișa numărul '''S''', reprezentând suma calculată. Dacă în vector nu există niciun element par, '''în loc de suma S''' se va afișa '''"Nu există niciun număr par."'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 1.000
* elementele vectorului vor fi mai mici decât '''100.000'''

== Exemple ==
===Exemplul 1===
; Intrare
: 5
: 7 6 1 2 8
; Ieșire
: Datele sunt introduse corect.
: 17
===Explicație exemplul 1===
: 17 = 6 + 1 + 2 + 8
===Exemplul 2===
; Intrare
: 6
: 1 2 5 7 9 11
; Ieșire
: Datele sunt introduse corect.
: 2
===Explicație exemplul 2===
: Deși există doar un element par în vector, el este și primul și ultimul, așadar rezultatul va fi 2.
===Exemplul 3===
; Intrare
: 3
: 3 5 7
; Ieșire
: Datele sunt introduse corect.
: Nu există niciun număr par.
===Exemplul 4===
; Intrare
: 1234
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0491 - Suma2

def suma_elem_dintre_primul_elem_par_si_ultimul(vector, n):
a, b = -1, -1
for i in range(n):
if vector[i] % 2 == 0:
if a == -1:
a = i
b = i
if a != -1:
S = sum(vector[a:b + 1])
print(S)
else:
print("Nu există niciun număr par.")

def citire_conform_restrictiilor(n, vector):
if n < 1 or n > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in vector:
if x >= 100000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(n, vector)
suma_elem_dintre_primul_elem_par_si_ultimul(vector, n)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''suma_elem_dintre_primul_elem_par_si_ultimul(vector, n)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 31) după citirea numărului n (linia 32) și celor n numere pe care le vom pune în șirul „vector” (linia 33). După ce am citit elementele, se va apela '''funcția citire_conform_restrictiilor(n, vector)''' care primește doi parametri: numărul n și cele n numere pe care le punem în vectorul „vector”. Funcția verifică dacă n este între 1 și 1000 (linia 18), dacă elementele vectorului sunt mai mici decât 100000 (liniile 21, 22) și dacă n este lungimea vectorului „vector” (linia 25). Dacă oricare dintre condiții este încălcată, se va afișa mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 28) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''suma_elem_dintre_primul_elem_par_si_ultimul(vector, n)''' care primește ca parametrii vectorul „vector” și dimensiunea sa „n”. În această funcție se inițializează a și b, cu valoarea -1. Aceste variabile vor fi utilizate pentru a reține poziția primului și ultimului element par din vector. Apoi, parcurgem vectorul folosind un ciclu for (linia 5), iar pentru fiecare element verifică dacă este un număr par, folosind operatorul de modulo % care calculează restul împărțirii la 2. Dacă restul este 0, înseamnă că elementul este par. Dacă un element par este găsit, se verifică dacă a are valoarea -1, ceea ce indică faptul că este primul element par găsit. Dacă da, a va fi actualizat cu poziția acestui element. În mod similar, variabila b va fi actualizată la fiecare pas cu poziția ultimului element par găsit, astfel încât, la finalul parcurgerii vectorului, b va reține poziția ultimului element par din vector. După parcurgerea întregului vector, verificăm dacă s-au găsit cel puțin un element par în vector, verificând dacă a are o valoare diferită de -1. Dacă da, calculează suma elementelor din vector începând de la poziția a și până la poziția b + 1, folosind funcția predefinită sum() și o afișează pe ecran. Dacă nu există niciun element par în vector, afișează mesajul "Nu există niciun număr par."

1550 - DivFactorial

2023-04-13T13:50:26Z

Csatari Mălina: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/1550/divfactorial 1550 - DivFactorial] ---- == Cerinţa == Se da un vector cu '''n''' elemente. Sa se afișeze pe ecran elementele din vector care divid factorialul numărului de elemente '''n'''. == 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 introduse co...

Sursa: [https://www.pbinfo.ro/probleme/1550/divfactorial 1550 - DivFactorial]
----
== Cerinţa ==
Se da un vector cu '''n''' elemente. Sa se afișeze pe ecran elementele din vector care divid factorialul numărului de elemente '''n'''.
== 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 introduse corect."''', apoi pe un rând nou va afișa pe ecran elementele din vector care divid factorialul numărului de elemente n. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 12
* cele '''n''' numere citite vor fi mai mici decât '''1.000.000'''
* pentru toate testele va exista cel puțin un element al vectorului care divide '''n!'''

== Exemple ==
===Exemplul 1===
; Intrare
: 5
: 16 3 71 30 25
; Ieșire
: Datele sunt introduse corect.
: 3 30
===Explicație exemplul 1===
: Factorialul numărului de elemente '''n''' este '''120'''. Elementele din vector care îl divid pe '''120''' sunt '''3''' și '''30'''.
===Exemplul 2===
; Intrare
: 13
: 1 2 3 4 5 6 7 8 9 10 11 12 13
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1550 DivFactorial

def factorial(n):
if n == 0 or n == 1:
return 1
else:
return n * factorial(n-1)

def afis_elem_div_cu_n_factorial(vector):
factorial_n = factorial(n)
elemente_divizibile = []
for element in vector:
if factorial_n % element == 0:
elemente_divizibile.append(element)
print(' '.join(map(str, elemente_divizibile)))

def citire_conform_restrictiilor(n, vector):
if n < 1 or n > 12:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element >= 1000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
n = int(input())
vector = list(map(int, input().split()))
citire_conform_restrictiilor(n, vector)
afis_elem_div_cu_n_factorial(vector)

</syntaxhighlight>

== Explicație rezolvare ==
În blocul '''if __name__ == '__main__' ''': se efectuează citirea de la tastatură a valorilor pentru n și vector (liniile 34, 35), apoi se apelează funcția citire_conform_restrictiilor() pentru a verifica conformitatea datelor introduse cu restricțiile impuse. Apoi, se apelează funcția afis_elem_div_cu_n_factorial() pentru a calcula și afișa elementele din vector care divid factorialul numărului n citit. Funcția '''factorial(n)''' primește un argument n și calculează factorialul acestuia folosind o implementare recursivă. Dacă n este 0 sau 1, se returnează 1, altfel se returnează n multiplicat cu factorialul lui n-1. Aceasta este o implementare obișnuită a formulei matematice pentru factorial. Funcția '''afis_elem_div_cu_n_factorial(vector)''' primește ca argument un vector de numere și calculează factorialul numărului n citit anterior (presupus a fi definit global), apoi parcurge vectorul de numere și afișează elementele care divid acest factorial. Elementele care divid factorialul sunt adăugate într-o listă elemente_divizibile utilizând un loop for și operatorul de modulo % pentru a verifica dacă un număr este divizibil cu factorialul calculat. La final, lista de elemente este afișată utilizând funcția print(), metoda join() pentru a le separa prin spații și funcția map() pentru a le converti în string-uri. Funcția '''citire_conform_restrictiilor(n, vector)''' primește ca argumente n și vector și verifică dacă valorile acestora sunt conforme cu restricțiile impuse de problema. Dacă n nu se află în intervalul [1, 12], sau cel puțin un element din vector este mai mare sau egal cu 1.000.000, sau numărul de elemente din vector nu este egal cu n, atunci se afișează "Datele nu corespund restricțiilor impuse.". și se încheie execuția programului utilizând funcția exit(). Altfel, se afișează "Datele sunt introduse corect." și se continuă programul conform main-ului.

0248 - Pozitie

2023-04-13T13:33:08Z

Csatari Mălina: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/248/pozitie 0248 - Pozitie] ---- == Cerinţa == Se dă un şir cu '''n''' numere naturale distincte două câte două. Să se determine poziţia pe care s-ar afla primul element al şirului în şirul sortat. == Date de intrare == Fişierul de intrare '''pozitie.in''' conţine pe prima linie numărul '''n'''. Urmează '''n''' numere naturale, dispuse pe mai multe linii, separate prin spaţii. == Date de ieșire == Dacă datele sunt intr...

Sursa: [https://www.pbinfo.ro/probleme/248/pozitie 0248 - Pozitie]
----
== Cerinţa ==
Se dă un şir cu '''n''' numere naturale distincte două câte două. Să se determine poziţia pe care s-ar afla primul element al şirului în şirul sortat.
== Date de intrare ==
Fişierul de intrare '''pozitie.in''' conţine pe prima linie numărul '''n'''. Urmează '''n''' numere naturale, dispuse pe mai multe linii, separate prin spaţii.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi, fişierul de ieşire pozitie.out va conţine pe prima linie numărul p, reprezentând poziţia în şirul sortat a primului element din şirul dat. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''1 ≤ n ≤ 10000'''
* elementele şirului vor avea cel mult '''9''' cifre
* numerotarea elementelor se face de la '''1'''

== Exemple ==
===Exemplul 1===
; pozitie.in
: 6
: 267 13 45 628 7 79
; Ecran
: Datele sunt introduse corect.
; pozitie.out
: 5
===Exemplul 2===
; pozitie.in
: 5
: 5 3 2 4
; Ecran
: Datele nu corespund restricțiilor impuse.
 

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

def afisare_pozitia_prim_elem_daca_sortat(vector):
vector_sortat = sorted(vector)
pozitie = vector_sortat.index(vector[0]) + 1
with open('pozitie.out', 'w') as fisier_iesire:
fisier_iesire.write(str(pozitie) + "\n")

def citire_conform_restrictiilor(n, vector):
if n < 1 or n > 10000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element >= 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('pozitie.in', 'r') as fisier_intrare:
n = int(fisier_intrare.readline().strip())
vector = list(map(int, fisier_intrare.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
afisare_pozitia_prim_elem_daca_sortat(vector)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''afisare_pozitia_prim_elem_daca_sortat(vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 24) după citirea numărului n (linia 26) și celor n numere pe care le vom pune în șirul „vector” (linia 27), pe care le citim prin deschiderea fișierului pozitie.in (linia 25). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 1 și 10000 (linia 11), dacă elementele vectorului „vector” sunt mai mici decât 1000000000 (liniile 14, 15, elementele trebuie să fie aibă cel mult 9 cifre) și dacă n este lungimea vectorului „vector” (linia 18). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 21) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''afisare_pozitia_prim_elem_daca_sortat(vector)''' care primește ca parametrii numărul n și vectorul „vector”. Funcția sortează vectorul utilizând funcția implicită Python sorted() (linia 4), determină poziția primului element în șirul sortat utilizând metoda index() (tot metodă implicită Python, linia 5, 0 este poziția primului element în vectorul nostru, iar după ce aflăm indicele în vectorul sortat, îi adăugam 1 pentru a avea valoarea dacă vectorul începe de la 1), și apoi scrie rezultatul în fișierul de ieșire 'pozitie.out' utilizând funcția write().

0238 - Zone

2023-04-13T13:17:05Z

Csatari Mălina: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/238/zone 0238 - Zone] ---- == Cerinţa == Se dă un număr natural '''n''' şi un tablou unidimensional cu '''3*n''' elemente, numere naturale cu cel mult 4 cifre. Tabloul este împărţit în trei zone, cu câte n elemente: prima zonă conţine primele n elemente din tablou, a doua zonă conţine următoarele '''n''' elemente din tablou, restul elementelor fiind în zona a treia. Se cere interschimbarea primulul element par (dacă ex...

Sursa: [https://www.pbinfo.ro/probleme/238/zone 0238 - Zone]
----
== Cerinţa ==
Se dă un număr natural '''n''' şi un tablou unidimensional cu '''3*n''' elemente, numere naturale cu cel mult 4 cifre. Tabloul este împărţit în trei zone, cu câte n elemente: prima zonă conţine primele n elemente din tablou, a doua zonă conţine următoarele '''n''' elemente din tablou, restul elementelor fiind în zona a treia. Se cere interschimbarea primulul element par (dacă există) al zonei '''unu''' cu ultimul element impar (dacă există) al zonei '''trei'''. În cazul în care unul dintre elementele care urmează a fi interschimbate nu există, tabloul rămâne nemodificat.
== Date de intrare ==
Fişierul de intrare '''zone.in''' conţine pe prima linie numărul '''n''', iar pe a doua linie '''3*n''' numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi, fişierul de ieşire zone.out va conţine pe prima linie elementele tabloului, după interschimbarea cerută, separate prin exact un spaţiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''1 ≤ n ≤ 100'''
== Exemple ==
===Exemplul 1===
; zone.in
: 3
: 1 2 3 4 5 6 7 8 9
; Ecran
: Datele sunt introduse corect.
; zone.out
: 1 9 3 4 5 6 7 8 2
===Exemplul 2===
; zone.in
: 0
: 1 2 3
; Ecran
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0238 zone

def interschimba_elemente(n, vector):
primul_par = None
ultimul_impar = None
for i in range(n):
if vector[i] % 2 == 0 and primul_par is None:
primul_par = i
if vector[3 * n - 1 - i] % 2 != 0 and ultimul_impar is None:
ultimul_impar = 3 * n - 1 - i
if primul_par is not None and ultimul_impar is not None:
vector[primul_par], vector[ultimul_impar] = vector[ultimul_impar], vector[primul_par]
with open('zone.out', 'w') as fisier_iesire:
fisier_iesire.write(' '.join(map(str, vector)) + "\n")

def citire_conform_restrictiilor(n, vector):
if n < 1 or n > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
if 3 * n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('zone.in', 'r') as fisier_intrare:
n = int(fisier_intrare.readline().strip())
vector = list(map(int, fisier_intrare.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
interschimba_elemente(n, vector)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''interschimba_elemente(n, vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 27) după citirea numărului n (linia 29) și celor 3*n numere pe care le vom pune în șirul „vector” (linia 30), pe care le citim prin deschiderea fișierului maxsim.in (linia 28). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 1 și 100 (linia 18) și dacă n este de 3 ori lungimea vectorului „vector” (linia 21). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 24) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''interschimba_elemente(n, vector)''' care primește ca parametrii numărul n și vectorul „vector”. În interiorul funcției se inițializează două variabile, primul_par și ultimul_impar, cu None, reprezentând că nu s-au găsit încă un element par în zona 1 și respectiv un element impar în zona 3, apoi se parcurge tabloul unidimensional vector cu o buclă for de la 0 la n-1 utilizând range(n). Pentru fiecare element din vector, se verifică dacă este par (vector[i] % 2 == 0) și dacă primul_par este None. Dacă da, se actualizează valoarea lui primul_par cu indexul elementului curent. Apoi, pentru fiecare element din vector, se verifică dacă este impar (vector[3 * n - 1 - i] % 2 != 0) și dacă ultimul_impar este None. Dacă da, se actualizează valoarea lui ultimul_impar cu indexul elementului curent calculat ca 3 * n - 1 - i, pentru a corespunde zonei 3 a tabloului. Dacă s-au găsit atât un element par în zona 1, cât și un element impar în zona 3, se face interschimbarea lor în tablou folosind indexurile primul_par și ultimul_impar (linia 12). La final, rezultatul modificat (sau nemodificat dacă nu este cazul) al tabloului este scris în fișierul de ieșire 'zone.out' utilizând funcția write și metoda join pentru a transforma elementele tabloului într-un șir de caractere separate prin spațiu.

0237 - Sume

2023-04-13T12:55:02Z

Csatari Mălina: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/237/sume 0237 - Sume] ---- == Cerinţa == Se dă un şir cu '''n''' numere naturale. Să se afişeze suma primilor '''n''' termeni din şir, apoi suma primilor '''n-1''' termeni din şir, şi aşa mai departe. == Date de intrare == Fişierul de intrare '''sume.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 ecr...

Sursa: [https://www.pbinfo.ro/probleme/237/sume 0237 - Sume]
----
== Cerinţa ==
Se dă un şir cu '''n''' numere naturale. Să se afişeze suma primilor '''n''' termeni din şir, apoi suma primilor '''n-1''' termeni din şir, şi aşa mai departe.
== Date de intrare ==
Fişierul de intrare '''sume.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 introduse corect."''', apoi, fişierul de ieşire sume.out va conţine '''n''' linii, linia '''i''' conţinând suma primilor '''n-i+1''' termeni din şir. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''1 ≤ n ≤ 100'''
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât '''1000'''
== Exemple ==
===Exemplul 1===
; sume.in
: 4
: 1 7 3 4
; Ecran
: Datele sunt introduse corect.
; sume.out
: 15
: 11
: 8
: 1
===Exemplul 2===
; sume.in
: 5
: 1 7 3 4 1001
; Ecran
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0237 sume

def calculeaza_sumele(n, vector):
with open('sume.out', 'w') as fisier_iesire:
suma = sum(vector)
fisier_iesire.write(str(suma) + "\n")
for i in range(n-1, 0, -1):
suma -= vector[i]
fisier_iesire.write(str(suma) + "\n")

def citire_conform_restrictiilor(n, vector):
if n < 1 or n > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('sume.in', 'r') as fisier_intrare:
n = int(fisier_intrare.readline().strip())
vector = list(map(int, fisier_intrare.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
calculeaza_sumele(n, vector)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''calculeaza_sumele(n, vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 26) după citirea numărului n (linia 28) și celor n numere pe care le vom pune în șirul „vector” (linia 29), pe care le citim prin deschiderea fișierului sume.in (linia 27). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 1 și 100 (linia 13), dacă elementele vectorului „vector” sunt mai mici decât 1000 (liniile 16-17) și dacă n este lungimea vectorului „vector” (linia 20). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 23) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''calculeaza_sumele(n, vector)''' care primește ca parametrii numărul n și vectorul „vector”, apoi: -> se deschide fișierul de ieșire 'sume.out' în modul 'w' (write) folosind instrucțiunea with open('sume.out', 'w') as fisier_iesire; -> se calculează suma tuturor elementelor din vector folosind funcția built-in sum(vector) și se stochează în variabila suma; -> se scrie suma calculată pe prima linie a fișierului de ieșire utilizând metoda write() a obiectului fisier_iesire, convertind valoarea la tipul șir de caractere folosind str(suma), apoi se adaugă un caracter de linie nouă ("\n") pentru a trece la linia următoare; -> se parcurge șirul în ordine inversă, începând de la ultimul element până la primul element, utilizând bucla for i in range(n-1, 0, -1). Se folosește un pas negativ -1 pentru a parcurge în ordine inversă. În fiecare pas, se scade valoarea elementului curent din suma pentru a calcula suma primelor n-i+1 termeni din șir, unde i este indicele elementului curent și se scade valoarea elementului curent din suma pentru a calcula suma primelor n-i+1 termeni din șir, unde i este indicele elementului curent, apoi se scrie suma calculată în fiecare pas pe o linie separată în fișierul de ieșire utilizând metoda write() a obiectului fisier_iesire, convertind valoarea la tipul șir de caractere folosind str(suma), apoi se adaugă un caracter de linie nouă ("\n") pentru a trece la linia următoare.

0165 - maxsim

2023-04-13T12:32:22Z

Csatari Mălina: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/165/maxsim 0165 - maxsim] ---- == Cerinţa == Se dau '''n''' numere naturale reprezentând elementele unui vector. Să se determine perechea de elemente egal depărtate de centru pentru care suma valorilor este maximă. Dacă sunt mai multe perechi cu suma maximă se va determina perechea cea mai apropiată de capete. == Date de intrare == Fişierul de intrare '''maxsim.in''' conţine pe prima linie numărul '''n''', iar pe a doua linie...

Sursa: [https://www.pbinfo.ro/probleme/165/maxsim 0165 - maxsim]
----
== Cerinţa ==
Se dau '''n''' numere naturale reprezentând elementele unui vector. Să se determine perechea de elemente egal depărtate de centru pentru care suma valorilor este maximă. Dacă sunt mai multe perechi cu suma maximă se va determina perechea cea mai apropiată de capete.
== Date de intrare ==
Fişierul de intrare '''maxsim.in''' conţine pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spaţii, reprezentând elementele vectorului.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi, fişierul de ieşire maxsim.out va conţine pe prima linie trei numere '''S, i, j''', separate prin exact un spațiu, reprezentând suma maximă obținută și pozițiile elementelor din pereche. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''0''' < '''n''' ≤ '''1000'''
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât '''1.000.000.000'''
* elementele vectorului se consideră numerotate de la '''1'''
* '''1 ≤ i < j ≤ n'''
== Exemple ==
===Exemplul 1===
; maxsim.in
: 7
: 6 2 5 4 3 6 1
; Ecran
: Datele sunt introduse corect.
; maxsim.out
: 8 2 6
===Exemplul 2===
; elempp.in
: 5
: 5 3 2 4
; Ecran
: Datele nu corespund restricțiilor impuse.
 

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

def afis_perechea_elem_egal_departate_cu_sum_max(n, vector):
S = -1
i = -1
j = -1
for k in range(1, n // 2 + 1):
if vector[k - 1] + vector[n - k] > S:
S = vector[k - 1] + vector[n - k]
i = k
j = n - k + 1
with open('maxsim.out', 'w') as fisier_iesire:
fisier_iesire.write(str(S) + " " + str(i) + " " + str(j))

def citire_conform_restrictiilor(n, vector):
if n < 1 or n > 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element >= 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('maxsim.in', 'r') as fisier_intrare:
n = int(fisier_intrare.readline().strip())
vector = list(map(int, fisier_intrare.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
afis_perechea_elem_egal_departate_cu_sum_max(n, vector)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''afis_perechea_elem_egal_departate_cu_sum_max(n, vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 30) după citirea numărului n (linia 32) și celor n numere pe care le vom pune în șirul „vector” (linia 33), pe care le citim prin deschiderea fișierului maxsim.in (linia 35). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 0 și 1000 (linia 17), dacă elementele vectorului „vector” sunt mai mici decât 1000000000 (liniile 20-21) și dacă n este lungimea vectorului „vector” (linia 24). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 27) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''afis_perechea_elem_egal_departate_cu_sum_max(n, vector)''' care primește ca parametrii numărul n și vectorul „vector”. Mai exact, funcția parcurge vectorul vector de la început până la jumătate (folosind o buclă for care merge de la 1 până la n // 2 + 1, linia 7). Pentru fiecare pereche de elemente egal depărtate de centru, se calculează suma valorilor acestora (vector[k - 1] + vector[n - k]) și se compară cu valoarea maximă curentă (S). Dacă suma valorilor pentru o pereche de elemente este mai mare decât maximul curent (S), se actualizează suma maximă (S) și se rețin pozițiile elementelor în variabilele i și j. Aceste poziții reprezintă poziția elementului din stânga și poziția elementului din dreapta, în perechea de elemente cu suma maximă. La final, valorile maximului (S) și pozițiilor elementelor (i și j) sunt scrise în fișierul de ieșire "maxsim.out" folosind funcția write() a unui obiect de fișier deschis în modul de scriere ('w').

0132 - ElemPP

2023-04-13T12:28:18Z

Csatari Mălina: /* Explicație rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/132/elempp 0132 - ElemPP]
----
== Cerinţa ==
Se citeşte '''n''' şi un şir de '''n''' numere naturale. Să se afișeze elementele din șir care au proprietatea că primele două cifre din scrierea zecimală formează un pătrat perfect.
== Date de intrare ==
Fişierul de intrare '''elempp.in''' conţine pe prima linie numărul '''n''' şi 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 introduse corect."''', apoi, fişierul de ieşire elempp.out va conţine pe prima linie elementele din șirul dat care respectă proprietatea precizată (vezi cerință). Ordinea acestor elemente este cea în care se află în șirul dat. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''1''' &les; '''n''' &les; '''20'''
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât '''1.000.000.000''' și au cel puțin două cifre

== Exemple ==
===Exemplul 1===
; elempp.in
: 5
: 253 16 225 100 3678
; Ecran
: Datele sunt introduse corect.
; elempp.out
: 253 16 3678
===Exemplul 2===
; elempp.in
: 5
: 5 3 2 4 1
; Ecran
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0132 ElemPP

import math

def este_patrat_perfect(n):
radical_n = int(math.sqrt(n))
return radical_n * radical_n == n

def afisare_elem_primele_2_cifre_pp(vector):
rezultat = []
for numar in vector:
if este_patrat_perfect(int(str(numar)[:2])):
rezultat.append(str(numar))
with open('elempp.out', 'w') as fisier_iesire:
fisier_iesire.write(' '.join(rezultat))

def citire_conform_restrictiilor(n, vector):
if n < 1 or n >= 20:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element < 10 or element >= 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('elempp.in', 'r') as fisier_intrare:
n = int(fisier_intrare.readline().strip())
vector = list(map(int, fisier_intrare.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
afisare_elem_primele_2_cifre_pp(vector)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține trei funcții, funcția '''este_patrat_perfect(n)''', funcția '''afisare_elem_primele_2_cifre_pp(vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 34) după citirea numărului n (linia 36) și celor n numere pe care le vom pune în șirul „vector” (linia 37), pe care le citim prin deschiderea fișierului elempp.in (linia 35). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 1 și 20 (linia 21), dacă elementele vectorului „vector” sunt mai mici decât 1000000000, respectiv strict mai mari decât 10 (liniile 24-25, trebuie să fie strict mai mari decât 10 deoarece numerele trebuie să aibă cel puțin două cifre) și dacă n este lungimea vectorului „vector” (linia 28). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 31) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''afisare_elem_primele_2_cifre_pp(vector)''' care primește ca parametrii numărul n și vectorul „vector”, apoi: -> se inițializează o listă vidă rezultat care va conține elementele care respectă proprietatea cerută; -> parcurge fiecare număr din vector utilizând un ciclu for (linia 13); -> pentru fiecare număr numar din vector, extrage primele două cifre din scrierea zecimală a acestuia utilizând str(numar)[:2], care convertește numar într-un șir de caractere și apoi obține primele două caractere din acest șir; -> convertește cele două caractere extrase într-un număr întreg utilizând int(str(numar)[:2]); -> verifică dacă acest număr întreg este un pătrat perfect utilizând funcția '''este_patrat_perfect(n)''', care determină dacă radicalul pătrat al lui n (calculat cu math.sqrt(n), este necesar la începutul programului să importăm biblioteca math, linia 3) este un număr întreg. Dacă este un pătrat perfect, adaugă numar în lista rezultat; -> deschide fișierul de ieșire 'elempp.out' în modul de scriere ('w'); -> scrie elementele din lista rezultat separate prin spații în fișierul de ieșire utilizând metoda write() a obiectului fișier (fisier_iesire.write(' '.join(rezultat))), astfel încât ele să fie afișate în aceeași linie în fișierul de ieșire. Astfel, funcția '''afisare_elem_primele_2_cifre_pp(vector)''' identifică și scrie în fișierul de ieșire elementele din vectorul dat care au primele două cifre din scrierea zecimală care formează un pătrat perfect, în ordinea în care se află în vectorul de intrare.

0132 - ElemPP

2023-04-13T11:47:35Z

Csatari Mălina: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/132/elempp 0132 - ElemPP] ---- == Cerinţa == Se citeşte '''n''' şi un şir de '''n''' numere naturale. Să se afișeze elementele din șir care au proprietatea că primele două cifre din scrierea zecimală formează un pătrat perfect. == Date de intrare == Fişierul de intrare '''elempp.in''' conţine pe prima linie numărul '''n''' şi pe a doua linie '''n''' numere naturale separate prin spaţii. == Date de ieșire == Dacă datel...

Sursa: [https://www.pbinfo.ro/probleme/132/elempp 0132 - ElemPP]
----
== Cerinţa ==
Se citeşte '''n''' şi un şir de '''n''' numere naturale. Să se afișeze elementele din șir care au proprietatea că primele două cifre din scrierea zecimală formează un pătrat perfect.
== Date de intrare ==
Fişierul de intrare '''elempp.in''' conţine pe prima linie numărul '''n''' şi 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 introduse corect."''', apoi, fişierul de ieşire elempp.out va conţine pe prima linie elementele din șirul dat care respectă proprietatea precizată (vezi cerință). Ordinea acestor elemente este cea în care se află în șirul dat. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''1''' &les; '''n''' &les; '''20'''
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât '''1.000.000.000''' și au cel puțin două cifre

== Exemple ==
===Exemplul 1===
; elempp.in
: 5
: 253 16 225 100 3678
; Ecran
: Datele sunt introduse corect.
; elempp.out
: 253 16 3678
===Exemplul 2===
; elempp.in
: 5
: 5 3 2 4 1
; Ecran
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0132 ElemPP

import math

def este_patrat_perfect(n):
radical_n = int(math.sqrt(n))
return radical_n * radical_n == n

def afisare_elem_primele_2_cifre_pp(vector):
rezultat = []
for numar in vector:
if este_patrat_perfect(int(str(numar)[:2])):
rezultat.append(str(numar))
with open('elempp.out', 'w') as fisier_iesire:
fisier_iesire.write(' '.join(rezultat))

def citire_conform_restrictiilor(n, vector):
if n < 1 or n >= 20:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element < 10 or element >= 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('elempp.in', 'r') as fisier_intrare:
n = int(fisier_intrare.readline().strip())
vector = list(map(int, fisier_intrare.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
afisare_elem_primele_2_cifre_pp(vector)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține trei funcții, funcția '''este_patrat_perfect(n)''', funcția '''afisare_elem_primele_2_cifre_pp(vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 34) după citirea numărului n (linia 36) și celor n numere pe care le vom pune în șirul „vector” (linia 37), pe care le citim prin deschiderea fișierului maxim4.in (linia 35). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 1 și 20 (linia 21), dacă elementele vectorului „vector” sunt mai mici decât 1000000000, respectiv strict mai mari decât 10 (liniile 24-25, trebuie să fie strict mai mari decât 10 deoarece numerele trebuie să aibă cel puțin două cifre) și dacă n este lungimea vectorului „vector” (linia 28). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 31) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''afisare_elem_primele_2_cifre_pp(vector)''' care primește ca parametrii numărul n și vectorul „vector”, apoi: -> se inițializează o listă vidă rezultat care va conține elementele care respectă proprietatea cerută; -> parcurge fiecare număr din vector utilizând un ciclu for (linia 13); -> pentru fiecare număr numar din vector, extrage primele două cifre din scrierea zecimală a acestuia utilizând str(numar)[:2], care convertește numar într-un șir de caractere și apoi obține primele două caractere din acest șir; -> convertește cele două caractere extrase într-un număr întreg utilizând int(str(numar)[:2]); -> verifică dacă acest număr întreg este un pătrat perfect utilizând funcția '''este_patrat_perfect(n)''', care determină dacă radicalul pătrat al lui n (calculat cu math.sqrt(n), este necesar la începutul programului să importăm biblioteca math, linia 3) este un număr întreg. Dacă este un pătrat perfect, adaugă numar în lista rezultat; -> deschide fișierul de ieșire 'elempp.out' în modul de scriere ('w'); -> scrie elementele din lista rezultat separate prin spații în fișierul de ieșire utilizând metoda write() a obiectului fișier (fisier_iesire.write(' '.join(rezultat))), astfel încât ele să fie afișate în aceeași linie în fișierul de ieșire. Astfel, funcția '''afisare_elem_primele_2_cifre_pp(vector)''' identifică și scrie în fișierul de ieșire elementele din vectorul dat care au primele două cifre din scrierea zecimală care formează un pătrat perfect, în ordinea în care se află în vectorul de intrare.

0100 - NrApPrime

2023-04-13T11:25:12Z

Csatari Mălina: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/100/nrapprime 0100 - NrApPrime] ---- == Cerinţa == Se citeşte n şi un şir de n numere naturale. Să se determine câte elemente din şir sunt numere prime. == Date de intrare == Fişierul de intrare '''nrapprime.in''' conţine pe prima linie numărul '''n''' şi 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 introduse co...

Sursa: [https://www.pbinfo.ro/probleme/100/nrapprime 0100 - NrApPrime]
----
== Cerinţa ==
Se citeşte n şi un şir de n numere naturale. Să se determine câte elemente din şir sunt numere prime.
== Date de intrare ==
Fişierul de intrare '''nrapprime.in''' conţine pe prima linie numărul '''n''' şi 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 introduse corect."''', apoi, fişierul de ieşire nrapprime.out va conţine pe prima linie un singur număr natural, reprezentând numărul de elemente prime din şir. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''0''' < '''n''' < '''100'''
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât '''1.000.000.000'''

== Exemple ==
===Exemplul 1===
; nrapprime.in
: 5
: 25 17 2 10 13
; Ecran
: Datele sunt introduse corect.
; nrapprime.out
: 3
===Exemplul 2===
; nrapprime.in
: 5
: 5 3 2 4
; Ecran
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0100 NrApPrime

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

def numar_elemente_prime(vector):
nr_prime = 0
for numar in vector:
if e_prim(numar):
nr_prime += 1
return nr_prime

def citire_conform_restrictiilor(n, vector):
if n < 1 or n >= 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element >= 1000000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('nrapprime.in', 'r') as in_file:
n = int(in_file.readline().strip())
vector = list(map(int, in_file.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
nr_prime = numar_elemente_prime(vector)
with open('nrapprime.out', 'w') as out_file:
out_file.write(str(nr_prime))

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus începe în main (''' if __name__ == '__main__' ''', linia 34) unde se deschide fișierul de intrare 'nrapprime.in' pentru a citi valorile lui n și vector, apoi se apelează funcția '''citire_conform_restrictiilor()''' pentru a verifica restricțiile asupra datelor de intrare, se calculează numărul de elemente prime din vector folosind '''funcția numar_elemente_prime()''', și apoi se scrie rezultatul în fișierul de ieșire 'nrapprime.out' folosind funcția write(). Funcția '''citire_conform_restrictiilor(n, vector)''' verifică dacă datele de intrare (n și vector) corespund restricțiilor impuse de problemă. Se verifică dacă n este mai mic decât 1 sau mai mare sau egal cu 100, și dacă fiecare element din vector este mai mic decât 1.000.000.000. De asemenea, se verifică dacă n este egal cu lungimea vectorului vector. Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 31) și se va continua programul. Funcția '''e_prim(numar)''' verifică dacă un număr numar este prim. Dacă numar este mai mic sau egal cu 1, se returnează False, deoarece numerele prime sunt definite ca fiind mai mari decât 1. Apoi, se parcurge intervalul [2, sqrt(numar)] și se verifică dacă numar este divizibil cu vreun număr din acest interval. Dacă este divizibil, funcția returnează False, altfel returnează True. Funcția '''numar_elemente_prime(vector)''' primește un vector de numere întregi vector și calculează numărul de elemente prime din acest vector. Se inițializează un contor nr_prime cu valoarea 0 și se parcurge fiecare număr din vector. Pentru fiecare număr, se apelează funcția e_prim() pentru a verifica dacă este prim. Dacă este prim, se incrementează contorul nr_prime. La final, se returnează nr_prime.

0099 - NrAparitii

2023-04-13T11:07:15Z

Csatari Mălina: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/99/nraparitii 0099 - NrAparitii] ---- == Cerinţa == Se citeşte n şi un şir de n numere naturale. Să se determine câte elemente din şir sunt egale cu ultimul element al acestuia. == Date de intrare == Fişierul de intrare '''nraparitii.in''' conţine pe prima linie numărul '''n''' şi 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: ''...

Sursa: [https://www.pbinfo.ro/probleme/99/nraparitii 0099 - NrAparitii]
----
== Cerinţa ==
Se citeşte n şi un şir de n numere naturale. Să se determine câte elemente din şir sunt egale cu ultimul element al acestuia.
== Date de intrare ==
Fişierul de intrare '''nraparitii.in''' conţine pe prima linie numărul '''n''' şi 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 introduse corect."''', apoi, fişierul de ieşire nraparitii.out va conţine pe prima linie un singur număr natural, reprezentând numărul de elemente din şir care sunt egale cu ultimul element. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''0''' < '''n''' < '''100'''
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât '''1000'''

== Exemple ==
===Exemplul 1===
; nraparitii.in
: 5
: 5 3 2 4 5
; Ecran
: Datele sunt introduse corect.
; nraparitii.out
: 2
===Exemplul 2===
; nraparitii.in
: 5
: 5 3 2 4 1001
; Ecran
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0099 NrAparitii

def numar_aparitii(vector):
ultimul_element = vector[-1]
nr_aparitii = vector.count(ultimul_element)
return nr_aparitii

def citire_conform_restrictiilor(n, vector):
if n < 1 or n >= 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('nraparitii.in', 'r') as in_file:
n = int(in_file.readline().strip())
vector = list(map(int, in_file.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
nr_aparitii = numar_aparitii(vector)
with open('nraparitii.out', 'w') as out_file:
out_file.write(str(nr_aparitii))

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''numar_aparitii(vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 23) după citirea numărului n (linia 25) și celor n numere pe care le vom pune în șirul „vector” (linia 26), pe care le citim prin deschiderea fișierului maxim4.in (linia 24). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 0 și 100 (linia 10), dacă elementele vectorului „vector” sunt mai mici decât 1000 (liniile 13-14) și dacă n este lungimea vectorului „vector” (linia 17). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 20) și se va continua programul. Dacă s-au introdus corect datele, se va continua în main ( '''if __name__ == '__main__' ''') și se va inițializa variabila nr_aparitii care va avea valoarea returnată de funcția '''numar_aparitii(vector)'''. Funcția '''numar_aparitii(vector)''' are o variabilă numită „ultim_element” care va corespunde valorii ultimului element din șir (linia 4), iar apoi numărăm aparițiile acestei valori cu ajutorul metodei „count()” și punem această valoare în variabila nr_aparitii, pe care o returnăm. Apoi, în continuarea main-ului ( '''if __name__ == '__main__' ''') deschidem nraparitii.out în modul de scriere ("w") utilizând contextul "with open()" pentru a se asigura că fișierul este închis corect la finalul execuției și se scrie numărul „nr_aparitii” utilizând metoda "write()". Valoarea este scrisă într-un format specific folosind interpolarea de șiruri f"{}" pentru a înlocui „nr_aparitii” în șir de caractere.

0082 - MinMax

2023-04-13T10:55:59Z

Csatari Mălina: /* Exemple */

Sursa: [https://www.pbinfo.ro/probleme/82/minmax 0082 - MinMax]
----
== Cerinţa ==
Se citește n, apoi încă n numere întregi. Calculaţi valoarea minima minim si valoarea maxima maxim a celor n numere date.
== Date de intrare ==
Fişierul de intrare '''minmax.in''' conţine pe prima linie numărul '''n''' si 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 introduse corect.", apoi, în fişierul de ieşire minmax.out va conţine pe prima linie două numere minim şi maxim, separate printr-un singur spaţiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
* '''0''' < '''n''' < '''1000'''
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât '''1000000'''

== Exemple ==
===Exemplul 1===
; minmax.in
: 5
: 8 2 9 4 5
; Ecran
: Datele sunt introduse corect.
; minmax.out
: 2 9
===Exemplul 2===
; minmax.in
: 5
: 8 2 9 4
; Ecran
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0082 MinMax

def afisare_min_max(n, vector):
maxim = max(vector)
minim = min(vector)
with open('minmax.out', 'w') as out_file:
out_file.write(f"{minim} {maxim}")

def citire_conform_restrictiilor(n, vector):
if n < 1 or n >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element >= 1000000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('minmax.in', 'r') as in_file:
n = int(in_file.readline().strip())
vector = list(map(int, in_file.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
afisare_min_max(n, vector)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''afisare_min_max(n, vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 24) după citirea numărului n (linia 26) și celor n numere pe care le vom pune în șirul „vector” (linia 27), pe care le citim prin deschiderea fișierului minmax.in (linia 25). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 0 și 1000 (linia 11), dacă elementele vectorului „vector” sunt mai mici decât 1000000 (liniile 14-15) și dacă n este lungimea vectorului „vector” (linia 18). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 21) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''afisare_min_max(n, vector)''' care primește ca parametrii numărul n și vectorul „vector”. Funcția calculează valoarea minimă și maximă din „vector” utilizând funcțiile predefinite din Python „min()” și „max()”. Aceste funcții returnează, respectiv, cel mai mic și cel mai mare element dintr-o listă (liniile 4, 5). Apoi, funcția deschide fișierul "minmax.out" în modul de scriere ('w') utilizând contextul "with open()" pentru a se asigura că fișierul este închis corect la finalul execuției (linia 6). Funcția scrie valorile minimă și maximală în fișierul de ieșire utilizând metoda "write()" a obiectului de fișier. Valorile sunt scrise într-un format specific folosind interpolarea de șiruri f"{}" pentru a înlocui variabilele „minim” și „maxim” în șirul de caractere.

0098 - Maxim4

2023-04-13T10:55:18Z

Csatari Mălina: /* Exemple */

Sursa: [https://www.pbinfo.ro/probleme/98/maxim4 0098 - Maxim4]
----
== Cerinţa ==
Se citeşte n şi un şir de n numere naturale. Calculaţi valoarea maxima maxim a celor n numere date şi numărul nrmax de apariţii ale acestei valori în şir.
== Date de intrare ==
Fişierul de intrare '''maxim4.in''' conţine pe prima linie numărul '''n''' şi 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 introduse corect."''', apoi, fişierul de ieşire maxim4.out va conţine pe prima linie două numere '''maxim''' şi '''nrmax''', separate printr-un singur spaţiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''0''' < '''n''' < '''100'''
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât '''1000'''

== Exemple ==
===Exemplul 1===
; maxim4.in
: 5
: 5 3 2 4 5
; Ecran
: Datele sunt introduse corect.
; maxim4.out
: 5 2
===Exemplul 2===
; maxim4.in
: 5
: 5 3 2 4 1001
; Ecran
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0098 Maxim4

def afis_max_si_nr_aparitii_max(n, vector):
maxim = max(vector)
nrmax = vector.count(maxim)
with open('maxim4.out', 'w') as out_file:
out_file.write(f"{maxim} {nrmax}")

def citire_conform_restrictiilor(n, vector):
if n < 1 or n >= 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('maxim4.in', 'r') as in_file:
n = int(in_file.readline().strip())
vector = list(map(int, in_file.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
afis_max_si_nr_aparitii_max(n, vector)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''afis_max_si_nr_aparitii_max(n, vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 24) după citirea numărului n (linia 26) și celor n numere pe care le vom pune în șirul „vector” (linia 27), pe care le citim prin deschiderea fișierului maxim4.in (linia 25). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 0 și 100 (linia 11), dacă elementele vectorului „vector” sunt mai mici decât 1000 (liniile 14-15) și dacă n este lungimea vectorului „vector” (linia 18). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 21) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''afis_max_si_nr_aparitii_max(n, vector)''' care primește ca parametrii numărul n și vectorul „vector”, apoi: -> se calculează valoarea maximă din lista „vector” utilizând funcția predefinită din Python „max()” și se pune în variabila „maxim” (linia 4); -> se numără de câte ori apare valoarea maximă „maxim” în lista „vector” utilizând metoda „count()” a listei; -> se deschide fișierul de ieșire "maxim4.out" în modul de scriere ("w") utilizând contextul "with open()" pentru a se asigura că fișierul este închis corect la finalul execuției și se scrie valoarea maximă „maxim” și numărul de apariții ale acesteia „nrmax” în fișierul de ieșire utilizând metoda "write()". Valorile sunt scrise într-un format specific folosind interpolarea de șiruri f"{}" pentru a înlocui variabilele „maxim” și „nrmax” în șirul de caractere.

0098 - Maxim4

2023-04-13T10:53:44Z

Csatari Mălina:

Sursa: [https://www.pbinfo.ro/probleme/98/maxim4 0098 - Maxim4]
----
== Cerinţa ==
Se citeşte n şi un şir de n numere naturale. Calculaţi valoarea maxima maxim a celor n numere date şi numărul nrmax de apariţii ale acestei valori în şir.
== Date de intrare ==
Fişierul de intrare '''maxim4.in''' conţine pe prima linie numărul '''n''' şi 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 introduse corect."''', apoi, fişierul de ieşire maxim4.out va conţine pe prima linie două numere '''maxim''' şi '''nrmax''', separate printr-un singur spaţiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''0''' < '''n''' < '''100'''
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât '''1000'''

== Exemple ==
===Exemplul 1===
; maxim4.in
: 5
: 5 3 2 4 5
; Ieșire
: Datele sunt introduse corect.
; maxim4.out
: 5 2
===Exemplul 2===
; Intrare
: 5
: 5 3 2 4 1001
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0098 Maxim4

def afis_max_si_nr_aparitii_max(n, vector):
maxim = max(vector)
nrmax = vector.count(maxim)
with open('maxim4.out', 'w') as out_file:
out_file.write(f"{maxim} {nrmax}")

def citire_conform_restrictiilor(n, vector):
if n < 1 or n >= 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('maxim4.in', 'r') as in_file:
n = int(in_file.readline().strip())
vector = list(map(int, in_file.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
afis_max_si_nr_aparitii_max(n, vector)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''afis_max_si_nr_aparitii_max(n, vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 24) după citirea numărului n (linia 26) și celor n numere pe care le vom pune în șirul „vector” (linia 27), pe care le citim prin deschiderea fișierului maxim4.in (linia 25). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 0 și 100 (linia 11), dacă elementele vectorului „vector” sunt mai mici decât 1000 (liniile 14-15) și dacă n este lungimea vectorului „vector” (linia 18). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 21) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''afis_max_si_nr_aparitii_max(n, vector)''' care primește ca parametrii numărul n și vectorul „vector”, apoi: -> se calculează valoarea maximă din lista „vector” utilizând funcția predefinită din Python „max()” și se pune în variabila „maxim” (linia 4); -> se numără de câte ori apare valoarea maximă „maxim” în lista „vector” utilizând metoda „count()” a listei; -> se deschide fișierul de ieșire "maxim4.out" în modul de scriere ("w") utilizând contextul "with open()" pentru a se asigura că fișierul este închis corect la finalul execuției și se scrie valoarea maximă „maxim” și numărul de apariții ale acesteia „nrmax” în fișierul de ieșire utilizând metoda "write()". Valorile sunt scrise într-un format specific folosind interpolarea de șiruri f"{}" pentru a înlocui variabilele „maxim” și „nrmax” în șirul de caractere.

0098 - Maxim4

2023-04-13T10:47:46Z

Csatari Mălina: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/98/maxim4 0098 - Maxim4] ---- == Cerinţa == Se citeşte n şi un şir de n numere naturale. Calculaţi valoarea maxima maxim a celor n numere date şi numărul nrmax de apariţii ale acestei valori în şir. == Date de intrare == Fişierul de intrare '''maxim4.in''' conţine pe prima linie numărul '''n''' şi pe a doua linie '''n''' numere naturale separate prin spaţii. == Date de ieșire == Dacă datele sunt introduse corect, pe ecr...

Sursa: [https://www.pbinfo.ro/probleme/98/maxim4 0098 - Maxim4]
----
== Cerinţa ==
Se citeşte n şi un şir de n numere naturale. Calculaţi valoarea maxima maxim a celor n numere date şi numărul nrmax de apariţii ale acestei valori în şir.
== Date de intrare ==
Fişierul de intrare '''maxim4.in''' conţine pe prima linie numărul '''n''' şi 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 introduse corect."''', apoi, fişierul de ieşire maxim4.out va conţine pe prima linie două numere '''maxim''' şi '''nrmax''', separate printr-un singur spaţiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."''''.

== Restricţii şi precizări ==
* '''0''' < '''n''' < '''100'''
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât '''1000'''

== Exemple ==
===Exemplul 1===
; minmax.in
: 5
: 5 3 2 4 5
; Ieșire
: Datele sunt introduse corect.
; minmax.out
: 5 2
===Exemplul 2===
; Intrare
: 5
: 5 3 2 4 1001
; Ieșire
: Datele nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0098 Maxim4

def afis_max_si_nr_aparitii_max(n, vector):
maxim = max(vector)
nrmax = vector.count(maxim)
with open('maxim4.out', 'w') as out_file:
out_file.write(f"{maxim} {nrmax}")

def citire_conform_restrictiilor(n, vector):
if n < 1 or n >= 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for element in vector:
if element >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
if n != len(vector):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")

if __name__ == '__main__':
with open('maxim4.in', 'r') as in_file:
n = int(in_file.readline().strip())
vector = list(map(int, in_file.readline().strip().split()))
citire_conform_restrictiilor(n, vector)
afis_max_si_nr_aparitii_max(n, vector)

</syntaxhighlight>

== Explicație rezolvare ==
Programul de mai sus conține două funcții, funcția '''afis_max_si_nr_aparitii_max(n, vector)''' și funcția '''citire_conform_restrictiilor(n, vector)''', care se vor rula în interiorul main-ului ('''if __name__ == '__main__' ''', linia 24) după citirea numărului n (linia 26) și celor n numere pe care le vom pune în șirul „vector” (linia 27), pe care le citim prin deschiderea fișierului maxim4.in (linia 25). După ce am citit toate datele de intrare, se va apela funcția '''citire_conform_restrictiilor(n, vector)''' care primește doi parametri: n și vector. Funcția verifică n între 0 și 100 (linia 11), dacă elementele vectorului „vector” sunt mai mici decât 1000 (liniile 14-15) și dacă n este lungimea vectorului „vector” (linia 18). Dacă oricare dintre condiții este încălcată, se va afișa pe ecran mesajul „Datele nu corespund restricțiilor impuse.” și se va ieși din program cu comanda exit(). Dacă toate condițiile sunt respectate, se va afișa mesajul „Datele sunt introduse corect.” (linia 21) și se va continua programul. Dacă s-au introdus corect datele, se va apela funcția '''afis_max_si_nr_aparitii_max(n, vector)''' care primește ca parametrii numărul n și vectorul „vector”, apoi: -> se calculează valoarea maximă din lista „vector” utilizând funcția predefinită din Python „max()” și se pune în variabila „maxim” (linia 4); -> se numără de câte ori apare valoarea maximă „maxim” în lista „vector” utilizând metoda „count()” a listei; -> se deschide fișierul de ieșire "maxim4.out" în modul de scriere ("w") utilizând contextul "with open()" pentru a se asigura că fișierul este închis corect la finalul execuției și se scrie valoarea maximă „maxim” și numărul de apariții ale acesteia „nrmax” în fișierul de ieșire utilizând metoda "write()". Valorile sunt scrise într-un format specific folosind interpolarea de șiruri f"{}" pentru a înlocui variabilele „maxim” și „nrmax” în șirul de caractere.