Bitnami MediaWiki - User contributions [en]

28251

2024-01-07T10:06:21Z

Flaviu: Pagină nouă: '''28251 (Trif Flaviu) ''' ''Fie'' <math>(n \geq 2)</math> ''un număr natural și'' <math> f: [0,1] \longrightarrow \mathbb{R} </math> ''o funcție continuă astfel încât'' <math>f(0) \geq 0</math> si <math>\int_{0}^{1} e^2f(x) dx = 1+\frac{2}{n^3}</math>. a) ''Dați un exemplu de o funcție f cu proprietățile din enunț''. b) ''Arătați că există'' <math> c \in [0,1] </math> astfel încât <math> f(c) = c^{n^{3}} - 1 </math>. '''Solu...

'''28251 (Trif Flaviu) '''
 
 
''Fie'' <math>(n \geq 2)</math> ''un număr natural și'' <math> f: [0,1] \longrightarrow \mathbb{R} </math> ''o funcție continuă astfel încât'' <math>f(0) \geq 0</math> si <math>\int_{0}^{1} e^2f(x) dx = 1+\frac{2}{n^3}</math>.
 
a) ''Dați un exemplu de o funcție f cu proprietățile din enunț''.
 
b) ''Arătați că există'' <math> c \in [0,1] </math> astfel încât <math> f(c) = c^{n^{3}} - 1
</math>.

'''Soluție.''' a) Funcția <math> f: [0,1] \longrightarrow \mathbb{R}, \quad f(x) = \ln\sqrt{1 + \frac{4x}{n^3}}</math> are toate proprietățile din enunț.
 
b) Deoarece <math> e^t \geq t + 1</math> pentru orice <math> t \in \mathbb{R}</math>, avem

<math> 1 + \frac{2}{n^3} = \int_{0}^{1} e^{2f(x)} dx \geq \int_{0}^{1} (2f(x) + 1) dx = 2\int_{0}^{1} f(x)dx + 1</math>,
 
de unde rezultă că <math> \int_{0}^{1} f(x)dx\leq \frac{1}{n^3}</math>. Cum <math> \int_{0}^{1} x^{n^3-1}dx</math>, deducem că <math> \int_{0}^{1} (f(x) - x^{n^3-1}_dx \leq 0 </math>, deci există <math> a \in [0,1] </math>, astfel încât <math> f(a) - a^{n^{3}}-1 \leq 0 </math>.
 
Functia <math> g : [0,1] \longrightarrow \mathbb{R}, g(x) = f(x) - x^{n^{3}}</math> este continuă și <math> g(0) * g(a) \leq 0</math>.
 
Rezultă că exsită <math> c \in [0,a] \subseteq [0,1]</math> astfel încât <math> g(c) = 0 </math>.

2405 - politic

2023-05-14T22:06:16Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/304/secvente 2405 - politic]
----
Î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.

== Cerinţa ==
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 ==
Fișierul de ieșire politic.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 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:01:44Z

Flaviu:

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 ==
Fișierul de ieșire ksum2.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 '''rima 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-14T21:58:47Z

Flaviu:

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 ==
Fișierul de ieșire ksum.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 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-14T21:56:47Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/1804/ursulet 1804 - ursulet]
----
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ă.

== Cerinţa ==
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 ==
Fișierul de ieșire ursulet.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 î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.

1446 - Memory002

2023-05-14T21:54:17Z

Flaviu:

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 ==
Fișierul de ieșire memory002.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 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-14T21:52:39Z

Flaviu:

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 ==
Fișierul de ieșire secmax.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, 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-14T21:51:01Z

Flaviu:

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 ==
Fișierul de ieșire ou.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 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-14T21:48:42Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/3273/cmmdcsecv 3273 - cmmdcsecv]
----
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.

== Cerinţa ==
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-14T21:45:24Z

Flaviu:

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

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.

== Cerinţa ==
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ă.

3274 - secvb

2023-05-14T21:44:46Z

Flaviu:

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

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.

== Cerinţa ==
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.

read_input() - Această funcție este responsabilă de citirea datelor de intrare din fișierul "secvb.in". Ea returnează valorile citite pentru N, T și 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-14T21:43:25Z

Flaviu:

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 ==
Fișierul de ieșire sminus.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 se vor găsi două numere naturale x și y separate printr-un spațiu reprezentând perechea de indici. 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-14T21:41:28Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/4177/livada2 4177 - livada2]
----
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.

== Cerinţa ==
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.

0300 - SumaInSecv

2023-05-14T21:37:14Z

Flaviu:

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.

== 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:
return 0, 0
else:
return lmax, c

def validate_input(n, S, v):
if not (1 <= n <= 100):
return False
if len(v) != n:
return False
for i in range(n):
if not (1 <= v[i] <= 9999):
return False
return True

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 not validate_input(n, S, v):
raise ValueError("Datele nu corespund restricțiilor impuse.")
print("Datele sunt introduse corect.")
lmax, c = secv_suma(n, S, v)
with open("secv10.out", "w") as f:
f.write(f"{lmax} {c}")
except Exception as e:
print("Datele nu corespund restricțiilor impuse.")
print(e)

</syntaxhighlight>
== Explicatie Rezolvare ==

`secv_suma(n, S, v)`: Această funcție primește trei argumente: `n` - lungimea listei `v`, `S` - suma căutată și `v` - lista de numere întregi. Scopul funcției este să găsească cea mai lungă subsecvență continuă a listei `v` a cărei sumă este egală cu `S`. Funcția utilizează o abordare dinamică pentru a calcula matricea `dp` care stochează sumele parțiale ale subsecvențelor. Apoi, se verifică fiecare subsecvență pentru a determina cea mai lungă subsecvență cu suma `S`. Funcția returnează un tuplu `(lmax, c)` unde `lmax` este lungimea celei mai lungi subsecvențe și `c` este numărul de subsecvențe cu aceeași lungime maximă.

`validate_input(n, S, v)`: Această funcție primește trei argumente: `n` - lungimea listei `v`, `S` - suma căutată și `v` - lista de numere întregi. Scopul funcției este să valideze datele de intrare conform restricțiilor impuse. Verifică dacă lungimea listei `v` este `n`, dacă `n` se încadrează în intervalul permis și dacă fiecare element din `v` se încadrează în intervalul permis. Returnează `True` dacă datele sunt valide și `False` în caz contrar.

Funcția principală `if __name__ == "__main__"` citeste datele de intrare din fișierul "sumainsecv.in", validează datele folosind funcția `validate_input()`, apoi apelează funcția `secv_suma()` pentru a obține rezultatul dorit. Rezultatul este scris în fișierul "secv10.out". Dacă apar erori în citirea sau validarea datelor, se afișează un mesaj corespunzător pe ecran.

4233 - SecvDeSumaS

2023-05-14T21:33:47Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/4233/secvdesumas 4233 - SecvDeSumaS]
----
== Cerinţa ==
Se dă un șir a1, a2, …, an de numere întregi și un număr întreg S. Să se determine numărul secvențelor nevide care au suma egală cu S.

== Date de intrare ==
Programul citește de la tastatură de pe prima linie numerele n, S, iar de pe a doua linie numerele separate prin spații a1, a2, …, an.

== 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 numărul secvențelor nevide care au suma egală cu S'', 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
* -1000 ≤ ai ≤ 1000 pentru orice i=1..n
* -1.000.000.000 ≤ S ≤ 1.000.000.000
O secvență nevidă este formată din unul sau mai multe elemente ale șirului aflate pe poziții consecutive.nță 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
: 13 -10
: 2 3 -11 1 -11 4 -8 10 -14 10 -5 4 -17
; Ieșire
: Datele sunt introduse correct.
: 4

== Exemplu ==
; Intrare
: 22 3 5 9 2
: 1 2 3 5 0 0 -1 0 2 -76 23
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 4233 - SecvDeSumaS

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

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

count = 0
current_sum = 0
prefix_sum = {0: 1}

for i in range(n):
current_sum += arr[i]
diff = current_sum - S
if diff in prefix_sum:
count += prefix_sum[diff]
prefix_sum[current_sum] = prefix_sum.get(current_sum, 0) + 1

return count

if __name__ == '__main__':
n, S = map(int, input("Introduceti n si S: ").split())
arr = list(map(int, input("Introduceti vectorul de numere întregi: ").split()))

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

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(n, S, arr) este responsabilă pentru validarea datelor de intrare. Aceasta verifică dacă valorile îndeplinesc restricțiile impuse în cerință. Verifică următoarele condiții:

n trebuie să fie între 1 și 1.000.000
lungimea listei arr trebuie să fie n
fiecare element din arr trebuie să fie între -1000 și 1000
S trebuie să fie între -1.000.000.000 și 1.000.000.000
Dacă oricare dintre aceste condiții nu este îndeplinită, funcția returnează False, altfel returnează True.
Funcția count_sequences(n, S, arr) primește parametrii validați și calculează numărul de secvențe nevide care au suma egală cu S.

Verifică dacă datele de intrare sunt valide folosind funcția validate_input(). Dacă nu sunt valide, returnează mesajul "Datele nu corespund restricțiilor impuse."
Inițializează variabila count cu 0 pentru a număra secvențele care îndeplinesc condiția.
Inițializează variabilele current_sum cu 0 și prefix_sum ca un dicționar cu o singură valoare inițială: {0: 1}. Aceasta înseamnă că avem o sumă curentă de 0 și avem o secvență goală cu sumă 0 (aceasta va fi folosită pentru a număra secvențele care încep de la începutul listei arr și au suma S).
Parcurge fiecare element num din arr.
Adaugă num la current_sum.
Calculează diferența diff dintre current_sum și S.
Verifică dacă diff există în dicționarul prefix_sum. Dacă există, înseamnă că am găsit o secvență cu suma S. Adaugă valoarea corespunzătoare din prefix_sum la count.
Incrementăm sau actualizăm valoarea corespunzătoare current_sum în dicționarul prefix_sum.
La sfârșitul buclei, count va conține numărul total de secvențe care au suma S.
Returnează valoarea count.
Blocul if __name__ == '__main__': este responsabil pentru citirea datelor de intrare și apelarea funcțiilor corespunzătoare.

Citim n și S de la tastatură și le convertim la întregi utilizând map și int.
Citim vectorul arr de numere întregi de la tastatură, îl splituim într-o listă folosind split

3937 - KSum3

2023-05-14T21:31:31Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/3937/ksum3 3937 - KSum3]
----
== Cerinţa ==
Se dă N și un vector de N elemente numere întregi, găsiți suma maximă a unei subsecvențe (elemente adiacente) cu lungimile cuprinse între K și W (K <= lungime <= W).

== Date de intrare ==
Programul citește de la tastatură numerele N, K, W iar apoi un vector de N numere întregi.

== 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 suma maxima a unei subsecvențe care respectă condițiile din enunț'', 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 ≤ 1.000.000
* cele N numere citite vor fi din intervalul [-1.000.000.000, 1.000.000.000].crescător
== Exemplu 1 ==
; Intrare
: 6 3 4
: 5 4 -10 1 2 3
; Ieșire
: Datele sunt introduse correct.
: 6

== Exemplu 1 ==
; Intrare
: 256
: 5 4 -10 -3 -3 0 0 0
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3937 - KSum3

