Bitnami MediaWiki - User contributions [en]

2405 - politic

2023-05-14T22:42:24Z

Monica Dragos:

Sursa: [https://www.pbinfo.ro/probleme/304/secvente 2405 - politic]
----

== Cerinţa ==
În Țara lui Papură Vodă s-au organizat de curând primele alegeri democratice. A rezultat astfel un parlament din care fac parte deputați cu diverse doctrine politice, de stânga sau de dreapta. Acestea sunt descrise prin numere naturale nenule (orientarea politică este cu atât mai de stânga cu cât numărul este mai mic). Parlamentarii s-au asociat în partide politice în funcție de doctrina fiecăruia. Oricare doi deputați ale căror doctrine corespund unor numere consecutive fac parte din același partid. Prin urmare, partidele vor fi alcătuite din deputați ale căror doctrine sunt numere consecutive. (De exemplu, dacă parlamentul are 5 deputați, cu doctrinele 1, 2, 3, 5 şi 6, atunci înseamnă că aceștia sunt grupați în două partide: unul format din 1, 2 și 3 și altul din 5 și 6.)
Un guvern trebuie să beneficieze de susținerea a mai mult de jumătate dintre parlamentari. De exemplu, dacă parlamentul este format din 7 deputați, atunci un guvern are nevoie de susținerea a cel puțin 4 deputați.
Pentru a putea guverna, partidele se pot grupa in coaliţii. Regula după care se asociază este urmatoarea: două partide A şi B, A având o doctrină mai de stânga, pot face parte din aceeași coaliţie doar dacă din coaliţia respectivă fac parte toate partidele a căror doctrină este mai de dreapta decât cea a lui A şi mai de stânga decât cea a lui B. De exemplu, dacă parlamentul este alcătuit din deputaţi cu orientările politice 1, 2, 4, 5, 7 şi 8, atunci partidul format din 1 şi 2 nu se poate asocia cu partidul format din 7 şi 8 decât dacă din coaliţia respectivă face parte şi partidul format din 4 şi 5.
Fiind dat parlamentul din Ţara lui Papură Vodă printr-un şir ordonat strict crescător de numere naturale nenule, se cere să se stabilească numărul de partide parlamentare şi numărul variantelor de coaliţie majoritară.

== Date de intrare ==
Fișierul de intrare politic.in conține pe prima linie un număr natural nenul N, reprezentând numărul de deputați din parlament. Pe a doua linie se află N numere naturale nenule separate prin câte un spațiu, ordonate strict crescător, reprezentând doctrinele parlamentarilor.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', fișierul de ieșire politic.out conține prima linie numărul C, reprezentând numărul de secvenţe cu elementele ordonate crescător din şirul dat''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 0 < N ≤ 20.000
* numerele din șir sunt mai mici sau egale cu 30.000
== Exemplu 1 ==
; Intrare
: politic.in
: 10
: 1 2 3 5 6 8 10 11 14 15
; Ieșire
: Datele sunt introduse correct.
: politic.out
: 5
: 4

== Exemplu 2 ==
; Intrare
: politic.in
: 20
: 0 7 8 9 1 2 3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 2405 - politic

def validate_input(n, arr):
if n <= 0 or n > 20000:
return False
if any(x <= 0 or x > 30000 for x in arr):
return False
return True

def count_sequences(arr):
cnt = 1
max_cnt = 1
for i in range(1, len(arr)):
if arr[i] > arr[i-1]:
cnt += 1
if cnt > max_cnt:
max_cnt = cnt
else:
cnt = 1
return max_cnt

def count_coalitions(arr):
cnt = 0
for i in range(len(arr)):
for j in range(i+1, len(arr)):
diff = abs(arr[i] - arr[j])
if diff == 1:
break
else:
for k in range(i+1, j):
if abs(arr[k] - arr[i]) > diff and abs(arr[k] - arr[j]) > diff:
continue
else:
break
else:
cnt += 1
return cnt

if __name__ == "__main__":
n = int(input())
arr = list(map(int, input().split()))
if validate_input(n, arr):
print("Datele sunt introduse corect.")
print(count_sequences(arr))
print(count_coalitions(arr))
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(n, arr) verifică dacă numărul n este între 1 și 20000 și dacă fiecare element din array-ul arr este între 1 și 30000. Dacă datele nu corespund acestor restricții, funcția returnează False, altfel returnează True.

Funcția count_sequences(arr) numără cel mai lung șir crescător de elemente consecutive din array-ul arr. Inițial, variabila cnt este setată la 1, pentru că fiecare element din array poate fi considerat un șir crescător de lungime 1. Apoi, se parcurge array-ul și se verifică dacă elementul curent este mai mare decât cel anterior. Dacă da, se crește numărul de elemente din șirul crescător curent, și se actualizează max_cnt dacă valoarea lui cnt este mai mare. Dacă elementul curent este mai mic sau egal decât cel anterior, se resetează cnt la 1. La final, funcția returnează max_cnt, lungimea maximă a unui șir crescător de elemente consecutive.

Funcția count_coalitions(arr) numără numărul de sub-șiruri neadiacente din array-ul arr care au diferența maximă între cel mai mare și cel mai mic element mai mică sau egală cu 1. Funcția parcurge fiecare pereche de elemente din array, calculează diferența dintre ele și verifică dacă aceasta este mai mare sau egală cu 2. Dacă da, atunci verifică dacă există vreun alt element între cele două care să aibă o diferență mai mică sau egală cu cea dintre cele două. Dacă există un astfel de element, atunci sub-șirul nu este valid și se trece la următoarea pereche de elemente. Dacă nu există un astfel de element, atunci sub-șirul este valid și se crește numărul de sub-șiruri găsite. La final, funcția returnează numărul de sub-șiruri valide găsite.

Funcția __main__ primește datele de intrare și le validează folosind funcția validate_input. Dacă datele sunt valide, afișează un mesaj de confirmare și calculează valorile cerute folosind funcțiile count_sequences și count_coalitions. Dacă datele nu sunt valide, afișează un mesaj de eroare.

3846 - KSum2

2023-05-14T22:41:04Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3846/ksum2 3846 - KSum2]
----
== Cerinţa ==
După ce Ionuț a învățat despre algoritmul lui Kadane își pune următoarea întrebare: se dă N, K și W apoi un vector cu N elemente, din acest vector care este suma maximă a unei secvențe (elemente adiacente) de lungime cel puțin K și cel mult W. A zis să vă întrebe pe voi cum se face.

== Date de intrare ==
Fișierul de intrare ksum2.in conține pe prima linie numerele N, K și W, pe următoarea linie N elemente întregi reprezentând elementele vectorului.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' fișierul de ieșire ksum2.out va conține pe prima linie numărul S, reprezentând suma maximă a unei secvențe (elemente adiacente) din vector de lungime cel puțin K și cel mult W''', 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 ≤ n ≤ 1000
* elementele şirului vor avea cel mult 4 cifre
* o secvență cu elemente ordonate crescător este maximală dacă adăugând la secvență încă un element ea nu mai are elementele ordonate crescător
== Exemplu 1 ==
; Intrare
: ksum2.in
: 8
: 12 10 15 17 17
: 10 12 14
; Ieșire
: Datele sunt introduse correct.
: ksum2.out
: 3

== Exemplu 1 ==
; Intrare
: ksum2.in
: 8
: 1 2 3 4 5 6
: -0,12 123 0 1 -2 -3 1,23
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3846 - KSum2

def validate_input(N, K, W, arr):
# Verificăm dacă N, K și W respectă restricțiile
if not 1 <= N <= 1000 or not 1 <= K <= N or not K <= W <= N:
return False

# Verificăm dacă elementele din vector respectă restricțiile
for x in arr:
if not -9999 <= x <= 9999:
return False

return True

def max_sequence_sum(arr, K, W):
# Inițializăm variabilele necesare pentru calculul sumei maxime
max_sum = -float('inf')
cur_sum = 0
start = end = 0

# Parcurgem vectorul și calculăm suma maximă
for i in range(len(arr)):
# Adăugăm elementul curent la suma curentă
cur_sum += arr[i]

# Dacă secvența devine prea lungă, scădem primul element din ea
if i >= K:
cur_sum -= arr[i-K]

# Dacă secvența este suficient de lungă, verificăm dacă suma ei este maximă
if i >= W-1:
if cur_sum > max_sum:
max_sum = cur_sum
start = i-W+1
end = i

# Dacă suma curentă devine negativă, o resetăm la 0 și mutăm începutul secvenței
if cur_sum < 0:
cur_sum = 0

return max_sum

if __name__ == '__main__':
# Citim datele de intrare
N, K, W = map(int, input().split())
arr = list(map(int, input().split()))

# Verificăm dacă datele de intrare sunt corecte
if not validate_input(N, K, W, arr):
print('Datele nu corespund restricțiilor impuse.')
else:
# Calculăm suma maximă și o afișăm
max_sum = max_sequence_sum(arr, K, W)
print(max_sum)

</syntaxhighlight>
== Explicatie Rezolvare ==

Funcția validate_input primește patru argumente: N, K, W și arr. Această funcție validează datele de intrare pentru a se asigura că ele respectă restricțiile impuse în enunțul problemei. Mai exact, verifică dacă N, K și W se încadrează în intervalul specificat, iar elementele din vectorul arr sunt numere întregi de cel mult patru cifre. Funcția returnează True dacă datele de intrare sunt corecte și False în caz contrar.

Funcția max_sequence_sum primește trei argumente: arr, K și W. Această funcție calculează suma maximă a unei secvențe (elemente adiacente) din vectorul dat, de lungime cel puțin K și cel mult W. Pentru a realiza aceasta, parcurge vectorul dat și calculează suma tuturor secvențelor de lungime între K și W. În timpul parcurgerii, menține suma curentă și, dacă aceasta devine negativă, o resetează la 0 și mută începutul secvenței. Dacă suma curentă depășește maximul anterior, aceasta devine noua sumă maximă. Funcția returnează suma maximă calculată.

În blocul de cod if __name__ == '__main__', se citesc datele de intrare și se apelează funcția validate_input pentru a verifica dacă datele sunt introduse corect. Dacă datele sunt introduse corect, se calculează suma maximă folosind funcția max_sequence_sum și se afișează rezultatul. În caz contrar, se afișează un mesaj de eroare.

3844 - KSum

2023-05-14T22:40:16Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3844/ksum 3844 - KSum]
----
== Cerinţa ==
După ce Ionuț a învățat despre algoritmul lui Kadane își pune următoarea întrebare: se dă N și K apoi un vector cu N elemente, din acest vector care este suma maximă a unei secvențe (elemente adiacente) de lungime cel puțin K. A zis să vă întrebe pe voi cum se face.

== Date de intrare ==
Fișierul de intrare ksum.in conține pe prima linie numerele N și K, pe următoarea linie N elemente întregi reprezentând elementele vectorului.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' fișierul ksum.out va conține pe prima linie numărul S, reprezentând suma maximă a unei secvențe (elemente adiacente) din vector de lungime cel puțin K''', 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 ≤ K <= W <= n ≤ 100.000
* numerele de pe a doua linie a fișierului de intrare vor fi din intervalul [-1.000, 1.000].
== Exemplu 1 ==
; Intrare
: ksum.in
: 6 3 4
: 5 4 -10 1 2 3
; Ieșire
: Datele sunt introduse correct.
: ksum.out
: 6

== Exemplu 2 ==
; Intrare
: ksum.in
: 6 3 4
: 2,34 -2 -3 -1 0 99 100
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3844 - KSum

def validare_date(n, k, w):
return 1 <= k <= w <= n <= 100000

def k_sum(n, k, w, numere):
if not validare_date(n, k, w):
print("Datele nu corespund restricțiilor impuse.")
return

print("Datele sunt introduse corect.")

# caz particular - vectorul este deja de lungime cel putin k
if n >= k:
max_sum = sum(numere[:k])
else:
max_sum = sum(numere)

current_sum = max_sum

# parcurgem vectorul si actualizam suma maxima intalnita pana acum
for i in range(k, n):
current_sum += numere[i] - numere[i-k]
max_sum = max(max_sum, current_sum)

with open('ksum.out', 'w') as f:
f.write(str(max_sum))

if __name__ == "__main__":
with open('ksum.in', 'r') as f:
n, k, w = map(int, f.readline().split())
numere = list(map(int, f.readline().split()))

k_sum(n, k, w, numere)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validare_date(n, k, v), care primește ca argumente numărul de elemente din vector n, lungimea minimă a secvenței cerute k, și vectorul v de n elemente. Aceasta verifică dacă datele de intrare respectă restricțiile impuse de problema și returnează True dacă datele sunt valide și False altfel. Verificarea se face astfel:

Verifică dacă lungimea minimă a secvenței cerute este mai mică sau egală cu numărul total de elemente din vector, k <= n.
Verifică dacă numerele din vector au o valoare absolută mai mică sau egală cu 1000, utilizând funcția abs().
Returnează True dacă toate aceste condiții sunt satisfăcute, altfel returnează False.
Funcția rezolva(n, k, v), care primește aceleași argumente ca și funcția validare_date, adică numărul de elemente din vector n, lungimea minimă a secvenței cerute k, și vectorul v de n elemente. Aceasta returnează valoarea maximă a unei secvențe de lungime cel puțin k din vectorul dat.

Algoritmul utilizat pentru a găsi această valoare este următorul:

Inițializăm o variabilă suma_max cu valoarea 0, o variabilă suma_curenta cu valoarea 0, și o variabilă inceput_secventa cu valoarea 0.
Parcurgem elementele vectorului v folosind un iterator i.
Adunăm elementul v[i] la suma curentă a secvenței, suma_curenta.
Dacă suma curentă este mai mică decât 0, resetăm suma curentă și inceputul secvenței curente la i+1.
Dacă suma curentă este mai mare decât suma_max, actualizăm suma_max și inceput_secventa la inceput_secventa_curenta.
La final, returnăm suma_max.
Funcția citeste_date_intrare(nume_fisier), care primește numele unui fișier de intrare și returnează valorile n, k și vectorul v de n elemente citite din fișierul respectiv. Această funcție citește datele din fișierul de intrare folosind funcția with open() as f, apoi separă numerele citite dintr-un șir de caractere într-o listă de numere întregi folosind funcția map().

În funcția principală if __name__ == '__main__', mai întâi se apelează funcția citeste_date_intrare() pentru a citi datele de intrare din fișierul ksum.in.

1804 - ursulet

2023-05-14T22:39:52Z

Monica Dragos:

Sursa: [https://www.pbinfo.ro/probleme/1804/ursulet 1804 - ursulet]
----

== Cerinţa ==
Ursuleţul Grizzlyuță a plecat la drum prin Ţara Ursuleţilor. El are de parcurs zone de diferite altitudini, care sunt numere întregi. Atunci când trece dintr-o zonă în alta oboseala ursuleţului creşte cu o valoare egală cu altitudinea zonei în care trece. Pentru că drumul este prea lung, şi-a chemat prietena, pe domnişoara Lupita, pentru a îl ajuta. Aceasta i-a promis că îl va transporta cu maşina ei de-a lungul zonelor în care acesta acumulează oboseală maximă.
Să se determine zonele în care Lupita îl transportă pe ursuleţul Grizzlyuță.

== Date de intrare ==
Fișierul de intrare ursulet.in conține pe prima linie numărul N, ce semnifică numărul de zone traversate de ursuleţ. Pe linia următoare se află N numere întregi, altitudinile zonelor.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' fișierul de ieșire ursulet.out va conține pe prima linie un număr întreg ce semnifică oboseală maximă acumulată de ursuleţ pe o porţiune de zone consecutive. Pe a doua linie se află două numere, indicii primei şi ultimei zone din drumul parcurs de Lupita şi Grizzlyuță''', 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 ≤ n ≤ 100.000
* -1000 ≤ a ≤ 1000, a fiind altitudinea unei zone
* Dacă există mai multe subsecvenţe candidate la soluţie, atunci se va tipări cea cu indicele de început cel mai mic, iar în caz de egalitate, cea mai scurtă.ă cu elemente ordonate crescător este maximală dacă adăugând la secvență încă un element ea nu mai are elementele ordonate crescător
== Exemplu 1 ==
; Intrare
: ursulet.in
: 6
: -5 0 3 1 -4 2
; Ieșire
: Datele sunt introduse correct.
: ursulet.out
: 4
: 2 4

== Exemplu 2 ==
; Intrare
: ursulet.in
: 6
: 0.23 0 1 1 4.76 -1 -2
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 1804 - ursulet

def validare_altitudini(altitudini):
for altitudine in altitudini:
if not (-1000 <= altitudine <= 1000):
return False
return True

def obos_max(altitudini):
suma_oboseala = 0
obos_maxim = 0
inceput = 0
sfarsit = 0
index = 0

for i in range(len(altitudini)):
suma_oboseala += altitudini[i]

if suma_oboseala < 0:
suma_oboseala = 0
index = i + 1
elif suma_oboseala > obos_maxim:
obos_maxim = suma_oboseala
inceput = index
sfarsit = i

return (obos_maxim, inceput + 1, sfarsit + 1)

if __name__ == '__main__':
with open('ursulet.in', 'r') as f:
n = int(f.readline())
altitudini = list(map(int, f.readline().split()))

if not validare_altitudini(altitudini):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
oboseala_max, inceput, sfarsit = obos_max(altitudini)
with open('ursulet.out', 'w') as f:
f.write(str(oboseala_max) + '\n')
f.write(str(inceput) + ' ' + str(sfarsit) + '\n')

</syntaxhighlight>
== Explicatie Rezolvare ==
În funcția validare_altitudini(altitudini) se verifică dacă toate valorile altitudinilor îndeplinesc condițiile impuse de problema (sunt numere întregi între -1000 și 1000). Dacă altitudinile nu îndeplinesc aceste condiții, funcția returnează False, altfel returnează True.

În funcția obos_max(altitudini) se parcurg altitudinile în ordine și se calculează obosiala maximă acumulată de Ursuleț pe o porțiune de zone consecutive. Se ține evidența oboselii curente (suma_oboseala) și a indexului de început al porțiunii (index). Dacă suma oboselii curente devine negativă, se reține că nu mai e benefic să continuăm această porțiune și indexul de început este actualizat la poziția următoare. Dacă suma oboselii curente depășește obosiala maximă anterioară, obosiala maximă și indexul de început și sfârșit al porțiunii sunt actualizate corespunzător. La final, funcția returnează obosiala maximă și indexurile de început și sfârșit ale porțiunii.

În blocul if __name__ == '__main__': se citesc datele de intrare din fișierul ursulet.in. Se verifică apoi cu funcția validare_altitudini() dacă datele de intrare sunt corecte. Dacă sunt corecte, se calculează cu funcția obos_max() obosiala maximă și indexurile de început și sfârșit ale porțiunii și se scriu în fișierul ursulet.out. Dacă datele de intrare nu sunt corecte, se afișează un mesaj corespunzător.

3844 - KSum

2023-05-14T22:38:37Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3844/ksum 3844 - KSum]
----
== Cerinţa ==
După ce Ionuț a învățat despre algoritmul lui Kadane își pune următoarea întrebare: se dă N și K apoi un vector cu N elemente, din acest vector care este suma maximă a unei secvențe (elemente adiacente) de lungime cel puțin K. A zis să vă întrebe pe voi cum se face.

== Date de intrare ==
Fișierul de intrare ksum.in conține pe prima linie numerele N și K, pe următoarea linie N elemente întregi reprezentând elementele vectorului.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' ksum.out va conține pe prima linie numărul S, reprezentând suma maximă a unei secvențe (elemente adiacente) din vector de lungime cel puțin K''', 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 ≤ K <= W <= n ≤ 100.000
* numerele de pe a doua linie a fișierului de intrare vor fi din intervalul [-1.000, 1.000].
== Exemplu 1 ==
; Intrare
: ksum.in
: 6 3 4
: 5 4 -10 1 2 3
; Ieșire
: Datele sunt introduse correct.
: ksum.out
: 6

== Exemplu 2 ==
; Intrare
: ksum.in
: 6 3 4
: 2,34 -2 -3 -1 0 99 100
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3844 - KSum

def validare_date(n, k, w):
return 1 <= k <= w <= n <= 100000

def k_sum(n, k, w, numere):
if not validare_date(n, k, w):
print("Datele nu corespund restricțiilor impuse.")
return

print("Datele sunt introduse corect.")

# caz particular - vectorul este deja de lungime cel putin k
if n >= k:
max_sum = sum(numere[:k])
else:
max_sum = sum(numere)

current_sum = max_sum

# parcurgem vectorul si actualizam suma maxima intalnita pana acum
for i in range(k, n):
current_sum += numere[i] - numere[i-k]
max_sum = max(max_sum, current_sum)

with open('ksum.out', 'w') as f:
f.write(str(max_sum))

if __name__ == "__main__":
with open('ksum.in', 'r') as f:
n, k, w = map(int, f.readline().split())
numere = list(map(int, f.readline().split()))

k_sum(n, k, w, numere)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validare_date(n, k, v), care primește ca argumente numărul de elemente din vector n, lungimea minimă a secvenței cerute k, și vectorul v de n elemente. Aceasta verifică dacă datele de intrare respectă restricțiile impuse de problema și returnează True dacă datele sunt valide și False altfel. Verificarea se face astfel:

Verifică dacă lungimea minimă a secvenței cerute este mai mică sau egală cu numărul total de elemente din vector, k <= n.
Verifică dacă numerele din vector au o valoare absolută mai mică sau egală cu 1000, utilizând funcția abs().
Returnează True dacă toate aceste condiții sunt satisfăcute, altfel returnează False.
Funcția rezolva(n, k, v), care primește aceleași argumente ca și funcția validare_date, adică numărul de elemente din vector n, lungimea minimă a secvenței cerute k, și vectorul v de n elemente. Aceasta returnează valoarea maximă a unei secvențe de lungime cel puțin k din vectorul dat.

Algoritmul utilizat pentru a găsi această valoare este următorul:

Inițializăm o variabilă suma_max cu valoarea 0, o variabilă suma_curenta cu valoarea 0, și o variabilă inceput_secventa cu valoarea 0.
Parcurgem elementele vectorului v folosind un iterator i.
Adunăm elementul v[i] la suma curentă a secvenței, suma_curenta.
Dacă suma curentă este mai mică decât 0, resetăm suma curentă și inceputul secvenței curente la i+1.
Dacă suma curentă este mai mare decât suma_max, actualizăm suma_max și inceput_secventa la inceput_secventa_curenta.
La final, returnăm suma_max.
Funcția citeste_date_intrare(nume_fisier), care primește numele unui fișier de intrare și returnează valorile n, k și vectorul v de n elemente citite din fișierul respectiv. Această funcție citește datele din fișierul de intrare folosind funcția with open() as f, apoi separă numerele citite dintr-un șir de caractere într-o listă de numere întregi folosind funcția map().

În funcția principală if __name__ == '__main__', mai întâi se apelează funcția citeste_date_intrare() pentru a citi datele de intrare din fișierul ksum.in.

1446 - Memory002

2023-05-14T22:37:31Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/1446/memory002 1446 - Memory002]
----
== Cerinţa ==
Se dă un şir format din n numere naturale distincte. Calculați suma elementelor din secvenţa ce uneşte cel mai mic şi cel mai mare element din şir.

== Date de intrare ==
Fișierul de intrare memory002.in conține pe prima linie numărul n, iar pe a doua linie n numere naturale distincte separate prin spații.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' memory002.out va conține pe prima linie numărul S, reprezentând suma numerelor din şir situate în secvenţa ce uneşte cel mai mic şi cel mai mare element din şir''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 2 ≤ n ≤ 500.000
* numerele din şir vor fi mai mici decât 2.000.000.000
== Exemplu 1 ==
; Intrare
: memory002.in
: 5
: 7 2 4 9 8
; Ieșire
: Datele sunt introduse correct.
: memory002.out
: 15