def validate_input(N, K, W, arr):
if not (1 <= K <= W <= N <= 1000000):
return False
if len(arr) != N:
return False
if any(num < -1000000000 or num > 1000000000 for num in arr):
return False
return True

def find_max_subsequence_sum(N, K, W, arr):
if not validate_input(N, K, W, arr):
return "Datele nu corespund restricțiilor impuse."

max_sum = float("-inf")
current_sum = 0

for i in range(N):
current_sum += arr[i]
if i >= K - 1:
max_sum = max(max_sum, current_sum)
current_sum -= arr[i - K + 1]

return max_sum

if __name__ == "__main__":
N = int(input("Introduceti N: "))
K = int(input("Introduceti K: "))
W = int(input("Introduceti W: "))

arr = list(map(int, input("Introduceti vectorul de numere întregi: ").split()))

result = find_max_subsequence_sum(N, K, W, arr)
print(result)

</syntaxhighlight>
== Explicatie Rezolvare ==
validate_input(N, K, W, arr): Această funcție primește patru parametri: N, K, W și arr, reprezentând numărul de elemente, limitele K și W, și lista de numere întregi arr. Scopul acestei funcții este să valideze datele de intrare conform restricțiilor impuse. Verificările includ:

Dacă K și W sunt în intervalul permis, adică 1 <= K <= W <= N <= 1000000.
Dacă lungimea listei arr este egală cu N.
Dacă oricare dintre numerele din lista arr depășește limitele [-1000000000, 1000000000].
Dacă oricare dintre aceste condiții nu este îndeplinită, funcția returnează False, indicând că datele nu corespund restricțiilor. În caz contrar, funcția returnează True, semnificând că datele sunt introduse corect.

find_max_subsequence_sum(N, K, W, arr): Această funcție primește aceiași parametri ca și validate_input: N, K, W și arr. Scopul acestei funcții este să găsească suma maximă a unei subsecvențe cu lungimi cuprinse între K și W în lista arr. Funcția verifică întâi datele de intrare utilizând funcția validate_input. Dacă datele nu sunt valide, funcția returnează mesajul "Datele nu corespund restricțiilor impuse."

Dacă datele sunt valide, funcția inițializează max_sum cu o valoare negativă foarte mică și current_sum cu 0. Apoi, utilizează o buclă for pentru a itera prin lista arr. La fiecare pas, adaugă elementul curent la suma curentă current_sum. Dacă indicele curent i este mai mare sau egal cu K - 1, înseamnă că lungimea subsecvenței este cel puțin K, așa că compară current_sum cu max_sum și actualizează max_sum dacă este necesar. În final, se scade elementul din subsecvență care nu mai face parte din fereastra curentă, adică arr[i - K + 1], din current_sum.

La sfârșit, funcția returnează max_sum, care reprezintă suma maximă a subsecvenței.

if __name__ == "__main__": : Acesta este blocul principal al programului care va fi executat doar atunci când scriptul este rulat direct și nu importat ca modul în altă parte a codului. În acest bloc, se face citirea datelor utilizând funcția input() și map(), apoi se apelează funcția find_max_subsequence_sum

1364 - produs3

2023-05-14T21:30:46Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/1364/produs3 1364 - produs3]
----
== Cerinţa ==
Se dă un şir cu n numere naturale nenule care sunt divizibile doar cu numerele prime 2, 3 sau 5. Determinaţi numărul secvenţelor din şir pentru care produsul elementelor este pătrat perfect.

== Date de intrare ==
Fișierul de intrare produs3.in conține pe prima linie numărul n, iar pe a doua linie n numere naturale nenule divizibile doar cu numerele prime 2, 3 sau 5, separate prin spații.

== Date de ieșire ==
Fișierul de ieșire produs3.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 '''numărul S, reprezentând numărul secvenţelor din şir pentru care produsul elementelor este pătrat perfect''', 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
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât 1.000.000
== Exemplu 1 ==
; Intrare
: produs3.in
: 5
: 12 3 4 5 45
; Ieșire
: Datele sunt introduse correct.
: produs3.out
: 6
== Exemplu 2 ==
; Intrare
: produs3.in
: 0 0 0 1
: -2 -3 1 5 0
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 1364 - produs3

import math

def solve(n, arr):
cnt = 0
for i in range(n):
prod = 1
for j in range(i, n):
prod *= arr[j]
if math.isqrt(prod) ** 2 == prod:
cnt += 1
return cnt

def validate(n, arr):
primes = [2, 3, 5]
for x in arr:
for prime in primes:
while x % prime == 0:
x //= prime
if x != 1:
return False
return True

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

if validate(n, arr):
print("Datele sunt introduse corect.")
result = solve(n, arr)
print(result)
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicatie Rezolvare ==
solve(n, arr): Această funcție primește numărul de elemente n și lista de numere arr. Scopul acestei funcții este să determine numărul de secvențe din lista arr pentru care produsul elementelor este un pătrat perfect. Funcția utilizează două bucle for pentru a itera prin toate secvențele posibile și calculează produsul elementelor. Dacă produsul este un pătrat perfect (verificat utilizând funcția math.isqrt()), se incrementează un contor cnt. La final, funcția returnează valoarea contorului cnt.

validate(n, arr): Această funcție primește numărul de elemente n și lista de numere arr. Scopul acestei funcții este să valideze lista arr, verificând dacă fiecare număr din listă este divizibil doar cu numerele prime 2, 3 și 5. Funcția parcurge fiecare număr din listă și îl împarte succesiv la aceste numere prime până când nu mai poate fi împărțit. Dacă la final rămâne un rest diferit de 1, funcția returnează False, semnificând că datele nu corespund restricțiilor impuse. În caz contrar, returnează True.

if __name__ == '__main__': : Acesta este blocul principal al programului care va fi executat doar atunci când scriptul este rulat direct și nu importat ca modul în altă parte a codului. În acest bloc, se face citirea datelor utilizând funcția input(), se validează datele utilizând funcția validate(), iar dacă datele sunt valide, se apelează funcția solve() pentru a obține rezultatul și se afișează rezultatul. În cazul în care datele nu sunt valide, se afișează un mesaj corespunzător.

3937 - KSum3

2023-05-14T21:28:01Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/3937/ksum3 3937 - KSum3]
----
== Cerinţa ==
Se dă N și un vector de N elemente numere întregi, găsiți suma maximă a unei subsecvențe (elemente adiacente) cu lungimile cuprinse între K și W (K <= lungime <= W).

== Date de intrare ==
Programul citește de la tastatură numerele N, K, W iar apoi un vector de N numere întregi.

== 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 suma maxima a unei subsecvențe care respectă condițiile din enunț'', 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 ≤ 1.000.000
* cele N numere citite vor fi din intervalul [-1.000.000.000, 1.000.000.000].crescător
== Exemplu 1 ==
; Intrare
: 6 3 4
: 5 4 -10 1 2 3
; Ieșire
: Datele sunt introduse correct.
: 6

== Exemplu 1 ==
; Intrare
: 256
: 5 4 -10 -3 -3 0 0 0
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3937 - KSum3

def validate_input(N, K, W, arr):
if not (1 <= K <= W <= N <= 1000000):
return False
if len(arr) != N:
return False
if any(num < -1000000000 or num > 1000000000 for num in arr):
return False
return True

def find_max_subsequence_sum(N, K, W, arr):
if not validate_input(N, K, W, arr):
return "Datele nu corespund restricțiilor impuse."

max_sum = float("-inf")
current_sum = 0

for i in range(N):
current_sum += arr[i]
if i >= K - 1:
max_sum = max(max_sum, current_sum)
current_sum -= arr[i - K + 1]

return max_sum

if __name__ == "__main__":
N = int(input("Introduceti N: "))
K = int(input("Introduceti K: "))
W = int(input("Introduceti W: "))

arr = list(map(int, input("Introduceti vectorul de numere întregi: ").split()))

result = find_max_subsequence_sum(N, K, W, arr)
print(result)

</syntaxhighlight>
== Explicatie Rezolvare ==
validate_input(n, k, w, arr): Această funcție validează datele de intrare. Verifică dacă valorile N, K și W respectă restricțiile impuse și dacă dimensiunea vectorului este în concordanță cu N. Returnează True dacă datele sunt valide și False în caz contrar.

find_max_subsequence_sum(n, k, w, arr): Această funcție calculează suma maximă a unei subsecvențe care respectă condițiile date. Verifică mai întâi validitatea datelor de intrare utilizând funcția validate_input(). Apoi, parcurge vectorul de la stânga la dreapta și, pentru fiecare poziție, calculează suma maximă a unei subsecvențe de lungime cuprinsă între K și W. Returnează suma maximă calculată.

Blocul if __name__ == "__main__": este locul în care se face citirea datelor de intrare și apelarea funcțiilor pentru rezolvarea problemei.

Se deschide fișierul "ksum3.in" pentru citire și se citesc valorile N, K, W de pe prima linie și elementele vectorului de pe a doua linie.
Se apelează funcția find_max_subsequence_sum() cu datele citite.
Dacă rezultatul returnat este o sumă validă, se afișează "Datele sunt introduse corect." și suma calculată. Altfel, se afișează mesajul "Datele nu corespund restricțiilor impuse."

2142 - easy sum

2023-05-14T21:25:30Z

Flaviu:

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."''', apoi pe un rând nou '''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-14T21:24:38Z

Flaviu:

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."''', apoi pe un rând nou '''numărul S, reprezentând numărul secvenţelor din şir având produsul mai mic decât p'', 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 = 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-14T21:23:44Z

Flaviu:

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."''', apoi pe un rând nou '''numărul S, reprezentând numărul secvenţelor din şir având produsul mai mic decât p'', 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 = 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.
Verifică dacă product este mai mic decât p. Dacă da, înseamn

0310 - SecvPal

2023-05-14T21:21:56Z

Flaviu:

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 ==
Fişierul de ieşire secvpal.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 ''' 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

2236 - swap01

2023-05-14T21:20:01Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/2236/swap01 2236 - swap01]
----
Se consideră un șir binar a[1], a[2], …, a[n]. Asupra șirului se poate efectua operația swap(i, j) prin care se interschimbă valorile a[i] și a[j].

== Cerinţa ==
Să se determine numărul minim de operații swap care pot fi efectuate astfel încât toate valorile de 1 să apară pe poziții consecutive în șir.

== Date de intrare ==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații reprezentând elementele șirului binar.

== 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 '''umărul minim de operații swap care pot fi efectuate astfel încât toate valorile de 1 să apară pe poziții consecutive în ș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 ==
* 1 ≤ n ≤ 100.000
== Exemplu 1 ==
; Intrare
: 14
: 1 0 0 1 0 1 1 0 1 0 0 0 1 0
; Ieșire
: Datele sunt introduse correct.
: 2

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

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 2236 - swap01

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

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

# Determinăm numărul de valori de 1 din șir
count_ones = arr.count(1)

# Numărul minim de operații swap este diferența dintre lungimea șirului și numărul de valori de 1
min_swaps = n - count_ones

return min_swaps

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

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

</syntaxhighlight>
== Explicatie Rezolvare ==
Avem funcția validate_input care verifică dacă datele de intrare sunt valide. Verificăm dacă n se află în intervalul [1, 100000] și dacă lungimea listei arr este egală cu n.