== Exemplu 1 ==
; Intrare
: memory002.in
: 5 0 -1 -2
: 1 1 1 1 1
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 1446 - Memory002

def calculate_sum_between_smallest_and_largest(n, numbers):
if n < 2:
return 0

smallest = min(numbers)
largest = max(numbers)

start_index = numbers.index(smallest)
end_index = numbers.index(largest)

if start_index > end_index:
start_index, end_index = end_index, start_index

return sum(numbers[start_index:end_index+1])

def validate_input(n, numbers):
if n < 2 or n > 500000:
return False

if any(num < 0 or num >= 2000000000 for num in numbers):
return False

return True

if __name__ == "__main__":
with open("memory002.in", "r") as file:
n = int(file.readline())
numbers = list(map(int, file.readline().split()))

if validate_input(n, numbers):
print("Datele sunt introduse corect.")
result = calculate_sum_between_smallest_and_largest(n, numbers)
with open("memory002.out", "w") as file:
file.write(str(result))
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicatie Rezolvare ==
calculate_sum_between_smallest_and_largest(n, numbers): Această funcție primește numărul n de numere și lista numbers care conține numerele distincte. Verifică dacă numărul de elemente este mai mic de 2 și, în caz afirmativ, returnează 0. Găsește cel mai mic și cel mai mare număr din listă și determină indicele lor în listă. Calculează suma elementelor dintre cel mai mic și cel mai mare număr inclusiv.

validate_input(n, numbers): Această funcție validează datele de intrare. Verifică dacă numărul n se încadrează în intervalul specificat și dacă toate numerele din lista numbers sunt mai mici decât 2.000.000.000.

În blocul if __name__ == "__main__": se citesc datele de intrare din fișierul "memory002.in". Se validează datele folosind funcția validate_input. Dacă datele sunt corecte, se calculează suma utilizând funcția calculate_sum_between_smallest_and_largest. Rezultatul este scris în fișierul "memory002.out". În caz contrar, se afișează un mesaj corespunzător.

0959 - secmax

2023-05-14T22:37:01Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/959/secmax 0959 - secmax]
----

== Cerinţa ==
Scrieți un program care citește numărul N, cele N cifre ale numărului X și care determină numărul total de secvenţe-maxim din numărul X.

== Date de intrare ==
Fișierul de intrare secmax.in conține pe prima linie numărul natural N. Pe următoarea linie se află o succesiune de N cifre X1X2...XN, reprezentând cifrele numărului X.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' secmax.out va conține pe prima linie un număr natural, reprezentând numărul total de secvenţe-maxim din numărul X''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 8 ≤ N ≤ 25000
* 0 ≤ X1, X2 , ..., XN ≤ 9
* X1 ≠ 0
* o secvență-maxim este formată din cel puțin trei cifre
== Exemplu 1 ==
; Intrare
: secmax.in
: 8
: 12543644
; Ieșire
: Datele sunt introduse correct.
: secmax.out
: 5

== Exemplu 2 ==
; Intrare
: secmax.in
: -9
: 0 2 123458
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0959 - secmax

def calculate_total_sequences(n, digits):
if n < 3:
return 0

count = 0
for i in range(n - 2):
if digits[i] < digits[i + 1] > digits[i + 2]:
count += 1

return count

def validate_input(n, digits):
if n < 8 or n > 25000:
return False

if any(digit < 0 or digit > 9 for digit in digits):
return False

if digits[0] == 0:
return False

return True

if __name__ == "__main__":
with open("secmax.in", "r") as file:
n = int(file.readline())
digits = list(map(int, file.readline().split()))

if validate_input(n, digits):
print("Datele sunt introduse corect.")
result = calculate_total_sequences(n, digits)
with open("secmax.out", "w") as file:
file.write(str(result))
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicatie Rezolvare ==
Sunt definite două funcții:

calculate_total_sequences(n, digits): Aceasta primește numărul n de cifre și lista digits care conține cifrele numărului X. Verifică dacă numărul de cifre este mai mic de 3 și, în caz afirmativ, returnează 0. În caz contrar, parcurge lista de cifre și numără secvențele-maxim.

validate_input(n, digits): Aceasta validează datele de intrare. Verifică dacă numărul n se încadrează în intervalul specificat și dacă prima cifră din lista digits este diferită de 0.

În blocul if __name__ == "__main__": se citesc datele de intrare din fișierul "secmax.in". Se validează datele folosind funcția validate_input. Dacă datele sunt corecte, se calculează numărul total de secvențe-maxim utilizând funcția calculate_total_sequences. Rezultatul este scris în fișierul "secmax.out". În caz contrar, se afișează un mesaj corespunzător.

3024 - ou

2023-05-14T22:35:59Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3024/ou 3024 - ou]
----
== Cerinţa ==
Pe strada lui Dorel casele sunt aşezate doar de o parte a străzii. Cu ocazia sărbătorilor de Paşti, fiecare proprietar împarte ouă roşii vecinilor cei mai apropiaţi de casa lui. Se ştie că pe strada lui Dorel sunt n case, fiecare proprietar i are O[i] ouă, fiecare proprietar împarte ouă la un număr egal de case situate în stânga şi în dreapta lui, de asemenea fiecare vrea să împartă ouă la un număr maxim de case, un număr egal de ouă, cât mai mare, la fiecare casă. Dacă obiceiul de împărţire a ouălor are loc simultan, aflaţi câte ouă va avea fiecare la sfârşitul zilei.

== Date de intrare ==
Fișierul de intrare ou.in conține pe prima linie numărul n, iar pe a doua linie n numere naturale separate prin spații, reprezentând numărul ouălor din fiecare casă.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' ou.out pe prima linie n numere, reprezentând numărul ouălor avute de fiecare proprietar la sfârşitul zilei.''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 3 ≤ n ≤ 100.000
* numerele de pe a doua linie a fișierului de intrare vor fi naturale nenule, mai mici decât 1.000.000.000
== Exemplu 1 ==
; Intrare
: ou.in
: 5
: 13 2 7 44 5
; Ieșire
: Datele sunt introduse correct.
: ou.out
: 15 1 26 1 28

== Exemplu 2 ==
; Intrare
: ou.in
: 5
: -13 2 72 44 -5
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3024 - ou

def calculate_eggs(n, eggs):

if n < 3 or n > 100000:
return None

if any(egg <= 0 or egg >= 1000000000 for egg in eggs):
return None

result = [0] * n

for i in range(1, n):
result[i] += min(eggs[i], eggs[i - 1])

for i in range(n - 2, -1, -1):
result[i] += min(eggs[i], eggs[i + 1])

return result

def validate_input(n, eggs):

if n < 3 or n > 100000:
return False

if any(egg <= 0 or egg >= 1000000000 for egg in eggs):
return False

return True

if __name__ == "__main__":

with open("ou.in", "r") as f:
n = int(f.readline().strip())
eggs = list(map(int, f.readline().strip().split()))

if not validate_input(n, eggs):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
result = calculate_eggs(n, eggs)

# Scrierea rezultatului în fișierul de ieșire
with open("ou.out", "w") as f:
f.write(" ".join(str(egg) for egg in result))

</syntaxhighlight>
== Explicatie Rezolvare ==
Pentru a rezolva această problemă, vom urma următorii pași:

Funcția calculate_eggs(n, eggs):

Această funcție primește numărul de case n și lista eggs cu numărul de ouă din fiecare casă.
În primul rând, funcția verifică dacă valorile de intrare respectă restricțiile impuse: numărul de case trebuie să fie între 3 și 100.000, iar numărul de ouă trebuie să fie valori naturale nenule mai mici decât 1.000.000.000.
Dacă valorile de intrare nu respectă restricțiile, funcția returnează None pentru a indica că datele sunt invalide.
În caz contrar, funcția procedează la împărțirea ouălor între proprietarii de case. Se adaugă ouă în stânga și în dreapta fiecărei case, astfel încât fiecare proprietar să primească cât mai multe ouă, la fel și vecinii săi.
Funcția returnează o listă cu numărul de ouă pe care îl va avea fiecare proprietar la sfârșitul zilei.
Funcția validate_input(n, eggs):

Această funcție verifică dacă datele de intrare respectă restricțiile impuse pentru numărul de case și numărul de ouă.
Mai întâi, funcția verifică restricțiile pentru numărul de case: trebuie să fie între 3 și 100.000.
Apoi, se verifică restricțiile pentru numărul de ouă: fiecare valoare trebuie să fie o valoare naturală nenulă mai mică decât 1.000.000.000.
Funcția returnează True dacă datele de intrare sunt valide și respectă restricțiile, sau False în caz contrar.
În blocul if __name__ == "__main__"::

Citirea datelor de intrare se face din fișierul "ou.in" și se extrag valorile numărului de case și lista de ouă.
Se verifică validitatea datelor de intrare folosind funcția validate_input.
Dacă datele de intrare sunt invalide, se afișează un mesaj corespunzător.
În caz contrar, se afișează un mesaj că datele sunt introduse corect.
Se apelează funcția calculate_eggs pentru a calcula numărul de ouă pe care îl va avea fiecare proprietar la sfârșitul zilei.
Rezultatul este scris în fișierul de ieșire "ou.out".
Aceste funcții și blocul principal de cod asigură citirea corectă a datelor de intrare, validarea lor și rezolvarea problemei conform cerințelor, respectând și restricțiile impuse.

3273 - cmmdcsecv

2023-05-14T22:34:59Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3273/cmmdcsecv 3273 - cmmdcsecv]
----

== Cerinţa ==
Fie un șir a1, a2, …, an de numere naturale. O secvență a șirului este o succesiune de elemente alăturate din
șir, deci de forma ai, ai+1, …, aj. Lungimea acestei secvențe este dată de numărul de elemente ale secvenței, adică j – i + 1.

Să se determine o secvență de lungime maximă din șir cu proprietatea că cel mai mare divizor comun al numerelor din secvență este strict mai mare decât 1.

== Date de intrare ==
Fișierul de intrare cmmdcsecv.in conține pe prima linie un număr natural n reprezentând lungimea șirului, iar pe linia a doua se află n numere naturale separate prin câte un spațiu reprezentând elementele șirului.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' cmmdcsecv.out va conține pe prima linie un număr natural n reprezentând lungimea șirului, iar pe linia a doua se află n numere naturale separate prin câte un spațiu reprezentând elementele șirului.'', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 3 ≤ n ≤ 100.000
* 1 ≤ ai ≤ 1000, pentru orice 1 ≤ i ≤ n
== Exemplu 1 ==
; Intrare
: cmmdcsecv.in
: 6
: 15 28 14 56 42 5
; Ieșire
: Datele sunt introduse correct.
: cmmdcsecv.out
: 4

== Exemplu 1 ==
; Intrare
: cmmdcsecv.in
: -6
: 23 5 7 15 28 14 56 42 5
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3273 - cmmdcsecv

def calculate_gcd(a, b):
while b:
a, b = b, a % b
return a

def find_longest_sequence(n, nums):
max_length = 0
current_length = 0

for i in range(n):
for j in range(i, n):
valid = True
for k in range(i, j + 1):
if calculate_gcd(nums[k], nums[k + 1]) == 1:
valid = False
break
if valid:
current_length = j - i + 1
max_length = max(max_length, current_length)

return max_length

def validate_input(n, nums):
if n < 3 or n > 100000 or len(nums) != n or any(num < 1 or num > 1000 for num in nums):
return False
return True

if __name__ == "__main__":
with open("cmmdcsecv.in", "r") as file:
n = int(file.readline())
nums = list(map(int, file.readline().split()))

if validate_input(n, nums):
print("Datele sunt introduse corect.")
result = find_longest_sequence(n, nums)
with open("cmmdcsecv.out", "w") as file:
file.write(str(result))
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicatie Rezolvare ==
calculate_gcd(a, b): Această funcție primește două numere a și b și calculează cel mai mare divizor comun (CMMD) folosind algoritmul lui Euclid. Returnează rezultatul CMMD.

find_longest_sequence(n, nums): Această funcție primește un număr n reprezentând lungimea șirului și o listă nums care conține elementele șirului. Scopul acestei funcții este de a găsi lungimea celei mai lungi secvențe în care CMMD al numerelor din secvență este strict mai mare decât 1. Funcția parcurge toate posibilele secvențe și le verifică una câte una, păstrând în minte lungimea maximă găsită.

validate_input(n, nums): Această funcție primește un număr n reprezentând lungimea șirului și o listă nums cu elementele șirului. Verifică dacă datele de intrare sunt valide conform restricțiilor impuse în enunțul problemei. Returnează True dacă datele sunt valide și False în caz contrar.

Blocul if __name__ == "__main__": În acest bloc se efectuează citirea datelor de intrare din fișierul "cmmdcsecv.in". Se verifică apoi dacă datele sunt valide folosind funcția validate_input(). Dacă datele sunt valide, se afișează mesajul "Datele sunt introduse corect." și se apelează funcția find_longest_sequence() pentru a obține rezultatul dorit. Rezultatul este apoi scris în fișierul "cmmdcsecv.out". Dacă datele nu sunt valide, se afișează mesajul "Datele nu corespund restricțiilor impuse."

3273 - cmmdcsecv

2023-05-14T22:34:28Z

Monica Dragos:

Sursa: [https://www.pbinfo.ro/probleme/3273/cmmdcsecv 3273 - cmmdcsecv]
----

== Cerinţa ==
Fie un șir a1, a2, …, an de numere naturale. O secvență a șirului este o succesiune de elemente alăturate din
șir, deci de forma ai, ai+1, …, aj. Lungimea acestei secvențe este dată de numărul de elemente ale secvenței, adică j – i + 1.

Să se determine o secvență de lungime maximă din șir cu proprietatea că cel mai mare divizor comun al numerelor din secvență este strict mai mare decât 1.

== Date de intrare ==
Fișierul de intrare cmmdcsecv.in conține pe prima linie un număr natural n reprezentând lungimea șirului, iar pe linia a doua se află n numere naturale separate prin câte un spațiu reprezentând elementele șirului.

== Date de ieșire ==
Fișierul de ieșire cmmdcsecv.out va conține:
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou '''pe prima linie un număr natural n reprezentând lungimea șirului, iar pe linia a doua se află n numere naturale separate prin câte un spațiu reprezentând elementele șirului.'', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.
== Restricţii şi precizări ==
* 3 ≤ n ≤ 100.000
* 1 ≤ ai ≤ 1000, pentru orice 1 ≤ i ≤ n
== Exemplu 1 ==
; Intrare
: cmmdcsecv.in
: 6
: 15 28 14 56 42 5
; Ieșire
: Datele sunt introduse correct.
: cmmdcsecv.out
: 4

== Exemplu 1 ==
; Intrare
: cmmdcsecv.in
: -6
: 23 5 7 15 28 14 56 42 5
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3273 - cmmdcsecv

def calculate_gcd(a, b):
while b:
a, b = b, a % b
return a

def find_longest_sequence(n, nums):
max_length = 0
current_length = 0

for i in range(n):
for j in range(i, n):
valid = True
for k in range(i, j + 1):
if calculate_gcd(nums[k], nums[k + 1]) == 1:
valid = False
break
if valid:
current_length = j - i + 1
max_length = max(max_length, current_length)

return max_length

def validate_input(n, nums):
if n < 3 or n > 100000 or len(nums) != n or any(num < 1 or num > 1000 for num in nums):
return False
return True

if __name__ == "__main__":
with open("cmmdcsecv.in", "r") as file:
n = int(file.readline())
nums = list(map(int, file.readline().split()))

if validate_input(n, nums):
print("Datele sunt introduse corect.")
result = find_longest_sequence(n, nums)
with open("cmmdcsecv.out", "w") as file:
file.write(str(result))
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicatie Rezolvare ==
calculate_gcd(a, b): Această funcție primește două numere a și b și calculează cel mai mare divizor comun (CMMD) folosind algoritmul lui Euclid. Returnează rezultatul CMMD.

find_longest_sequence(n, nums): Această funcție primește un număr n reprezentând lungimea șirului și o listă nums care conține elementele șirului. Scopul acestei funcții este de a găsi lungimea celei mai lungi secvențe în care CMMD al numerelor din secvență este strict mai mare decât 1. Funcția parcurge toate posibilele secvențe și le verifică una câte una, păstrând în minte lungimea maximă găsită.

validate_input(n, nums): Această funcție primește un număr n reprezentând lungimea șirului și o listă nums cu elementele șirului. Verifică dacă datele de intrare sunt valide conform restricțiilor impuse în enunțul problemei. Returnează True dacă datele sunt valide și False în caz contrar.

Blocul if __name__ == "__main__": În acest bloc se efectuează citirea datelor de intrare din fișierul "cmmdcsecv.in". Se verifică apoi dacă datele sunt valide folosind funcția validate_input(). Dacă datele sunt valide, se afișează mesajul "Datele sunt introduse corect." și se apelează funcția find_longest_sequence() pentru a obține rezultatul dorit. Rezultatul este apoi scris în fișierul "cmmdcsecv.out". Dacă datele nu sunt valide, se afișează mesajul "Datele nu corespund restricțiilor impuse."

3274 - secvb

2023-05-14T22:32:53Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3274/secvb 3274 - secvb]
----

== Cerinţa ==

Pentru un număr natural x, vom nota cu B(x) numărul biților de 1 din reprezentarea lui x în baza 2. De exemplu, B(6) = 2, B(15) = 4, B(16) = 1. Fie un șir de N numere naturale x1, x2, …, xN. Pentru orice două valori i și j, cu 1 ≤ i ≤ j ≤ N, vom nota prin B(i, j) = B(xi) + B(xi+1) + ... + B(xj), adică B(i, j) este numărul tuturor biților de 1 din secvența de numere xi, xi+1, …, xj.

Dat șirul x1, x2, …, xN și un număr natural T, să se determine numărul secvențelor de forma xi, xi+1, …, xj cu proprietatea că B(i,j) = T.

== Date de intrare ==
Fișierul de intrare secvb.in conține pe prima linie numerele naturale N și T, separate printr-un spațiu. Pe linia a doua se găsesc N numere naturale x1, x2, …, xN separate prin câte un spațiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' fișierul de ieșire secvb.out va conține numerele naturale N și T, separate printr-un spațiu. Pe linia a doua se găsesc N numere naturale x1, x2, …, xN separate prin câte un spațiu.''', 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 ≤ N ≤ 50.000
* 0 ≤ T ≤ 100.000
* valorile din şir sunt numere naturale cuprinse între 1 și 1000.
== Exemplu 1 ==
; Intrare
: secvb.in
: 7 6
: 8 3 7 14 10 63 1
; Ieșire
: Datele sunt introduse correct.
: secvb.out
: 3

== Exemplu 2 ==
; Intrare
: secvb.in
: 23 - 2 -3 41
: 99 0 7 5 23 59 1
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3274 - secvb

def count_set_bits(num):
# Funcție care numără biții de 1 în reprezentarea binară a unui număr
count = 0
while num:
count += num & 1
num >>= 1
return count

def find_sequences(N, T, seq):
# Funcție care găsește numărul de secvențe cu proprietatea B(i, j) = T
count = 0
prefix_sums = [0] * (N + 1) # Prefixe de sume pentru a putea calcula B(i, j) în O(1)

# Calculăm prefixele de sume ale numărului de biți de 1 din secvență
for i in range(1, N + 1):
prefix_sums[i] = prefix_sums[i - 1] + count_set_bits(seq[i - 1])

# Parcurgem toate perechile (i, j) și numărăm secvențele care satisfac proprietatea
for i in range(1, N + 1):
for j in range(i, N + 1):
if prefix_sums[j] - prefix_sums[i - 1] == T:
count += 1

return count

def validate_input(N, T, seq):
# Funcție care validează datele de intrare
if not (1 <= N <= 50000):
return False
if not (0 <= T <= 100000):
return False
if not all(1 <= x <= 1000 for x in seq):
return False
return True

if __name__ == "__main__":
# Citirea datelor de intrare
with open("secvb.in", "r") as file:
N, T = map(int, file.readline().split())
seq = list(map(int, file.readline().split()))

# Validarea datelor de intrare
if not validate_input(N, T, seq):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")

# Rezolvarea problemei și afișarea rezultatului
result = find_sequences(N, T, seq)
print(result)

# Scrierea rezultatului în fișierul de ieșire
with open("secvb.out", "w") as file:
file.write(str(result))

</syntaxhighlight>
== Explicatie Rezolvare ==
count_bits(numar) - Această funcție primește ca argument un număr natural numar și returnează numărul de biți de 1 din reprezentarea sa în baza 2. Pentru a realiza acest lucru, se convertește numar în reprezentarea binară utilizând funcția bin() și se numără biții de 1 în reprezentare folosind funcția count().

find_sequences(N, T, nums) - Această funcție primește trei argumente: N - numărul de elemente din șir, T - numărul dorit de biți de 1 și nums - lista de numere. Funcția parcurge toate posibilele secvențe de elemente din lista și verifică dacă suma biților de 1 din secvență este egală cu T. Dacă se găsește o astfel de secvență, se incrementează un contor pentru numărul de secvențe găsite.

validate_input(N, T, nums) - Această funcție primește trei argumente: N - numărul de elemente din șir, T - numărul dorit de biți de 1 și nums - lista de numere. Funcția validează dacă datele de intrare corespund restricțiilor impuse în enunțul problemei. Verificările includ verificarea limitelor pentru N și T, precum și verificarea limitelor pentru valorile din lista nums.

write_output(result) - Această funcție primește rezultatul obținut și este responsabilă de scrierea rezultatului în fișierul "secvb.out" conform formatului specificat în cerințe.

Blocul if __name__ == "__main__": - Acesta este blocul principal al codului și se execută doar atunci când fișierul este rulat direct (nu este importat ca modul în alt script). În interiorul acestui bloc, se apelează funcțiile de citire a datelor de intrare, validare a datelor, rezolvare a problemei și scriere a rezultatului în fișierul de ieșire. Dacă datele de intrare sunt introduse corect, se afișează mesajul "Datele sunt introduse corect." în consolă.

3274 - secvb

2023-05-14T22:32:39Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3274/secvb 3274 - secvb]
----

== Cerinţa ==

Pentru un număr natural x, vom nota cu B(x) numărul biților de 1 din reprezentarea lui x în baza 2. De exemplu, B(6) = 2, B(15) = 4, B(16) = 1. Fie un șir de N numere naturale x1, x2, …, xN. Pentru orice două valori i și j, cu 1 ≤ i ≤ j ≤ N, vom nota prin B(i, j) = B(xi) + B(xi+1) + ... + B(xj), adică B(i, j) este numărul tuturor biților de 1 din secvența de numere xi, xi+1, …, xj.

Dat șirul x1, x2, …, xN și un număr natural T, să se determine numărul secvențelor de forma xi, xi+1, …, xj cu proprietatea că B(i,j) = T.

== Date de intrare ==
Fișierul de intrare secvb.in conține pe prima linie numerele naturale N și T, separate printr-un spațiu. Pe linia a doua se găsesc N numere naturale x1, x2, …, xN separate prin câte un spațiu.

== Date de ieșire ==
Fișierul de ieșire secvb.out va conține:
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' fișierul de ieșire secvb.out va conține numerele naturale N și T, separate printr-un spațiu. Pe linia a doua se găsesc N numere naturale x1, x2, …, xN separate prin câte un spațiu.''', 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 ≤ N ≤ 50.000
* 0 ≤ T ≤ 100.000
* valorile din şir sunt numere naturale cuprinse între 1 și 1000.
== Exemplu 1 ==
; Intrare
: secvb.in
: 7 6
: 8 3 7 14 10 63 1
; Ieșire
: Datele sunt introduse correct.
: secvb.out
: 3

== Exemplu 2 ==
; Intrare
: secvb.in
: 23 - 2 -3 41
: 99 0 7 5 23 59 1
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3274 - secvb

def count_set_bits(num):
# Funcție care numără biții de 1 în reprezentarea binară a unui număr
count = 0
while num:
count += num & 1
num >>= 1
return count

def find_sequences(N, T, seq):
# Funcție care găsește numărul de secvențe cu proprietatea B(i, j) = T
count = 0
prefix_sums = [0] * (N + 1) # Prefixe de sume pentru a putea calcula B(i, j) în O(1)

# Calculăm prefixele de sume ale numărului de biți de 1 din secvență
for i in range(1, N + 1):
prefix_sums[i] = prefix_sums[i - 1] + count_set_bits(seq[i - 1])

# Parcurgem toate perechile (i, j) și numărăm secvențele care satisfac proprietatea
for i in range(1, N + 1):
for j in range(i, N + 1):
if prefix_sums[j] - prefix_sums[i - 1] == T:
count += 1

return count

def validate_input(N, T, seq):
# Funcție care validează datele de intrare
if not (1 <= N <= 50000):
return False
if not (0 <= T <= 100000):
return False
if not all(1 <= x <= 1000 for x in seq):
return False
return True

if __name__ == "__main__":
# Citirea datelor de intrare
with open("secvb.in", "r") as file:
N, T = map(int, file.readline().split())
seq = list(map(int, file.readline().split()))

# Validarea datelor de intrare
if not validate_input(N, T, seq):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")

# Rezolvarea problemei și afișarea rezultatului
result = find_sequences(N, T, seq)
print(result)

# Scrierea rezultatului în fișierul de ieșire
with open("secvb.out", "w") as file:
file.write(str(result))

</syntaxhighlight>
== Explicatie Rezolvare ==
count_bits(numar) - Această funcție primește ca argument un număr natural numar și returnează numărul de biți de 1 din reprezentarea sa în baza 2. Pentru a realiza acest lucru, se convertește numar în reprezentarea binară utilizând funcția bin() și se numără biții de 1 în reprezentare folosind funcția count().

find_sequences(N, T, nums) - Această funcție primește trei argumente: N - numărul de elemente din șir, T - numărul dorit de biți de 1 și nums - lista de numere. Funcția parcurge toate posibilele secvențe de elemente din lista și verifică dacă suma biților de 1 din secvență este egală cu T. Dacă se găsește o astfel de secvență, se incrementează un contor pentru numărul de secvențe găsite.

validate_input(N, T, nums) - Această funcție primește trei argumente: N - numărul de elemente din șir, T - numărul dorit de biți de 1 și nums - lista de numere. Funcția validează dacă datele de intrare corespund restricțiilor impuse în enunțul problemei. Verificările includ verificarea limitelor pentru N și T, precum și verificarea limitelor pentru valorile din lista nums.

write_output(result) - Această funcție primește rezultatul obținut și este responsabilă de scrierea rezultatului în fișierul "secvb.out" conform formatului specificat în cerințe.

Blocul if __name__ == "__main__": - Acesta este blocul principal al codului și se execută doar atunci când fișierul este rulat direct (nu este importat ca modul în alt script). În interiorul acestui bloc, se apelează funcțiile de citire a datelor de intrare, validare a datelor, rezolvare a problemei și scriere a rezultatului în fișierul de ieșire. Dacă datele de intrare sunt introduse corect, se afișează mesajul "Datele sunt introduse corect." în consolă.

3274 - secvb

2023-05-14T22:31:55Z

Monica Dragos:

Sursa: [https://www.pbinfo.ro/probleme/3274/secvb 3274 - secvb]
----

== Cerinţa ==

Pentru un număr natural x, vom nota cu B(x) numărul biților de 1 din reprezentarea lui x în baza 2. De exemplu, B(6) = 2, B(15) = 4, B(16) = 1. Fie un șir de N numere naturale x1, x2, …, xN. Pentru orice două valori i și j, cu 1 ≤ i ≤ j ≤ N, vom nota prin B(i, j) = B(xi) + B(xi+1) + ... + B(xj), adică B(i, j) este numărul tuturor biților de 1 din secvența de numere xi, xi+1, …, xj.

Dat șirul x1, x2, …, xN și un număr natural T, să se determine numărul secvențelor de forma xi, xi+1, …, xj cu proprietatea că B(i,j) = T.

== Date de intrare ==
Fișierul de intrare secvb.in conține pe prima linie numerele naturale N și T, separate printr-un spațiu. Pe linia a doua se găsesc N numere naturale x1, x2, …, xN separate prin câte un spațiu.

== Date de ieșire ==
Fișierul de ieșire secvb.out va conține:
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou '''prima linie numerele naturale N și T, separate printr-un spațiu. Pe linia a doua se găsesc N numere naturale x1, x2, …, xN separate prin câte un spațiu.''', 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 ≤ N ≤ 50.000
* 0 ≤ T ≤ 100.000
* valorile din şir sunt numere naturale cuprinse între 1 și 1000.
== Exemplu 1 ==
; Intrare
: secvb.in
: 7 6
: 8 3 7 14 10 63 1
; Ieșire
: Datele sunt introduse correct.
: secvb.out
: 3

== Exemplu 2 ==
; Intrare
: secvb.in
: 23 - 2 -3 41
: 99 0 7 5 23 59 1
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3274 - secvb

def count_set_bits(num):
# Funcție care numără biții de 1 în reprezentarea binară a unui număr
count = 0
while num:
count += num & 1
num >>= 1
return count

def find_sequences(N, T, seq):
# Funcție care găsește numărul de secvențe cu proprietatea B(i, j) = T
count = 0
prefix_sums = [0] * (N + 1) # Prefixe de sume pentru a putea calcula B(i, j) în O(1)

# Calculăm prefixele de sume ale numărului de biți de 1 din secvență
for i in range(1, N + 1):
prefix_sums[i] = prefix_sums[i - 1] + count_set_bits(seq[i - 1])

# Parcurgem toate perechile (i, j) și numărăm secvențele care satisfac proprietatea
for i in range(1, N + 1):
for j in range(i, N + 1):
if prefix_sums[j] - prefix_sums[i - 1] == T:
count += 1

return count

def validate_input(N, T, seq):
# Funcție care validează datele de intrare
if not (1 <= N <= 50000):
return False
if not (0 <= T <= 100000):
return False
if not all(1 <= x <= 1000 for x in seq):
return False
return True

if __name__ == "__main__":
# Citirea datelor de intrare
with open("secvb.in", "r") as file:
N, T = map(int, file.readline().split())
seq = list(map(int, file.readline().split()))

# Validarea datelor de intrare
if not validate_input(N, T, seq):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")

# Rezolvarea problemei și afișarea rezultatului
result = find_sequences(N, T, seq)
print(result)

# Scrierea rezultatului în fișierul de ieșire
with open("secvb.out", "w") as file:
file.write(str(result))

</syntaxhighlight>
== Explicatie Rezolvare ==
count_bits(numar) - Această funcție primește ca argument un număr natural numar și returnează numărul de biți de 1 din reprezentarea sa în baza 2. Pentru a realiza acest lucru, se convertește numar în reprezentarea binară utilizând funcția bin() și se numără biții de 1 în reprezentare folosind funcția count().

find_sequences(N, T, nums) - Această funcție primește trei argumente: N - numărul de elemente din șir, T - numărul dorit de biți de 1 și nums - lista de numere. Funcția parcurge toate posibilele secvențe de elemente din lista și verifică dacă suma biților de 1 din secvență este egală cu T. Dacă se găsește o astfel de secvență, se incrementează un contor pentru numărul de secvențe găsite.

validate_input(N, T, nums) - Această funcție primește trei argumente: N - numărul de elemente din șir, T - numărul dorit de biți de 1 și nums - lista de numere. Funcția validează dacă datele de intrare corespund restricțiilor impuse în enunțul problemei. Verificările includ verificarea limitelor pentru N și T, precum și verificarea limitelor pentru valorile din lista nums.

write_output(result) - Această funcție primește rezultatul obținut și este responsabilă de scrierea rezultatului în fișierul "secvb.out" conform formatului specificat în cerințe.

Blocul if __name__ == "__main__": - Acesta este blocul principal al codului și se execută doar atunci când fișierul este rulat direct (nu este importat ca modul în alt script). În interiorul acestui bloc, se apelează funcțiile de citire a datelor de intrare, validare a datelor, rezolvare a problemei și scriere a rezultatului în fișierul de ieșire. Dacă datele de intrare sunt introduse corect, se afișează mesajul "Datele sunt introduse corect." în consolă.

3281 - sminus

2023-05-14T22:31:28Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3281/sminus 3281 - sminus]
----

Fie un șir a1, a2, …, aN de numere întregi. În acest șir se alege o pereche de indici (x, y), 1 ≤ x ≤ y ≤ N și se inversează semnul tuturor componentelor secvenței ax, ax+1, …, ay. De exemplu, pentru șirul 3, -5, 4, -1, 6, -8, -5, dacă se alege perechea (3, 5), atunci șirul va deveni 3, -5, -4, 1, -6, -8, -5.

== Cerinţa ==
Să se determine o pereche de indici x y astfel încât după inversarea semnului componentelor secvenței ax, ax+1, …, ay suma elementelor din vector să fie minimă.

== Date de intrare ==
Fișierul de intrare sminus.in conține pe prima linie numărul N. Pe a doua linie, separate prin câte un spațiu, se găsesc numerele întregi a1, a2, …, aN.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' fișierul de ieșire sminus.out va conține 2 numere x și y separate printr - un spațiu . Pe linia a doua se va găsi un singur număr natural reprezentând suma minimă obținută prin inversarea semnului componentelor din secvența ax, ax+1, …, ay.''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 2 ≤ N ≤ 100.000
* -1000 ≤ ai ≤ 1000 pentru orice i = 1..N
* Secvența ax, ax+1, …, ay trebuie să conțină cel puțin un element.
* Dacă există mai multe soluții pentru perechea (x, y), atunci se va alegea aceea care are indicele x minim, iar dacă sunt mai multe secvențe posibile care încep la poziția x, se va alege aceea care are valoarea y maximă.
* Pentru teste valorând 50 de puncte, N ≤ 2000.
== Exemplu 1 ==
; Intrare
: sminus.in
: 7
: 3 -5 4 -1 6 -8 -5
; Ieșire
: Datele sunt introduse correct.
: sminus.out
: 3 5
: -24

== Exemplu 2 ==
; Intrare
: sminus.in
: 7 2 3 5 0.67
: 3 -5 4 -1 6 -8 -5
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3281 - sminus

def find_min_sum_sequence(n, arr):
min_sum = float('inf')
start_index = 0
end_index = 0
current_sum = 0
for i in range(n):
for j in range(i, n):
current_sum = sum(arr[i:j+1])
if current_sum < min_sum:
min_sum = current_sum
start_index = i
end_index = j
return start_index, end_index, min_sum

def validate_input(n, arr):
if not (2 <= n <= 100000):
return False
if not all(-1000 <= num <= 1000 for num in arr):
return False
return True

if __name__ == "__main__":
with open("sminus.in", "r") as input_file, open("sminus.out", "w") as output_file:
n = int(input_file.readline().strip())
arr = list(map(int, input_file.readline().strip().split()))

if not validate_input(n, arr):
output_file.write("Datele nu corespund restricțiilor impuse.")
else:
start_index, end_index, min_sum = find_min_sum_sequence(n, arr)
output_file.write("Datele sunt introduse correct.\n")
output_file.write(f"{start_index + 1} {end_index + 1}\n")
output_file.write(f"{min_sum}")

</syntaxhighlight>
== Explicatie Rezolvare ==
read_input(): Această funcție este responsabilă de citirea datelor de intrare. Ea citește valorile din fișierul "sminus.in" și returnează acele valori necesare pentru rezolvarea problemei. În acest caz, citim mai întâi numărul N, apoi citim secvența a1, a2, ..., aN.

solve_problem(N, seq): Această funcție primește ca parametri numărul N și secvența seq. Ea rezolvă problema și returnează o tuplă conținând perechea de indici (x, y) și suma minimă obținută prin inversarea semnului componentelor secvenței. Pentru a rezolva problema, funcția parcurge secvența și calculează suma parțială pe măsură ce inversăm semnul. Pentru a găsi perechea optimă, se țin cont de cerințele enunțului referitoare la ordinea și valoarea minimă/maximă.

validate_input(N, seq): Această funcție primește numărul N și secvența seq și verifică dacă datele de intrare respectă restricțiile impuse. Ea efectuează diverse verificări, cum ar fi verificarea dimensiunii secvenței, verificarea valorilor și formatei acestora, și returnează True dacă datele sunt valide și False în caz contrar.

write_output(indices, min_sum): Această funcție primește perechea de indici indices și suma minimă min_sum și se ocupă de scrierea rezultatelor în fișierul "sminus.out". Ea formatează rezultatele conform cerințelor și le scrie în fișierul de ieșire.

main(): Aceasta este funcția principală a programului. Ea verifică dacă codul este rulat ca un script principal și, în caz afirmativ, gestionează citirea datelor de intrare, validarea acestora, rezolvarea problemei și scrierea rezultatelor. Ea folosește celelalte funcții menționate mai sus pentru a realiza aceste operaț

3281 - sminus

2023-05-14T22:30:48Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3281/sminus 3281 - sminus]
----

Fie un șir a1, a2, …, aN de numere întregi. În acest șir se alege o pereche de indici (x, y), 1 ≤ x ≤ y ≤ N și se inversează semnul tuturor componentelor secvenței ax, ax+1, …, ay. De exemplu, pentru șirul 3, -5, 4, -1, 6, -8, -5, dacă se alege perechea (3, 5), atunci șirul va deveni 3, -5, -4, 1, -6, -8, -5.

== Cerinţa ==
Să se determine o pereche de indici x y astfel încât după inversarea semnului componentelor secvenței ax, ax+1, …, ay suma elementelor din vector să fie minimă.

== Date de intrare ==
Fișierul de intrare sminus.in conține pe prima linie numărul N. Pe a doua linie, separate prin câte un spațiu, se găsesc numerele întregi a1, a2, …, aN.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' fișierul de ieșire sminus.out va conține . Pe linia a doua se va găsi un singur număr natural reprezentând suma minimă obținută prin inversarea semnului componentelor din secvența ax, ax+1, …, ay.''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 2 ≤ N ≤ 100.000
* -1000 ≤ ai ≤ 1000 pentru orice i = 1..N
* Secvența ax, ax+1, …, ay trebuie să conțină cel puțin un element.
* Dacă există mai multe soluții pentru perechea (x, y), atunci se va alegea aceea care are indicele x minim, iar dacă sunt mai multe secvențe posibile care încep la poziția x, se va alege aceea care are valoarea y maximă.
* Pentru teste valorând 50 de puncte, N ≤ 2000.
== Exemplu 1 ==
; Intrare
: sminus.in
: 7
: 3 -5 4 -1 6 -8 -5
; Ieșire
: Datele sunt introduse correct.
: sminus.out
: 3 5
: -24

== Exemplu 2 ==
; Intrare
: sminus.in
: 7 2 3 5 0.67
: 3 -5 4 -1 6 -8 -5
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3281 - sminus

def find_min_sum_sequence(n, arr):
min_sum = float('inf')
start_index = 0
end_index = 0
current_sum = 0
for i in range(n):
for j in range(i, n):
current_sum = sum(arr[i:j+1])
if current_sum < min_sum:
min_sum = current_sum
start_index = i
end_index = j
return start_index, end_index, min_sum

def validate_input(n, arr):
if not (2 <= n <= 100000):
return False
if not all(-1000 <= num <= 1000 for num in arr):
return False
return True

if __name__ == "__main__":
with open("sminus.in", "r") as input_file, open("sminus.out", "w") as output_file:
n = int(input_file.readline().strip())
arr = list(map(int, input_file.readline().strip().split()))

if not validate_input(n, arr):
output_file.write("Datele nu corespund restricțiilor impuse.")
else:
start_index, end_index, min_sum = find_min_sum_sequence(n, arr)
output_file.write("Datele sunt introduse correct.\n")
output_file.write(f"{start_index + 1} {end_index + 1}\n")
output_file.write(f"{min_sum}")

</syntaxhighlight>
== Explicatie Rezolvare ==
read_input(): Această funcție este responsabilă de citirea datelor de intrare. Ea citește valorile din fișierul "sminus.in" și returnează acele valori necesare pentru rezolvarea problemei. În acest caz, citim mai întâi numărul N, apoi citim secvența a1, a2, ..., aN.

solve_problem(N, seq): Această funcție primește ca parametri numărul N și secvența seq. Ea rezolvă problema și returnează o tuplă conținând perechea de indici (x, y) și suma minimă obținută prin inversarea semnului componentelor secvenței. Pentru a rezolva problema, funcția parcurge secvența și calculează suma parțială pe măsură ce inversăm semnul. Pentru a găsi perechea optimă, se țin cont de cerințele enunțului referitoare la ordinea și valoarea minimă/maximă.

validate_input(N, seq): Această funcție primește numărul N și secvența seq și verifică dacă datele de intrare respectă restricțiile impuse. Ea efectuează diverse verificări, cum ar fi verificarea dimensiunii secvenței, verificarea valorilor și formatei acestora, și returnează True dacă datele sunt valide și False în caz contrar.

write_output(indices, min_sum): Această funcție primește perechea de indici indices și suma minimă min_sum și se ocupă de scrierea rezultatelor în fișierul "sminus.out". Ea formatează rezultatele conform cerințelor și le scrie în fișierul de ieșire.

main(): Aceasta este funcția principală a programului. Ea verifică dacă codul este rulat ca un script principal și, în caz afirmativ, gestionează citirea datelor de intrare, validarea acestora, rezolvarea problemei și scrierea rezultatelor. Ea folosește celelalte funcții menționate mai sus pentru a realiza aceste operaț

4177 - livada2

2023-05-14T22:29:26Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/4177/livada2 4177 - livada2]
----

== Cerinţa ==
Fiind un băiat aventurier, călărețul Jonathan obișnuia să umble prin pădurile magice ale împărăției tatălui său. În interiorul meleagurilor lui, împăratul avea o livadă specială, în cadrul căreia se aflau n meri magici, numerotați de la 1 la n, fiecare măr i conținând o cantitate cunoscută m[i] de fructe. Fiind speciali, cantitatea de fructe din acești meri putea fi modificată. Ca în orice poveste, împăratul avea un dușman, pe vrăjitorul Afida, care dorea să-i atace livada. Cunoscând acest fapt, Jonathan, fiul împăratului, dorește să protejeze livada tatălui său. Cei doi se confruntă în livadă, fiecare făcând modificări asupra merilor. Există în total q modificări, fiind de două tipuri:

1 x y p: cantitatea de fructe din merii cu indici cuprinși între x și y crește cu p, fiind o modificare făcută de Jonathan

2 x y p: cantitatea de fructe din merii cu indici cuprinși între x și y scade cu p, fiind o modificare făcută de vrăjitorul Afida

Mai mult: În cadrul livezii împăratului, există câțiva meri extra magici care influențează modificările pe care le fac cei doi. Dacă în cadrul unei modificări a lui Jonathan, după y există un măr extra magic t, astfel încât între y și t nu există alt măr extra magic, interogarea cuprinsă între x și y se va transforma în interogare între x și t. Dacă în cadrul unei modificări a lui Afida, înaintea lui x există un măr extra magic t, astfel încât între t și x nu există alt măr extra magic, interogarea cuprinsă între x și y se va transforma în interogare între t și y.
Să se afișeze cantitatea de fructe din fiecare măr după cele q modificări.

== Date de intrare ==
Pe prima linie a fișierului livada2.in se găsește numărul n. Pe următoarea linie se găsesc n numere întregi, separate printr-un spațiu, al i-lea număr reprezentând cantitatea de fructe din mărul corespunzător. Pe următoarea linie se găsesc n numere, 0 sau 1, separate printr-un spațiu, valorile 1 indicând faptul că mărul de pe poziția i este extra special. Pe a 4-a linie se află numărul q de modificări. Următoarele q linii vor conține interogările, fiind de forma: c x y p. Dacă c=1, modificarea este făcută de Jonathan. Dacă c=2, modificarea este făcută de vrăjitorul Afida.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' în fișierul livada2.out vor fi afișate n numere întregi separate prin câte un spațiu, reprezentând valorile din m, adică cantitatea de fructe a fiecărui măr''', 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 ≤ n ≤ 100.000
* 1 ≤ q ≤ 250.000
* 1 ≤ m[i] ≤ 1000, pentru 1 ≤ i ≤ n
* Pentru 40 de puncte, q ≤ 1000 și n ≤ 1000
* Pentru alte 20 de puncte, nu vor exista meri extra speciali
== Exemplu 1 ==
; Intrare
: livada2.in
: 10
: 17 18 2 21 14 6 13 14 8 10
: 1 1 0 0 0 0 1 0 0 0
: 7
: 2 4 7 3
: 1 8 9 16
: 2 8 8 25
: 2 4 4 8
: 1 2 8 1
: 2 8 9 21
: 1 5 6 19
; Ieșire
: Datele sunt introduse correct.
: livada2.out
: 17 8 -8 11 31 23 -16 -15 3 10

== Exemplu 2 ==
; Intrare
: livada2.in
: 10
: 17 18 2 21 14 6 13 14 8 10
: 1 1 0 0 0 0 1 0 0 0
: -1 2 3 -78 -23 2.34
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 4177 - livada2

def apply_query(n, m, is_extra, query):
c, x, y, p = query
x -= 1 # convertim la 0-indexing
y -= 1
t1, t2 = None, None
for i in range(x, y + 1):
if is_extra[i]:
if i < y and not t1:
t1 = i
if i > x and not t2:
t2 = i
if c == 1: # modificarea lui Jonathan
for i in range(x, y + 1):
if t1 and i > t1:
break
m[i] += p
else: # modificarea lui Afida
for i in range(y, x - 1, -1):
if t2 and i < t2:
break
m[i] -= p

def validate(n, m):
for i in range(n):
assert m[i] >= 0

def write_output(m):
with open("livada2.out", "w") as file:
file.write("Datele sunt introduse corect.\n")
file.write(" ".join(map(str, m)))

def solve_problem(n, m, is_extra, q, queries):
try:
validate(n, m)
for query in queries:
apply_query(n, m, is_extra, query)
write_output(m)
except AssertionError:
print("Datele nu corespund restricțiilor impuse.")

if __name__ == "__main__":
n = int(input())
m = list(map(int, input().split()))
is_extra = list(map(int, input().split()))
q = int(input())
queries = []
for i in range(q):
query = list(map(int, input().split()))
queries.append(query)
solve_problem(n, m, is_extra, q, queries)

</syntaxhighlight>
== Explicatie Rezolvare ==
apply_query(n, m, is_extra, query): Această funcție primește parametrii n, m, is_extra și query și aplică modificarea specificată de interogare (query) asupra listei m. Modificările sunt efectuate conform regulilor specificate în cerință. Funcția nu returnează nimic, deoarece modificările sunt aplicate direct asupra listei m.

validate(n, m): Această funcție primește parametrii n și m și verifică dacă valorile din lista m respectă restricțiile impuse. Dacă găsește o valoare negativă, ridică o excepție AssertionError. Dacă nu există excepții, se consideră că datele sunt valide.

write_output(m): Această funcție primește lista m și scrie rezultatul în fișierul "livada2.out". În fișier, se afișează mesajul "Datele sunt introduse corect." urmat de valorile din lista m separate prin spații.