Funcția principală count_swaps primește numărul de elemente n și lista arr ca argumente. În primul rând, verificăm validitatea datelor de intrare folosind funcția validate_input. Apoi, numărăm numărul de valori de 1 din șir utilizând metoda count a listei. Numărul minim de operații swap este diferența dintre lungimea șirului n și numărul de valori de 1 count_ones.

În blocul if __name__ == "__main__":, citim valorile de intrare n și arr folosind funcția input(). Apoi apelăm funcția count_swaps și afișăm rezultatul.

4241 - max2secv

2023-05-14T21:18:28Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/4241/max2secv - max2secv]
----
Se dă un șir a1, a2, …, an de numere întregi. Definim suma unei secvențe ai, ai+1, …, aj ca fiind suma elementelor sale, adică ai + ai+1 + ... + aj.

== Cerinţa ==
Să se determine suma maximă posibilă care se poate obține din două secvențe disjuncte din șir.

== Date de intrare ==
Programul citește de la tastatură numărul n, iar apoi șirul de n numere întregi, 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 suma maximă care se poate obține din două secvențe disjuncte''', 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
* -100 ≤ a[i] ≤ 100
* Două secvențe sunt disjuncte dacă nu au niciun element comun.
== Exemplu 1 ==
; Intrare
: 6
: 2 -1 3 -8 4 -5
; Ieșire
: Datele sunt introduse correct.
: 8

== Exemplu 2 ==
; Intrare
: 1 2 3
: 77
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 4241 - max2secv

def validate_input(n, nums):
if not (2 <= n <= 100000):
return False
if len(nums) != n:
return False
if any(num < -100 or num > 100 for num in nums):
return False
return True

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

max_sum = float('-inf')
for i in range(n-1):
sum1 = sum(nums[:i+1])
sum2 = sum(nums[i+1:])
max_sum = max(max_sum, sum1 + sum2)

return max_sum

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

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

</syntaxhighlight>
== Explicatie Rezolvare ==
validate_input(n, nums): Această funcție primește numărul n și lista nums și verifică dacă datele de intrare sunt valide în conformitate cu restricțiile cerinței. Verificările efectuate sunt:

Verifică dacă n se află în intervalul [2, 100000]. Dacă nu, funcția returnează False.
Verifică dacă lungimea listei nums este egală cu n. Dacă nu, funcția returnează False.
Verifică dacă există cel puțin un element în lista nums care nu se încadrează în intervalul [-100, 100]. Dacă da, funcția returnează False.
Dacă toate verificările sunt îndeplinite, funcția returnează True, semnalând că datele sunt valide.
find_max_sum(n, nums): Această funcție primește numărul n și lista nums și determină suma maximă care se poate obține din două secvențe disjuncte din șir. Funcția inițializează max_sum cu o valoare extrem de mică (pentru a permite compararea și actualizarea corectă).

Apoi, folosind o buclă for de la 0 la n-2, se calculează suma primelor i+1 elemente (sum1) și suma ultimelor n-i-1 elemente (sum2). Suma acestor două secvențe este calculată ca sum1 + sum2, iar rezultatul este actualizat dacă această sumă este mai mare decât max_sum. Astfel, se determină suma maximă posibilă.

La final, funcția returnează max_sum, reprezentând suma maximă a două secvențe disjuncte.

__main__: Această secțiune verifică dacă scriptul este executat direct (nu importat ca modul) și conține citirea datelor de intrare de la tastatură și apelarea funcției find_max_sum.

0297 - SecvSumMax

2023-05-14T21:17:20Z

Flaviu:

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 ==
Fișierul de ieșire secvsummax.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 ''' 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-14T21:14:43Z

Flaviu:

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 ==
Fișierul de ieșire intervale6.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 ''' umă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-14T21:11:56Z

Flaviu:

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 ==
Fişierul de ieşire oglindiri.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 ''' 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ă.

0283 - Secventa

2023-05-14T21:07:56Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/283/secventa - Secventa]
----
== Cerinţa ==
Se dă un şir cu n elemente, numere naturale. Determinaţi cea mai lungă secvenţă de elemente din şir cu proprietatea că oricare două valori consecutive în secvenţă au parităţi diferite.

Dacă există mai multe secvente de lungime maximă cu această proprietate, se va determina aceea cu suma elementelor maximă. Dacă există mai multe secvenţe de lungime maximă cu aceeaşi sumă maximă a elementelor se va determina cea mai din dreapta.

== Date de intrare ==
Fişierul de intrare secventa.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 ==
Fişierul de ieşire secventa.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 ''' două numere p şi u, separate printr-un spaţiu, reprezentând indicele primului, respectiv al ultimului element din secvenţa determinată''', 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 9 cifre şi sunt numerotate de la 1 la n;
== Exemplu 1 ==
; Intrare
: secventa.in
: 10
: 2 4 3 6 7 5 2 5 8 10
; Ieșire
: secventa.out
: Datele sunt introduse correct.
: 6 9

== Exemplu 2 ==
; Intrare
: secventa.in
: 10 2 3 4
: 1 9 22 13 5 2 5 8 10
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0283 - Secventa
def rezolvare(n, a):
p = u = -1
max_lungime = max_suma = 0

# Cautam secventa maximă
lungime_secventa = suma_elementelor = 1
for i in range(1, n):
if a[i] % 2 == a[i-1] % 2:
lungime_secventa = 1
suma_elementelor = a[i]
else:
lungime_secventa += 1
suma_elementelor += a[i]
if lungime_secventa > max_lungime or (lungime_secventa == max_lungime and suma_elementelor > max_suma):
max_lungime = lungime_secventa
max_suma = suma_elementelor
p = i - lungime_secventa + 1
u = i

return p, u

def validare(p, u):
with open("secventa.out", "w") as f:
if p == -1:
f.write("-1\n")
else:
f.write(f"{p+1} {u+1}\n")

if __name__ == "__main__":
try:
with open("secventa.in", "r") as f:
n = int(f.readline())
a = list(map(int, f.readline().split()))
if n < 1 or n > 100000:
raise ValueError("Numarul n nu se incadreaza in limitele problemei.")
for i in range(n):
if a[i] < 0 or a[i] > 999999999:
raise ValueError("Elementele sirului trebuie sa fie numere naturale de cel mult 9 cifre.")
p, u = rezolvare(n, a)
if p != -1 and u != -1:
print("Datele sunt introduse corect.")
else:
print("Datele nu corespund restricțiilor impuse.")
validare(p, u)
except Exception as e:
print("Datele nu corespund restricțiilor impuse.")
print(e)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția de rezolvare, rezolvare(n, a), care primește ca parametri numărul de elemente din șir n și șirul propriu-zis a. Scopul acestei funcții este de a determina cea mai lungă secvență cu proprietatea specificată în enunț și de a returna pozițiile primului și ultimului element din această secvență.

Această funcție începe prin a inițializa variabilele p și u cu valoarea -1, semnificând faptul că încă nu am găsit nicio secvență cu proprietatea specificată. De asemenea, funcția mai inițializează două variabile max_lungime și max_suma cu valoarea 0, care vor fi folosite pentru a determina secvența maximă în ceea ce privește lungimea și suma elementelor.

În continuare, se parcurge șirul a și se calculează lungimea și suma elementelor din secvența curentă, utilizând variabilele lungime_secventa și suma_elementelor. Dacă se întâlnește un element cu paritatea identică cu elementul anterior, secvența curentă se întrerupe și se inițializează lungimea și suma elementelor pentru o nouă secvență începând cu elementul curent. În caz contrar, se actualizează lungimea și suma elementelor din secvența curentă, și se compară aceste valori cu cele ale secvenței maximale găsite până în acel moment (max_lungime și max_suma). Dacă lungimea secvenței curente depășește lungimea secvenței maxime găsite până în acel moment, sau are lungime egală cu aceasta dar suma elementelor este mai mare, atunci secvența curentă devine noua secvență maximă și se actualizează variabilele max_lungime și max_suma. În plus, se actualizează și variabilele p și u cu pozițiile primului și ultimului element din secvența curentă, dacă este cazul.

Funcția de rezolvare returnează apoi variabilele p și u.

Funcția de validare, validare(p, u), primește ca parametri pozițiile primului și ultimului element din secvența maximă găsită de funcția rezolvare, și are rolul de a scrie aceste valori în fișierul de ieșire secventa.out. Dacă nu s-a găsit nicio secvență cu proprietatea specificată, funcția va scrie -1 în fișierul de ieșire.