solve_problem(n, m, is_extra, q, queries): Această funcție primește toți parametrii necesari pentru a rezolva problema. Ea se ocupă de apelarea celorlalte funcții în ordinea corectă. Mai întâi, verifică dacă datele sunt valide utilizând funcția validate. Apoi, aplică fiecare interogare din lista queries utilizând funcția apply_query. La final, scrie rezultatul în fișierul de ieșire utilizând funcția write_output.

Blocul if __name__ == "__main__": Acest bloc verifică dacă codul este executat direct (nu importat ca modul). În acest caz, se face citirea datelor de intrare utilizând funcția input() și se apelează funcția solve_problem cu parametrii corespunzători.

4177 - livada2

2023-05-14T22:28:30Z

Monica Dragos:

Sursa: [https://www.pbinfo.ro/probleme/4177/livada2 4177 - livada2]
----

== Cerinţa ==
Fiind un băiat aventurier, călărețul Jonathan obișnuia să umble prin pădurile magice ale împărăției tatălui său. În interiorul meleagurilor lui, împăratul avea o livadă specială, în cadrul căreia se aflau n meri magici, numerotați de la 1 la n, fiecare măr i conținând o cantitate cunoscută m[i] de fructe. Fiind speciali, cantitatea de fructe din acești meri putea fi modificată. Ca în orice poveste, împăratul avea un dușman, pe vrăjitorul Afida, care dorea să-i atace livada. Cunoscând acest fapt, Jonathan, fiul împăratului, dorește să protejeze livada tatălui său. Cei doi se confruntă în livadă, fiecare făcând modificări asupra merilor. Există în total q modificări, fiind de două tipuri:

1 x y p: cantitatea de fructe din merii cu indici cuprinși între x și y crește cu p, fiind o modificare făcută de Jonathan

2 x y p: cantitatea de fructe din merii cu indici cuprinși între x și y scade cu p, fiind o modificare făcută de vrăjitorul Afida

Mai mult: În cadrul livezii împăratului, există câțiva meri extra magici care influențează modificările pe care le fac cei doi. Dacă în cadrul unei modificări a lui Jonathan, după y există un măr extra magic t, astfel încât între y și t nu există alt măr extra magic, interogarea cuprinsă între x și y se va transforma în interogare între x și t. Dacă în cadrul unei modificări a lui Afida, înaintea lui x există un măr extra magic t, astfel încât între t și x nu există alt măr extra magic, interogarea cuprinsă între x și y se va transforma în interogare între t și y.
Să se afișeze cantitatea de fructe din fiecare măr după cele q modificări.

== Date de intrare ==
Pe prima linie a fișierului livada2.in se găsește numărul n. Pe următoarea linie se găsesc n numere întregi, separate printr-un spațiu, al i-lea număr reprezentând cantitatea de fructe din mărul corespunzător. Pe următoarea linie se găsesc n numere, 0 sau 1, separate printr-un spațiu, valorile 1 indicând faptul că mărul de pe poziția i este extra special. Pe a 4-a linie se află numărul q de modificări. Următoarele q linii vor conține interogările, fiind de forma: c x y p. Dacă c=1, modificarea este făcută de Jonathan. Dacă c=2, modificarea este făcută de vrăjitorul Afida.

== Date de ieșire ==
n fișierul livada2.out vor fi afișate:
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou ''' n numere întregi separate prin câte un spațiu, reprezentând valorile din m, adică cantitatea de fructe a fiecărui măr''', 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 ≤ n ≤ 100.000
* 1 ≤ q ≤ 250.000
* 1 ≤ m[i] ≤ 1000, pentru 1 ≤ i ≤ n
* Pentru 40 de puncte, q ≤ 1000 și n ≤ 1000
* Pentru alte 20 de puncte, nu vor exista meri extra speciali
== Exemplu 1 ==
; Intrare
: livada2.in
: 10
: 17 18 2 21 14 6 13 14 8 10
: 1 1 0 0 0 0 1 0 0 0
: 7
: 2 4 7 3
: 1 8 9 16
: 2 8 8 25
: 2 4 4 8
: 1 2 8 1
: 2 8 9 21
: 1 5 6 19
; Ieșire
: Datele sunt introduse correct.
: livada2.out
: 17 8 -8 11 31 23 -16 -15 3 10

== Exemplu 2 ==
; Intrare
: livada2.in
: 10
: 17 18 2 21 14 6 13 14 8 10
: 1 1 0 0 0 0 1 0 0 0
: -1 2 3 -78 -23 2.34
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 4177 - livada2

def apply_query(n, m, is_extra, query):
c, x, y, p = query
x -= 1 # convertim la 0-indexing
y -= 1
t1, t2 = None, None
for i in range(x, y + 1):
if is_extra[i]:
if i < y and not t1:
t1 = i
if i > x and not t2:
t2 = i
if c == 1: # modificarea lui Jonathan
for i in range(x, y + 1):
if t1 and i > t1:
break
m[i] += p
else: # modificarea lui Afida
for i in range(y, x - 1, -1):
if t2 and i < t2:
break
m[i] -= p

def validate(n, m):
for i in range(n):
assert m[i] >= 0

def write_output(m):
with open("livada2.out", "w") as file:
file.write("Datele sunt introduse corect.\n")
file.write(" ".join(map(str, m)))

def solve_problem(n, m, is_extra, q, queries):
try:
validate(n, m)
for query in queries:
apply_query(n, m, is_extra, query)
write_output(m)
except AssertionError:
print("Datele nu corespund restricțiilor impuse.")

if __name__ == "__main__":
n = int(input())
m = list(map(int, input().split()))
is_extra = list(map(int, input().split()))
q = int(input())
queries = []
for i in range(q):
query = list(map(int, input().split()))
queries.append(query)
solve_problem(n, m, is_extra, q, queries)

</syntaxhighlight>
== Explicatie Rezolvare ==
apply_query(n, m, is_extra, query): Această funcție primește parametrii n, m, is_extra și query și aplică modificarea specificată de interogare (query) asupra listei m. Modificările sunt efectuate conform regulilor specificate în cerință. Funcția nu returnează nimic, deoarece modificările sunt aplicate direct asupra listei m.

validate(n, m): Această funcție primește parametrii n și m și verifică dacă valorile din lista m respectă restricțiile impuse. Dacă găsește o valoare negativă, ridică o excepție AssertionError. Dacă nu există excepții, se consideră că datele sunt valide.

write_output(m): Această funcție primește lista m și scrie rezultatul în fișierul "livada2.out". În fișier, se afișează mesajul "Datele sunt introduse corect." urmat de valorile din lista m separate prin spații.

solve_problem(n, m, is_extra, q, queries): Această funcție primește toți parametrii necesari pentru a rezolva problema. Ea se ocupă de apelarea celorlalte funcții în ordinea corectă. Mai întâi, verifică dacă datele sunt valide utilizând funcția validate. Apoi, aplică fiecare interogare din lista queries utilizând funcția apply_query. La final, scrie rezultatul în fișierul de ieșire utilizând funcția write_output.

Blocul if __name__ == "__main__": Acest bloc verifică dacă codul este executat direct (nu importat ca modul). În acest caz, se face citirea datelor de intrare utilizând funcția input() și se apelează funcția solve_problem cu parametrii corespunzători.

2142 - easy sum

2023-05-14T22:27:14Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/2142/easy-sum 2142 - easy sum]
----
== Cerinţa ==
Se consideră un vector cu n elemente numere naturale. Calculați suma sumelor tuturor subsecvențelor ce se pot forma cu elementele vectorului. Pentru că suma poate fi foarte mare, afișați suma modulo 1.000.000.007.

== Date de intrare ==
Fișierul de intrare easy_sum.in conține pe prima linie numărul n, iar pe a doua linie n numere naturale separate prin spații.

== Date de ieșire ==
Fișierul de ieșire easy_sum.out va conține:
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' fișierul de ieșire easy_sum.out va conține numărul S, reprezentând suma sumelor tuturor subsecvențelor modulo 1.000.000.007''', 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 ≤ n ≤ 100.000
* numerele de pe a doua linie a fișierului de intrare vor fi cuprinse în intervalul [1,1.000.000]
* prin subsecvență înțelegem orice înșiruire de elemente din vector aflate pe poziții consecutive.
== Exemplu 1 ==
; Intrare
: easy_sum.in
: 3
: 1 2 3
; Ieșire
: Datele sunt introduse correct.
: easy_sum.out
: 20

== Exemplu 2 ==
; Intrare
: easy_sum.in
: 21
: 1 2 3 4 2 7 -8
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 2142 - easy sum

MOD = 1000000007

def validate_input(n, arr):
if not (1 <= n <= 100000):
return False
if len(arr) != n:
return False
if any(num < 1 or num > 1000000 for num in arr):
return False
return True

def calculate_subsequence_sum(n, arr):
if not validate_input(n, arr):
return "Datele nu corespund restricțiilor impuse."

MOD = 1000000007
total_sum = 0

for i in range(n):
total_sum = (total_sum + (arr[i] * (i + 1) * (n - i)) % MOD) % MOD

return total_sum

if __name__ == "__main__":
file_name = "easy_sum.in"
with open(file_name, "r") as file:
n = int(file.readline())
arr = list(map(int, file.readline().split()))

result = calculate_subsequence_sum(n, arr)
print(result)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(n, arr):

Această funcție primește doi parametri: n - numărul de elemente din vector și arr - lista de numere.
Verifică dacă valoarea n se încadrează în intervalul specificat în cerință și dacă lungimea listei arr este egală cu n.
Verifică, de asemenea, dacă există vreun număr din lista arr care este mai mic decât 1 sau mai mare decât 1000000. Dacă da, se returnează False, semnalând că datele nu corespund restricțiilor impuse.
Dacă toate verificările sunt trecute cu succes, înseamnă că datele de intrare sunt valide, astfel că se returnează True.
Funcția calculate_subsequence_sum(n, arr):

Această funcție primește doi parametri: n - numărul de elemente din vector și arr - lista de numere.
Verifică mai întâi validitatea datelor de intrare folosind funcția validate_input(n, arr). Dacă datele nu sunt valide, returnează un mesaj corespunzător.
Inițializează variabila total_sum cu valoarea 0, care va fi utilizată pentru a calcula suma subsecvențelor.
Parcurge lista arr și pentru fiecare element, adaugă la total_sum valoarea elementului înmulțită cu (i + 1) * (n - i). Aceasta reprezintă numărul de subsecvențe în care elementul curent apare.
Se aplică modularitatea cu MOD pentru a menține suma subsecvențelor într-un interval valid.
La final, se returnează total_sum calculat modulo MOD.
În funcția if __name__ == "__main__", se realizează citirea datelor de intrare din fișierul

1350 - produs2

2023-05-14T22:26:25Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/1350/produs2 1350 - produs2]
----
== Cerinţa ==
Se dă un şir cu n numere naturale nenule. Aflaţi câte secvenţe din şir au produsul mai mic decât un număr natural p dat.

== Date de intrare ==
Fișierul de intrare produs2.in conține pe prima linie numerele n şi p, iar pe a doua linie n numere naturale nenule separate prin spații, reprezentând elementele şirului.

== Date de ieșire ==
Fișierul de ieșire produs2.out va conține:
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' fișierul de ieșire produs2.out va conține 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 ≤ n ≤ 1.000.000
* 1 < p ≤ 2.000.000.000
* numerele din şir vor fi mai mici decât 1.000
== Exemplu 1 ==
; Intrare
: produs2.in
: 5 10
: 1 2 3 4 2
; Ieșire
: Datele sunt introduse correct.
: produs2.out
: 9
== Exemplu 2 ==
; Intrare
: produs2.in
: 1 2 3 4 5
: 21 57 44 90
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 1350 - produs2

def validate_input(n, p, arr):
if not (1 <= n <= 1000000):
return False
if not (1 < p <= 2000000000):
return False
if len(arr) != n:
return False
if any(num >= 1000 for num in arr):
return False
return True

def count_sequences(n, p, arr):
if not validate_input(n, p, arr):
return "Datele nu corespund restricțiilor impuse."

count = 0
product = 1

for i in range(n):
product *= arr[i]

if product < p:
count += 1
else:
product //= arr[i - count]
count -= 1

return count

if __name__ == "__main__":
file_name = "produs2.in"
with open(file_name, "r") as file:
n, p = map(int, file.readline().split())
arr = list(map(int, file.readline().split()))

result = count_sequences(n, p, arr)
print(result)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(n, p, arr):

Această funcție primește trei parametri: n - numărul de elemente din șir, p - limita produsului și arr - lista de numere.
Verifică dacă valorile n și p se încadrează în intervalele valide specificate în cerință și dacă lungimea listei arr este egală cu n.
Verifică, de asemenea, dacă există vreun număr din lista arr care este mai mare sau egal cu 1000. Dacă da, se returnează False, semnalând că datele nu corespund restricțiilor impuse.
Dacă toate verificările sunt trecute cu succes, înseamnă că datele de intrare sunt valide, astfel că se returnează True.
Funcția count_sequences(n, p, arr):

Această funcție primește trei parametri: n - numărul de elemente din șir, p - limita produsului și arr - lista de numere.
Verifică mai întâi validitatea datelor de intrare folosind funcția validate_input(n, p, arr). Dacă datele nu sunt valide, returnează un mesaj corespunzător.
Inițializează variabila count cu valoarea 0, care va fi utilizată pentru a număra secvențele cu produs mai mic decât p.
Inițializează variabila product cu valoarea 1, care reprezintă produsul curent al secvenței.
Parcurge lista arr și în fiecare pas înmulțește product cu elementul curent.
Functia if __name__ == '__main__' se dechisde fisierul din care se citesc datele pentru a se rezolva problema

1350 - produs2

2023-05-14T22:26:14Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/1350/produs2 1350 - produs2]
----
== Cerinţa ==
Se dă un şir cu n numere naturale nenule. Aflaţi câte secvenţe din şir au produsul mai mic decât un număr natural p dat.

== Date de intrare ==
Fișierul de intrare produs2.in conține pe prima linie numerele n şi p, iar pe a doua linie n numere naturale nenule separate prin spații, reprezentând elementele şirului.

== Date de ieșire ==
Fișierul de ieșire produs2.out va conține:
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."'''fișierul de ieșire produs2.out va conține 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 ≤ n ≤ 1.000.000
* 1 < p ≤ 2.000.000.000
* numerele din şir vor fi mai mici decât 1.000
== Exemplu 1 ==
; Intrare
: produs2.in
: 5 10
: 1 2 3 4 2
; Ieșire
: Datele sunt introduse correct.
: produs2.out
: 9
== Exemplu 2 ==
; Intrare
: produs2.in
: 1 2 3 4 5
: 21 57 44 90
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 1350 - produs2

def validate_input(n, p, arr):
if not (1 <= n <= 1000000):
return False
if not (1 < p <= 2000000000):
return False
if len(arr) != n:
return False
if any(num >= 1000 for num in arr):
return False
return True

def count_sequences(n, p, arr):
if not validate_input(n, p, arr):
return "Datele nu corespund restricțiilor impuse."

count = 0
product = 1

for i in range(n):
product *= arr[i]

if product < p:
count += 1
else:
product //= arr[i - count]
count -= 1

return count

if __name__ == "__main__":
file_name = "produs2.in"
with open(file_name, "r") as file:
n, p = map(int, file.readline().split())
arr = list(map(int, file.readline().split()))

result = count_sequences(n, p, arr)
print(result)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(n, p, arr):

Această funcție primește trei parametri: n - numărul de elemente din șir, p - limita produsului și arr - lista de numere.
Verifică dacă valorile n și p se încadrează în intervalele valide specificate în cerință și dacă lungimea listei arr este egală cu n.
Verifică, de asemenea, dacă există vreun număr din lista arr care este mai mare sau egal cu 1000. Dacă da, se returnează False, semnalând că datele nu corespund restricțiilor impuse.
Dacă toate verificările sunt trecute cu succes, înseamnă că datele de intrare sunt valide, astfel că se returnează True.
Funcția count_sequences(n, p, arr):

Această funcție primește trei parametri: n - numărul de elemente din șir, p - limita produsului și arr - lista de numere.
Verifică mai întâi validitatea datelor de intrare folosind funcția validate_input(n, p, arr). Dacă datele nu sunt valide, returnează un mesaj corespunzător.
Inițializează variabila count cu valoarea 0, care va fi utilizată pentru a număra secvențele cu produs mai mic decât p.
Inițializează variabila product cu valoarea 1, care reprezintă produsul curent al secvenței.
Parcurge lista arr și în fiecare pas înmulțește product cu elementul curent.
Functia if __name__ == '__main__' se dechisde fisierul din care se citesc datele pentru a se rezolva problema

0310 - SecvPal

2023-05-14T22:24:48Z

Monica Dragos:

Sursa: [https://www.pbinfo.ro/probleme/310/secvpal 0310 - SecvPal]
----

== Cerinţa ==
O secvenţă a unui vector se numeşte palindromică dacă primul element ale secvenţei este egal cu ultimul, al doilea cu penultimul, etc.

Se dă un vector cu n elemente, numere naturale. Determinaţi secvenţa palindromică de lungime maximă.

== Date de intrare ==
Fişierul de intrare secvpal.in conţine pe prima linie numărul n; urmează cele n elemente ale vectorului, dispuse pe mai multe linii şi separate prin spaţii.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', fişierul de ieşire secvpal.out ''' numerele p şi u, reprezentând indicii de început şi sfârşit ai secvenţei determinate''', 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 ≤ n ≤ 1000;
* numerele de pe a doua linie a fişierului de intrare vor avea cel mult 4 cifre;
* dacă există mai multe secvenţe palindromice de lungime maximă, se va determina cea mai din stânga;
== Exemplu 1 ==
; Intrare
: secvpal.in
: 12
: 1 2 10 9 8 5 8 9 10 5 5 10
; Ieșire
: Datele sunt introduse correct.
: secvpal.out
: 3 9

== Exemplu 2 ==
; Intrare
: secvpal.in
: 99
: 9 2 8 4 7 1 23 37 7 3
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0310 - SecvPal

def validate_input(n, arr):
if not (1 <= n <= 1000):
return False
if len(arr) != n:
return False
return True

def find_max_palindrome(n, arr):
if not validate_input(n, arr):
return "Datele nu corespund restricțiilor impuse."

max_length = 0
start = 0
end = 0

for i in range(n):
for j in range(i, n):
if arr[i:j+1] == arr[i:j+1][::-1] and len(arr[i:j+1]) > max_length:
max_length = len(arr[i:j+1])
start = i
end = j

return f"{start + 1} {end + 1}"

if __name__ == "__main__":
file_name = "secvpal.in"
with open(file_name, "r") as file:
n = int(file.readline())
arr = list(map(int, file.readline().split()))

result = find_max_palindrome(n, arr)
print(result)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(n, arr):
Această funcție primește doi parametri, n și arr, reprezentând numărul de elemente din vector (n) și vectorul în sine (arr).
Verifică dacă numărul n se află în intervalul valid, adică între 1 și 1000. Dacă nu este adevărată această condiție, returnează False, semnalând că datele nu corespund restricțiilor impuse.
Verifică dacă lungimea vectorului arr este egală cu n. Dacă această condiție nu este îndeplinită, returnează False.
Dacă toate verificările sunt trecute cu succes, înseamnă că datele de intrare sunt valide, astfel că returnează True.
Funcția find_max_palindrome(n, arr):

Această funcție primește doi parametri, n și arr, reprezentând numărul de elemente din vector (n) și vectorul în sine (arr).
Verifică mai întâi validitatea datelor de intrare folosind funcția validate_input(n, arr). Dacă datele nu sunt valide, returnează un mesaj corespunzător.
Inițializează variabilele max_length, start și end cu valorile 0. Acestea vor fi actualizate pe măsură ce se găsesc secvențe palindromice de lungime maximă.
Parcurge toate sub-secvențele posibile ale vectorului, utilizând două bucle for imbricate (i și j).
Verifică dacă sub-secvența curentă, arr[i:j+1], este un palindrom. Aceasta se realizează prin compararea sub-secvenței cu reversul său, arr[i:j+1][::-1].
Dacă sub-secvența este un palindrom și are o lungime mai mare decât max_length, se actualizează max_length cu noua valoare a lungimii, iar start și end cu indicii de început și sfârșit ai secvenței palindromice.
După parcurgerea tuturor sub-secvențelor, se returnează o frază formatată care indică indicii de început și sfârșit ai celei mai lungi secvențe palindromice găsite în vectorul dat.
În funcția if __name__ == "__main__", se realizează citirea datelor de intrare din fișierul "secvpal.in" și se apelează funcția find_max_palindrome cu valorile citite. Rezultatul este apoi afișat pe ecran.

Aceste funcții rezolvă problema cerută de determinare a celei mai lungi secvențe palindromice dintr-un vector

0310 - SecvPal

2023-05-14T22:24:00Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/310/secvpal 0310 - SecvPal]
----
O secvenţă a unui vector se numeşte palindromică dacă primul element ale secvenţei este egal cu ultimul, al doilea cu penultimul, etc.

== Cerinţa ==
Se dă un vector cu n elemente, numere naturale. Determinaţi secvenţa palindromică de lungime maximă.

== Date de intrare ==
Fişierul de intrare secvpal.in conţine pe prima linie numărul n; urmează cele n elemente ale vectorului, dispuse pe mai multe linii şi separate prin spaţii.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', fişierul de ieşire secvpal.out ''' numerele p şi u, reprezentând indicii de început şi sfârşit ai secvenţei determinate''', 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 ≤ n ≤ 1000;
* numerele de pe a doua linie a fişierului de intrare vor avea cel mult 4 cifre;
* dacă există mai multe secvenţe palindromice de lungime maximă, se va determina cea mai din stânga;
== Exemplu 1 ==
; Intrare
: secvpal.in
: 12
: 1 2 10 9 8 5 8 9 10 5 5 10
; Ieșire
: Datele sunt introduse correct.
: secvpal.out
: 3 9

== Exemplu 2 ==
; Intrare
: secvpal.in
: 99
: 9 2 8 4 7 1 23 37 7 3
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0310 - SecvPal

def validate_input(n, arr):
if not (1 <= n <= 1000):
return False
if len(arr) != n:
return False
return True

def find_max_palindrome(n, arr):
if not validate_input(n, arr):
return "Datele nu corespund restricțiilor impuse."

max_length = 0
start = 0
end = 0

for i in range(n):
for j in range(i, n):
if arr[i:j+1] == arr[i:j+1][::-1] and len(arr[i:j+1]) > max_length:
max_length = len(arr[i:j+1])
start = i
end = j

return f"{start + 1} {end + 1}"

if __name__ == "__main__":
file_name = "secvpal.in"
with open(file_name, "r") as file:
n = int(file.readline())
arr = list(map(int, file.readline().split()))

result = find_max_palindrome(n, arr)
print(result)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(n, arr):
Această funcție primește doi parametri, n și arr, reprezentând numărul de elemente din vector (n) și vectorul în sine (arr).
Verifică dacă numărul n se află în intervalul valid, adică între 1 și 1000. Dacă nu este adevărată această condiție, returnează False, semnalând că datele nu corespund restricțiilor impuse.
Verifică dacă lungimea vectorului arr este egală cu n. Dacă această condiție nu este îndeplinită, returnează False.
Dacă toate verificările sunt trecute cu succes, înseamnă că datele de intrare sunt valide, astfel că returnează True.
Funcția find_max_palindrome(n, arr):

Această funcție primește doi parametri, n și arr, reprezentând numărul de elemente din vector (n) și vectorul în sine (arr).
Verifică mai întâi validitatea datelor de intrare folosind funcția validate_input(n, arr). Dacă datele nu sunt valide, returnează un mesaj corespunzător.
Inițializează variabilele max_length, start și end cu valorile 0. Acestea vor fi actualizate pe măsură ce se găsesc secvențe palindromice de lungime maximă.
Parcurge toate sub-secvențele posibile ale vectorului, utilizând două bucle for imbricate (i și j).
Verifică dacă sub-secvența curentă, arr[i:j+1], este un palindrom. Aceasta se realizează prin compararea sub-secvenței cu reversul său, arr[i:j+1][::-1].
Dacă sub-secvența este un palindrom și are o lungime mai mare decât max_length, se actualizează max_length cu noua valoare a lungimii, iar start și end cu indicii de început și sfârșit ai secvenței palindromice.
După parcurgerea tuturor sub-secvențelor, se returnează o frază formatată care indică indicii de început și sfârșit ai celei mai lungi secvențe palindromice găsite în vectorul dat.
În funcția if __name__ == "__main__", se realizează citirea datelor de intrare din fișierul "secvpal.in" și se apelează funcția find_max_palindrome cu valorile citite. Rezultatul este apoi afișat pe ecran.

Aceste funcții rezolvă problema cerută de determinare a celei mai lungi secvențe palindromice dintr-un vector

0310 - SecvPal

2023-05-14T22:23:48Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/310/secvpal 0310 - SecvPal]
----
O secvenţă a unui vector se numeşte palindromică dacă primul element ale secvenţei este egal cu ultimul, al doilea cu penultimul, etc.

== Cerinţa ==
Se dă un vector cu n elemente, numere naturale. Determinaţi secvenţa palindromică de lungime maximă.

== Date de intrare ==
Fişierul de intrare secvpal.in conţine pe prima linie numărul n; urmează cele n elemente ale vectorului, dispuse pe mai multe linii şi separate prin spaţii.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', işierul de ieşire secvpal.out ''' numerele p şi u, reprezentând indicii de început şi sfârşit ai secvenţei determinate''', 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 ≤ n ≤ 1000;
* numerele de pe a doua linie a fişierului de intrare vor avea cel mult 4 cifre;
* dacă există mai multe secvenţe palindromice de lungime maximă, se va determina cea mai din stânga;
== Exemplu 1 ==
; Intrare
: secvpal.in
: 12
: 1 2 10 9 8 5 8 9 10 5 5 10
; Ieșire
: Datele sunt introduse correct.
: secvpal.out
: 3 9

== Exemplu 2 ==
; Intrare
: secvpal.in
: 99
: 9 2 8 4 7 1 23 37 7 3
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0310 - SecvPal

def validate_input(n, arr):
if not (1 <= n <= 1000):
return False
if len(arr) != n:
return False
return True

def find_max_palindrome(n, arr):
if not validate_input(n, arr):
return "Datele nu corespund restricțiilor impuse."

max_length = 0
start = 0
end = 0

for i in range(n):
for j in range(i, n):
if arr[i:j+1] == arr[i:j+1][::-1] and len(arr[i:j+1]) > max_length:
max_length = len(arr[i:j+1])
start = i
end = j

return f"{start + 1} {end + 1}"

if __name__ == "__main__":
file_name = "secvpal.in"
with open(file_name, "r") as file:
n = int(file.readline())
arr = list(map(int, file.readline().split()))

result = find_max_palindrome(n, arr)
print(result)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(n, arr):
Această funcție primește doi parametri, n și arr, reprezentând numărul de elemente din vector (n) și vectorul în sine (arr).
Verifică dacă numărul n se află în intervalul valid, adică între 1 și 1000. Dacă nu este adevărată această condiție, returnează False, semnalând că datele nu corespund restricțiilor impuse.
Verifică dacă lungimea vectorului arr este egală cu n. Dacă această condiție nu este îndeplinită, returnează False.
Dacă toate verificările sunt trecute cu succes, înseamnă că datele de intrare sunt valide, astfel că returnează True.
Funcția find_max_palindrome(n, arr):

Această funcție primește doi parametri, n și arr, reprezentând numărul de elemente din vector (n) și vectorul în sine (arr).
Verifică mai întâi validitatea datelor de intrare folosind funcția validate_input(n, arr). Dacă datele nu sunt valide, returnează un mesaj corespunzător.
Inițializează variabilele max_length, start și end cu valorile 0. Acestea vor fi actualizate pe măsură ce se găsesc secvențe palindromice de lungime maximă.
Parcurge toate sub-secvențele posibile ale vectorului, utilizând două bucle for imbricate (i și j).
Verifică dacă sub-secvența curentă, arr[i:j+1], este un palindrom. Aceasta se realizează prin compararea sub-secvenței cu reversul său, arr[i:j+1][::-1].
Dacă sub-secvența este un palindrom și are o lungime mai mare decât max_length, se actualizează max_length cu noua valoare a lungimii, iar start și end cu indicii de început și sfârșit ai secvenței palindromice.
După parcurgerea tuturor sub-secvențelor, se returnează o frază formatată care indică indicii de început și sfârșit ai celei mai lungi secvențe palindromice găsite în vectorul dat.
În funcția if __name__ == "__main__", se realizează citirea datelor de intrare din fișierul "secvpal.in" și se apelează funcția find_max_palindrome cu valorile citite. Rezultatul este apoi afișat pe ecran.

Aceste funcții rezolvă problema cerută de determinare a celei mai lungi secvențe palindromice dintr-un vector

0297 - SecvSumMax

2023-05-14T22:06:23Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/297/secvsummax 0297 - SecvSumMax]
----
== Cerinţa ==
Se dă un șir cu n elemente, numere întregi. Determinați secvența de elemente cu suma maximă.

== Date de intrare ==
Fișierul de intrare secvsummax.in conține pe prima linie numărul n; urmează cele n elemente ale șirului, dispuse pe mai multe linii și separate prin spații.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' fișierul de ieșire secvsummax.out va conține''' numerele p și u, separate printr-un spațiu, reprezentând poziția de început și de sfârșit a secvenței determinate''', 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 ≤ n ≤ 100.000
* elementele șirului vor avea cel mult 4 cifre și sunt numerotate de la 1 la n
* dacă șirul conține mai multe secvențe de suma maximă, se va determina cea cu indicele de început cel mai mic, iar în caz de egalitate, cea mai scurtă
* șirul va conține cel puțin un element pozitiv
== Exemplu 1 ==
; Intrare
: secvsummax.out
: 10
: -4 1 -5 1 4 -2 2 3 -4 4
; Ieșire
: secvsummax.out
: Datele sunt introduse correct.
: 4 8

== Exemplu 2 ==
; Intrare
: secvsummax.out
: 67
: -1 2 3 -10 2 8 5 8 4
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0297 - SecvSumMax

def validate_input(n, nums):
if not (1 <= n <= 100000):
return False
if len(nums) != n:
return False
if all(num <= 0 for num in nums):
return False
return True

def find_max_subsequence(n, nums):
if not validate_input(n, nums):
return "Datele nu corespund restricțiilor impuse."

start, end = 0, 0
max_sum = 0
current_sum = 0

for i in range(n):
current_sum += nums[i]
if current_sum > max_sum:
max_sum = current_sum
end = i
if current_sum < 0:
current_sum = 0
start = i + 1

return f"{start + 1} {end + 1}"

if __name__ == "__main__":
file_name = "secvsummax.in"
with open(file_name, "r") as file:
n = int(file.readline())
nums = []
for _ in range(n):
nums.extend(map(int, file.readline().split()))

result = find_max_subsequence(n, nums)
print(result)

</syntaxhighlight>
== Explicatie Rezolvare ==
validate_input(n, nums): Această funcție primește un număr n și o listă nums și validează datele de intrare în conformitate cu restricțiile impuse. Verificările efectuate sunt:

Verifică dacă n se află în intervalul [1, 100000]. Dacă nu se îndeplinește această condiție, funcția returnează False, semnalând că datele nu sunt valide.
Verifică dacă lungimea listei nums este egală cu n. Dacă lungimea nu este corectă, funcția returnează False.
Verifică dacă toate numerele din lista nums sunt mai mici sau egale cu 0. Dacă există cel puțin un număr mai mare decât 0, funcția returnează False.
Dacă toate aceste verificări sunt îndeplinite, funcția returnează True, semnalând că datele de intrare sunt valide.
find_max_subsequence(n, nums): Această funcție primește un număr n și o listă nums și aplică algoritmul pentru a găsi secvența de elemente cu suma maximă. Funcția începe prin apelarea funcției validate_input pentru a verifica validitatea datelor de intrare. Dacă datele nu sunt valide, funcția returnează mesajul "Datele nu corespund restricțiilor impuse."

Dacă datele sunt valide, funcția inițializează variabilele start, end, max_sum și current_sum cu valorile inițiale 0. Apoi, parcurge lista nums folosind un buclă for și adaugă fiecare element la suma curentă current_sum. Dacă current_sum devine mai mare decât max_sum, actualizează max_sum cu current_sum și actualizează end la poziția curentă. Dacă current_sum devine mai mică decât 0, resetează-o la 0 și actualizează start la poziția curentă + 1.

La finalul buclei, funcția returnează rezultatul sub forma unui șir format din start + 1 și end + 1. Adăugarea valorii 1 este necesară pentru a respecta numerotarea elementelor de la 1 la n.

__main__: Această secțiune verifică dacă scriptul este executat direct (nu importat ca modul) și conține codul de citire a fișierului de intrare și apelarea funcției find_max_subsequence. Mai întâi, se deschide fișierul de intrare secvsummax.in în modul "r" (citire). Se citește prima linie pentru a obține valoarea lui n, iar apoi se citesc următoarele `n

3939 - Intervale6

2023-05-14T22:05:40Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3939/intervale6 - Intervale6]
----
== Cerinţa ==
Se dă un șir n numere naturale separate prin câte un spațiu.
Se cere să se afișeze numărul de intervale care nu conțin niciun termen al șirului.

== Date de intrare ==
Fișierul de intrare intervale6.in conține:
* pe prima linie un număr n.
* pe a doua linie un șir de n numere.
* iar pe fiecare dintre următoarele linii, până la finalul fișierului, câte o pereche de numere, reprezentând extremitățile unui interval închis.

== 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 ''' fișierul intervale6.out conține numărul de intervale care nu conțin niciun termen al șirului aflat pe a doua linie a fișierului.''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* Fișierul intervale6.in conține numere naturale din intervalul [1, 10.000].
* Numerele aflate pe a doua linie a fișierului sunt în ordine crescătoare.
* Vor fi cel mult 200.000 de intervale
== Exemplu 1 ==
; Intrare
: intervale6.in
: 5
: 4 8 9 16 25
: 1 3
: 2 5
: 9 15
: 5 7
: 20 100
: 10 12
; Ieșire
: Datele sunt introduse correct.
: intervale6.out
: 3

== Exemplu 2 ==
; Intrare
: intervale6.in
: 2 1
: 1 2 3 4 8 9 16 25
: 2 6
: 9 1
: 9 15
: 11 23
: 25 70
: 10 12
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3939 - Intervale6

def validate_input(n, sir, intervale):
if n < 1 or n > 10000:
return False

if len(sir) != n or any(sir[i] >= sir[i+1] for i in range(n-1)):
return False

if len(intervale) > 200000:
return False

return True

def numar_intervale(n, sir, intervale):
if not validate_input(n, sir, intervale):
return "Datele nu corespund restricțiilor impuse."

termene_sir = set(sir)
numar_intervale_fara_termene = 0

for i, j in intervale:
interval_are_termen = False
for termen in sir:
if i <= termen <= j:
interval_are_termen = True
break
if not interval_are_termen:
numar_intervale_fara_termene += 1

return numar_intervale_fara_termene

if __name__ == "__main__":
with open("intervale6.in", "r") as fin:
n = int(fin.readline())
sir = list(map(int, fin.readline().split()))
intervale = []
for line in fin.readlines():
i, j = map(int, line.split())
intervale.append((i, j))

rezultat = numar_intervale(n, sir, intervale)

if isinstance(rezultat, str):
print(rezultat)
else:
print("Datele sunt introduse corect.")
print(rezultat)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(n, sir, intervale): Această funcție primește parametrii n, sir și intervale și are rolul de a valida datele de intrare conform restricțiilor impuse în cerință. Verificările includ:

Verifică dacă n se încadrează în intervalul permis (1 ≤ n ≤ 10,000).
Verifică dacă sir are lungimea n și este ordonat în mod crescător.
Verifică dacă numărul de intervale intervale este mai mic sau egal cu 200,000.
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția numar_intervale(n, sir, intervale): Această funcție primește datele de intrare n, sir și intervale și rezolvă problema în conformitate cu cerințele. Algoritmul funcției este următorul:

Verifică dacă datele de intrare sunt valide utilizând funcția validate_input. Dacă nu sunt valide, funcția returnează un mesaj de eroare.
Creează un set termene_sir care conține toate numerele din sir.
Inițializează variabila numar_intervale_fara_termene cu 0, care va reprezenta numărul de intervale care nu conțin niciun termen din sir.
Pentru fiecare interval din lista intervale, verifică dacă există cel puțin un termen din sir în interval. Dacă nu există, incrementăm numar_intervale_fara_termene.
Returnează numar_intervale_fara_termene.
Blocul if __name__ == "__main__": Acest bloc de cod verifică dacă scriptul Python este rulat direct (nu importat ca modul în alt script). În acest caz, citirea datelor de intrare se face din fișierul "intervale6.in" și se apelează funcția numar_intervale pentru a rezolva problema. Rezultatul este afișat în consolă.

0190 - Oglindiri

2023-05-14T22:03:15Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/190/oglindiri 0190 - Oglindiri]
----
== Cerinţa ==
Se dă un vector cu n elemente numere naturale, numerotate de la 1 la n, și m perechi de indici (i,j), cu 1≤i<j≤n. Fiecare secvență de elemente determinată de o pereche (i,j) se oglindește – primul elemente din secvență se interschimbă cu ultimul, al doilea cu penultimul, etc..

Să se afișeze elementele vectorului după realizarea, în ordine, a celor m oglindiri.

== Date de intrare ==
Fişierul de intrare oglindiri.in conţine pe prima linie numărul n, iar pe a doua linie cele n elemente ale vectorului. Următoarea linie conține numărul m, iar următoarele m linii câte o pereche de indici i j.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."'''și fișierul oglindiri.out n elemente ale vectorul obținute după cele m oglindiri, separate prin câte un spațiu''', 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 ≤ n ≤ 100
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât 1000
* 1 ≤ m ≤ 100
== Exemplu 1 ==
; Intrare
: oglindiri.in
: 10
: 55 50 16 37 66 44 31 24 10 63
: 3
: 5 8
: 2 6
: 6 10
; Ieșire
: oglindiri.out
: Datele sunt introduse correct.
: 55 31 24 37 16 63 10 66 44 50

== Exemplu 2 ==
; Intrare
: oglindiri.in
: 2
: 55 50 16 37 66 44 31 24 10 63
: 3 2 1
: 51 8
: 22 6
: 68 10
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0190 - Oglindiri

def validate_input(n, vector, m, perechi):
if n < 1 or n > 100 or m < 1 or m > 100:
return False

if len(vector) != n or any(num >= 1000 for num in vector):
return False

if any(i >= j or i <= 0 or j > n for i, j in perechi):
return False

return True

def oglindiri(n, vector, m, perechi):
if not validate_input(n, vector, m, perechi):
return "Datele nu corespund restricțiilor impuse."

for i, j in perechi:
i -= 1
j -= 1
while i < j:
vector[i], vector[j] = vector[j], vector[i]
i += 1
j -= 1

return vector

if __name__ == "__main__":
with open("oglindiri.in", "r") as fin:
n = int(fin.readline())
vector = list(map(int, fin.readline().split()))
m = int(fin.readline())
perechi = []
for _ in range(m):
i, j = map(int, fin.readline().split())
perechi.append((i, j))

rezultat = oglindiri(n, vector, m, perechi)

if isinstance(rezultat, str):
print(rezultat)
else:
print("Datele sunt introduse corect.")
print(" ".join(str(num) for num in rezultat))

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(n, vector, m, perechi): Această funcție primește parametrii n, vector, m și perechi și are rolul de a valida datele de intrare conform restricțiilor impuse în cerință. Verificările includ:

Verifică dacă n și m se încadrează în intervalul permis (1 ≤ n, m ≤ 100).
Verifică dacă lungimea listei vector este egală cu n și dacă toate numerele din vector sunt mai mici decât 1000.
Verifică dacă toate perechile (i, j) din lista perechi satisfac restricțiile: 1 ≤ i < j ≤ n.
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția oglindiri(n, vector, m, perechi): Această funcție primește datele de intrare n, vector, m și perechi și rezolvă problema în conformitate cu cerințele. Algoritmul funcției este următorul:

Verifică dacă datele de intrare sunt valide utilizând funcția validate_input. Dacă nu sunt valide, funcția returnează un mesaj de eroare.
Pentru fiecare pereche (i, j) din lista perechi:
Aduce indicii i și j la forma corectă pentru indexarea în Python (scăzând 1 din fiecare).
Realizează oglindirea în lista vector între indicii i și j, prin interschimbarea elementelor în mod repetat până când indicii se întâlnesc.
Returnează lista vector obținută după efectuarea oglindirilor.
Blocul if __name__ == "__main__": Acest bloc de cod verifică dacă scriptul Python este rulat direct (nu importat ca modul în alt script). În acest caz, citirea datelor de intrare se face din fișierul "oglindiri.in" și se apelează funcția oglindiri pentru a rezolva problema. Rezultatul este afișat în consolă.

0181 - SecvCresc

2023-05-14T20:36:25Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/181/secvcresc 0181 - SecvCresc]
----
== Cerinţa ==
Se dau n numere naturale, reprezentând elementele unui vector. Determinați cea mai lungă secvență de elemente ordonate strict crescător din vector. Dacă există mai multe astfel de secvențe se va determina cea mai din stânga.

== Date de intrare ==
Fișierul de intrare secvcresc.in conține numărul n și n valori naturale, reprezentând elementele vectorului. Valorile din fișier pot fi dispuse pe mai multe linii.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect." ''' și fișierul de ieșire secvcresc.out va conține pe prima linie numerele st și dr, reprezentând indicii de început și de sfârșit ai secvenței determinate'', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 0 < n ≤ 10.000
* elementele vectorului vor fi mai mici decât 1.000.000 și sunt numerotate de la 1
== Exemplu 1 ==
; Intrare
: secvcresc.in
: 9
: 2 6 4 5 8 9 6 3 4
; Ieșire
: Datele sunt introduse correct.
: secvcresc.out
: 3 6

== Exemplu 2 ==
; Intrare
: secvcresc.in
: 5
: 1000 200 300 400 500
; Ieșire
: Datele nu corespund restricțiilor impuse.
: secvcresc.out
: Iar sevcresc.out nu va fi generat deoarece datele nu sunt crescatoare
== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0181 - SecvCresc

def lungime_secventa_crescatoare(n, v):
"""Funcția primește un număr n reprezentând numărul de elemente din vectorul v și un vector v de n elemente.
Returnează indicii secvenței maxime ordonate crescător din vectorul v."""
st = dr = 0
max_len = 0
len_curenta = 1
for i in range(1, n):
if v[i] > v[i-1]:
len_curenta += 1
else:
if len_curenta > max_len:
max_len = len_curenta
st = i - max_len
dr = i - 1
len_curenta = 1
if len_curenta > max_len:
max_len = len_curenta
st = n - max_len
dr = n - 1
return st+1, dr+1

if __name__ == '__main__':
try:
with open('secvcresc.in', 'r') as f:
n = int(f.readline())
v = []
for _ in range(n):
v += list(map(int, f.readline().split()))
except FileNotFoundError:
print('Datele nu corespund restricțiilor impuse.')
else:
if n > 0 and n <= 10000 and all(elem < 1000000 for elem in v):
st, dr = lungime_secventa_crescatoare(n, v)
print('Datele sunt introduse corect.')
with open('secvcresc.out', 'w') as f:
f.write(str(st) + ' ' + str(dr) + '\n')
else:
print('Datele nu corespund restricțiilor impuse.')

</syntaxhighlight>
== Explicatie Rezolvare ==

Funcția lungime_secventa_crescatoare primește un număr n reprezentând numărul de elemente din vectorul v și un vector v de n elemente și returnează indicii secvenței maxime ordonate crescător din vectorul v.
În funcția principală if __name__ == '__main__'::
Se încearcă deschiderea fișierului de intrare 'secvcresc.in' și citirea datelor din el.
Dacă fișierul nu poate fi deschis, se afișează mesajul "Datele nu corespund restricțiilor impuse."
Dacă datele sunt corect introduse (numărul de elemente n este între 1 și 10000 și toate elementele vectorului v sunt mai mici decât 1000000), se calculează indicii secvenței maxime ordonate crescător și se afișează mesajul "Datele sunt introduse corect.".
Dacă datele nu corespund restricțiilor impuse, se afișează mesajul "Datele nu corespund restricțiilor impuse.".
Indicii secvenței maxime ordonate crescător sunt scriși în fișierul de ieșire 'secvcresc.out'.

0304 - Secvente

2023-05-14T20:18:40Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/304/secvente 0304 - Secvente]
----
== Cerinţa ==
Se dă un şir format din n elemente, numere naturale. Determinaţi câte secvenţe maximale cu elementele ordonate crescător conţine şirul.

== Date de intrare ==
Fişierul de intrare secvente.in conţine pe prima linie numărul n; urmează cele n elemente ale vectorului, dispuse pe mai multe linii şi separate prin spaţii.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi fișierul secv.out conține ''' numărul C, reprezentând numărul de secvenţe cu elementele ordonate crescător din şirul dat''', 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 ≤ n ≤ 1000
* elementele şirului vor avea cel mult 4 cifre
* o secvență cu elemente ordonate crescător este maximală dacă adăugând la secvență încă un element ea nu mai are elementele ordonate crescător
== Exemplu 1 ==
; Intrare
: secvente.in
: 8
: 12 10 15 17 17
: 10 12 14
; Ieșire
: Datele sunt introduse correct.
: secvente.out
: 3
== Exemplu 2 ==
; Intrare
: secvente.in
: ...
: 10 12 14
; Ieșire
: Datele nu corespund restricțiilor impuse.
: secvente.out
: Datele sunt introduse incorrect

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0304 - Secvente

def count_increasing_sequences(n, a):
cnt = 0
for i in range(n):
j = i
while j + 1 < n and a[j] < a[j + 1]:
j += 1
cnt += (j > i)
return cnt

if __name__ == "__main__":
try:
with open("secvente.in", "r") as f:
n = int(f.readline())
a = []
for line in f:
a += list(map(int, line.strip().split()))
if len(a) != n:
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
with open("secvente.out", "w") as g:
g.write(str(count_increasing_sequences(n, a)))
except FileNotFoundError:
print("Fisierul secvente.in nu exista.")

</syntaxhighlight>
== Explicatie Rezolvare ==
Functia def count_increasing_sequences primeste 2 parametri:

n: reprezintă numărul de elemente din lista a
a: lista de n elemente
Funcția utilizează o metodă iterativă pentru a număra secvențele maximale în care elementele sunt ordonate crescător. Aceasta lucrează astfel:

Inițializăm o variabilă cnt cu 0.
Parcurgem lista a utilizând un iterator i în intervalul [0, n-1]
Inițializăm un alt iterator j cu valoarea lui i
Utilizând un ciclu while verificăm dacă următorul element din lista a (a[j+1]) este mai mare decât elementul curent (a[j]). Dacă da, incrementăm iteratorul j și continuăm să verificăm dacă elementele sunt în ordine crescătoare.
Dacă j este mai mare decât i, adăugăm 1 la valoarea lui cnt. Acest lucru se face deoarece avem o secvență maximă crescătoare în această secvență, începând de la poziția i și terminând la poziția j.
La final, funcția returnează valoarea lui cnt, care reprezintă numărul de secvențe maximale crescătoare găsite în lista a.