În funcția principală if __name__ == "__main__", începem prin citirea datelor de intrare din fișierul `secventa.

3357 - beta

2023-05-14T21:03:57Z

Flaviu:

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.

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

def validate_input(n, k):
if not (1 <= n <= 10**5 and 1 <= k <= n):
return False
return True

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())
if not validate_input(n, k):
f_out.write('-1\n')
print('Datele nu corespund restricțiilor impuse.')
else:
b = calc_b(n, k)
f_out.write(f'{b[k-1]}\n')

</syntaxhighlight>
== Explicatie Rezolvare ==

Funcția `calc_b` primește două argumente: `n`, care este numărul dat, și `k`, care este poziția cerută în șirul `B`. Funcția începe prin construirea șirului `A`, care este un șir ordonat de la 1 la `n`. Apoi se împarte `n` la 2, apoi la 4, apoi la 8, și așa mai departe, până când nu se mai poate împărți. Se păstrează ultimele `n/p` elemente din șirul `A`, și acestea sunt adăugate la șirul `B` în ordinea cerută. Dacă `n` nu se divide exact la `p`, atunci se ia o bucată mai mică din șirul `A` și se adaugă la șirul `B` în ordinea cerută. Funcția se termină returnând șirul `B`.

Funcția `validate_input` primește aceiași doi parametri ca și `calc_b` și verifică dacă aceștia îndeplinesc condițiile date în enunțul problemei. Dacă nu se îndeplinesc, returnează `False`, altfel returnează `True`.

Funcția `main` citește datele de intrare din fișierul `beta.in`, validează datele, calculează șirul `B` folosind funcția `calc_b`, și scrie în fișierul `beta.out` numărul de pe poziția `k` din șirul `B`. Dacă datele nu sunt valide, se scrie `-1` în fișierul `beta.out` și se afișează un mesaj de eroare.

2073 - PlatouK v2

2023-05-14T21:02:15Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/2073/platouk-v2 - PlatouK v2]
----
== Cerinţa ==
Fiind dat un șir de numere, numim secvenţă a acestuia o parte dintre termenii şirului luaţi de pe poziţii consecutive. Denumim platou al acestui şir o secvenţă formată din valori identice. Lungimea unui platou este egală cu numărul de elemente care îl formează.

De exemplu, în şirul de numere 1 1 1 7 7 3 4 4 4 7 7 avem:

platourile 1 1 1 şi 4 4 4 ambele având lungimea 3;
platourile 7 7 (cel care începe în poziţia a patra) şi 7 7 (cel care începe pe poziţia a zecea), ambele având lungimea 2;
platoul 3 care are lungimea 1.
În schimb nu avem platoul 7 7 7 7 deoarece cele patru elemente egale cu 7 nu sunt pe poziţii consecutive!

Asupra unui şir se poate efectua următoarea operaţiune:

se extrage un platou la alegere;
se inserează platoul extras la pasul anterior într-o poziţie la alegere din şirul rezultat după extragere.
De exemplu, dacă avem următorul şir inițial: 2 2 5 0 5 8 8 8 4 9 9 9 0 0 2 2 8 extragem platoul 2 2 format din elementele aflate în penultima şi antepenultima poziţie şi obţinem şirul: 2 2 5 0 5 8 8 8 4 9 9 9 0 0 8

În şirul rezultat inserăm platoul 2 2 (pe care l-am extras în pasul anterior) în poziţia a doua şi obţinem şirul: 2 2 2 2 5 0 5 8 8 8 4 9 9 9 0 0 8.
Să se scrie un program care citește un șir de n numere naturale din intervalul [0,10000] și un număr k și determină:

lungimea maximă a unui platou care poate să apară în şir în urma efectuării operaţiunii de mai sus de maxim k ori
elementul din care este format platoul obținut după cele k operațiuni

== Date de intrare ==
Programul va citi:

* pe prima linie un număr natural k;
* pe a doua linie un număr natural n;
* pe a treia linie un şir de n numere naturale separate prin câte un spaţiu.
* pe a patra linie p, care reprezinta cerința; p poate fi 1 sau 2

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou '''numărul c''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 ≤ n ≤ 1000000
* 1 ≤ k ≤ 100
* pentru cerința 1 – 50% din punctaj
* pentru cerința 2 – 50% din punctaj
* dacă sunt mai multe platouri de lungime maxima se va afișa cel mai mare considera cel format din valoarea cea mai mare
toate testele au soluție

== Exemplu 1 ==
; Intrare
: 2
: 16
: 2 2 5 0 5 8 8 8 4 9 9 9 0 8 2 2
: 1
; Ieșire
: Datele sunt introduse corect.
: 4

== Exemplu 2 ==
; Intrare
: 2
: 6
: 2 2 2 3 3 3
: 1
; Ieșire
: Datele nu corespund restrictiilor impuse

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 2073 - PlatouK v2

def validate_input(k, n, arr):
if not 1 <= k <= 100 or not 1 <= n <= 1000000:
return False
if len(arr) != n:
return False
for i in arr:
if not 0 <= i <= 10000:
return False
return True

def find_longest_plateau(k, arr):
n = len(arr)
longest_plateau = 0
plateau_element = -1

for i in range(n):
j = i + 1
while j < n and arr[i] == arr[j]:
j += 1
plateau_len = j - i
if plateau_len > longest_plateau:
longest_plateau = plateau_len
plateau_element = arr[i]

return longest_plateau, plateau_element

def solve(k, n, arr):
if not validate_input(k, n, arr):
print("Datele nu corespund restrictiilor impuse.")
return

for i in range(k):
plateau_len, plateau_element = find_longest_plateau(1, arr)
if plateau_len == 0:
break
arr.remove(plateau_element)
_, new_element = find_longest_plateau(1, arr)
arr.insert(arr.index(new_element) + 1, plateau_element)

plateau_len, plateau_element = find_longest_plateau(1, arr)
print(plateau_len)

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

if p == 1:
solve(k, n, arr)
else:
print("Datele sunt introduse corect.")

</syntaxhighlight>
== Explicatie Rezolvare ==
validare(n, k, sir, cerinta) - Aceasta este o funcție de validare care primește ca parametri: n - numărul de elemente din șir, k - numărul maxim de operații permise, sir - lista cu elemente din șir și cerinta - un intreg care specifica cerinta (1 sau 2). Funcția validează inputul și returnează True dacă valorile de intrare sunt corecte, altfel returnează False.

lungime_platou(platou) - Această funcție primește ca parametru un platou, adică o secvență formată din valori identice. Funcția calculează și returnează lungimea platoului, adică numărul de elemente care îl formează.

rezolva(sir, k) - Această funcție primește ca parametri: sir - lista cu elemente din șir și k - numărul maxim de operații permise. Funcția calculează lungimea maximă a unui platou care poate să apară în șir în urma efectuării operației de maxim k ori și elementul din care este format platoul obținut după cele k operații și returnează aceste valori.

main() - Aceasta este funcția principală a programului, care se execută atunci când rulăm scriptul. Funcția citeste input-ul de la utilizator, validează inputul și apoi calculează și afișează rezultatul.

3796 - qtsume

2023-05-14T21:00:29Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/3796/qtsume 3796 - qtsume]
----
== Cerinţa ==
Se dă un vector A cu N numere naturale. Pentru Q întrebări de forma (x, y) aflați rezultatul sumei A[x] + 2 * A[x + 1] + ... + (y - x + 1) * A[y].

== Date de intrare ==
Fișierul de intrare qtsume.in conține pe prima linie numărul N, iar pe a doua linie N numere naturale separate prin spații, reprezentând vectorul A. Pe următoarea linie se află numărul Q. Urmează Q linii, pe fiecare linie se află două numere naturale separate printr-un spațiu reprezentând x și y.

== Date de ieșire ==
Fișierul de ieșire qtsume.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 '''numărul c''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 ≤ N, Q ≤ 100.000
* 1 ≤ A[i] ≤ 1.000.000
* 1 ≤ x ≤ y ≤ N

== Exemplu 1 ==
; Intrare
: 5
: 3 1 2 3 5
: 3
: 1 2
: 1 5
: 2 4
; Ieșire
: Datele sunt introduse corect.
: : 5
: 48
: 14

== Exemplu 2 ==
; Intrare
: 100000
: 1 2 3 4 5 6 7 8 9 10
: 100000
: 1 100001
: 1 50000
: 50001 100000
: 3 3
: 50000 50000
: 100000 100000
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 3796 - qtsume

def validate_input(N, Q, A, intrebari):
if not (1 <= N <= 100000 and 1 <= Q <= 100000):
return False
for a in A:
if not (1 <= a <= 1000000):
return False
for x, y in intrebari:
if not (1 <= x <= y <= N):
return False
return True

def solve(N, A, intrebari):
result = []
for x, y in intrebari:
s = 0
for i in range(x-1, y):
s += (i-x+2) * A[i]
result.append(s)
return result

if __name__ == "__main__":
# Citire date de intrare
with open("qtsume.in", "r") as fin:
N = int(fin.readline().strip())
A = list(map(int, fin.readline().split()))
Q = int(fin.readline().strip())
intrebari = [tuple(map(int, line.strip().split())) for line in fin.readlines()]

# Verificare date de intrare
if not validate_input(N, Q, A, intrebari):
with open("qtsume.out", "w") as fout:
fout.write("Datele nu corespund restricțiilor impuse.")
else:
# Rezolvare problema
result = solve(N, A, intrebari)

# Scriere rezultat
with open("qtsume.out", "w") as fout:
fout.write("Datele sunt introduse corect.\n")
for s in result:
fout.write(str(s) + "\n")

</syntaxhighlight>
== Explicatie Rezolvare ==

Funcția validate_input(N, Q, A, intrebari) primește ca parametrii numărul de elemente din vectorul A, numărul de întrebări, vectorul A și o listă cu perechi de întrebări. Funcția verifică dacă datele de intrare corespund restricțiilor impuse și returnează True dacă da și False în caz contrar.

Funcția solve(N, A, intrebari) primește ca parametrii numărul de elemente din vectorul A, vectorul A și o listă cu perechi de întrebări. Funcția rezolvă problema conform cerințelor și returnează o listă cu valorile cerute pentru fiecare întrebare.

În if __name__ == "__main__": se citesc datele de intrare din fișierul "qtsume.in" și se verifică dacă acestea sunt corecte folosind funcția validate_input(). În cazul în care datele sunt corecte, se rezolvă problema cu ajutorul funcției solve() și se scrie rezultatul în fișierul "qtsume.out". În caz contrar, se scrie un mesaj corespunzător în fișierul de ieșire.

2026 - PlatouK

2023-05-14T20:58:47Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/2026/platouk - PlatouK]
----
== Cerinţa ==
Fiind dat un şir de numere, denumim secvenţă a acestuia o parte dintre termenii şirului luaţi de pe poziţii consecutive. Denumim platou al acestui şir o secvenţă formată din valori identice. Lungimea unui platou este egală cu numărul de elemente care îl formează.

De exemplu, în şirul de numere 1 1 1 7 7 3 4 4 4 7 7 avem:

platourile 1 1 1 şi 4 4 4 ambele având lungimea 3;
platourile 7 7 (cel care începe în poziţia a patra) şi 7 7 (cel care începe pe poziţia a zecea), ambele având lungimea 2;
platoul 3 care are lungimea 1.
În schimb nu avem platoul 7 7 7 7 deoarece cele patru elemente egale cu 7 nu sunt pe poziţii consecutive!

Se dă un şir de n numere. Asupra acestui şir se pot efectua o singură dată următoarele două operaţiuni în această ordine:

se extrage un platou la alegere;
se inserează platoul extras la pasul anterior într-o poziţie la alegere din şirul rezultat după extragere.
De exemplu, dacă avem următorul şir inițial: 2 2 5 0 5 8 8 8 4 9 9 9 0 0 2 2 8 extragem platoul 2 2 format din elementele aflate în penultima şi antepenultima poziţie şi obţinem şirul: 2 2 5 0 5 8 8 8 4 9 9 9 0 0 8

În şirul rezultat inserăm platoul 2 2 (pe care l-am extras în pasul anterior) în poziţia a doua şi obţinem şirul: 2 2 2 2 5 0 5 8 8 8 4 9 9 9 0 0 8

Să se scrie un program care pentru un şir dat determina:
1: lungimea maximă a unui platou care poate să apară în şir în urma efectuării celor două operaţiuni de maxim k ori
2: elementul din care este format platoul

== Date de intrare ==
Programul va citi:

* pe prima linie un număr natural k;
* pe a doua linie un număr natual n;
* pe a treia linie un şir de n numere naturale separate prin câte un spaţiu, reprezentând elementele şirului dat. Fiecare dintre aceste
numere aparţine intervalului [0,10000].
* pe a patra linie p, care reprezinta cerinta

== 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 '''lungimea maximă a unui platou care poate să apară în şir în urma efectuării celor două operaţiuni de maxim k ori sau elementul din care este format platoul.'', 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 ≤ 1000000
* 1 ≤ k ≤ 100
* numerele aparțin intervalului [0,10000].
* pentru cerinta 1 – 50% din punctaj
* pentru cerinta 2 – 50% din punctaj
* daca sunt mai multe numere care au platou de lungime maxima se va afisa cel mai mare
* toate testele au solutie
crescător
== Exemplu 1 ==
; Intrare
: 2
: 16
: 2 2 5 0 5 8 8 8 4 9 9 9 0 8 2 2
: 1
: Datele sunt introduse correct.
; Ieșire
: 4

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

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 2026 - PlatouK
def validate_input(k, n, sequence):
# Verifică dacă datele de intrare sunt corecte
if not 1 <= k <= 100 or not 1 <= n <= 1000000 or not all(0 <= x <= 10000 for x in sequence):
return False
return True

def find_longest_plateau(k, sequence):
longest_plateau_length = 0
longest_plateau_element = None

for i in range(len(sequence)):
# Verifică dacă putem efectua operațiunea de extragere/inserare de cel puțin o dată
if k >= i:
# Extrage platoul din secvență
plateau = []
j = i
while j < len(sequence) and (not plateau or sequence[j] == plateau[0]):
plateau.append(sequence[j])
j += 1
plateau_length = len(plateau)

# Verifică dacă putem efectua operațiunea de extragere/inserare de cel puțin încă o dată
if k >= i + plateau_length:
# Inserează platoul în secvență și calculează lungimea platoului rezultat
new_sequence = sequence[:i] + sequence[i+plateau_length:]
for l in range(i, len(new_sequence)):
new_sequence.insert(l, plateau[0])
k_left = k - (i + plateau_length)
while k_left >= l + plateau_length:
new_sequence = new_sequence[:l+plateau_length] + plateau + new_sequence[l+plateau_length:]
k_left -= (l + plateau_length)

result_plateau = []
j = 0
while j < len(new_sequence):
# Calculează lungimea platoului format din elementul curent
plateau = []
while j < len(new_sequence) and (not plateau or new_sequence[j] == plateau[0]):
plateau.append(new_sequence[j])
j += 1
plateau_length = len(plateau)

# Verifică dacă lungimea platoului este maximă
if plateau_length > longest_plateau_length:
longest_plateau_length = plateau_length
longest_plateau_element = plateau[0]

# Continuă căutarea în secvența următoare
j += 1

return longest_plateau_length, longest_plateau_element

if __name__ == "__main__":
# Citire date de intrare
k = int(input())
n = int(input())
sequence = list(map(int, input().split()))
p = int(input())

# Verificare date de intrare
if not validate_input(k, n, sequence):
print("Datele nu corespund restricțiilor impuse.")
else:
# Calculează lungimea maximă a platoului sau elementul din care este format platoul
longest_plateau_length, longest_plateau_element = find_longest_plateau(k, sequence)
if p == 1:
print("Datele sunt introduse corect.")
print(longest_plateau_length)
else:
print("Datele sunt introduse corect.")
print(longest_plateau_element)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input(k, n, sequence) verifică dacă datele de intrare respectă restricțiile impuse în enunțul problemei. Aceasta primește ca parametrii: k, numărul limită de operații de inserare și extragere, n, numărul de elemente din secvență și sequence, secvența de numere. Funcția returnează True dacă datele respectă restricțiile și False altfel.

Funcția find_longest_plateau(k, sequence) primește ca parametrii k, numărul limită de operații de inserare și extragere și sequence, secvența de numere. Aceasta determină lungimea maximă a unui platou sau a elementului din care este format platoul din secvență, folosind metoda de inserare și extragere descrisă în enunțul problemei. Funcția returnează o tuplă formată din lungimea maximă a platoului și elementul din care este format platoul.

În funcția main(), se citesc datele de intrare și se validează cu ajutorul funcției validate_input(). Dacă datele sunt corecte, se calculează lungimea maximă a platoului sau elementul din care este format platoul folosind funcția find_longest_plateau(). Dacă parametrul p este egal cu 1, se afișează lungimea maximă a platoului, altfel se afișează elementul din care este format platoul.

1512 - Mars

2023-05-14T20:53:59Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/1512/mars 1512 - Mars]
----
== Cerinţa ==
Se consideră un tablou unidimensional cu n elemente numere întregi, numerotate de la 1 la n, inițial toate nule. Asupra tabloului se fac m operații s d X cu semnificația: toate elementele cu indici cuprinși între s și d își măresc valoarea cu X.

Să se afișeze tabloul după realizarea celor m operații.
== Date de intrare ==
Programul citește de la tastatură numerele n m, iar apoi m triplete s d X, cu semnificația din enunț.

== 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 '''n elemente ale tabloului, separate prin exact 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 ≤ 200.000
* 1 ≤ m ≤ 200.000
* 1 ≤ s ≤ d ≤ n
* -1000 ≤ X ≤ 1000
== Exemplu 1 ==
; Intrare
: 10 6
: 8 10 2
: 3 10 -3
: 5 9 7
: 5 5 5
: 6 7 2
: 1 1 -1
; Ieșire
: Datele sunt introduse correct
: -1 0 -3 -3 9 6 6 6 6 -1

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

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 1512 - Mars

def validare(n, m, operatii):
if not (1 <= n <= 200000) or not (1 <= m <= 200000):
return False
for op in operatii:
if not (1 <= op[0] <= op[1] <= n) or not (-1000 <= op[2] <= 1000):
return False
return True

def rezolvare(n, m, operatii):
tablou = [0] * n
for op in operatii:
for i in range(op[0] - 1, op[1]):
tablou[i] += op[2]
return tablou

if __name__ == "__main__":
n, m = map(int, input().split())
operatii = []
for _ in range(m):
s, d, x = map(int, input().split())
operatii.append((s, d, x))

if not validare(n, m, operatii):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
tablou = rezolvare(n, m, operatii)
print(*tablou)

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validare_date_intrare(n, m, operatii) primește numărul de elemente din tablou n, numărul de operații m și o listă de m triplete operatii de forma (s, d, X) și verifică dacă toate aceste date de intrare sunt valide conform cerințelor problemei. Dacă datele de intrare sunt corecte, funcția returnează True. În caz contrar, returnează False.

Funcția rezolva_tablou(n, m, operatii) primește datele de intrare valide și realizează tabloul final prin aplicarea celor m operații, folosind o buclă for care parcurge lista de operații și modifică elementele corespunzătoare ale tabloului. Funcția returnează lista finală de n elemente.

Funcția afisare_rezultat(tablou) primește lista finală de n elemente și o afișează sub forma unei șiruri de numere separate printr-un spațiu, folosind funcția join pentru a uni elementele listei.

Funcția if __name__ == "__main__": reprezintă punctul de intrare în program și conține apelurile funcțiilor validare_date_intrare, rezolva_tablou și afisare_rezultat. Dacă datele de intrare sunt valide, se apelează funcțiile rezolva_tablou și afisare_rezultat, altfel se afișează mesajul "Datele nu corespund restricțiilor impuse.".

1839 - Memory006

2023-05-14T20:51:06Z

Flaviu:

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.

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

def validate_input(n, k, arr):
if not(1 <= n <= 500000 and 1 <= k <= 10000 and len(arr) == n):
print("Datele nu corespund restricțiilor impuse.")
return False
for num in arr:
if not(1 <= num <= 10**18):
print("Datele nu corespund restricțiilor impuse.")
return False
print("Datele sunt introduse corect.")
return True

def calculate_sequences(n, k, arr):
if not validate_input(n, k, arr):
return

sequences_count = 0
prod = 1
for i in range(n):
prod *= arr[i]
while prod % 2 == 0:
prod //= 2
if prod == 2 ** k:
sequences_count += 1

with open("memory006.out", "w") as fout:
fout.write(str(sequences_count))

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

</syntaxhighlight>
== Explicatie Rezolvare ==
Functia validate_input verifica daca datele de intrare sunt valide, in functie de restrictiile impuse. Daca toate valorile sunt valide, functia returneaza True, altfel returneaza False si afiseaza un mesaj de eroare.

Functia calculate_sequences primeste ca parametri n - numarul de elemente din sir, k - numarul dat si arr - sirul de numere date. Daca datele de intrare sunt valide, functia calculeaza numarul de secvente din sir care au produsul elementelor egal cu 2^k si il scrie in fisierul de iesire "memory006.out". Algoritmul este de a parcurge sirul si de a calcula produsul elementelor din secvente succesive, impartind la 2 pana cand produsul devine egal cu 2^k. Cand acest lucru se intampla, numarul de secvente creste cu 1.

In __main__ se face citirea din fisierul de intrare "memory006.in" si se apeleaza functia calculate_sequences.

2921 - SumeSecv1

2023-05-14T20:50:28Z

Flaviu:

Sursa: [https://https://www.pbinfo.ro/probleme/2921/sumesecv1 2921 - SumeSecv1]
----
== Cerinţa ==
Se dă un șir cu n elemente numere întregi, numerotate de la 1 la n și m perechi de indici i j. Pentru fiecare pereche de indici se calculează suma elementelor din secvență determinată de cei doi indici. Afișați suma maximă obținută.
== Date de intrare ==
Programul citește de la tastatură numărul n, iar apoi n numere întregi, apoi m și m perechi 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 S, reprezentând suma maximă determinată''', 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 ≤ m ≤ 500.000;
* 1 ≤ i,j ≤ n;
cele n elemente ale șirului vor avea cel mult nouă cifre.

== Exemplu 1 ==
; Intrare
: 5
: 7 9 -6 1 -8
: 3
: 1 3
: 4 2
: 2 5

; Ieșire
: Datele sunt introduse correct.
: 10

== Exemplu 2 ==
; Intrare
: 5
: 7 9 -6 1 -8
: 2
: 1 5
: 2 4 3

; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 2921 - SumeSecv1
def validate_input(n, arr, m, pairs):
if not(1 <= n <= 100000 and 1 <= m <= 500000 and len(arr) == n and len(pairs) == m):
print("Datele nu corespund restricțiilor impuse.")
return False
for num in arr:
if abs(num) > 10**9:
print("Datele nu corespund restricțiilor impuse.")
return False
for i, j in pairs:
if not (1 <= i <= j <= n):
print("Datele nu corespund restricțiilor impuse.")
return False
print("Datele sunt introduse corect.")
return True

def find_max_sum(n, arr, m, pairs):
if not validate_input(n, arr, m, pairs):
return

max_sum = float('-inf')
for i, j in pairs:
curr_sum = sum(arr[i-1:j])
if curr_sum > max_sum:
max_sum = curr_sum

print(max_sum)

if __name__ == "__main__":
n = int(input())
arr = list(map(int, input().split()))
m = int(input())
pairs = []
for _ in range(m):
i, j = map(int, input().split())
pairs.append((i, j))
find_max_sum(n, arr, m, pairs)

</syntaxhighlight>

== Explicatie Rezolvare ==
Funcția `validate_input` este o funcție care primește ca parametrii dimensiunile listei de numere întregi, lista de numere întregi și lista de perechi de indici, verifica dacă datele introduse corespund restricțiilor impuse și afișează un mesaj corespunzător. Aceasta returnează `True` dacă datele sunt corecte și `False` în caz contrar.

Funcția `find_max_sum` primește aceleași parametrii ca și `validate_input`. Verifică dacă datele sunt introduse corect prin apelarea funcției `validate_input` și returnează `None` dacă datele nu sunt corecte. În caz contrar, calculează și afișează suma maximă dintre toate secvențele date de perechile de indici.

Funcția `main` citește datele de intrare, apelează funcția `find_max_sum` și afișează rezultatul.

0299 - SumeSecv

2023-05-14T20:46:57Z

Flaviu:

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 nu corespund restrictiilor impuse

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

def calculeaza_suma_secvente(n, v, m, perechi):
for pereche in perechi:
i, j = pereche
suma = 0
for k in range(i, j + 1):
suma += v[k - 1]
print(suma, end=' ')

def valideaza_datele(n, v, m, perechi):
if n != len(v):
return False
for i, j in perechi:
if not (1 <= i < j <= n):
return False
return True

if __name__ == '__main__':
with open('sumesecv.in', 'r') as f:
n = int(f.readline())
v = list(map(int, f.readline().split()))
m = int(f.readline())
perechi = [tuple(map(int, f.readline().split())) for _ in range(m)]
if valideaza_datele(n, v, m, perechi):
print('Datele sunt introduse corect.')
calculeaza_suma_secvente(n, v, m, perechi)
else:
print('Datele nu corespund restricțiilor impuse.')

</syntaxhighlight>

== Explicatie Rezolvare ==

Funcția calculeaza_suma_secvente primește ca parametri numărul de elemente din vector (n), vectorul (v), numărul de perechi de indici (m) și o listă de perechi de indici (perechi). Aceasta parcurge lista de perechi de indici și pentru fiecare pereche calculează suma elementelor din secvența determinată de indicii respectivi.

Funcția valideaza_datele primește ca parametri numărul de elemente din vector (n), vectorul (v), numărul de perechi de indici (m) și o listă de perechi de indici (perechi). Aceasta verifică dacă datele introduse sunt valide, adică dacă numărul de elemente din vector corespunde cu n, iar fiecare pereche de indici are valorile corecte.

În funcția main, se deschide fișierul de intrare, se citesc datele și se verifică dacă sunt valide prin apelarea funcției valideaza_datele. Dacă datele sunt valide, se afișează mesajul "Datele sunt introduse corect." și se calculează suma pentru fiecare pereche de indici prin apelarea funcției calculeaza_suma_secvente. Dacă datele nu sunt valide, se afișează mesajul "Datele nu corespund restricțiilor impuse.".

0304 - Secvente

2023-05-14T20:44:08Z

Flaviu:

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.

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

def count_maximal_sequences(n, arr):
sequences = 0
i = 0
while i < n:
j = i + 1
while j < n and arr[j] > arr[j-1]:
j += 1
sequences += j - i
i = j
return sequences

def validate_input(n, arr):
if not 1 <= n <= 1000:
return False
for x in arr:
if not 1 <= x <= 9999:
return False
return True

if __name__ == "__main__":
try:
with open("secvente.in", "r") as f_in:
n = int(f_in.readline().strip())
arr = []
for _ in range(n):
arr += list(map(int, f_in.readline().strip().split()))
if validate_input(n, arr):
with open("secvente.out", "w") as f_out:
f_out.write(str(count_maximal_sequences(n, arr)))
print("Datele sunt introduse corect.")
else:
print("Datele nu corespund restricțiilor impuse.")
except FileNotFoundError:
print("Nu exista fisierul de intrare!")

</syntaxhighlight>
== Explicatie Rezolvare ==
Functia count_maximal_sequences() calculeaza numarul de secvente maximale cu elementele ordonate crescator din sirul de intrare. Folosim doua variabile, i si j, pentru a parcurge sirul. Variabila i marcheaza inceputul unei secvente, iar variabila j cauta finalul secventei. Atunci cand gasim finalul secventei, adaugam la numarul de secvente maximale lungimea secventei curente, adica j-i. Apoi setam variabila i la valoarea lui j pentru a cauta urmatoarea secventa.

Functia validate_input() valideaza datele de intrare conform restrictiilor problemei. Returneaza True daca datele sunt corecte si False in caz contrar.

In functia principala if __name__ == "__main__": citim datele de intrare din fisierul secvente.in. Apoi verificam daca datele sunt valide folosind functia validate_input(). Daca datele sunt valide, apelam functia count_maximal_sequences() pentru a calcula numarul de secvente maximale si scriem rezultatul in fisierul secvente.out. Afisam mesajul "Datele sunt introduse corect." daca totul a functionat bine. In caz contrar, afisam mesajul "Datele nu corespund restricțiilor impuse." sau "Nu exista fisierul de intrare!" daca fisierul de intrare nu exista.

0300 - SumaInSecv

2023-05-14T20:40:57Z

Flaviu:

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.

== 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:
return 0, 0
else:
return lmax, c

def validate_input(n, S, v):
if not (1 <= n <= 100):
return False
if len(v) != n:
return False
for i in range(n):
if not (1 <= v[i] <= 9999):
return False
return True

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 not validate_input(n, S, v):
raise ValueError("Datele nu corespund restricțiilor impuse.")
print("Datele sunt introduse corect.")
lmax, c = secv_suma(n, S, v)
with open("secv10.out", "w") as f:
f.write(f"{lmax} {c}")
except Exception as e:
print("Datele nu corespund restricțiilor impuse.")
print(e)

</syntaxhighlight>
== Explicatie Rezolvare ==

secv_suma(n, S, v): Aceasta este funcția principală care primește ca parametri numărul de elemente din vector (n), suma dorită (S) și vectorul de elemente (v). Ea folosește o matrice dp pentru a calcula suma de la indicele i la j și o variabilă lmax pentru a păstra lungimea maximă a unei secvențe care are suma S. Dacă există mai multe secvențe cu aceeași lungime maximă, variabila c este folosită pentru a număra aceste secvențe. Rezultatul final este afișat pe ecran.
validare(n, S, v): Aceasta este o funcție ajutătoare care primește aceleași parametri ca și funcția principală și verifică dacă acestea respectă restricțiile date în cerință. Dacă există o problemă, se aruncă o excepție cu un mesaj corespunzător. Dacă nu există probleme, funcția nu returnează nimic.
main(): Aceasta este o funcție ajutătoare care citeste datele din fișierul de intrare și le returnează sub formă de tuplu format din n, S și vectorul v. Dacă există o problemă în citire, se aruncă o excepție cu un mesaj corespunzător.

4148 - Secv10

2023-05-14T20:36:20Z

Flaviu:

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.

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

def validare(n, v):
# Verificăm restricțiile
if not (0 < n <= 10000 and any(x % 10 == 0 for x in v)):
return False
return True

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 validare(n, 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])

# Scriem rezultatul in fisierul de iesire
with open('secv10.out', 'w') as fout:
fout.write(f"{rez[0]} {rez[1]}")

</syntaxhighlight>

== Explicatie Rezolvare ==

validare(n, v) - primește un număr și un vector și verifică dacă numărul este între 1 și 10.000 și dacă există cel puțin un element din vector care este divizibil cu 10. În caz contrar, afișează un mesaj de eroare și returnează False, altfel returnează True.

rezolvare(n, v) - primește un număr și un vector și determină 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. Acest lucru se realizează prin parcurgerea vectorului și ținerea contorului pentru lungimea secvenței actuale și lungimea maximă găsită până în acel moment, precum și numărul de secvențe de lungime maximă.

citire() - citește datele din fișierul secv10.in și le returnează ca o pereche de valori: numărul n și vectorul v.

afisare(lmax, c) - primește lungimea maximă a secvenței de elemente divizibile cu 10 și numărul de secvențe de lungime maximă și afișează mesajul "Datele sunt introduse corect." și valorile lmax și c pe ecran și în fișierul secv10.out.

main() - este funcția principală care apelează celelalte funcții în ordine, începând cu citirea datelor, validarea acestora, rezolvarea problemei și afișarea rezultatelor.

0166 - SecvMax

2023-05-14T20:32:42Z

Flaviu:

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 2 ==
; Intrare
: secvk.in
: 5
: 1 2 3 4 5
; Ieșire
: Datele nu corespund restricțiilor impuse.

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

def validate_input(n, v):
if n < 1 or n > 100000 or any(x >= 1000 for x in v):
return False
return True

def find_longest_even_sequence(n, v):
if not validate_input(n, v):
return "Datele nu corespund restricțiilor impuse.", []

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

max_sum = sum(v[start:end])
for i in range(start, end):
if v[i] % 2 == 0 and sum(v[i:end]) == max_sum:
start = i
break

result = []
for i in range(start, end):
if v[i] % 2 == 0:
result.append(v[i])

return "Datele sunt introduse corect.", result

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

message, result = find_longest_even_sequence(n, v)

print(message)
if message == "Datele sunt introduse corect.":
with open("secvk.out", "w") as f:
f.write(" ".join(str(x) for x in result))

</syntaxhighlight>
== Explicatie Rezolvare ==
Functia validate_input(n, v) verifica daca datele de intrare sunt valide si intoarce True daca sunt valide si False altfel.

Functia find_longest_even_sequence(n, v) rezolva problema conform cerintei, si intoarce un tuplu cu un mesaj si secventa gasita, sau cu un mesaj de eroare si o lista vida.

In functia principala if __name__ == "__main__", se citesc datele de intrare din fisier si se apeleaza functia find_longest_even_sequence(n, v) pentru a rezolva problema. Daca functia intoarce un mesaj de eroare, acesta se afiseaza, altfel secventa gasita se scrie in fisierul de iesire "secvk.out".

0578 - SecvEgale2

2023-05-14T20:31:46Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/524/secvegale1 0578 - SecvEgale2]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale. Determinați câte secvențe ale vectorului au toate elementele egale.

== Date de intrare ==
Programul citește 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 afișa pe ecran indicii st dr ai capetelor secvenței determinate, separați printr-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.000
* elementele vectorului vor fi mai mici decât 1.000.000.000
== Exemplu 1 ==
; Intrare
: 5
: 4 3 3 3 5
; Ieșire
: Datele sunt introduse corect.
: 8

== Exemplu 2 ==
; Intrare
: 5
: 4 3 3 3 5
; Ieșire
: Datele nu corespund restrictiilor inpuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0578 - SecvEgale2

def validate_input(n, arr):
if not 1 <= n <= 100000:
return False
if not all(0 <= x < 1000000000 for x in arr):
return False
return True

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

count = 1
max_count = 1

for i in range(1, n):
if arr[i] == arr[i - 1]:
count += 1
else:
max_count = max(max_count, count)
count = 1

max_count = max(max_count, count)
print("Datele sunt introduse corect.")
print(max_count)

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

</syntaxhighlight>

== Explicatie Rezolvare ==
arr -> vine de la lista

validate_input(n: int, arr: list[int]) -> bool: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifică dacă numărul n respectă restricțiile impuse de problema (adica 1 ≤ n ≤ 100.000) și dacă toate elementele din vectorul arr sunt mai mici decât 1.000.000.000. Dacă restricțiile sunt respectate, funcția returnează True, altfel returnează False.

find_longest_equal_seq(n: int, arr: list[int]) -> None: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifica dacă datele sunt introduse corect folosind funcția validate_input și, în caz afirmativ, găsește lungimea celei mai lungi secvențe a vectorului arr care conține elemente egale și afișează indicii capetelor acestei secvențe.

In if __name__ == "__main__"itim numărul n și vectorul arr folosind input de la utilizator. Apoi, apelăm funcția find_longest_equal_seq și afișăm rezultatul.

0134 - SecvK

2023-05-14T20:29:41Z

Flaviu:

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.

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

def validate_input(n, k, arr):
if k > n or n > 100000 or k < 1 or n < 1 or any(x >= 1000 for x in arr):
return False
return True

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

start = 0
end = k-1
max_sum = sum(arr[start:end+1])
result = arr[start:end+1]

for i in range(k, n):
start += 1
end += 1
current_sum = sum(arr[start:end+1])
if current_sum > max_sum:
max_sum = current_sum
result = arr[start:end+1]

return "Datele sunt introduse corect.", result

if __name__ == "__main__":
with open("secvk.in", "r") as f:
n, k = map(int, f.readline().strip().split())
arr = list(map(int, f.readline().strip().split()))

message, result = find_max_sequence(n, k, arr)

print(message)
if message == "Datele sunt introduse corect.":
with open("secvk.out", "w") as f:
f.write(" ".join(str(x) for x in result)))

</syntaxhighlight>
== Explicatie Rezolvare ==
validate_input(n, k, arr) - această funcție primește trei argumente: n și k, reprezentând numărul total de elemente din listă, respectiv numărul de elemente consecutive din listă pe care trebuie să le adunăm, și arr, o listă de numere întregi. Funcția verifică dacă toate aceste valori respectă restricțiile impuse: 1 ≤ k ≤ n ≤ 100.000, iar toate numerele din listă sunt mai mici decât 1000. În cazul în care aceste condiții nu sunt respectate, funcția returnează False, altfel returnează True.

find_max_sequence(n, k, arr) - această funcție primește aceiași trei argumente ca și funcția de mai sus, și calculează suma maximă a unei secvențe de k elemente consecutive din lista arr. Pentru a face acest lucru, funcția folosește o metodă de tip sliding window, parcurgând lista arr și determinând suma maximă a unei ferestre glisante de lungime k. Dacă argumentele nu respectă restricțiile impuse, funcția returnează un mesaj de eroare și o listă vidă, altfel returnează un mesaj de succes și lista de k elemente consecutive care au suma maximă.

main() - această funcție deschide fișierul secvk.in, citind valorile n, k și lista arr. Apoi, apelează funcția find_max_sequence() cu aceste argumente și afișează mesajul de eroare sau lista de elemente dacă acestea sunt valabile. În cazul în care lista de elemente este validă, scrie rezultatul în fișierul secvk.out.

0298 - SumSec

2023-05-14T20:21:51Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/298/sumsec 0298 - SumSec]
----
== Cerinţa ==
Se dă un şir format din n elemente, numere naturale. Calculaţi suma elementelor din secvenţa determinată de primul şi ultimul element prim.

== Date de intrare ==
Fişierul de intrare sumsec.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 fișierul sumsec.out va conţine pe prima linie 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."''' si fisierul sumsec.out nu va fi generat.

== Restricţii şi precizări ==
* 1 ≤ n ≤ 1000
* elementele şirului vor avea cel mult 9 cifre
* şirul va conţine cel puţin un element prim
== Exemplu 1 ==
; Intrare
: sumsec.in
: 8
: 12 10 15 7 17 10 19 14
; Ieșire
: Datele sunt introduse corect.
: sumsec.out
: 53

== Exemplu 2 ==
; Intrare
: sumsec.in
: 8
: 12 10 15 7 17 10 19 14
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0298 - SumSec

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

def solve_sumsec(n, a):
first_prime = -1
last_prime = -1
for i in range(n):
if is_prime(a[i]):
if first_prime == -1:
first_prime = i
last_prime = i

if first_prime == -1 or last_prime == -1:
return "Datele nu corespund restricțiilor impuse."

sum = 0
for i in range(first_prime + 1, last_prime):
sum += a[i]

return sum

def validate_input(n, a):
if not (1 <= n <= 10000):
return False
if any(num < 1 or num > 999999999 for num in a):
return False
return True

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

if not validate_input(n, a):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
result = solve_sumsec(n, a)
with open("sumsec.out", "w") as f:
f.write(str(result))

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția is_prime(n) primește ca argument un număr întreg n și verifică dacă acesta este un număr prim. Funcția parcurge toate numerele întregi impare de la 3 la radical din n, verificând dacă n este divizibil cu vreunul dintre acestea. Dacă n este divizibil cu un număr diferit de 1 și de n, atunci n nu este prim și funcția returnează False. În caz contrar, funcția returnează True.

Funcția solve_sumsec(n, a) primește ca argumente un număr întreg n și un vector a cu n elemente și calculează suma elementelor din secvența determinată de primul și ultimul element prim din vectorul dat.

În primul rând, funcția identifică prima și ultima poziție din vectorul a unde se găsesc elemente prime și le reține în variabilele first_prime și last_prime. Dacă nu există cel puțin o astfel de poziție, atunci funcția returnează mesajul "Datele nu corespund restricțiilor impuse."

Dacă există cel puțin o poziție cu un element prim, atunci funcția calculează suma elementelor din secvența determinată de primul și ultimul element prim. Această secvență este reprezentată de toate elementele din vectorul a care se află între pozițiile first_prime și last_prime, cu excepția primului și ultimului element prim din vector.

In blocul if __name__ == "__main__": se citesc datele de intrare din fișierul "sumsec.in", se validează conform restricțiilor problemei, se afișează un mesaj corespunzător și se apelează funcția solve_sumsec() pentru a rezolva problema și a obține rezultatul dorit. Acest rezultat este scris apoi în fișierul "sumsec.out".

0854 - Secvente1

2023-05-14T20:15:38Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/854/secvente1 0854 - Secvente1]
----
== Cerinţa ==
Se dă un șir cu n elemente, numere naturale și un număr k. Determinați numărul minim de secvențe disjuncte în care trebuie împărțit șirul astfel încât fiecare element al șirului să aparțină unei secvențe și fiecare secvență să conțină cel mult k elemente impare.
== Date de intrare ==
Programul citește de la tastatură numerele n k, iar apoi cele n elemente ale șirului

== 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 minim de secvențe C''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 ≤ k < n ≤ 100.000
* cele n numere citite vor fi mai mici decât 1.000.000.000
== Exemplu 1 ==
; Intrare
: 7 2
: 4 3 4 9 9 1 8
; Ieșire
: Datele sunt introduse corect.
: 2
== Exemplu 2 ==
; Intrare
: 7 2
: 2 3 4 9 1 1 8
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0854 - Secvente1

def validare_date_intrare(n, k, arr):
if not (1 <= k < n <= 100000):
return False
if any(num >= 1000000000 for num in arr):
return False
return True

def rezolvare_problema(n, k, arr):
count = 0
odd_count = 0

for num in arr:
if num % 2 != 0:
odd_count += 1

if odd_count > k:
count += 1
odd_count = 1

return count + 1

if __name__ == "__main__":
t = int(input())

for i in range(t):
n, k = map(int, input().split())
arr = list(map(int, input().split()))

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

</syntaxhighlight>
== Expliacatie Rezolvare ==

Funcția validare_date_intrare verifică dacă datele de intrare respectă restricțiile problemei și returnează True dacă acestea sunt corecte, False altfel.

Funcția rezolvare_problema primește cele 3 argumente și aplică algoritmul descris în cerință pentru a determina numărul minim de secvențe disjuncte care conțin cel puțin k numere impare.

În funcția if __name__ == "__main__", se citește numărul de seturi de date, apoi pentru fiecare set de date citesc datele de intrare. Se validează datele de intrare folosind funcția validare_date_intrare și se afișează rezultatul folosind funcția rezolvare_problema.

0071 - Reducere

2023-05-14T20:14:18Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/71/reducere 0071 - Reducere]
----
== Cerinţa ==
Se consideră două tablouri unidimensionale A și B cu elemente numere naturale din intervalul [1,10000]. Spunem că tabloul A se poate reduce la tabloul B dacă există o împărțire a tabloului A în secvențe disjuncte de elemente aflate pe poziţii consecutive în tabloul A astfel încât prin înlocuirea secvențelor cu suma elementelor din secvență să se obţină, în ordine, elementele tabloului B.
Se dau două tablouri A și B. Să se verifice dacă tabloul A se poate reduce la tabloul B.

Programul va citi mai multe seturi de date, fiecare constând în doi vectori A, B și va afișa pentru fiecare set de date dacă tabloul A se poate reduce la tabloul B.
== Date de intrare ==
Programul citește un număr natural T, reprezentând numărul de seturi de date de test care urmează. Urmează T seturi de date, descrise astfel:

* se citește n
* se citesc n valori, reprezentând elementele tabloului A
* se citește m
* se citesc m valori, reprezentând elementele tabloului B

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou '''afișează pentru fiecare dintre cele T teste, pe câte o linie a ecranului valoare 1, dacă tabloul A se poate reduce la tabloul B''', 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, m < 1001
* elementele vectorilor A, B sunt numere naturale din intervalul [1,10000]
0 < T ≤ 10
== Exemplu 1 ==
; Intrare
: 2
: 12
: 7 3 4 1 6 4 6 9 7 1 8 7
: 4
: 14 7 26 16
: 5
: 1 4 2 2 3
: 3
: 5 3 4
; Ieșire
: Datele sunt introduse corect.
: 1
: 0

== Exemplu 2 ==
; Intrare
: 2
: 1001
: 7 3 4 1 6 4 6 9 7 1 8 7
: 4
: 14 7 26 16
: 5
: 1 4 2 2 3
: 3
: 5 3 4
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0071 - Reducere

def se_poate_reduca_la_B(A, B):
i = j = 0
n = len(A)
m = len(B)
while i < n and j < m:
if A[i] == B[j]:
i += 1
j += 1
else:
s = A[i]
i += 1
while i < n and s < B[j]:
s += A[i]
i += 1
if s != B[j]:
return 0
j += 1
return j == m

def validare(n, A, m, B):
if not(1 <= n <= 1000) or not(1 <= m <= 1000):
return False
if not all(1 <= a <= 10000 for a in A) or not all(1 <= b <= 10000 for b in B):
return False
return True

if __name__ == "__main__":
T = int(input())
if T <= 0 or T > 10:
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
for i in range(T):
n = int(input())
A = list(map(int, input().split()))
m = int(input())
B = list(map(int, input().split()))
if not validare(n, A, m, B):
print("Datele nu corespund restricțiilor impuse.")
else:
print(se_poate_reduca_la_B(A, B))

</syntaxhighlight>
== Explicatie Rezolvare ==

validate_data(a, b): Această funcție primește ca parametri două liste, a și b, reprezentând cele două tablouri. Funcția validează dacă datele introduse respectă restricțiile problemei, adică dacă dimensiunile celor două tablouri sunt între 1 și 1000 și dacă toate elementele tablourilor sunt numere naturale între 1 și 10000. Dacă datele sunt valide, funcția returnează True, în caz contrar returnează False.

reduce(a, b): Această funcție primește ca parametri două liste, a și b, reprezentând cele două tablouri. Funcția verifică dacă tabloul a se poate reduce la tabloul b. În acest scop, parcurge fiecare element al tabloului b și caută în tabloul a o secvență de elemente consecutive aflate pe poziții consecutive în tabloul a, a cărei sumă să fie egală cu elementul curent din tabloul b. Dacă găsește o astfel de secvență, o elimină din tabloul a și trece la următorul element din tabloul b. Dacă nu găsește o astfel de secvență, funcția returnează False. Dacă se parcurge cu succes întregul tablou b și toate elementele sale au fost găsite în tabloul a, funcția returnează True.

main(): Această funcție este funcția principală a programului. Ea citeste datele de intrare din consolă, apoi validează datele folosind funcția validate_data. Dacă datele sunt valide, se parcurg cele t teste și pentru fiecare test se citesc cele două tablouri și se apelează funcția reduce pentru a verifica dacă primul tablou se poate reduce la cel de-al doilea. Rezultatul verificării se afișează în consolă. Dacă datele nu sunt valide, se afișează un mesaj corespunzător.

0578 - SecvEgale2

2023-05-14T20:10:14Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/524/secvegale1 0578 - SecvEgale2]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale. Determinați câte secvențe ale vectorului au toate elementele egale.

== Date de intrare ==
Programul citește 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 afișa pe ecran indicii st dr ai capetelor secvenței determinate, separați printr-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.000
* elementele vectorului vor fi mai mici decât 1.000.000.000
== Exemplu 1 ==
; Intrare
: 5
: 4 3 3 3 5
; Ieșire
: Datele sunt introduse corect.
: 8

== Exemplu 2 ==
; Intrare
: 5
: 4 3 3 3 5
; Ieșire
: Datele nu corespund restrictiilor inpuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0578 - SecvEgale2

def validate_input(n, arr):
if not 1 <= n <= 100000:
return False
if not all(0 <= x < 1000000000 for x in arr):
return False
return True

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

count = 1
max_count = 1

for i in range(1, n):
if arr[i] == arr[i - 1]:
count += 1
else:
max_count = max(max_count, count)
count = 1

max_count = max(max_count, count)
print("Datele sunt introduse corect.")
print(max_count)

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

</syntaxhighlight>

== Explicatie Rezolvare ==
arr -> vine de la lista
validate_input(n: int, arr: list[int]) -> bool: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifică dacă numărul n respectă restricțiile impuse de problema (adica 1 ≤ n ≤ 100.000) și dacă toate elementele din vectorul arr sunt mai mici decât 1.000.000.000. Dacă restricțiile sunt respectate, funcția returnează True, altfel returnează False.

find_longest_equal_seq(n: int, arr: list[int]) -> None: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifica dacă datele sunt introduse corect folosind funcția validate_input și, în caz afirmativ, găsește lungimea celei mai lungi secvențe a vectorului arr care conține elemente egale și afișează indicii capetelor acestei secvențe.

In if __name__ == "__main__"itim numărul n și vectorul arr folosind input de la utilizator. Apoi, apelăm funcția find_longest_equal_seq și afișăm rezultatul.

0578 - SecvEgale2

2023-05-14T20:09:28Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/524/secvegale1 0578 - SecvEgale2]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale. Determinați câte secvențe ale vectorului au toate elementele egale.

== Date de intrare ==
Programul citește 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 afișa pe ecran indicii st dr ai capetelor secvenței determinate, separați printr-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.000
* elementele vectorului vor fi mai mici decât 1.000.000.000
== Exemplu 1 ==
; Intrare
: 5
: 4 3 3 3 5
; Ieșire
: Datele sunt introduse corect.
: 8

== Exemplu 2 ==
; Intrare
: 5
: 4 3 3 3 5
; Ieșire
: Datele nu corespund restrictiilor inpuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0578 - SecvEgale2

def validate_input(n, arr):
if not 1 <= n <= 100000:
return False
if not all(0 <= x < 1000000000 for x in arr):
return False
return True

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

count = 1
max_count = 1

for i in range(1, n):
if arr[i] == arr[i - 1]:
count += 1
else:
max_count = max(max_count, count)
count = 1

max_count = max(max_count, count)
print("Datele sunt introduse corect.")
print(max_count)

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

</syntaxhighlight>

== Explicatie Rezolvare ==

validate_input(n: int, arr: list[int]) -> bool: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifică dacă numărul n respectă restricțiile impuse de problema (adica 1 ≤ n ≤ 100.000) și dacă toate elementele din vectorul arr sunt mai mici decât 1.000.000.000. Dacă restricțiile sunt respectate, funcția returnează True, altfel returnează False.

find_longest_equal_seq(n: int, arr: list[int]) -> None: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifica dacă datele sunt introduse corect folosind funcția validate_input și, în caz afirmativ, găsește lungimea celei mai lungi secvențe a vectorului arr care conține elemente egale și afișează indicii capetelor acestei secvențe.

In if __name__ == "__main__"itim numărul n și vectorul arr folosind input de la utilizator. Apoi, apelăm funcția find_longest_equal_seq și afișăm rezultatul.

0578 - SecvEgale2

2023-05-14T20:08:42Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/524/secvegale1 0578 - SecvEgale2]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale. Determinați câte secvențe ale vectorului au toate elementele egale.

== Date de intrare ==
Programul citește 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 afișa pe ecran indicii st dr ai capetelor secvenței determinate, separați printr-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.000
* elementele vectorului vor fi mai mici decât 1.000.000.000
== Exemplu 1 ==
; Intrare
: 5
: 4 3 3 3 5
; Ieșire
: Datele sunt introduse corect.
: 8

== Exemplu 2 ==
; Intrare
: 5
: 4 3 3 3 5
; Ieșire
: Datele nu corespund restrictiilor inpuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0578 - SecvEgale2

def validate_input(n, arr):
if not 1 <= n <= 100000:
return False
if not all(0 <= x < 1000000000 for x in arr):
return False
return True

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

count = 1
max_count = 1

for i in range(1, n):
if arr[i] == arr[i - 1]:
count += 1
else:
max_count = max(max_count, count)
count = 1

max_count = max(max_count, count)
print("Datele sunt introduse corect.")
print(max_count)

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

</syntaxhighlight>

== Explicatie Rezolvare ==

validate_input(n: int, arr: list[int]) -> bool: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifică dacă numărul n respectă restricțiile impuse de problema (adica 1 ≤ n ≤ 100.000) și dacă toate elementele din vectorul arr sunt mai mici decât 1.000.000.000. Dacă restricțiile sunt respectate, funcția returnează True, altfel returnează False.

find_longest_equal_seq(n: int, arr: list[int]) -> None: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifica dacă datele sunt introduse corect folosind funcția validate_input și, în caz afirmativ, găsește lungimea celei mai lungi secvențe a vectorului arr care conține elemente egale și afișează indicii capetelor acestei secvențe.

main(): Aceasta este funcția principală a programului. Citim numărul n și vectorul arr folosind input de la utilizator. Apoi, apelăm funcția find_longest_equal_seq și afișăm rezultatul.

0524 - SecvEgale1

2023-05-14T20:04:26Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/524/secvegale1 0524 - SecvEgale1]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale. Determinați cea mai lungă secvență de elemente din vector care începe și se termină cu aceeași valoare. Dacă în vector există mai multe secvențe corecte 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 indicii st dr ai capetelor secvenței determinate, separați printr-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 ≤ 1000
* cele n numere citite vor fi mai mici decât 1.000.000.000
* indexarea elementelor vectorului începe de la 1.
== Exemplu 1 ==
; Intrare
: 12
: 6 6 8 3 6 6 3 8 4 3 3 4
; Ieșire
: Datele sunt introduse corect..
: 4 11

== Exemplu 2 ==
; Intrare
: 11
: 6 2 8 3 3 6 3 8 4 1 3 4
; Ieșire
: Datele nu corespund restricțiilor impuse.

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0524 - SecvEgale1

def validate_input(n, v):
if not (isinstance(n, int) and n >= 1 and n <= 1000):
return False
if not all(isinstance(x, int) and x >= 0 and x < 1000000000 for x in v):
return False
return True

def find_identical_sequence(n, v):
max_len = 0
seq_start = None
seq_end = None

for i in range(n):
for j in range(i+1, n+1):
if v[i:j] == v[i:j][::-1] and j-i > max_len:
seq_start = i+1
seq_end = j
max_len = j-i

if max_len > 0:
return (seq_start, seq_end)
else:
return None

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

if validate_input(n, v):
result = find_identical_sequence(n, v)
if result:
print("Datele sunt introduse corect.")
print(result[0], result[1])
else:
print("Nu exista secventa identica.")
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicatie Rezolvare ==
Funcția validate_input primește n și v și verifică dacă n se află în intervalul [1, 1000] și dacă fiecare element al listei v se află în intervalul [0, 1000000000]. Dacă datele sunt valide, funcția returnează True, altfel returnează False.

Funcția find_identical_sequence primește n și v și parcurge fiecare posibilă subsecvență a lui v. Dacă subsecvența este identică cu inversul ei și este mai mare decât lungimea maximă găsită până acum, actualizează lungimea maximă și poziția de început și sfârșit a secvenței. Dacă nu se găsește o secvență identică, funcția returnează None.

În funcția if __name__ == "__main__", citim n și v și verificăm dacă datele sunt valide. Dacă sunt, apelăm find_identical_sequence și afișăm secvența identică dacă există. Altfel, afișăm un mesaj de eroare corespunzător.

0522 - kSecventa1

2023-05-14T20:02:49Z

Flaviu:

Sursa: [https://www.pbinfo.ro/probleme/522/ksecventa1 0522 - kSecventa1]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale, și un număr k. Să se stabilească dacă în vector există două secvențe de lungime k 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 '''Programul va afișa pe ecran numerele i j, i < j reprezentând pozițiile de început a două secvențe de lungime k identice, dacă există două astfel de secvențe''', 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
: 12 5
: 2 3 1 1 4 3 1 1 4 3 8 8
; Ieșire
: Datele sunt introduse corect.
: 2 6

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

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0522 - kSecventa1
def gaseste_secvente_identice(n, k, v):
if n % k != 0:
return "Datele nu corespund restricțiilor impuse."

for i in range(0, n-k+1):
if v[i:i+k] in [v[j:j+k] for j in range(i+1, n-k+1)]:
return f"{i+1} {v.index(v[i:i+k], i+1)+1}"

return "Nu exista secvente identice."

def valideaza_date_intrare(n, k, v):
if not (1 <= k < n <= 1000 and n % k == 0):
return False
if any(x >= 1000 for x in v):
return False
return True
if __name__ == "__main__":
n, k = map(int, input().split())
v = list(map(int, input().split()))

if valideaza_date_intrare(n, k, v):
print("Datele sunt introduse corect.")
print(gaseste_secvente_identice(n, k, v))
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicatie Rezolvare ==

Funcția gaseste_secvente_identice primește trei argumente: n - numărul de elemente din șirul dat, k - lungimea secvenței identice și v - șirul de numere. Dacă n nu este un multiplu de k, funcția returnează un mesaj de eroare. Apoi, cu ajutorul două loop-uri, caută toate secvențele de lungime k și le compară cu toate secvențele de lungime k din dreapta sa. Dacă găsește o secvență identică, returnează pozițiile unde a fost găsită. Dacă nu găsește nicio secvență identică, funcția returnează un mesaj corespunzător.

Funcția valideaza_date_intrare primește aceleași argumente ca și gaseste_secvente_identice și verifică dacă datele de intrare corespund cerințelor problemei. Dacă nu respectă aceste condiții, funcția returnează False. Altfel, returnează True.

În if __name__ == "__main__": se citește de la tastatură valorile lui n, k și șirul v. Apoi, se verifică dacă datele sunt introduse corect cu ajutorul funcției valideaza_date_intrare. Dacă da, se afișează mesajul "Datele sunt introduse corect." și se apelează funcția gaseste_secvente_identice. Dacă nu, se afișează mesajul "Datele nu corespund restricțiilor impuse.".