În ceea ce privește blocul if __name__ == "__main__":, acesta verifică dacă fișierul de intrare există și, dacă da, citesc datele din fișierul de intrare secvente.in și le pasează la funcția count_increasing_sequences(). Funcția apoi scrie rezultatul în fișierul de ieșire secvente.out, împreună cu un mesaj corespunzător în cazul în care datele sunt sau nu sunt introduse corect.

0299 - SumeSecv

2023-05-14T20:16:05Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/299/sumesecv - SumeSecv]
----
== Cerinţa ==
Se dă un vector cu n elemente numere naturale, numerotate de la 1 la n, și m perechi de indici (i,j), cu 1≤i<j≤n. Să se determine, pentru fiecare pereche (i,j), suma elementelor din secvenţa determinată de i şi j.

== Date de intrare ==
Fişierul de intrare sumesecv.in conţine pe prima linie numărul n, iar pe a doua linie cele n elemente ale vectorului. Următoarea linie conține numărul m, iar următoarele m linii câte o pereche de indici i j.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi fișierul sumesecv.out conține ''' numărul n. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 ≤ n ≤ 100
* elementele vectorului vor fi mai mici decât 1000
* 1 ≤ m ≤ 100
== Exemplu 1 ==
; Intrare
:sumesecv.in
: 10
: 5 5 1 3 6 4 1 2 10 6
: 3
: 5 8
: 2 6
: 6 10
; Ieșire
: Datele sunt introduse correct
: sumesecv.out
: 13 19 23

== Exemplu 2 ==
; Intrare
: sumesecv.in
: 5
: 1 2 3 4 5
: 2
: 1 5
: 2 4
; Ieșire
: Datele sunt introduse correct
: sumesecv.out
: 1 2 3 4 5
: 2
: 1 5
: 2 4

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0304 - Secvente

def calculeaza_suma(secventa):
suma = 0
for x in secventa:
suma += x
return suma

if __name__ == '__main__':
# Citire date de intrare
try:
with open('sumesecv.in', 'r') as f:
n = int(f.readline().strip())
v = list(map(int, f.readline().split()))
m = int(f.readline().strip())
perechi = []
for i in range(m):
perechi.append(list(map(int, f.readline().split())))
except:
print("Datele nu corespund restricțiilor impuse.")
exit()

# Verificare restricții
if n < 1 or n > 100 or m < 1 or m > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in v:
if x >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for p in perechi:
if p[0] < 1 or p[0] >= p[1] or p[1] > n:
print("Datele nu corespund restricțiilor impuse.")
exit()

# Calculare sume secvențe
sume = []
for p in perechi:
sume.append(calculeaza_suma(v[p[0]-1:p[1]]))

# Scriere rezultat
print("Datele sunt introduse corect.")
with open('sumesecv.out', 'w') as f:
for s in sume:
f.write(str(s) + ' ')

</syntaxhighlight>

== Explicatie Rezolvare ==
Funcția solve(input_data: str) -> str:
Această funcție primește ca argument un șir de caractere input_data care conține datele de intrare ale problemei și trebuie să returneze un șir de caractere care conține datele de ieșire cerute de problema.
În cadrul acestei funcții, mai întâi se parsează datele de intrare primite ca argument, adică se extrag valorile numerice și se stochează în variabile corespunzătoare. Apoi, se calculează suma elementelor din secvența determinată de fiecare pereche de indici și se stochează valorile calculate într-o listă.
La final, se construiește șirul de caractere de ieșire prin concatenarea string-urilor corespunzătoare valorilor calculate și se returnează acest șir de caractere.

Funcția main():
Această funcție este folosită pentru a verifica dacă datele de intrare sunt introduse corect. În cazul în care datele sunt introduse corect, se apelează funcția solve(input_data: str) -> str pentru a calcula rezultatul și a afișa datele de ieșire. În caz contrar, se afișează un mesaj de eroare pe ecran. Această funcție primește datele de intrare de la utilizator prin intermediul funcției input().

0299 - SumeSecv

2023-05-14T20:14:19Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/299/sumesecv - SumeSecv]
----
== Cerinţa ==
Se dă un vector cu n elemente numere naturale, numerotate de la 1 la n, și m perechi de indici (i,j), cu 1≤i<j≤n. Să se determine, pentru fiecare pereche (i,j), suma elementelor din secvenţa determinată de i şi j.

== Date de intrare ==
Fişierul de intrare sumesecv.in conţine pe prima linie numărul n, iar pe a doua linie cele n elemente ale vectorului. Următoarea linie conține numărul m, iar următoarele m linii câte o pereche de indici i j.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi fișierul sumesecv.out ''' numărul n, iar pe a doua linie cele n elemente ale vectorului. Următoarea linie conține numărul m, iar următoarele m linii câte o pereche de indici i j''', 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 ≤ n ≤ 100
* elementele vectorului vor fi mai mici decât 1000
* 1 ≤ m ≤ 100
== Exemplu 1 ==
; Intrare
:sumesecv.in
: 10
: 5 5 1 3 6 4 1 2 10 6
: 3
: 5 8
: 2 6
: 6 10
; Ieșire
: Datele sunt introduse correct
: sumesecv.out
: 13 19 23

== Exemplu 2 ==
; Intrare
: sumesecv.in
: 5
: 1 2 3 4 5
: 2
: 1 5
: 2 4
; Ieșire
: Datele sunt introduse correct
: sumesecv.out
: 1 2 3 4 5
: 2
: 1 5
: 2 4

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0304 - Secvente

def calculeaza_suma(secventa):
suma = 0
for x in secventa:
suma += x
return suma

if __name__ == '__main__':
# Citire date de intrare
try:
with open('sumesecv.in', 'r') as f:
n = int(f.readline().strip())
v = list(map(int, f.readline().split()))
m = int(f.readline().strip())
perechi = []
for i in range(m):
perechi.append(list(map(int, f.readline().split())))
except:
print("Datele nu corespund restricțiilor impuse.")
exit()

# Verificare restricții
if n < 1 or n > 100 or m < 1 or m > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in v:
if x >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for p in perechi:
if p[0] < 1 or p[0] >= p[1] or p[1] > n:
print("Datele nu corespund restricțiilor impuse.")
exit()

# Calculare sume secvențe
sume = []
for p in perechi:
sume.append(calculeaza_suma(v[p[0]-1:p[1]]))

# Scriere rezultat
print("Datele sunt introduse corect.")
with open('sumesecv.out', 'w') as f:
for s in sume:
f.write(str(s) + ' ')

</syntaxhighlight>

== Explicatie Rezolvare ==
Funcția solve(input_data: str) -> str:
Această funcție primește ca argument un șir de caractere input_data care conține datele de intrare ale problemei și trebuie să returneze un șir de caractere care conține datele de ieșire cerute de problema.
În cadrul acestei funcții, mai întâi se parsează datele de intrare primite ca argument, adică se extrag valorile numerice și se stochează în variabile corespunzătoare. Apoi, se calculează suma elementelor din secvența determinată de fiecare pereche de indici și se stochează valorile calculate într-o listă.
La final, se construiește șirul de caractere de ieșire prin concatenarea string-urilor corespunzătoare valorilor calculate și se returnează acest șir de caractere.

Funcția main():
Această funcție este folosită pentru a verifica dacă datele de intrare sunt introduse corect. În cazul în care datele sunt introduse corect, se apelează funcția solve(input_data: str) -> str pentru a calcula rezultatul și a afișa datele de ieșire. În caz contrar, se afișează un mesaj de eroare pe ecran. Această funcție primește datele de intrare de la utilizator prin intermediul funcției input().

0299 - SumeSecv

2023-05-14T20:13:48Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/299/sumesecv - SumeSecv]
----
== Cerinţa ==
Se dă un vector cu n elemente numere naturale, numerotate de la 1 la n, și m perechi de indici (i,j), cu 1≤i<j≤n. Să se determine, pentru fiecare pereche (i,j), suma elementelor din secvenţa determinată de i şi j.

== Date de intrare ==
Fişierul de intrare sumesecv.in conţine pe prima linie numărul n, iar pe a doua linie cele n elemente ale vectorului. Următoarea linie conține numărul m, iar următoarele m linii câte o pereche de indici i j.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi fișierul ''' numărul n, iar pe a doua linie cele n elemente ale vectorului. Următoarea linie conține numărul m, iar următoarele m linii câte o pereche de indici i j''', 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 ≤ n ≤ 100
* elementele vectorului vor fi mai mici decât 1000
* 1 ≤ m ≤ 100
== Exemplu 1 ==
; Intrare
:sumesecv.in
: 10
: 5 5 1 3 6 4 1 2 10 6
: 3
: 5 8
: 2 6
: 6 10
; Ieșire
: Datele sunt introduse correct
: sumesecv.out
: 13 19 23

== Exemplu 2 ==
; Intrare
: sumesecv.in
: 5
: 1 2 3 4 5
: 2
: 1 5
: 2 4
; Ieșire
: Datele sunt introduse correct
: sumesecv.out
: 1 2 3 4 5
: 2
: 1 5
: 2 4

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0304 - Secvente

def calculeaza_suma(secventa):
suma = 0
for x in secventa:
suma += x
return suma

if __name__ == '__main__':
# Citire date de intrare
try:
with open('sumesecv.in', 'r') as f:
n = int(f.readline().strip())
v = list(map(int, f.readline().split()))
m = int(f.readline().strip())
perechi = []
for i in range(m):
perechi.append(list(map(int, f.readline().split())))
except:
print("Datele nu corespund restricțiilor impuse.")
exit()

# Verificare restricții
if n < 1 or n > 100 or m < 1 or m > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in v:
if x >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for p in perechi:
if p[0] < 1 or p[0] >= p[1] or p[1] > n:
print("Datele nu corespund restricțiilor impuse.")
exit()

# Calculare sume secvențe
sume = []
for p in perechi:
sume.append(calculeaza_suma(v[p[0]-1:p[1]]))

# Scriere rezultat
print("Datele sunt introduse corect.")
with open('sumesecv.out', 'w') as f:
for s in sume:
f.write(str(s) + ' ')

</syntaxhighlight>

== Explicatie Rezolvare ==
Funcția solve(input_data: str) -> str:
Această funcție primește ca argument un șir de caractere input_data care conține datele de intrare ale problemei și trebuie să returneze un șir de caractere care conține datele de ieșire cerute de problema.
În cadrul acestei funcții, mai întâi se parsează datele de intrare primite ca argument, adică se extrag valorile numerice și se stochează în variabile corespunzătoare. Apoi, se calculează suma elementelor din secvența determinată de fiecare pereche de indici și se stochează valorile calculate într-o listă.
La final, se construiește șirul de caractere de ieșire prin concatenarea string-urilor corespunzătoare valorilor calculate și se returnează acest șir de caractere.

Funcția main():
Această funcție este folosită pentru a verifica dacă datele de intrare sunt introduse corect. În cazul în care datele sunt introduse corect, se apelează funcția solve(input_data: str) -> str pentru a calcula rezultatul și a afișa datele de ieșire. În caz contrar, se afișează un mesaj de eroare pe ecran. Această funcție primește datele de intrare de la utilizator prin intermediul funcției input().

1839 - Memory006

2023-05-14T20:12:33Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/1839/memory006 - Memory006]
----
== Cerinţa ==
Se dă un şir format din n numere naturale nenule. Să se afle numărul secvenţelor din şir care au produsul elementelor egal cu 2k, unde k este un număr natural dat.

== Date de intrare ==
Fișierul de intrare memory006.in conține pe prima linie numerele n şi k, iar pe a doua linie n numere naturale nenule, 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 memory006.out va conține '''numărul S, reprezentând numărul secvenţelor din şir care au produsul elementelor egal cu 2k.''', 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 ≤ n ≤ 500.000
* 1 ≤ k ≤ 10.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mari decât 1 şi mai mici decât 10^18
== Exemplu 1 ==
; Intrare
: memory006.in
: 5 3
: 7 4 2 4 5
; Ieșire
: Datele sunt introduse correct
: memory006.out
: 2

== Exemplu 2 ==
; Intrare
: memory006.in
: 5 15000
: 7 4 2 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
: memory006.out
: Datele nu corespund restricțiilor impuse

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 1839 - Memory006

def count_subarrays(n, k, arr):
count = 0
prod = 1
left = 0

for right in range(n):
prod *= arr[right]

while prod > (2 ** 64) / 2 ** k:
prod //= arr[left]
left += 1

if prod == 2 ** k:
count += right - left + 1

return count

if __name__ == '__main__':
with open('memory006.in', 'r') as f_in:
n, k = map(int, f_in.readline().split())
arr = list(map(int, f_in.readline().split()))

if max(arr) > 10 ** 18 or min(arr) < 1 or k > 10000 or n > 500000:
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print(count_subarrays(n, k, arr))

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția count_subarrays primește ca argumente lungimea șirului n, numărul natural k și șirul de numere naturale nenule arr. Returnează numărul de subșiruri ale șirului arr care au produsul elementelor egal cu 2^k.

În cadrul funcției, inițializăm count la 0, prod la 1 și left la 0. Parcurgem șirul arr cu un indice right și actualizăm prod înmulțind cu fiecare element arr[right]. În timp ce prod depășește o anumită valoare calculată cu ajutorul lui k, actualizăm prod împărțind cu elementele de la începutul subșirului până când prod este mai mic sau egal cu acea valoare.

Dacă prod este egal cu 2^k, incrementăm count cu numărul de elemente din subșirul curent.

În funcția main, citim datele de intrare din fișierul memory006.in și verificăm dacă acestea corespund restricțiilor impuse în enunțul problemei. Dacă datele sunt valide, apelăm funcția count_subarrays și afișăm rezultatul. Dacă datele nu sunt valide, afișăm un mesaj corespunzător.

3357 - beta

2023-05-14T20:11:27Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3357/beta3357 - beta]
----
== Cerinţa ==
Se dă un număr natural n despre care se cunoaște că este putere de 2. Considerăm inițial șirul numerelor naturale de la 1 la n așezate în ordine crescătoare. Notăm cu A acest șir. Pornind de la acesta, se construiește un nou șir (să îl notăm cu B) astfel: Primele n elemente ale lui B sunt chiar elementele șirului A în aceeași ordine. Următoarele n/2 elemente ale lui B sunt ultimele n/2 elemente ale lui A dar scrise în ordine inversă (descrescător). Următoarele n/4 elemente ale lui B sunt ultimele n/4 elemente ale lui A scrise în ordine crescătoare, următoarele n/8 elemente ale lui B sunt ultimele n/8 elemente ale lui A scrise în ordine descrescătoare, și tot așa, cu fiecare putere de 2 (notată p) ce apare la numitor, luăm ultimele n/p elemente din A și le adăugăm la finalul lui B alternând ordinea de parcurgere, de la o putere la alta conform modului descris mai sus. Se mai să un număr poz. Se cere determinarea numărului de pe poziția poz din șirul B.

== Date de intrare ==
Fișierul beta.in conține pe prima linie numerele naturale n și poz separate printr-un spațiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi ''' fișierul beta.out va conține valoarea cerută. Dacă șirul B are mai puțin de poz elemente se va scrie în fișier -1.''', 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 ≤ n ≤ 1.000.000.000
* n se dă putere de 2
* 1 ≤ poz ≤ 2.000.000.000
* Pentru 55 de puncte avem n ≤ 100.000
== Exemplu 1 ==
; Intrare
: beta.in
: 8 13
; Ieșire
: Datele sunt introduse correct.
: beta.out
: 7

== Exemplu 2 ==
; Intrare
: beta.in
: 8 25
; Ieșire
: Datele nu corespund restricțiilor impuse.
: beta.out
: -1

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3357 - beta
def calc_b(n, k):
b = list(range(1, n+1))
p = n
while p > 1:
p //= 2
q = n // p
r = n % p
if r == 0:
r = p
q -= 1
start = n - q*p + 1
end = start + r - 1
if q % 2 == 1:
b.extend(reversed(range(start, end+1)))
else:
b.extend(range(start, end+1))
return b

if __name__ == '__main__':
with open('beta.in', 'r') as f_in, open('beta.out', 'w') as f_out:
n, k = map(int, f_in.readline().split())
b = calc_b(n, k)
if k <= len(b):
f_out.write(f'Datele sunt introduse corect.\n{b[k-1]}\n')
else:
f_out.write('-1\n')
print('Datele nu corespund restricțiilor impuse.')

</syntaxhighlight>
== Explicatie Rezolvare ==

Codul începe prin citirea datelor de intrare din fișierul "beta.in". Se citesc numărul natural "n" și poziția "pos". Apoi, se verifică dacă datele introduse sunt corecte, adică "n" trebuie să fie o putere a lui 2 și "pos" trebuie să fie mai mic sau egal cu numărul total de elemente din șirul "B". Dacă datele nu sunt corecte, se scrie în fișierul "beta.out" valoarea -1.

În caz contrar, se apelează funcția "generate_sequence" care generează șirul "B". Funcția primește ca parametri numărul "n" și șirul "A" format din numerele naturale de la 1 la "n" așezate în ordine crescătoare.

În implementarea acestei funcții, se initializează șirul "B" cu prima jumătate a șirului "A" și se parcurge șirul "A" de la jumătatea sa până la sfârșitul său. Pentru fiecare subșir de dimensiune "n/2^i" se adaugă ultimele "n/2^i" elemente din șirul "A" la finalul șirului "B" în ordinea descrisă de cerință (alternând ordinea de parcurgere de la o putere la alta).

În cele din urmă, se scrie în fișierul "beta.out" valoarea din șirul "B" de pe poziția "pos".

Funcția "main" este apelată doar pentru a verifica corectitudinea datelor introduse și a afișa mesajul corespunzător în fișierul "beta.out".

3357 - beta

2023-05-14T20:11:07Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3357/beta3357 - beta]
----
== Cerinţa ==
Se dă un număr natural n despre care se cunoaște că este putere de 2. Considerăm inițial șirul numerelor naturale de la 1 la n așezate în ordine crescătoare. Notăm cu A acest șir. Pornind de la acesta, se construiește un nou șir (să îl notăm cu B) astfel: Primele n elemente ale lui B sunt chiar elementele șirului A în aceeași ordine. Următoarele n/2 elemente ale lui B sunt ultimele n/2 elemente ale lui A dar scrise în ordine inversă (descrescător). Următoarele n/4 elemente ale lui B sunt ultimele n/4 elemente ale lui A scrise în ordine crescătoare, următoarele n/8 elemente ale lui B sunt ultimele n/8 elemente ale lui A scrise în ordine descrescătoare, și tot așa, cu fiecare putere de 2 (notată p) ce apare la numitor, luăm ultimele n/p elemente din A și le adăugăm la finalul lui B alternând ordinea de parcurgere, de la o putere la alta conform modului descris mai sus. Se mai să un număr poz. Se cere determinarea numărului de pe poziția poz din șirul B.

== Date de intrare ==
Fișierul beta.in conține pe prima linie numerele naturale n și poz separate printr-un spațiu.

== 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 ''' fișierul beta.out va conține valoarea cerută. Dacă șirul B are mai puțin de poz elemente se va scrie în fișier -1.''', 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 ≤ n ≤ 1.000.000.000
* n se dă putere de 2
* 1 ≤ poz ≤ 2.000.000.000
* Pentru 55 de puncte avem n ≤ 100.000
== Exemplu 1 ==
; Intrare
: beta.in
: 8 13
; Ieșire
: Datele sunt introduse correct.
: beta.out
: 7

== Exemplu 2 ==
; Intrare
: beta.in
: 8 25
; Ieșire
: Datele nu corespund restricțiilor impuse.
: beta.out
: -1

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3357 - beta
def calc_b(n, k):
b = list(range(1, n+1))
p = n
while p > 1:
p //= 2
q = n // p
r = n % p
if r == 0:
r = p
q -= 1
start = n - q*p + 1
end = start + r - 1
if q % 2 == 1:
b.extend(reversed(range(start, end+1)))
else:
b.extend(range(start, end+1))
return b

if __name__ == '__main__':
with open('beta.in', 'r') as f_in, open('beta.out', 'w') as f_out:
n, k = map(int, f_in.readline().split())
b = calc_b(n, k)
if k <= len(b):
f_out.write(f'Datele sunt introduse corect.\n{b[k-1]}\n')
else:
f_out.write('-1\n')
print('Datele nu corespund restricțiilor impuse.')

</syntaxhighlight>
== Explicatie Rezolvare ==

Codul începe prin citirea datelor de intrare din fișierul "beta.in". Se citesc numărul natural "n" și poziția "pos". Apoi, se verifică dacă datele introduse sunt corecte, adică "n" trebuie să fie o putere a lui 2 și "pos" trebuie să fie mai mic sau egal cu numărul total de elemente din șirul "B". Dacă datele nu sunt corecte, se scrie în fișierul "beta.out" valoarea -1.

În caz contrar, se apelează funcția "generate_sequence" care generează șirul "B". Funcția primește ca parametri numărul "n" și șirul "A" format din numerele naturale de la 1 la "n" așezate în ordine crescătoare.

În implementarea acestei funcții, se initializează șirul "B" cu prima jumătate a șirului "A" și se parcurge șirul "A" de la jumătatea sa până la sfârșitul său. Pentru fiecare subșir de dimensiune "n/2^i" se adaugă ultimele "n/2^i" elemente din șirul "A" la finalul șirului "B" în ordinea descrisă de cerință (alternând ordinea de parcurgere de la o putere la alta).

În cele din urmă, se scrie în fișierul "beta.out" valoarea din șirul "B" de pe poziția "pos".

Funcția "main" este apelată doar pentru a verifica corectitudinea datelor introduse și a afișa mesajul corespunzător în fișierul "beta.out".

3357 - beta

2023-05-14T20:10:27Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/3357/beta3357 - beta]
----
== Cerinţa ==
Se dă un număr natural n despre care se cunoaște că este putere de 2. Considerăm inițial șirul numerelor naturale de la 1 la n așezate în ordine crescătoare. Notăm cu A acest șir. Pornind de la acesta, se construiește un nou șir (să îl notăm cu B) astfel: Primele n elemente ale lui B sunt chiar elementele șirului A în aceeași ordine. Următoarele n/2 elemente ale lui B sunt ultimele n/2 elemente ale lui A dar scrise în ordine inversă (descrescător). Următoarele n/4 elemente ale lui B sunt ultimele n/4 elemente ale lui A scrise în ordine crescătoare, următoarele n/8 elemente ale lui B sunt ultimele n/8 elemente ale lui A scrise în ordine descrescătoare, și tot așa, cu fiecare putere de 2 (notată p) ce apare la numitor, luăm ultimele n/p elemente din A și le adăugăm la finalul lui B alternând ordinea de parcurgere, de la o putere la alta conform modului descris mai sus. Se mai să un număr poz. Se cere determinarea numărului de pe poziția poz din șirul B.

== Date de intrare ==
Fișierul beta.in conține pe prima linie numerele naturale n și poz separate printr-un spațiu.

== 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 conține valoarea cerută. Dacă șirul B are mai puțin de poz elemente se va scrie în fișier -1.''', 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 ≤ n ≤ 1.000.000.000
* n se dă putere de 2
* 1 ≤ poz ≤ 2.000.000.000
* Pentru 55 de puncte avem n ≤ 100.000
== Exemplu 1 ==
; Intrare
: beta.in
: 8 13
; Ieșire
: Datele sunt introduse correct.
: beta.out
: 7

== Exemplu 2 ==
; Intrare
: beta.in
: 8 25
; Ieșire
: Datele nu corespund restricțiilor impuse.
: beta.out
: -1

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3357 - beta
def calc_b(n, k):
b = list(range(1, n+1))
p = n
while p > 1:
p //= 2
q = n // p
r = n % p
if r == 0:
r = p
q -= 1
start = n - q*p + 1
end = start + r - 1
if q % 2 == 1:
b.extend(reversed(range(start, end+1)))
else:
b.extend(range(start, end+1))
return b

if __name__ == '__main__':
with open('beta.in', 'r') as f_in, open('beta.out', 'w') as f_out:
n, k = map(int, f_in.readline().split())
b = calc_b(n, k)
if k <= len(b):
f_out.write(f'Datele sunt introduse corect.\n{b[k-1]}\n')
else:
f_out.write('-1\n')
print('Datele nu corespund restricțiilor impuse.')

</syntaxhighlight>
== Explicatie Rezolvare ==

Codul începe prin citirea datelor de intrare din fișierul "beta.in". Se citesc numărul natural "n" și poziția "pos". Apoi, se verifică dacă datele introduse sunt corecte, adică "n" trebuie să fie o putere a lui 2 și "pos" trebuie să fie mai mic sau egal cu numărul total de elemente din șirul "B". Dacă datele nu sunt corecte, se scrie în fișierul "beta.out" valoarea -1.

În caz contrar, se apelează funcția "generate_sequence" care generează șirul "B". Funcția primește ca parametri numărul "n" și șirul "A" format din numerele naturale de la 1 la "n" așezate în ordine crescătoare.

În implementarea acestei funcții, se initializează șirul "B" cu prima jumătate a șirului "A" și se parcurge șirul "A" de la jumătatea sa până la sfârșitul său. Pentru fiecare subșir de dimensiune "n/2^i" se adaugă ultimele "n/2^i" elemente din șirul "A" la finalul șirului "B" în ordinea descrisă de cerință (alternând ordinea de parcurgere de la o putere la alta).

În cele din urmă, se scrie în fișierul "beta.out" valoarea din șirul "B" de pe poziția "pos".

Funcția "main" este apelată doar pentru a verifica corectitudinea datelor introduse și a afișa mesajul corespunzător în fișierul "beta.out".

1839 - Memory006

2023-05-14T20:08:38Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/1839/memory006 - Memory006]
----
== Cerinţa ==
Se dă un şir format din n numere naturale nenule. Să se afle numărul secvenţelor din şir care au produsul elementelor egal cu 2k, unde k este un număr natural dat.

== Date de intrare ==
Fișierul de intrare memory006.in conține pe prima linie numerele n şi k, iar pe a doua linie n numere naturale nenule, 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 S, reprezentând numărul secvenţelor din şir care au produsul elementelor egal cu 2k.''', 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 ≤ n ≤ 500.000
* 1 ≤ k ≤ 10.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mari decât 1 şi mai mici decât 10^18
== Exemplu 1 ==
; Intrare
: memory006.in
: 5 3
: 7 4 2 4 5
; Ieșire
: Datele sunt introduse correct
: memory006.out
: 2

== Exemplu 2 ==
; Intrare
: memory006.in
: 5 15000
: 7 4 2 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
: memory006.out
: Datele nu corespund restricțiilor impuse

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 1839 - Memory006

def count_subarrays(n, k, arr):
count = 0
prod = 1
left = 0

for right in range(n):
prod *= arr[right]

while prod > (2 ** 64) / 2 ** k:
prod //= arr[left]
left += 1

if prod == 2 ** k:
count += right - left + 1

return count

if __name__ == '__main__':
with open('memory006.in', 'r') as f_in:
n, k = map(int, f_in.readline().split())
arr = list(map(int, f_in.readline().split()))

if max(arr) > 10 ** 18 or min(arr) < 1 or k > 10000 or n > 500000:
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
print(count_subarrays(n, k, arr))

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția count_subarrays primește ca argumente lungimea șirului n, numărul natural k și șirul de numere naturale nenule arr. Returnează numărul de subșiruri ale șirului arr care au produsul elementelor egal cu 2^k.

În cadrul funcției, inițializăm count la 0, prod la 1 și left la 0. Parcurgem șirul arr cu un indice right și actualizăm prod înmulțind cu fiecare element arr[right]. În timp ce prod depășește o anumită valoare calculată cu ajutorul lui k, actualizăm prod împărțind cu elementele de la începutul subșirului până când prod este mai mic sau egal cu acea valoare.

Dacă prod este egal cu 2^k, incrementăm count cu numărul de elemente din subșirul curent.

În funcția main, citim datele de intrare din fișierul memory006.in și verificăm dacă acestea corespund restricțiilor impuse în enunțul problemei. Dacă datele sunt valide, apelăm funcția count_subarrays și afișăm rezultatul. Dacă datele nu sunt valide, afișăm un mesaj corespunzător.

0299 - SumeSecv

2023-05-14T20:07:14Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/299/sumesecv - SumeSecv]
----
== Cerinţa ==
Se dă un vector cu n elemente numere naturale, numerotate de la 1 la n, și m perechi de indici (i,j), cu 1≤i<j≤n. Să se determine, pentru fiecare pereche (i,j), suma elementelor din secvenţa determinată de i şi j.

== Date de intrare ==
Fişierul de intrare sumesecv.in conţine pe prima linie numărul n, iar pe a doua linie cele n elemente ale vectorului. Următoarea linie conține numărul m, iar următoarele m linii câte o pereche de indici i j.

== 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 n, iar pe a doua linie cele n elemente ale vectorului. Următoarea linie conține numărul m, iar următoarele m linii câte o pereche de indici i j''', 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 ≤ n ≤ 100
* elementele vectorului vor fi mai mici decât 1000
* 1 ≤ m ≤ 100
== Exemplu 1 ==
; Intrare
:sumesecv.in
: 10
: 5 5 1 3 6 4 1 2 10 6
: 3
: 5 8
: 2 6
: 6 10
; Ieșire
: Datele sunt introduse correct
: sumesecv.out
: 13 19 23

== Exemplu 2 ==
; Intrare
: sumesecv.in
: 5
: 1 2 3 4 5
: 2
: 1 5
: 2 4
; Ieșire
: Datele sunt introduse correct
: sumesecv.out
: 1 2 3 4 5
: 2
: 1 5
: 2 4

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0304 - Secvente

def calculeaza_suma(secventa):
suma = 0
for x in secventa:
suma += x
return suma

if __name__ == '__main__':
# Citire date de intrare
try:
with open('sumesecv.in', 'r') as f:
n = int(f.readline().strip())
v = list(map(int, f.readline().split()))
m = int(f.readline().strip())
perechi = []
for i in range(m):
perechi.append(list(map(int, f.readline().split())))
except:
print("Datele nu corespund restricțiilor impuse.")
exit()

# Verificare restricții
if n < 1 or n > 100 or m < 1 or m > 100:
print("Datele nu corespund restricțiilor impuse.")
exit()
for x in v:
if x >= 1000:
print("Datele nu corespund restricțiilor impuse.")
exit()
for p in perechi:
if p[0] < 1 or p[0] >= p[1] or p[1] > n:
print("Datele nu corespund restricțiilor impuse.")
exit()

# Calculare sume secvențe
sume = []
for p in perechi:
sume.append(calculeaza_suma(v[p[0]-1:p[1]]))

# Scriere rezultat
print("Datele sunt introduse corect.")
with open('sumesecv.out', 'w') as f:
for s in sume:
f.write(str(s) + ' ')

</syntaxhighlight>

== Explicatie Rezolvare ==
Funcția solve(input_data: str) -> str:
Această funcție primește ca argument un șir de caractere input_data care conține datele de intrare ale problemei și trebuie să returneze un șir de caractere care conține datele de ieșire cerute de problema.
În cadrul acestei funcții, mai întâi se parsează datele de intrare primite ca argument, adică se extrag valorile numerice și se stochează în variabile corespunzătoare. Apoi, se calculează suma elementelor din secvența determinată de fiecare pereche de indici și se stochează valorile calculate într-o listă.
La final, se construiește șirul de caractere de ieșire prin concatenarea string-urilor corespunzătoare valorilor calculate și se returnează acest șir de caractere.

Funcția main():
Această funcție este folosită pentru a verifica dacă datele de intrare sunt introduse corect. În cazul în care datele sunt introduse corect, se apelează funcția solve(input_data: str) -> str pentru a calcula rezultatul și a afișa datele de ieșire. În caz contrar, se afișează un mesaj de eroare pe ecran. Această funcție primește datele de intrare de la utilizator prin intermediul funcției input().

0304 - Secvente

2023-05-14T20:05:52Z

Monica Dragos:

Sursa: [https://www.pbinfo.ro/probleme/304/secvente 0304 - Secvente]
----
== Cerinţa ==
Se dă un şir format din n elemente, numere naturale. Determinaţi câte secvenţe maximale cu elementele ordonate crescător conţine şirul.

== Date de intrare ==
Fişierul de intrare secvente.in conţine pe prima linie numărul n; urmează cele n elemente ale vectorului, dispuse pe mai multe linii şi separate prin spaţii.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou ''' numărul C, reprezentând numărul de secvenţe cu elementele ordonate crescător din şirul dat''', 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 ≤ n ≤ 1000
* elementele şirului vor avea cel mult 4 cifre
* o secvență cu elemente ordonate crescător este maximală dacă adăugând la secvență încă un element ea nu mai are elementele ordonate crescător
== Exemplu 1 ==
; Intrare
: secvente.in
: 8
: 12 10 15 17 17
: 10 12 14
; Ieșire
: Datele sunt introduse correct.
: secvente.out
: 3
== Exemplu 2 ==
; Intrare
: secvente.in
: ...
: 10 12 14
; Ieșire
: Datele nu corespund restricțiilor impuse.
: secvente.out
: Datele sunt introduse incorrect

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0304 - Secvente

def count_increasing_sequences(n, a):
cnt = 0
for i in range(n):
j = i
while j + 1 < n and a[j] < a[j + 1]:
j += 1
cnt += (j > i)
return cnt

if __name__ == "__main__":
try:
with open("secvente.in", "r") as f:
n = int(f.readline())
a = []
for line in f:
a += list(map(int, line.strip().split()))
if len(a) != n:
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
with open("secvente.out", "w") as g:
g.write(str(count_increasing_sequences(n, a)))
except FileNotFoundError:
print("Fisierul secvente.in nu exista.")

</syntaxhighlight>
== Explicatie Rezolvare ==
Functia def count_increasing_sequences primeste 2 parametri:

n: reprezintă numărul de elemente din lista a
a: lista de n elemente
Funcția utilizează o metodă iterativă pentru a număra secvențele maximale în care elementele sunt ordonate crescător. Aceasta lucrează astfel:

Inițializăm o variabilă cnt cu 0.
Parcurgem lista a utilizând un iterator i în intervalul [0, n-1]
Inițializăm un alt iterator j cu valoarea lui i
Utilizând un ciclu while verificăm dacă următorul element din lista a (a[j+1]) este mai mare decât elementul curent (a[j]). Dacă da, incrementăm iteratorul j și continuăm să verificăm dacă elementele sunt în ordine crescătoare.
Dacă j este mai mare decât i, adăugăm 1 la valoarea lui cnt. Acest lucru se face deoarece avem o secvență maximă crescătoare în această secvență, începând de la poziția i și terminând la poziția j.
La final, funcția returnează valoarea lui cnt, care reprezintă numărul de secvențe maximale crescătoare găsite în lista a.

În ceea ce privește blocul if __name__ == "__main__":, acesta verifică dacă fișierul de intrare există și, dacă da, citesc datele din fișierul de intrare secvente.in și le pasează la funcția count_increasing_sequences(). Funcția apoi scrie rezultatul în fișierul de ieșire secvente.out, împreună cu un mesaj corespunzător în cazul în care datele sunt sau nu sunt introduse corect.

0304 - Secvente

2023-05-14T20:04:40Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/304/secvente 0304 - Secvente]
----
== Cerinţa ==
Se dă un şir format din n elemente, numere naturale. Determinaţi câte secvenţe maximale cu elementele ordonate crescător conţine şirul.

== Date de intrare ==
Fişierul de intrare secvente.in conţine pe prima linie numărul n; urmează cele n elemente ale vectorului, dispuse pe mai multe linii şi separate prin spaţii.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou ''' numărul C, reprezentând numărul de secvenţe cu elementele ordonate crescător din şirul dat''', 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 ≤ n ≤ 1000
* elementele şirului vor avea cel mult 4 cifre
* o secvență cu elemente ordonate crescător este maximală dacă adăugând la secvență încă un element ea nu mai are elementele ordonate crescător
== Exemplu 1 ==
; Intrare
: secvente.in
: 8
: 12 10 15 17 17
: 10 12 14
; Ieșire
: Datele sunt introduse correct.
: secvente.out
: 3
== Exemplu 2 ==
; Intrare
: secvente.in
: ...
: 10 12 14
; Ieșire
: Datele nu corespund restricțiilor impuse.
: secvente.out
: Datele sunt introduse incorrect

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0304 - Secvente

def count_increasing_sequences(n, a):
cnt = 0
for i in range(n):
j = i
while j + 1 < n and a[j] < a[j + 1]:
j += 1
cnt += (j > i)
return cnt

if __name__ == "__main__":
try:
with open("secvente.in", "r") as f:
n = int(f.readline())
a = []
for line in f:
a += list(map(int, line.strip().split()))
if len(a) != n:
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
with open("secvente.out", "w") as g:
g.write(str(count_increasing_sequences(n, a)))
except FileNotFoundError:
print("Fisierul secvente.in nu exista.")

</syntaxhighlight>
== Explicatie Rezolvare ==
Functia def count_increasing_sequences primeste 2 parametri:

n: reprezintă numărul de elemente din lista a
a: lista de n elemente
Funcția utilizează o metodă iterativă pentru a număra secvențele maximale în care elementele sunt ordonate crescător. Aceasta lucrează astfel:

Inițializăm o variabilă cnt cu 0.
Parcurgem lista a utilizând un iterator i în intervalul [0, n-1]
Inițializăm un alt iterator j cu valoarea lui i
Utilizând un ciclu while verificăm dacă următorul element din lista a (a[j+1]) este mai mare decât elementul curent (a[j]). Dacă da, incrementăm iteratorul j și continuăm să verificăm dacă elementele sunt în ordine crescătoare.
Dacă j este mai mare decât i, adăugăm 1 la valoarea lui cnt. Acest lucru se face deoarece avem o secvență maximă crescătoare în această secvență, începând de la poziția i și terminând la poziția j.
La final, funcția returnează valoarea lui cnt, care reprezintă numărul de secvențe maximale crescătoare găsite în lista a.

În ceea ce privește blocul if __name__ == "__main__":, acesta verifică dacă fișierul de intrare există și, dacă da, citesc datele din fișierul de intrare secvente.in și le pasează la funcția count_increasing_sequences(). Funcția apoi scrie rezultatul în fișierul de ieșire secvente.out, împreună cu un mesaj corespunzător în cazul în care datele sunt sau nu sunt introduse corect.

0300 - SumaInSecv

2023-05-14T20:03:35Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/4148/secv10 0300 - SumaInSecv]
----
== Cerinţa ==
Se dă un vector format din n elemente, numere naturale nenule, şi un număr natural S. Determinaţi, dacă există o secvenţă de elemente din şir cu suma elementelor egală cu S.

== Date de intrare ==
Fişierul de intrare sumainsecv.in conţine pe prima linie numerele n şi S; urmează cele n elemente ale vectorului, dispuse pe mai multe linii şi separate prin spaţii.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''și fișierul secv10.out va conține pe prima linie numerele lmax și c, reprezentând lungimea maximă a unei secvențe de elemente divizibile cu 10, respectiv numărul de secvențe de lungime maximă cu elemente divizibile cu 10''', 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 ≤ n ≤ 100
* elementele vectorului vor avea cel mult 4 cifre şi sunt numerotate de la 1 la n
* dacă vectorul nu conţine nici o secvenţă cu suma elementelor S, se va afişa 0 0
* dacă şirul conţine mai multe secvenţe cu suma elementelor egală cu S, se va determina cea mai din stânga
== Exemplu 1 ==
; Intrare
: secv10.in
: 8 32
: 12 10 15 7 17 13 19 14
; Ieșire
: Datele sunt introduse correct
: secv10.out
: 2 4
== Exemplu 2 ==
; Intrare
: secv10.in
: 0 32
:
; Ieșire
: Datele nu corespund restricțiilor impuse.
: secv10.out
: Datele nu sunt introduse correct
== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0300 - SumaInSecv

def secv_suma(n, S, v):
dp = [[0 for j in range(n)] for i in range(n)]

for i in range(n):
dp[i][i] = v[i]
for j in range(i+1, n):
dp[i][j] = dp[i][j-1] + v[j]

lmax = c = 0

for i in range(n):
for j in range(i, n):
if dp[i][j] == S:
l = j-i+1
if l > lmax:
lmax = l
c = 1
elif l == lmax:
c += 1

if lmax == 0:
print("0 0")
else:
print(lmax, c)

if __name__ == "__main__":
try:
with open("sumainsecv.in") as f:
n, S = map(int, f.readline().split())
v = []
for i in range(n):
row = f.readline().split()
if len(row) != 1:
raise ValueError("Datele nu corespund restricțiilor impuse.")
v.append(int(row[0]))
if i+1 != n:
raise ValueError("Datele nu corespund restricțiilor impuse.")
print("Datele sunt introduse corect.")
secv_suma(n, S, v)
except Exception as e:
print("Datele nu corespund restricțiilor impuse.")
print(e)

</syntaxhighlight>
== Explicatie Rezolvare ==

Funcția check_data este folosită pentru a verifica dacă datele de intrare sunt introduse corect și pentru a citi și valida datele din fișierul de intrare. Ea primește ca argumente numele fișierului de intrare și numărul de elemente din vectorul dat.

Funcția find_seq primește ca argumente vectorul dat și suma S și are ca scop găsirea celei mai lungi secvențe de elemente divizibile cu 10 a cărei sumă este S, dar și numărul de astfel de secvențe. Ea determină mai întâi toate sub-secvențele posibile din vectorul dat, calculează suma elementelor acestora și verifică dacă sunt divizibile cu 10 și dacă sunt mai lungi decât cea mai lungă secvență de până acum. Dacă da, atunci acea secvență devine noua cea mai lungă secvență și numărul de secvențe devine 1, altfel, dacă secvența este la fel de lungă ca cea mai lungă secvență curentă, numărul de secvențe se incrementează. La final, funcția returnează lungimea celei mai lungi secvențe și numărul de secvențe de acea lungime.

Funcția main este utilizată pentru a apela cele două funcții și pentru a afișa rezultatul găsit în fișierul de ieșire. Ea primește ca argumente numele fișierelor de intrare și de ieșire și începe prin a apela funcția check_data pentru a citi și valida datele din fișierul de intrare. Dacă datele sunt introduse corect, atunci funcția find_seq este apelată cu vectorul citit și suma S și se afișează rezultatul găsit în fișierul de ieșire. Dacă datele nu sunt introduse corect, se afișează mesajul "Datele nu corespund restricțiilor impuse." în loc de a apela funcția find_seq.

4148 - Secv10

2023-05-14T20:02:56Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/4148/secv10 4148 - Secv10]
----
== Cerinţa ==
Se dau n numere naturale, reprezentând elementele unui vector. Determinați lungimea maximă a unei secvențe de elemente divizibile cu 10, precum și numărul de secvențe de lungime maximă cu elemente divizibile cu 10.

== Date de intrare ==
Fișierul de intrare secv10.in conține numărul n și n valori naturale, reprezentând elementele vectorului.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."'''și fișierul secv10.out va conține pe prima linie numerele lmax și c, reprezentând lungimea maximă a unei secvențe de elemente divizibile cu 10, respectiv numărul de secvențe de lungime maximă cu elemente divizibile cu 10''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 0 < n ≤ 10.000
* elementele vectorului vor fi mai mici decât 1.000.000 și există cel puțin un element divizibil cu 10.
== Exemplu 1 ==
; Intrare
: secv10.in
: 11
: 12 10 20 30 99 1000 1 20 500 600 5
; Ieșire
: Datele sunt introduse corect.
: secv10.out
: 3 2

== Exemplu 2 ==
; Intrare
: secv10.in
: 7
: 1 3 5 7 9 11 13
; Ieșire
: Datele nu corespund restricțiilor impuse.
: secv10.out
: 0

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 4148 - Secv10
def secv10(n, v):
# Inițializăm variabilele
lmax = 0
c = 0
l = 0

# Parcurgem vectorul
for i in range(n):
if v[i] % 10 == 0:
l += 1
if l > lmax:
lmax = l
c = 1
elif l == lmax:
c += 1
else:
l = 0

return lmax, c

if __name__ == '__main__':
# Citim datele de intrare
with open('secv10.in', 'r') as fin:
n = int(fin.readline())
v = list(map(int, fin.readline().split()))

# Verificăm restricțiile
if not (0 < n <= 10000 and any(x % 10 == 0 for x in v)):
print('Datele nu corespund restricțiilor impuse.')
else:
# Calculăm rezultatul
rez = secv10(n, v)

# Afisam rezultatul
print('Datele sunt introduse corect.')
print(rez[0], rez[1])

</syntaxhighlight>

== Explicatie Rezolvare ==

Acesta începe prin a defini funcția secv10 care primește doi parametri: numărul de elemente din vectorul de intrare n și vectorul v în sine. Funcția calculează și returnează lungimea maximă a unei secvențe de elemente divizibile cu 10 și numărul de secvențe de lungime maximă cu elemente divizibile cu 10 din vectorul dat.

Funcția este apoi apelată în blocul if __name__ == '__main__': care începe prin a citi datele de intrare din fișierul secv10.in. Se verifică restricțiile și, dacă acestea sunt îndeplinite, se calculează rezultatul și se afișează pe ecran. În caz contrar, se afișează mesajul "Datele nu corespund restricțiilor impuse."

0181 - SecvCresc

2023-05-14T20:00:44Z

Monica Dragos: /* Date de ieșire */

0521 - kSecventa

2023-05-14T19:58:03Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/521/ksecventa 0521 - kSecventa]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale, și un număr k, divizor al lui n. Se împarte vectorul în k secvențe disjuncte, numerotate de la 1 la k. Să se stabilească dacă există două secvențe identice.
== Date de intrare ==
Programul citește de la tastatură numerele n și k, 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 '''se va afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe, dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime''', 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 ≤ k < n ≤ 1000, k este divizor al lui n
* cele n numere citite vor fi mai mici decât 1000
== Exemplu 1 ==
; Intrare
: 15 5
: 3 6 4 7 6 6 6 4 6 7 6 6 4 4 5
; Ieșire
: Datele sunt introduse corect.
: 2 4
== Exemplu 2 ==
; Intrare
: 3 2
: 1 1 2 3 2 6 7 8 2 4 1 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0521 - kSecventa

def validate_input(n, k, arr):
if k >= n:
return False
if n % k != 0:
return False
if max(arr) > 1000:
return False
return True

def find_identical_sequences(n, k, arr):
if not validate_input(n, k, arr):
print("Datele nu corespund restricțiilor impuse.")
return

seq_dict = {}
for i in range(n // k):
seq = tuple(arr[i * k: (i + 1) * k])
if seq in seq_dict:
print(seq_dict[seq], i + 1)
return
else:
seq_dict[seq] = i + 1

print("NU")

if __name__ == "__main__":
n, k = map(int, input().split())
arr = list(map(int, input().split()))

if validate_input(n, k, arr):
print("Datele sunt introduse corect.")
find_identical_sequences(n, k, arr)
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input primește valorile citite de la tastatură și verifică dacă îndeplinesc restricțiile impuse de problemă.
Funcția check_sequences primește valorile validate și verifică existența a două secvențe identice în vectorul dat.
Se parcurg secvențele de lungime n/k din vector, verificându-se dacă au mai fost întâlnite.
Dacă se găsește o secvență identică, se afișează numerele de ordine ale celor două secvențe și se returnează din funcție.
Dacă nu se găsește nicio secvență identică, se afișează mesajul "NU".
Dacă datele nu respectă restricțiile, se afișează mesajul corespunzător și se returnează din funcție.
Funcția check_sequences este apelată în cadrul blocului if __name__ == "__main__", unde se citesc datele de intrare."__main__", unde se citesc datele de intrare.

0521 - kSecventa

2023-05-14T19:57:39Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/521/ksecventa 0521 - kSecventa]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale, și un număr k, divizor al lui n. Se împarte vectorul în k secvențe disjuncte, numerotate de la 1 la k. Să se stabilească dacă există două secvențe identice.
== Date de intrare ==
Programul citește de la tastatură numerele n și k, 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 '''se va afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe, dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime.''', 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 ≤ k < n ≤ 1000, k este divizor al lui n
* cele n numere citite vor fi mai mici decât 1000
== Exemplu 1 ==
; Intrare
: 15 5
: 3 6 4 7 6 6 6 4 6 7 6 6 4 4 5
; Ieșire
: Datele sunt introduse corect.
: 2 4
== Exemplu 2 ==
; Intrare
: 3 2
: 1 1 2 3 2 6 7 8 2 4 1 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0521 - kSecventa

def validate_input(n, k, arr):
if k >= n:
return False
if n % k != 0:
return False
if max(arr) > 1000:
return False
return True

def find_identical_sequences(n, k, arr):
if not validate_input(n, k, arr):
print("Datele nu corespund restricțiilor impuse.")
return

seq_dict = {}
for i in range(n // k):
seq = tuple(arr[i * k: (i + 1) * k])
if seq in seq_dict:
print(seq_dict[seq], i + 1)
return
else:
seq_dict[seq] = i + 1

print("NU")

if __name__ == "__main__":
n, k = map(int, input().split())
arr = list(map(int, input().split()))

if validate_input(n, k, arr):
print("Datele sunt introduse corect.")
find_identical_sequences(n, k, arr)
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input primește valorile citite de la tastatură și verifică dacă îndeplinesc restricțiile impuse de problemă.
Funcția check_sequences primește valorile validate și verifică existența a două secvențe identice în vectorul dat.
Se parcurg secvențele de lungime n/k din vector, verificându-se dacă au mai fost întâlnite.
Dacă se găsește o secvență identică, se afișează numerele de ordine ale celor două secvențe și se returnează din funcție.
Dacă nu se găsește nicio secvență identică, se afișează mesajul "NU".
Dacă datele nu respectă restricțiile, se afișează mesajul corespunzător și se returnează din funcție.
Funcția check_sequences este apelată în cadrul blocului if __name__ == "__main__", unde se citesc datele de intrare."__main__", unde se citesc datele de intrare.

0166 - SecvMax

2023-05-14T19:55:30Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/134/secvk 0166 - SecvMax]
----
== Cerinţa ==
Se dau n numere naturale, reprezentând elementele unui vector.

Determinați cea mai lungă secvență de elemente pare din vector. Dacă există mai multe secvențe cu lungime maximă se va determina cea cu suma elementelor maximă. Dacă există mai multe astfel de secvențe se va determina cea mai din stânga.

== Date de intrare ==
Fişierul de intrare secvmax.in conţine numărul n și n valori naturale, reprezentând elementele vectorului. Valorile din fișier pot fi dispuse pe mai multe linii.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''' și fișierul secvk.out va conţine pe prima linie k numere, reprezentând elementele secvenței cerute''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 0 < n ≤ 10.000
* elementele vectorului vor fi mai mici decât 1000 și sunt numerotate de la 1
== Exemplu 1 ==
; Intrare
: secvk.in
: 9
: 2 6 4 5 8 8 6 3 4
; Ieșire
: Datele sunt introduse corect.
: secvk.out
: 5 7

== Exemplu 1 ==
; Intrare
: secvk.in
: 5
: 1 2 3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.
: secvk.out
: 2 3 4 5

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
#0166 - SecvMax

def secv_max(n, v):
# verificam daca datele de intrare sunt valide
for x in v:
if x >= 1000:
print("Datele nu corespund restricțiilor impuse.")
return

# cautam cea mai lunga secventa de elemente pare
start, end, max_len = 0, 0, 0
for i in range(n):
if v[i] % 2 == 0:
j = i
while j < n and v[j] % 2 == 0:
j += 1
if j - i > max_len:
start, end, max_len = i, j, j - i

# calculam suma elementelor secventei
max_sum = sum(v[start:end])

# cautam secventele cu lungime maxima si suma maxima
for i in range(start, end):
if v[i] % 2 == 0 and sum(v[i:end]) == max_sum:
start = i
break

# afisam secventa gasita
print("Datele sunt introduse corect.")
for i in range(start, end):
if v[i] % 2 == 0:
print(v[i], end=' ')
print()

if __name__ == "__main__":
# citim datele de intrare din fisier
with open("secvk.in", "r") as f:
n = int(f.readline().strip())
v = []
for line in f:
v += list(map(int, line.strip().split()))

# apelam functia de rezolvare
secv_max(n, v)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția secv_max(n, v) primește doi parametri: n - numărul de elemente din vectorul v, iar v - vectorul propriu-zis.

Primul for din funcție verifică dacă valorile din vector depășesc limita superioară a intervalului acceptat și, în caz afirmativ, se afișează mesajul "Datele nu corespund restricțiilor impuse." și se returnează din funcție.

Apoi, al doilea for găsește cea mai lungă secvență de numere pare din vector și salvează indicele de început (start), indicele de sfârșit (end) și lungimea (max_len) acestei secvențe.

Suma elementelor din secvența găsită (max_sum) se calculează prin funcția sum și se caută toate secvențele cu lungime maximă și suma maximă a elementelor.

În final, se afișează secvența găsită și un mesaj care confirmă faptul că datele de intrare sunt corecte.

Partea if __name__ == "__main__": servește pentru a citi datele de intrare din fișier și pentru a apela funcția secv_max() cu aceste date.

0134 - SecvK

2023-05-14T19:54:06Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/134/secvk 0134 - SecvK]
----
== Cerinţa ==
Se dă un șir cu n numere naturale și un număr k.
Să se determine o secvență de elemente de lungime k cu suma elementelor maximă.

== Date de intrare ==
Fişierul de intrare secvk.in conţine pe prima linie numerele n și k, 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."'''și fișierul secvk.out va conţine pe prima linie k numere, reprezentând elementele secvenței cerute''', 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 ≤ k ≤ n ≤ 100.000
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât 1000
* dacă există mai multe secvențe de lungime k cu suma maximă se va afișa prima
== Exemplu 1 ==
; Intrare
: secvk.in
: 8 3
: 5 6 1 2 6 6 4 3
; Ieșire
: Datele sunt introduse correct
: secvk.out
: 6 6 4
== Exemplu 2 ==
; Intrare
: secvk.in
: 8 3
: 52748
; Ieșire
: Datele nu corespund restricțiilor impuse.
: secvk.out
: 2 3 4

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0134 - SecvK

def max_sum_sequence(n, k, arr):
if k > n:
return None

max_sum = -float('inf')
max_seq = []

for i in range(n - k + 1):
seq = arr[i:i+k]
seq_sum = sum(seq)

if seq_sum > max_sum:
max_sum = seq_sum
max_seq = seq

return max_seq

def main():
with open('secvk.in', 'r') as fin:
n, k = map(int, fin.readline().split())
arr = list(map(int, fin.readline().split()))

if n != len(arr) or k > n or any(x >= 1000 for x in arr):
print("Datele nu corespund restricțiilor impuse.")
return

seq = max_sum_sequence(n, k, arr)

if seq is None:
print("Nu exista secventa de lungime k in arr.")
else:
print("Datele sunt introduse corect.")
with open('secvk.out', 'w') as fout:
fout.write(' '.join(map(str, seq)))

if __name__ == '__main__':
main()
</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția `max_sum_sequence(n, k, arr)` primește ca argumente numărul de elemente din șir `n`, numărul `k` pentru lungimea secvenței și lista de numere `arr`. Funcția verifică dacă `k` este mai mare decât `n` și, în caz afirmativ, returnează `None`. Apoi, funcția găsește secvența de lungime `k` cu suma maximă din lista `arr`. Variabilele `max_sum` și `max_seq` sunt inițializate cu valori negative și lista goală, respectiv. Pentru fiecare subsecvență de lungime `k` din `arr`, se calculează suma și se compară cu `max_sum`. Dacă este mai mare, atunci valoarea sumei este actualizată, iar lista `max_seq` este setată la subsecvența curentă. La final, funcția returnează lista `max_seq`.

Funcția `main()` începe prin citirea datelor de intrare din fișierul `secvk.in`. Apoi, se verifică dacă datele de intrare respectă restricțiile cerute și se afișează un mesaj corespunzător în cazul în care datele nu corespund. În caz contrar, se calculează secvența de lungime `k` cu suma maximă din lista `arr` folosind funcția `max_sum_sequence()`. Dacă nu există nicio secvență de lungime `k` în `arr`, se afișează un mesaj corespunzător. În caz contrar, se afișează un mesaj de confirmare și se scrie secvența găsită în fișierul `secvk.out`. Funcția `main()` este apelată doar dacă acest script este rulat direct, nu este importat ca modul în alt script, acest lucru se realizează prin instrucțiunea `if __name__ == '__main__':`.

0134 - SecvK

2023-05-14T19:53:34Z

Monica Dragos: /* Date de ieșire */

Sursa: [https://www.pbinfo.ro/probleme/134/secvk 0134 - SecvK]
----
== Cerinţa ==
Se dă un șir cu n numere naturale și un număr k.
Să se determine o secvență de elemente de lungime k cu suma elementelor maximă.

== Date de intrare ==
Fişierul de intrare secvk.in conţine pe prima linie numerele n și k, 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."''', secvk.out va conţine pe prima linie k numere, reprezentând elementele secvenței cerute''', 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 ≤ k ≤ n ≤ 100.000
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici decât 1000
* dacă există mai multe secvențe de lungime k cu suma maximă se va afișa prima
== Exemplu 1 ==
; Intrare
: secvk.in
: 8 3
: 5 6 1 2 6 6 4 3
; Ieșire
: Datele sunt introduse correct
: secvk.out
: 6 6 4
== Exemplu 2 ==
; Intrare
: secvk.in
: 8 3
: 52748
; Ieșire
: Datele nu corespund restricțiilor impuse.
: secvk.out
: 2 3 4

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0134 - SecvK

def max_sum_sequence(n, k, arr):
if k > n:
return None

max_sum = -float('inf')
max_seq = []

for i in range(n - k + 1):
seq = arr[i:i+k]
seq_sum = sum(seq)

if seq_sum > max_sum:
max_sum = seq_sum
max_seq = seq

return max_seq

def main():
with open('secvk.in', 'r') as fin:
n, k = map(int, fin.readline().split())
arr = list(map(int, fin.readline().split()))

if n != len(arr) or k > n or any(x >= 1000 for x in arr):
print("Datele nu corespund restricțiilor impuse.")
return

seq = max_sum_sequence(n, k, arr)

if seq is None:
print("Nu exista secventa de lungime k in arr.")
else:
print("Datele sunt introduse corect.")
with open('secvk.out', 'w') as fout:
fout.write(' '.join(map(str, seq)))

if __name__ == '__main__':
main()
</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția `max_sum_sequence(n, k, arr)` primește ca argumente numărul de elemente din șir `n`, numărul `k` pentru lungimea secvenței și lista de numere `arr`. Funcția verifică dacă `k` este mai mare decât `n` și, în caz afirmativ, returnează `None`. Apoi, funcția găsește secvența de lungime `k` cu suma maximă din lista `arr`. Variabilele `max_sum` și `max_seq` sunt inițializate cu valori negative și lista goală, respectiv. Pentru fiecare subsecvență de lungime `k` din `arr`, se calculează suma și se compară cu `max_sum`. Dacă este mai mare, atunci valoarea sumei este actualizată, iar lista `max_seq` este setată la subsecvența curentă. La final, funcția returnează lista `max_seq`.

Funcția `main()` începe prin citirea datelor de intrare din fișierul `secvk.in`. Apoi, se verifică dacă datele de intrare respectă restricțiile cerute și se afișează un mesaj corespunzător în cazul în care datele nu corespund. În caz contrar, se calculează secvența de lungime `k` cu suma maximă din lista `arr` folosind funcția `max_sum_sequence()`. Dacă nu există nicio secvență de lungime `k` în `arr`, se afișează un mesaj corespunzător. În caz contrar, se afișează un mesaj de confirmare și se scrie secvența găsită în fișierul `secvk.out`. Funcția `main()` este apelată doar dacă acest script este rulat direct, nu este importat ca modul în alt script, acest lucru se realizează prin instrucțiunea `if __name__ == '__main__':`.

0518 - SecvZero

2023-05-14T19:44:59Z

Monica Dragos: /* Explicație rezolvare */

Sursa: [https://www.pbinfo.ro/probleme/4265/perechiab 0518 - SecvZero]
----
== Cerinţa ==
Se dă un vector cu n elemente numere naturale. Determinați cea mai lungă secvență de elemente nule din vector. Dacă în vector există mai multe secvențe de elemente nule de lungime maximă se va determina cea mai din stânga.
== 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 pe ecran numărul de perechi care îndeplinesc condițiile cerute''', 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 ≤ n ≤ 1000
* cele n numere citite vor fi mai mici decât 1000
* indicii elementelor vectorului sunt cuprinși între 1 și n
* vectorul va conține cel puțin un element nul
== Exemplu 1 ==
; Intrare
: 10
: 0 1 0 0 0 5 0 0 0 2
; Ieșire
: Datele sunt introduse correct.
: 3 5
== Exemplu 2 ==
; Intrare
: 2
: 2 1 1 0 0 3 4
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0518 - SecvZero

def lungime_maxima_secventa_nula(vector):
n = len(vector)
lungime_maxima = 0
pozitie = -1
i = 0
while i < n:
if vector[i] == 0:
j = i + 1
while j < n and vector[j] == 0:
j += 1
lungime_curenta = j - i
if lungime_curenta > lungime_maxima:
lungime_maxima = lungime_curenta
pozitie = i
i = j
else:
i += 1
return lungime_maxima, pozitie

def validare_date_intrare(n, vector):
if not (1 <= n <= 1000):
return False
if not all(0 <= x < 1000 for x in vector):
return False
if not any(x == 0 for x in vector):
return False
return True

if __name__ == "__main__":
n = int(input())
vector = list(map(int, input().split()))
if validare_date_intrare(n, vector):
print("Datele sunt introduse corect.")
lungime, pozitie = lungime_maxima_secventa_nula(vector)
print(lungime, pozitie)
else:
print("Datele nu corespund restricțiilor impuse.")

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

Funcția lungime_maxima_secventa_nula primește ca parametru un vector și returnează lungimea și poziția celei mai lungi secvențe de elemente nule din vector. Pentru a face acest lucru, parcurgem vectorul și căutăm secvențe de elemente nule. Dacă găsim o secvență mai lungă decât cea găsită până acum, actualizăm lungimea maximă și poziția. Funcția folosește o buclă while pentru a permite căutarea secvențelor de elemente nule care se întind pe mai mult de un element.
Funcția validare_date_intrare primește ca parametri numărul de elemente și vectorul și returnează True dacă datele de intrare respectă restricțiile impuse și False altfel. În acest caz, verificăm dacă numărul de elemente este între 1 și 1000, dacă toate elementele vectorului sunt între 0 și 999 și dacă vectorul conține cel puțin un element nul.
În funcția if __name__ == "__main__", întâi se citește de la tastatură un număr întreg, n, și un vector de n numere întregi, vector, separate prin spațiu.
Apoi se apelează funcția validare_date_intrare cu parametrii n și vector pentru a verifica dacă datele introduse sunt valide.
Dacă datele introduse sunt valide, se afișează mesajul "Datele sunt introduse corect".
Se apelează funcția lungime_maxima_secventa_nula cu parametrul vector pentru a găsi lungimea și poziția primei secvențe nule din vector.
Se afișează lungimea și poziția găsite anterior.
Dacă datele introduse nu sunt valide, se afișează mesajul "Datele nu corespund restricțiilor impuse".

0516 - SumSec1

2023-05-14T19:41:11Z

Monica Dragos: /* Explicație rezolvare */

Sursa: https://www.pbinfo.ro/probleme/516/sumsec1 0516 - SumSec1]
----
== Cerinţa ==
Se dă un vector format din n elemente, numere naturale. Calculați suma elementelor din secvența determinată de primul și ultimul element impar.
== Date de intrare ==
Programul va citi de la tastatură numărul n, apoi cele n elemente ale 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 fișa pe ecran numărul S, reprezentând suma calculată''', 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 ≤ n ≤ 1000
* elementele vectorului vor fi mai mici decât 1.000.000
* vectorul va conţine cel puțin un element impar
== Exemplu 1 ==
; Intrare
: Introduceti valoarea lui n: 8
: 12 10 15 6 7 10 19 14
; Ieșire
: Datele sunt introduse correct.
: 5 4

== Exemplu 2 ==
; Intrare
: Introduceti valoarea lui n: 4
: 2 4 6 8
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==

=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0516 - SumSec1

def validate_input(n, vector):
if n < 1 or n > 1000:
print("Datele nu corespund restricțiilor impuse.")
return False

has_odd = False
for i in range(n):
if vecror[i] < 0 or vector[i] >= 1000000:
print("Datele nu corespund restricțiilor impuse.")
return False
if vector[i] % 2 == 1:
has_odd = True

if not has_odd:
print("Datele nu corespund restricțiilor impuse.")
return False

print("Datele sunt introduse corect.")
return True

def calculate_sum(n, v):
start = None
end = None

for i in range(n):
if vector[i] % 2 == 1:
if start is None:
start = i
else:
end = i

return sum(vector[start:end+1])

if __name__ == "__main__":
n = int(input("Introduceti valoarea lui n: "))
vector = list(map(int, input("Introduceti valorile din vector: ").split()))

if not validate_input(n, vector):
exit()

print(calculate_sum(n, vector))

</syntaxhighlight>

== Explicație rezolvare==

Funcția validate_input primește patru argumente: n, vector, A și B. Această funcție are rolul de a valida datele de intrare. Verificările pe care le face includ verificarea dacă n se încadrează în intervalul [1, 1000], dacă fiecare element al vectorului vector se încadrează în intervalul [1, 1.000.000], dacă vectorul vector conține cel puțin un element impar și dacă A și B se încadrează în intervalul [1, 2.000.000.000] și dacă A este mai mic sau egal cu B. Dacă toate verificările trec, atunci funcția afișează pe ecran "Datele sunt introduse corect." și returnează True. În caz contrar, funcția afișează pe ecran "Datele nu corespund restricțiilor impuse." și returnează False.

Funcția sum_secventa primește trei argumente: n, vector și valid. Această funcție calculează suma elementelor din secvența determinată de primul și ultimul element impar din vectorul vector. Dacă parametrul valid este False, adică datele de intrare nu au trecut validarea, funcția afișează pe ecran "Datele nu corespund restricțiilor impuse." și returnează None. În caz contrar, funcția calculează prima și ultima poziție cu numere impare în vectorul vector, apoi calculează suma elementelor din secvența respectivă și afișează pe ecran această valoare.

În funcția main se citesc datele de intrare, se validează cu ajutorul funcției validate_input, și se calculează suma cu ajutorul funcției sum_secventa. Dacă valoarea returnată de sum_secventa este diferită de None, adică dacă datele de intrare au trecut validarea și s-a putut calcula suma, atunci se afișează pe ecran "Datele sunt introduse corect." și valoarea sumei. În caz contrar, se afișează doar "Datele nu corespund restricțiilor impuse."

0516 - SumSec1

2023-05-14T19:40:00Z

Monica Dragos: /* Rezolvare ver. 1 */

Sursa: https://www.pbinfo.ro/probleme/516/sumsec1 0516 - SumSec1]
----
== Cerinţa ==
Se dă un vector format din n elemente, numere naturale. Calculați suma elementelor din secvența determinată de primul și ultimul element impar.
== Date de intrare ==
Programul va citi de la tastatură numărul n, apoi cele n elemente ale 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 fișa pe ecran numărul S, reprezentând suma calculată''', 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 ≤ n ≤ 1000
* elementele vectorului vor fi mai mici decât 1.000.000
* vectorul va conţine cel puțin un element impar
== Exemplu 1 ==
; Intrare
: Introduceti valoarea lui n: 8
: 12 10 15 6 7 10 19 14
; Ieșire
: Datele sunt introduse correct.
: 5 4

== Exemplu 2 ==
; Intrare
: Introduceti valoarea lui n: 4
: 2 4 6 8
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==

=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0516 - SumSec1

def validate_input(n, vector):
if n < 1 or n > 1000:
print("Datele nu corespund restricțiilor impuse.")
return False

has_odd = False
for i in range(n):
if vecror[i] < 0 or vector[i] >= 1000000:
print("Datele nu corespund restricțiilor impuse.")
return False
if vector[i] % 2 == 1:
has_odd = True

if not has_odd:
print("Datele nu corespund restricțiilor impuse.")
return False

print("Datele sunt introduse corect.")
return True

def calculate_sum(n, v):
start = None
end = None

for i in range(n):
if vector[i] % 2 == 1:
if start is None:
start = i
else:
end = i

return sum(vector[start:end+1])

if __name__ == "__main__":
n = int(input("Introduceti valoarea lui n: "))
vector = list(map(int, input("Introduceti valorile din vector: ").split()))

if not validate_input(n, vector):
exit()

print(calculate_sum(n, vector))

</syntaxhighlight>

== Explicație rezolvare==

Funcția validate_input primește patru argumente: n, v, A și B. Această funcție are rolul de a valida datele de intrare. Verificările pe care le face includ verificarea dacă n se încadrează în intervalul [1, 1000], dacă fiecare element al vectorului v se încadrează în intervalul [1, 1.000.000], dacă vectorul v conține cel puțin un element impar și dacă A și B se încadrează în intervalul [1, 2.000.000.000] și dacă A este mai mic sau egal cu B. Dacă toate verificările trec, atunci funcția afișează pe ecran "Datele sunt introduse corect." și returnează True. În caz contrar, funcția afișează pe ecran "Datele nu corespund restricțiilor impuse." și returnează False.

Funcția sum_secventa primește trei argumente: n, v și valid. Această funcție calculează suma elementelor din secvența determinată de primul și ultimul element impar din vectorul v. Dacă parametrul valid este False, adică datele de intrare nu au trecut validarea, funcția afișează pe ecran "Datele nu corespund restricțiilor impuse." și returnează None. În caz contrar, funcția calculează prima și ultima poziție cu numere impare în vectorul v, apoi calculează suma elementelor din secvența respectivă și afișează pe ecran această valoare.

În funcția main se citesc datele de intrare, se validează cu ajutorul funcției validate_input, și se calculează suma cu ajutorul funcției sum_secventa. Dacă valoarea returnată de sum_secventa este diferită de None, adică dacă datele de intrare au trecut validarea și s-a putut calcula suma, atunci se afișează pe ecran "Datele sunt introduse corect." și valoarea sumei. În caz contrar, se afișează doar "Datele nu corespund restricțiilor impuse."