Bitnami MediaWiki - User contributions [en]

E:15346

2025-01-13T10:39:47Z

Vasiliu Costel Andrei:

'''[[E:15346]] (Mihai Vijdeluc și Vasile Ienuțaș, Baia Mare)'''

''a) Calculați <math>1^3 + 1^3 + 5^3 + 6^3 - 7^3</math>.

b) Arătați că <math>5^{2018}+6^{2018}<7^{2018}</math>''

'''Soluție.'''

a) <math>1^3 + 1^3 + 5^3 + 6^3 - 7^3 = 0</math>.

b) Din punctul a) putem scrie <math>1^3 + 1^3 + 5^3 + 6^3 = 7^3</math> sau <math>\left(\frac{1}{7}\right)^3 + \left(\frac{1}{7}\right)^3 + \left(\frac{5}{7}\right)^3+\left(\frac{6}{7}\right)^3 = 1</math>.

Acum <math>\left(\frac{1}{7}\right)^{2018}<\left(\frac{1}{7}\right)^3
, \left(\frac{5}{7}\right)^{2018}<\left(\frac{5}{7}\right)^3, \left(\frac{6}{7}\right)^{2018}<\left(\frac{6}{7}\right)^3</math>, de unde <math>\left(\frac{1}{7}\right)^{2018}+\left(\frac{1}{7}\right)^{2018}+\left(\frac{5}{7}\right)^{2018}+\left(\frac{6}{7}\right)^{2018} < \left(\frac{1}{7}\right)^3 + \left(\frac{1}{7}\right)^3 + \left(\frac{5}{7}\right)^3 + \left(\frac{6}{7}\right)^3.</math>

Obținem astfel <math>\left(\frac{1}{7}\right)^{2018}+\left(\frac{1}{7}\right)^{2018}+\left(\frac{5}{7}\right)^{2018}+\left(\frac{6}{7}\right)^{2018}<1</math> sau <math>1^{2018}+1^{2018}+5^{2018}+6^{2018}<7^{2018}</math>.

Deoarece <math>5^{2018}+6^{2018} < 1^{2018}+1^{2018}+5^{2018}+6^{2018} < 7^{2018} </math>, inegalitatea este demonstrată.

E:15346

2025-01-13T10:38:09Z

Vasiliu Costel Andrei: Created page with "'''Soluție.''' a) <math>1^3 + 1^3 + 5^3 + 6^3 - 7^3 = 0</math>. b) Din punctul a) putem scrie <math>1^3 + 1^3 + 5^3 + 6^3 = 7^3</math> sau <math>\left(\frac{1}{7}\right)^3 + \left(\frac{1}{7}\right)^3 + \left(\frac{5}{7}\right)^3+\left(\frac{6}{7}\right)^3 = 1</math>. Acum <math>\left(\frac{1}{7}\right)^{2018}<\left(\frac{1}{7}\right)^3 , \left(\frac{5}{7}\right)^{2018}<\left(\frac{5}{7}\right)^3, \left(\frac{6}{7}\right)^{2018}<\left(\frac{6}{7}\right)^3</math>, de..."

'''Soluție.'''

a) <math>1^3 + 1^3 + 5^3 + 6^3 - 7^3 = 0</math>.

b) Din punctul a) putem scrie <math>1^3 + 1^3 + 5^3 + 6^3 = 7^3</math> sau <math>\left(\frac{1}{7}\right)^3 + \left(\frac{1}{7}\right)^3 + \left(\frac{5}{7}\right)^3+\left(\frac{6}{7}\right)^3 = 1</math>.

Acum <math>\left(\frac{1}{7}\right)^{2018}<\left(\frac{1}{7}\right)^3
, \left(\frac{5}{7}\right)^{2018}<\left(\frac{5}{7}\right)^3, \left(\frac{6}{7}\right)^{2018}<\left(\frac{6}{7}\right)^3</math>, de unde <math>\left(\frac{1}{7}\right)^{2018}+\left(\frac{1}{7}\right)^{2018}+\left(\frac{5}{7}\right)^{2018}+\left(\frac{6}{7}\right)^{2018} < \left(\frac{1}{7}\right)^3 + \left(\frac{1}{7}\right)^3 + \left(\frac{5}{7}\right)^3 + \left(\frac{6}{7}\right)^3.</math>

Obținem astfel <math>\left(\frac{1}{7}\right)^{2018}+\left(\frac{1}{7}\right)^{2018}+\left(\frac{5}{7}\right)^{2018}+\left(\frac{6}{7}\right)^{2018}<1</math> sau <math>1^{2018}+1^{2018}+5^{2018}+6^{2018}<7^{2018}</math>.

Deoarece <math>5^{2018}+6^{2018} < 1^{2018}+1^{2018}+5^{2018}+6^{2018} < 7^{2018} </math>, inegalitatea este demonstrată.

Gazeta matematică 2018

2025-01-13T10:20:49Z

Vasiliu Costel Andrei: /* Gazeta Matematică 4/2018 */

== Gazeta Matematică 1/2018 ==

=== Supliment ===

'''[[S:P18.12]] (Vasile Berinde)'''

''Reconstituiți înmulțirea <math>\overline{abc} \times 3 = \overline{bcc}</math>.''

== Gazeta Matematică 2/2018 ==

'''[[S:E15310|E:15310]] (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Arătați că nu există numere naturale <math>p</math> și <math>q</math> astfel încât să fie adevărată relația <math>p^2 - 2018 = 2^q</math>.''

'''[[S:E15313|E:15313]] (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Determinați cifra <math>a</math> pentru care fracția <math>\frac{a^2 \cdot \overline{aa} + a^2(a^2+1)}{\overline{202a}}</math> este echiunitară.''

'''[[S:E15.314|E:15314]] (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Determinați numerele naturale <math>m</math> și <math>n</math> pentru care este adevărată relația <math>2018^{m}=8^{n}+2010</math>.''

'''[[S:E15.316|E:15316]] (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Determinați numărul prim <math>p</math> și numărul natural <math>q</math> astfel încât <math>p^{2} + 5^{p} + 31 = 3181^{q}.</math>''

'''[[15323|E:15323]] (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Arătați că există o infinitate de numere naturale diferite <math>a</math> și <math>b</math> pentru care <math>4a^2 - 2022ab + 2018b^2 = 0</math>.''

'''[[15324|E:15324]] (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Determinați cifrele nenule <math>x</math> și <math>y</math> pentru care <math>\frac{y^3}{x^3} - \frac{\overline{xy}}{x} = 2\left(\frac{\overline{xy}}{x} - 16\right)</math>.''

'''[[S:E15.325|E:15325]] (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)'''
''Determinați numerele naturale <math>\overline{abcd}</math> pentru care:''
<math display="block">\frac{\sqrt{d+2 \cdot \overline{abc}}}{\overline{d0}} = \frac{\sqrt{3 \cdot \overline{abc}}}{\overline{abc}}</math>

'''[[S:E15310|E:15310]] (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)'''

''Arătați că nu există numere naturale <math>p</math> și <math>q</math> astfel încât să fie adevărată relația <math>p^2 - 2018 = 2^q</math>.''

'''[[S:E15313|E:15313]] (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)'''

''Determinați cifra <math>a</math> pentru care fracția <math>\frac{a^2 \cdot \overline{aa} + a^2(a^2+1)}{\overline{202a}}</math> este echiunitară.''

== Gazeta Matematică 3/2018 ==

'''[[15326|E:15326]] (Andreea Bogdanovici)'''

''Determinați numerele naturale <math>a,b,c</math> pentru care este adevărată relația <math>\frac{37}{10}=a+\frac{1}{b+\frac{1}{c+\frac{1}{3}}}</math>.''

== Gazeta Matematică 4/2018 ==

'''[[E:15344]] (Teodora Zetea și Bogdan Zetea)'''

''Un număr se numește primial dacă este format din cifre prime, distincte.''

a) ''Câte numere primiale de trei cifre există?''

b) ''Arătați că suma tuturor numerelor primiale nu este un pătrat perfect.''

'''[[E:15345]] (Călin Dănuț Hossu)'''

''Determinați numerele ''<math>\overline{xyz}</math> '', scrise în baza <math>10</math>, știind că <math>x^{y+z} + x^y + x^z - 584 = 0</math>.''

'''[[E:15346]] (Mihai Vijdeluc și Vasile Ienuțaș, Baia Mare)'''

''a) Calculați <math>1^3 + 1^3 + 5^3 + 6^3 - 7^3</math>.

b) Arătați că <math>5^{2018}+6^{2018}<7^{2018}</math>''

'''[[15347|E:15347]] (Meda Bojor)'''

''Determinați numerele prime <math>p, q, r, s</math> pentru care este adevărată relația <math>p \cdot q \cdot r \cdot s = 26(p + q + r + s)</math>.''

'''[[15348|E:15348]] (Gheorghe Boroica)'''

''Determinați valorile naturale ale numărului <math>a</math> pentru care există <math>x, y \in \mathbb{N}^*</math> astfel încât <math>x^3 + 2y^3 = a \cdot (2x^2y + xy^2)</math>.''

=== Supliment ===

'''S:E18.127 (Nicolae Mușuroia)'''

''Un copil se joacă. În prima etapă, scrie un număr pe tablă. La fiecare dintre etapele următoare, înlocuiește numărul de pe tablă cu un altul, obținut după una dintre următoarele reguli: sau scrie dublul numărului, sau scrie numărul obținut prin înlocuirea ultimei cifre a numărului cu ultima cifră a cubului acestuia. Știind că se pornește de la numărul <math>18</math>, stabiliți dacă''

a) s''e poate ajunge la numărul'' <math>78</math>;

b) ''se poate ajunge la numărul'' <math>2018</math>.

'''[[S:E18.128]] (Vasile Ienuțaș)'''

''Scrieți numărul <math>2018^{2017}</math> ca sumă de patru pătrate perfecte nenule distincte.''

'''S:E18.129 (Ioan-Iulian Bunu)'''

''Determinați numerele prime <math>a, b, c</math> din egalitatea <math>5a^6+13b^2+5^c=2018</math>''.

'''S:E18.130 (Traian Covaciu)'''

a) ''Determinați numerele prime <math>x,y,z</math> astfel încât'' <math>8x+9y+60z=1918</math>.

b) ''Aflați numerele naturale <math>x,y,z</math> astfel încât'' <math>20x+208y+209z=2018</math>.

'''[[S:E18.131]] (Nicolae Mușuroia)'''

''Determinați cel mai mic număr natural pătrat perfect care se poate scrie ca sumă de 2018 numere naturale consecutive.''

'''[[S:E18.154]] (Nicolae Mușuroia)'''

''Fie <math>a,b,c \in \mathbb{Z}</math> cu <math>b^{2}+c^{2}=a^{2}</math>. Arătați că pentru orice <math>n\in \mathbb{N}^{*}</math>, ecuația <math>x^{2}+2a^{n}x+b^{2n}+c^{2n}=0</math> are soluții reale.''

1912 - Becuri

2024-01-01T13:16:09Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Chris vă propune un joc cu becuri. * în joc sunt n becuri * inițial toate cele n becuri au culoarea albastru * fiecare bec poate avea doar două culori: roșu sau albastru * se efectuează n parcurgeri, pentru k de la 1 la n. La parcurgerea de rang k, se schimbă culoarea fiecărui bec situat pe poziţii având indicii multipli de k, din roşu în albastru şi invers. Știind numărul n de becuri, să se afișeze numărul de becuri car...

== Cerința ==
Chris vă propune un joc cu becuri. 

* în joc sunt n becuri 
* inițial toate cele n becuri au culoarea albastru 
* fiecare bec poate avea doar două culori: roșu sau albastru 
* se efectuează n parcurgeri, pentru k de la 1 la n. La parcurgerea de rang k, se schimbă culoarea fiecărui bec situat pe poziţii având indicii multipli de k, din roşu în albastru şi invers. 
Știind numărul n de becuri, să se afișeze numărul de becuri care au culoarea roșie după terminarea jocului.

== Date de intrare ==
Fișierul de intrare becuriin.txt conține pe prima linie numărul de becuri n.

== Date de ieșire ==
Fișierul de ieșire becuriout.txt va conține pe prima linie numărul de becuri care au culoarea roșie după terminarea jocului.

== Restricții și precizări ==
* numerotarea pozițiilor becurilor începe cu 1
* 1 &les; '''n''' &les; 10^9

== Exemplul 1 ==
; Intrare
; becuriin.txt
: 6
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; becuriout.txt
: 2

== Exemplul 2 ==
; Intrare
; becuriin.txt
: 10
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; becuriout.txt
: 3

== Exemplul 3 ==
; Intrare
; becuriin.txt
: 18
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; becuriout.txt
: 4

== Exemplul 4 ==
; Intrare
; becuriin.txt
: 0
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1912 - Becuri

def validare_date(n):
if not (1 <= n <= 10**9):
return False
return True

def numar_becuri_rosii(n):
becuri = [0] * (n + 1)

for k in range(1, n + 1):
for i in range(k, n + 1, k):
becuri[i] = 1 - becuri[i]

return sum(becuri)

with open("becuriin.txt", "r") as f:
n = int(f.readline().strip())

if validare_date(n):
print("Datele de intrare corespund restricțiilor impuse")

rezultat = numar_becuri_rosii(n)
with open("becuriout.txt", "w") as f:
f.write(str(rezultat) + "\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

1940 - Bomba

2024-01-01T13:01:16Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Războiul intergalactic a început, iar extratereștrii au invadat deja planeta noastră. Misiunea ta este să salvezi toți locuitorii planetei cât mai repede cu putință! Într-un hambar vechi, ai găsit un robot proiectat special pentru amplasarea de bombe nucleare și totodată o hartă a planetei sub formă de dreptunghi împărțită în N x M zone pătratice dispuse pe N linii și M coloane, de dimensiune 1. Pe hartă sunt reprezentate și pozițiile...

== Cerința ==
Războiul intergalactic a început, iar extratereștrii au invadat deja planeta noastră. Misiunea ta este să salvezi toți locuitorii planetei cât mai repede cu putință!

Într-un hambar vechi, ai găsit un robot proiectat special pentru amplasarea de bombe nucleare și totodată o hartă a planetei sub formă de dreptunghi împărțită în N x M zone pătratice dispuse pe N linii și M coloane, de dimensiune 1. Pe hartă sunt reprezentate și pozițiile extratereștrilor (xi,yi), unde xi reprezintă indicele de linie, iar yi reprezintă indicele de coloană al extraterestrului i. De asemenea, robotul poate amplasa bombe în orice poziție de pe hartă, iar la declanșarea lor, acestea distrug orice extraterestru de pe aceeași linie sau de pe aceeași coloană cu ele.

Din păcate, robotul nu este echipat decât cu o singură bombă. Datoria ta este să-i transmiți robotului coordonatele x y unde să amplaseze bomba, astfel încât toți extratereștrii să fie distruși. Poți să salvezi planeta? Timpul se scurge! Tic, tac, tic, tac…

== Date de intrare ==
Fișierul de intrare bombain.txt conține pe prima linie două numere naturale N și M, reprezentând numărul de linii, respectiv numărul de coloane ale hărții. Pe următoarele N linii se găsesc câte M caractere din mulțimea {0,1}; 0 reprezintă o poziție liberă, în timp ce 1 reprezintă o poziție ocupată de un extraterestru.

== Date de ieșire ==
Fișierul de ieșire bombaout.txt va conține pe prima linie două numere naturale x și y, reprezentând indicele liniei și al coloanei unde trebuie amplasată bomba astfel încât toți extratereștrii să fie distruși.

== Restricții și precizări ==
* 1 &les; '''n, m''' &les; 1.000
* Numărul de extratereștri nu depășește 2000.
* Dacă există mai multe celule în care poate fi amplasată bomba, se alege cea cu indicele de linie x minim. Dacă există mai multe celule în care poate fi amplasată bomba cu indicele de linie x minim, se alege cea cu indicele de coloană y minim.
* Liniile și coloanele hărții sunt numerotate începând cu 1.
* Se garantează că pentru datele de test există întotdeauna soluție.

== Exemplul 1 ==
; Intrare
; bombain.txt
: 4 4
: 0010
: 0000
: 0001
: 0001
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; bombaout.txt
: 1 4

=== Explicație ===
Bomba trebuie să fie amplasată pe poziția (1,4) astfel încât toți extratereștrii să fie distruși.

== Exemplul 2 ==
; Intrare
; bombain.txt
: 3 3
: 010
: 001
: 000
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; bombaout.txt
: 1 3

=== Explicație ===
Bomba poate să fie amplasată atât pe poziția (2,2), cât și pe poziția (1,3), astfel se afișează cea de-a doua poziție deoarece are indicele de linie X minim.

== Exemplul 3 ==
; Intrare
; bombain.txt
: 3001 3
: 010
: 001
: 000
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1940 - Bomba

def validare_date(n, m, harta):
if not (1 <= n <= 1000 and 1 <= m <= 1000):
return False

if len(harta) != n:
return False

for linie in harta:
if len(linie) != m:
return False
if not all(caracter in {'0', '1'} for caracter in linie):
return False

return True

def gaseste_pozitie_bomba(n, m, harta):
for coloana in range(m):
for linie in range(n):
if harta[linie][coloana] == '1':
return linie + 1, coloana + 2

with open("bombain.txt", "r") as fin:
n, m = map(int, fin.readline().split())
harta = [fin.readline().strip() for _ in range(n)]

if validare_date(n, m, harta):
print("Datele de intrare corespund restricțiilor impuse")

x, y = gaseste_pozitie_bomba(n, m, harta)

with open("bombaout.txt", "w") as fout:
fout.write(f"{x} {y}\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

0689 - Risipa

2024-01-01T12:38:22Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Fiul risipitor primeşte de ziua lui o sumă de S lei. Începând din acea zi (considerată ca ziua 1) în fiecare zi se întâmplă unul dintre următoarele evenimente: * Dacă S dă restul 0 la împărtirea cu 3 atunci el cheltuie două treimi din sumă. * Dacă S dă restul 1 la împărtirea cu 3 atunci el primeşte 3A+2 lei de la tata. * Dacă S dă restul 2 la împărtirea cu 3 atunci el primeşte 3B+1 lei de la mama. == Cerința == Cunos...

== Enunț ==

Fiul risipitor primeşte de ziua lui o sumă de S lei. Începând din acea zi (considerată ca ziua 1) în fiecare zi se întâmplă unul dintre următoarele evenimente: 

* Dacă S dă restul 0 la împărtirea cu 3 atunci el cheltuie două treimi din sumă. 
* Dacă S dă restul 1 la împărtirea cu 3 atunci el primeşte 3A+2 lei de la tata. 
* Dacă S dă restul 2 la împărtirea cu 3 atunci el primeşte 3B+1 lei de la mama. 

== Cerința ==
Cunoscându-se S – suma iniţiala, A, B – numere cu semnificaţia din enunţ să se determine primele două zile în ordine cronologică în care fiul risipitor va avea aceeaşi sumă precum şi suma respectivă.

== Date de intrare ==
Fişierul de intrare risipain.txt conţine pe prima linie numărul natural S reprezentând suma de care dispune fiul risipitor în prima zi iar pe a doua linie cele două valori naturale A şi B separate printr-un spaţiu.

== Date de ieșire ==
Fişierul de ieşire risipaout.txt va conţine pe prima linie o valoare naturală reprezentând prima sumă care se repetă iar pe a doua linie cele două valori naturale, separate printr-un spaţiu reprezentând prima respectiv a doua zi în care s-a obţinut respectiva sumă.

== Restricții și precizări ==
* 1 &les; '''n''' &les; 10^100
* 1 &les; '''a, b''' &les; 1.000
* Suma unei zile este considerată cea de la începutul zilei înainte ca fiul risipitor să cheltuie bani sau dupa caz să primească bani de la mama sau de la tata.

== Exemplul 1 ==
; Intrare
; risipain.txt
: 7
: 1 1
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; risipaout.txt
: 6
: 7 9

=== Explicație ===
Daca suma dă restul 1 primeşte 5 lei. 
Daca suma dă restul 2 primeşte 4 lei. 
Ziua 1 : suma 7 rest = 1 castigă 5 lei 
Ziua 2 : suma 12 rest = 0 pierde 8 lei 
Ziua 3 : suma 4 rest = 1 castigă 5 lei 
Ziua 4 : suma 9 rest = 0 pierde 6 lei 
Ziua 5 : suma 3 rest = 0 pierde 2 lei 
Ziua 6 : suma 1 rest = 1 castigă 5 lei 
Ziua 7 : suma 6 rest = 0 pierde 4 lei 
Ziua 8 : suma 2 rest = 2 castigă 4 lei 
Ziua 9 : suma 6 la fel ca in ziua 7 

== Exemplul 2 ==
; Intrare
; risipain.txt
: 7
: 1001 1
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0689 - Risipa

def valideaza_input(s, a, b):
if not (1 <= s <= 10100 and 1 <= a <= 1000 and 1 <= b <= 1000):
return False
return True

def risipitor(s, a, b):
sume_vazute = {}
suma_curenta = s
zi = 1

while True:
if suma_curenta in sume_vazute:
return suma_curenta, (sume_vazute[suma_curenta], zi)

sume_vazute[suma_curenta] = zi

if suma_curenta % 3 == 0:
suma_curenta -= suma_curenta // 3 * 2
elif suma_curenta % 3 == 1:
suma_curenta += 3 * a + 2
elif suma_curenta % 3 == 2:
suma_curenta += 3 * b + 1

zi += 1

with open("risipain.txt", "r") as file_in:
s = int(file_in.readline().strip())
a, b = map(int, file_in.readline().strip().split())

if valideaza_input(s, a, b):
print("Datele de intrare corespund restricțiilor impuse")

rezultat_suma, rezultat_zile = risipitor(s, a, b)

with open("risipaout.txt", "w") as file_out:
file_out.write(str(rezultat_suma) + "\n")
file_out.write(" ".join(map(str, rezultat_zile)) + "\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

0742 - Numar 2

2024-01-01T11:58:24Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Fie un număr natural a având n cifre. Scrieţi un program care să determine un număr natural x cu proprietatea că este cel mai mic număr mai mare decât a, care are exact aceleaşi cifre ca şi numărul a. == Date de intrare == Fișierul de intrare numar2in.tx conține două linii: * pe prima linie un număr natural reprezentând valoarea lui n; * pe a doua linie, fără spaţii între ele, n cifre reprezentând numărul a. == Date de ieșire == F...

== Cerința ==
Fie un număr natural a având n cifre. Scrieţi un program care să determine un număr natural x cu proprietatea că este cel mai mic număr mai mare decât a, care are exact aceleaşi cifre ca şi numărul a.

== Date de intrare ==
Fișierul de intrare numar2in.tx conține două linii:

* pe prima linie un număr natural reprezentând valoarea lui n; 
* pe a doua linie, fără spaţii între ele, n cifre reprezentând numărul a.

== Date de ieșire ==
Fișierul de ieșire numar2out.txt va conține o singură linie pe care se va afla numărul x.

== Restricții și precizări ==
* 1 &les; '''n''' &les; 5.000.000
* pentru '''50%''' din teste, '''n''' &les; 1.000.000
* pentru toate datele de test există soluţie.

== Exemplul 1 ==
; Intrare
; numar2in.txt
: 6
: 204924
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; numar2out.txt
: 204942

=== Explicație ===
Există mai multe numere formate din exact aceleaşi cifre ca şi numărul 204924 mai mari decât el. Dintre acestea, 204942 este cel mai mic.

== Exemplul 2 ==
; Intrare
; numar2in.txt
: 6
: 2049241
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0742 - Numar2

def valideaza_input(n, a):
if not (1 <= n <= 5000000):
return False

if len(str(a)) != n:
return False

return True

def gaseste_permutare_urmatoare(a):
a = list(str(a))
n = len(a)

# Găsim cea mai mică cifră care poate fi schimbată
i = n - 2
while i >= 0 and a[i] >= a[i + 1]:
i -= 1

# Dacă nu există o astfel de cifră, atunci a este cel mai mare și nu există soluție
if i == -1:
return None

# Găsim cea mai mică cifră mai mare decât a[i] în partea dreaptă
j = n - 1
while a[j] <= a[i]:
j -= 1

# Schimbăm a[i] cu a[j]
a[i], a[j] = a[j], a[i]

# Inversăm cifrele de la i+1 la sfârșit
a[i + 1:] = reversed(a[i + 1:])

return int(''.join(a))

def main():
with open("numar2in.txt", "r") as file:
n = int(file.readline().strip())
a = int(file.readline().strip())

if valideaza_input(n, a):
print("Datele de intrare corespund restricțiilor impuse")

rezultat = gaseste_permutare_urmatoare(a)

with open("numar2out.txt", "w") as file_out:
file_out.write(str(rezultat))
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
main()

</syntaxhighlight>

1687 - Omogene

2024-01-01T10:22:13Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Se consideră o matrice cu L linii și C coloane care memorează doar valori din mulțimea {0,1,2}. O submatrice nevidă (formată din cel puțin o linie și cel puțin o coloană) a acestei matrice o numim omogenă dacă numărul valorilor de 0 este egal cu numărul de valori de 1 și egal cu numărul valorilor de 2. De exemplu, în matricea 0 1 2 0 1 2 0 1 sunt șase submatrice omogene, acestea fiind: 0 1 2 1 2 0 1 2 0 2 0 1 <b...

== Enunț ==
Se consideră o matrice cu L linii și C coloane care memorează doar valori din mulțimea {0,1,2}. O submatrice nevidă (formată din cel puțin o linie și cel puțin o coloană) a acestei matrice o numim omogenă dacă numărul valorilor de 0 este egal cu numărul de valori de 1 și egal cu numărul valorilor de 2. De exemplu, în matricea

0 1 2 0 
1 2 0 1 
sunt șase submatrice omogene, acestea fiind: 

0 1 2 
1 2 0 
1 2 0 
2 0 1 
0 1 2 
1 2 0 
1 2 0 
2 0 1 
Submatricele a treia și a patra sunt formate din prima linie a matricei inițială, iar submatricele a cincea și a șasea sunt formate din a doua linie.

== Cerința ==
Să se determine câte submatrice nevide omogene există.

== Date de intrare ==
Fișierul de intrare omogenein.txt conține pe prima linie numerele naturale L și C. Pe următoarele L linii se află câte C numere naturale separate prin spații reprezentând câte o linie din matrice.

== Date de ieșire ==
Fișierul de ieșire omogeneout.txt va conține pe prima linie un singur număr natural reprezentând numărul submatricelor nevide omogene.

== Restricții și precizări ==
* 2 &les; '''l''' &les; '''c''' &les; 500
* 4 &les; '''l*c''' &les; 65536
* Atenție, o submatrice este formată dintr-o secvență continuă de linii și coloane, deci, de exemplu, dacă se aleg dintr-o matrice liniile 1, 2 și 5, atunci acestea nu formează o submatrice.
* Numărul submatricelor omogene va fi mai mic decât 2*10^9
* Întreaga matrice poate fi submatrice omogenă

== Exemplul 1 ==
; Intrare
; omogenein.txt
: 2 4
: 0 1 2 0
: 1 2 0 1
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; omogeneout.txt
: 6

=== Explicație ===
Cele șase submatrice au fost menționate în enunț.

== Exemplul 2 ==
; Intrare
; omogenein.txt
: 3 3
: 0 1 2
: 0 2 2
: 0 1 1
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; omogeneout.txt
: 3

== Exemplul 3 ==
; Intrare
; omogenein.txt
: 1 3
: 0 1 2
: 0 2 2
: 0 1 1
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1687 - Omogene

def validare_date(l, c, matrice):
if not (2 <= l <= c <= 5000):
return False
if not (4 <= l * c <= 65536):
return False
if len(matrice) != l or any(len(row) != c for row in matrice):
return False
return True

def numar_submatrici_omogene(l, c, matrice):
if not validare_date(l, c, matrice):
return 0

numar_submatrici = 0

for i in range(l):
for j in range(c):
for x in range(i, l):
for y in range(j, c):
submatrice = [matrice[k][j:y + 1] for k in range(i, x + 1)]
numar_0 = sum(row.count(0) for row in submatrice)
numar_1 = sum(row.count(1) for row in submatrice)
numar_2 = sum(row.count(2) for row in submatrice)

if numar_0 == numar_1 == numar_2:
numar_submatrici += 1

return numar_submatrici

with open("omogenein.txt", "r") as f:
l, c = map(int, f.readline().split())
matrice = [list(map(int, f.readline().split())) for _ in range(l)]

if validare_date(l, c, matrice):
print("Datele de intrare corespund restricțiilor impuse")

rezultat = numar_submatrici_omogene(l, c, matrice)

with open("omogeneout.txt", "w") as f:
f.write(str(rezultat))

else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

1685 - Dif 2

2023-12-31T18:47:46Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Sandu a studiat la ora de informatică mai multe aplicații cu vectori de numere naturale, iar acum are de rezolvat o problemă interesantă. Se dă un șir X=(X[1],X[2],…,X[n]) de numere naturale nenule și două numere naturale p1 și p2, unde p1<p2. Sandu trebuie să construiască un nou șir Y=(Y[1],Y[2],…,Y[n*n]) cu n*n elemente obținute din toate produsele de câte două elemente din șirul X (fiecare element din șirul Y este de forma X[i]*X[j], 1<=i,...

== Enunț ==
Sandu a studiat la ora de informatică mai multe aplicații cu vectori de numere naturale, iar acum are de rezolvat o problemă interesantă. Se dă un șir X=(X[1],X[2],…,X[n]) de numere naturale nenule și două numere naturale p1 și p2, unde p1<p2. Sandu trebuie să construiască un nou șir Y=(Y[1],Y[2],…,Y[n*n]) cu n*n elemente obținute din toate produsele de câte două elemente din șirul X (fiecare element din șirul Y este de forma X[i]*X[j], 1<=i, j<=n). Sandu are de calculat două valori naturale d1 și d2 obținute din șirul Y. Valoarea d1 este egală cu diferența maximă posibilă dintre două valori ale șirului Y. Pentru a obține valoarea d2, Sandu trebuie să considere că șirul Y are elementele ordonate descrescător iar d2 va fi diferența dintre valorile aflate pe pozițiile p1 și p2 în șirul ordonat descrescător. Sandu a găsit rapid valorile d1 și d2 și, pentru a le verifica, vă roagă să le determinați și voi.

== Cerința ==
Dându-se șirul X cu n elemente și valorile p1 și p2, determinați valorile d1 și d2.

== Date de intrare ==
Fișierul de intrare dif2in.txt conține pe prima linie un număr natural C care poate fi doar 1 sau 2. Dacă C=1, atunci pe linia a doua se va afla numărul natural n. Dacă C=2, atunci pe linia a doua se vor afla numerele naturale n p1 p2 separate prin câte un spațiu. În ambele cazuri, pe următoarele n linii se vor afla elementele șirului X, câte un număr natural pe fiecare linie a fișierului.

== Date de ieșire ==
În cazul C=1, fișierul de ieșire dif2out.txt va conține pe prima linie valoarea d1 egală cu diferența maximă dintre oricare două valori din șirul Y. În cazul C=2 fișierul de ieșire va conține pe prima linie un număr natural d2 reprezentând diferența dintre valorile aflate pe pozițiile p1 și p2 din șirul Y, presupunând că ar fi ordonat descrescător.

== Restricții și precizări ==
* 2 &les; '''n''' &les; 299.999
* 1 &les; '''p1''' &les; p2-1 &les;n^2
* 1 &les; '''x[i]''' &les; 299.999 '''i=1...n

== Exemplul 1 ==
; Intrare
; dif2in.txt
: 1
: 4
: 3
: 5
: 2
: 6
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; dif2out.txt
: 32

=== Explicație ===
Atenție, C=1, deci se rezolvă doar cerința 1!
Valoarea maximă d1 va fi 32 și se obține efectuând diferența dintre 6*6 și 2*2.

== Exemplul 2 ==
; Intrare
; dif2in.txt
: 2
: 4 5 11
: 3
: 5
: 2
: 6
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; dif2out.txt
: 8

=== Explicație ===
Atenție, C=2, deci se rezolvă doar cerința 2!
Se obțin în Y următoarele 16 valori: 3*3, 3*5, 3*2, 3*6, 5*3, 5*5, 5*2, 5*6, 2*3, 2*5, 2*2, 2*6, 6*3, 6*5, 6*2, 6*6.
Valoarea d2 va fi 8, deoarece dacă vom considera șirul Y ordonat descrescător (36, 30, 30, 25, 18, 18, 15, 15, 12, 12, 10, 10, 9, 6, 6, 4), atunci Y[5]-Y[11]=18-10=8

== Exemplul 3 ==
; Intrare
; dif2in.txt
: 3
: 4
: 3
: 5
: 2
: 6
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1685 - Dif2

def validare_input(c, n, p1, p2, x):
if not (3 < n < 300000):
raise ValueError("Valoarea lui n nu respectă restricțiile.")
if c == 2 and not (1 <= p1 < p2 <= n * n):
raise ValueError("Valorile lui p1 și p2 nu respectă restricțiile.")
if not all(1 <= x < 300000 for x in x):
raise ValueError("Elementele șirului x nu respectă restricțiile.")

def calcul_d1(x):
y = [x * y for x in x for y in x]
return max(y) - min(y)

def calcul_d2(x, p1, p2):
y = sorted([x * y for x in x for y in x], reverse=True)
return y[p1 - 1] - y[p2 - 1]

with open("dif2in.txt", "r") as file:
c = int(file.readline().strip())
if c == 1:
n = int(file.readline().strip())
p1 = None
p2 = None
else:
n, p1, p2 = map(int, file.readline().strip().split())

x = [int(file.readline().strip()) for _ in range(n)]

if validare_input(c, n, p1, p2, x):
print("Datele de intrare corespund restricțiilor impuse")

if c == 1:
d1 = calcul_d1(x)
with open("dif2out.txt", "w") as out_file:
out_file.write(str(d1))
else:
d2 = calcul_d2(x, p1, p2)
with open("dif2out.txt", "w") as out_file:
out_file.write(str(d2))
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

2463 - Inequation

2023-12-31T18:24:52Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Această problemă nu are o descriere plicticoasă, menită să vă încurce.Trebuie doar să aflați cel mai mare număr natural n, astfel încât b^0+b^1+...+b^n≤y, unde b și y sunt valori cunoscute. == Date de intrare == Fișierul de intrare inequationin.txt va conține pe prima linie numărul t, reprezentând numărul de teste ale problemei.Apoi urmează 3*t rânduri, pentru fiecare test fiind precizată baza b, numărul de cifre ale lui y, precum și c...

== Cerința ==
Această problemă nu are o descriere plicticoasă, menită să vă încurce.Trebuie doar să aflați cel mai mare număr natural n, astfel încât b^0+b^1+...+b^n≤y, unde b și y sunt valori cunoscute.

== Date de intrare ==
Fișierul de intrare inequationin.txt va conține pe prima linie numărul t, reprezentând numărul de teste ale problemei.Apoi urmează 3*t rânduri, pentru fiecare test fiind precizată baza b, numărul de cifre ale lui y, precum și cifrele numărului y, aflate fiecare pe un rând separat.

== Date de ieșire ==
Fișierul de ieșire inequationout.txt va conține pe linia i numărul maxim de termeni pentru care se respectă condiția pentru testul cu numărul de ordine t.

== Restricții și precizări ==
* 1 &les; '''b''' &les; 100
* numărul de cifre ale lui '''y''' &les; 25.000

== Exemplul 1 ==
; Intrare
; inequationin.txt
: 1
: 2
: 2
: 16
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; inequationout.txt
: 4

=== Explicație ===
2^0+2^1+2^2+2^3=15≤16, deci în total patru termeni.

== Exemplul 2 ==
; Intrare
; inequationin.txt
: 1
: 101
: 2
: 16
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2463 - Inequation

def validare_date(b, y):
if not (1 <= b <= 100):
return False
if not (1 <= len(y) <= 25000):
return False
if not all(0 <= int(cifra) <= 9 for cifra in y):
return False
return True

def calculeaza_numar_maxim_termeni(b, y):
suma = 0
numar_termeni = 0
i = 0
while suma + b ** i <= int(y):
suma += b ** i
numar_termeni += 1
i += 1
return numar_termeni

def main():
with open("inequationin.txt", "r") as file_input:
t = int(file_input.readline().strip())
for _ in range(t):
b = int(file_input.readline().strip())
lungime_y = int(file_input.readline().strip())
y = file_input.readline().strip()

if validare_date(b, y):
print("Datele de intrare corespund restricțiilor impuse")

rezultat = calculeaza_numar_maxim_termeni(b, y)

with open("inequationout.txt", "w") as file_output:
file_output.write(str(rezultat) + "\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")

if __name__ == "__main__":
main()

</syntaxhighlight>

2341 - Labirint 4

2023-12-31T18:00:03Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Cătălin s-a pierdut iarăși într-o matrice de N linii și M coloane în care unele celule sunt blocate. Cătălin nu găsește ieșirea așa că s-a decis să caute o comoară. El are o harta pe care a desenat-o când era mic și decide să o urmeze. Pe harta este scris un șir format din caracterele U, R, D, L. În fiecare secundă Cătălin se va deplasa în una dintre cele 4 celule adiacente. Presupunând că la secunda S Cătălin se află în celula i,...

== Cerința ==
Cătălin s-a pierdut iarăși într-o matrice de N linii și M coloane în care unele celule sunt blocate. Cătălin nu găsește ieșirea așa că s-a decis să caute o comoară. El are o harta pe care a desenat-o când era mic și decide să o urmeze. Pe harta este scris un șir format din caracterele U, R, D, L. În fiecare secundă Cătălin se va deplasa în una dintre cele 4 celule adiacente. Presupunând că la secunda S Cătălin se află în celula i, j el se va mișcă în funcție de al S-lea caracter de pe harta în felul următor: pentru U el va păși în celula i - 1, j; pentru R el va păși în celula i, j + 1; pentru D el va păși în celula i + 1, j, iar pentru L, el va păși în celula i, j - 1.

Dacă celula în care trebuie să pășească este în afara matricei sau este blocată, atunci Cătălin va sta pe loc în acea secunda. În ce celulă ajunge Cătălin?

== Date de intrare ==
Pe prima linie a fișierului de intrare labirint4in.txt se vor afla trei numere naturale N, M și K. Pe următoarele K linii se vor afla cate 2 numere reprezentând linia și coloana unei celule blocate. Pe următoarea linie se vor afla 2 numere naturale reprezentând linia, respectiv coloana de pe care începe Cătălin să se miște. Pe ultima linie se va afla numărul de caractere din șirul de pe hartă urmat de acele caractere.

== Date de ieșire ==
În fișierul de ieșire labirint4out.txt se vor afla două numere reprezentând linia și coloana pe care ajunge Cătălin.

== Restricții și precizări ==
* 1 &les; '''lungimea șirului de pe hartă''' &les; 10.000
* 1 &les; '''n, m''' &les; 10.000 și k = 0
* 1 &les; '''n, m''' &les; 500 și 1 &les; '''k''' &les; n*m
* 1 &les; '''n, m''' &les; 10.000 și 1 &les; '''k''' &les; 1.000

== Exemplul 1 ==
; Intrare
; labirint4in.txt
: 4 5 7
: 1 3
: 1 5
: 2 1
: 2 4
: 2 5
: 3 1
: 3 2
: 2 2
: 11
: ULRDDRDRDLU
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; labirint4out.txt
: 3 3

=== Explicație ===
Traseul lui Catalin este:
(2, 2) → (1, 2) → (1, 1) → (1, 2) → (2, 2) → (2, 3) → (3, 3) → (3, 4) → (4, 4) → (4, 3) → (3, 3)

== Exemplul 2 ==
; Intrare
; labirint4in.txt
: 10001 5 7
: 1 3
: 1 5
: 2 1
: 2 4
: 2 5
: 3 1
: 3 2
: 2 2
: 11
: ULRDDRDRDLU
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2341 - Labirint4

def este_valid(n, m, k, celule_blocate, start, lungime_harta):
if not (1 <= lungime_harta <= 10000):
return False

if not (1 <= n <= 10000) or not (1 <= m <= 10000):
return False

if not (0 <= k <= n * m):
return False

for i, j in celule_blocate:
if not (1 <= i <= n) or not (1 <= j <= m):
return False

if not (1 <= start[0] <= n) or not (1 <= start[1] <= m):
return False

return True

def este_in_matrice(i, j, n, m):
return 1 <= i <= n and 1 <= j <= m

def rezolva_labirint(n, m, celule_blocate, start, lungime_harta, harta):
directii = {'U': (-1, 0), 'R': (0, 1), 'D': (1, 0), 'L': (0, -1)}

i, j = start
for s in range(lungime_harta):
directie = harta[s]
di, dj = directii[directie]
i_nou, j_nou = i + di, j + dj

if este_in_matrice(i_nou, j_nou, n, m) and (i_nou, j_nou) not in celule_blocate:
i, j = i_nou, j_nou

return i, j

def main():
with open("labirint4in.txt", "r") as f:
n, m, k = map(int, f.readline().split())
celule_blocate = [tuple(map(int, f.readline().split())) for _ in range(k)]
start = tuple(map(int, f.readline().split()))
lungime_harta = int(f.readline())
harta = f.readline().strip()

if este_valid(n, m, k, celule_blocate, start, lungime_harta):
print("Datele de intrare corespund restricțiilor impuse")
rezultat = rezolva_labirint(n, m, celule_blocate, start, lungime_harta, harta)

with open("labirint4out.txt", "w") as f:
f.write(f"{rezultat[0]} {rezultat[1]}\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
main()

</syntaxhighlight>

2554 - Or

2023-12-29T20:22:17Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Se consideră numerele naturale X, N și o matrice pătratică A cu N x N elemente numere naturale. == Cerința == Determinați aria minimă a unei submatrice cu proprietatea că efectuând operația or pe biți or între toate elementele submatricei se obține valoarea X. == Date de intrare == Fișierul de intrare orin.txt conține pe primul rând numerele naturale X și N, separate printr-un spațiu. Pe următoarele N linii sunt câte N elemente numere natura...

== Enunț ==
Se consideră numerele naturale X, N și o matrice pătratică A cu N x N elemente numere naturale.

== Cerința ==
Determinați aria minimă a unei submatrice cu proprietatea că efectuând operația or pe biți or între toate elementele submatricei se obține valoarea X.

== Date de intrare ==
Fișierul de intrare orin.txt conține pe primul rând numerele naturale X și N, separate printr-un spațiu. Pe următoarele N linii sunt câte N elemente numere naturale separate printr-un spațiu, reprezentând elementele matricei.

== Date de ieșire ==
Fișierul de ieșire orout.txt va conține un număr natural reprezentând aria minimă a unei submatrice.

== Restricții și precizări ==
* 2 &les; '''N''' &les; 500
* 1 &les; '''A[i][j]''' &les; 2^31
* Operația pe biți or dintre două numere întregi este un întreg în care al i-lea bit este 0 dacă și numai dacă bitul i din ambele numere este 0.
* Se garantează că pentru toate datele de intrare există mereu o soluție și dimensiunea acesteia este cel puțin 2

== Exemplul 1 ==
; Intrare
; orin.txt
: 11 4
: 5 9 1 8
: 7 7 3 1
: 2 3 1 9
: 5 5 8 7
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; orout.txt
: 3

=== Explicație ===
Submatricea este formată din elementele 3 1 9 de pe linia a treia (3 | 1 | 9 = 11).

== Exemplul 2 ==
; Intrare
; orin.txt
: 11 1
: 5 9 1 8
: 7 7 3 1
: 2 3 1 9
: 5 5 8 7
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2554 - Or

import functools

def valideaza_input(n, matrice):
if not 2 <= n <= 500:
return False

for rand in matrice:
for element in rand:
if not 1 <= element < 2 ** 31:
return False

return True

def calculeaza_aria_minima(x, n, matrice):
aria_minima = float('inf')

for i in range(n):
for j in range(n):
for k in range(i, n):
for l in range(j, n):
submatrice = [rand[j:l + 1] for rand in matrice[i:k + 1]]
rezultat_or_pe_biti = functools.reduce(lambda x, y: x | y,
[element for rand in submatrice for element in rand])

if rezultat_or_pe_biti == x:
aria_minima = min(aria_minima, (k - i + 1) * (l - j + 1))

return aria_minima

if __name__ == "__main__":
with open("orin.txt", "r") as f:
x, n = map(int, f.readline().split())
matrice = [list(map(int, f.readline().split())) for _ in range(n)]

if valideaza_input(n, matrice):
print("Datele de intrare corespund restricțiilor impuse")

rezultat = calculeaza_aria_minima(x, n, matrice)

with open("orout.txt", "w") as f:
f.write(str(rezultat))
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

2101 - Traseu2

2023-12-29T19:36:39Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Fie un labirint reprezentat ca o matrice pătratică cu n linii (numerotate de sus în jos de la 1 la n) şi n coloane (numerotate de la stânga la dreapta de la 1 la n). Elementele matricei pot fi 0 (semnificând culoar de trecere) sau 1 (semnificând zid). Un roboţel se mişcă prin labirint după un anumit traseu, specificat ca o succesiune de direcţii de mişcare. Direcţiile pot fi: • N (nord), adică din poziţia curentă (x,y) robotul se deplasează...

== Enunț ==
Fie un labirint reprezentat ca o matrice pătratică cu n linii (numerotate de sus în jos de la 1 la n) şi n coloane (numerotate de la stânga la dreapta de la 1 la n). Elementele matricei pot fi 0 (semnificând culoar de trecere) sau 1 (semnificând zid). Un roboţel se mişcă prin labirint după un anumit traseu, specificat ca o succesiune de direcţii de mişcare. Direcţiile pot fi:

• N (nord), adică din poziţia curentă (x,y) robotul se deplasează în poziţia (x-1,y), dacă nu este zid; 
• S (sud), adică din poziţia curentă (x,y) robotul se deplasează în poziţia (x+1,y), dacă nu este zid; 
• E (est), adică din poziţia curentă (x,y) robotul se deplasează în poziţia (x,y+1), dacă nu este zid; 
• V (vest), adică din poziţia curentă (x,y) robotul se deplasează în poziţia (x,y-1), dacă nu este zid; 

Observaţi că roboţelul nu poate trece prin ziduri, prin urmare, dacă în direcţia de mişcare curentă se află un zid, el nu va efectua deplasarea respectivă.

== Cerința ==
Dată fiind configuraţia labirintului, poziţia iniţială a roboţelului şi traseul pe care se deplasează acesta, să se determine poziţia finală a robotului.

== Date de intrare ==
Fişierul de intrare traseu2in.txt conţine pe prima linie numărul natural n, reprezentând dimensiunea labirintului. Pe cea de a doua linie sunt scrise două numere naturale L C (cuprinse între 1 şi n), reprezentând poziţia iniţială a roboţelului (L fiind linia, iar C fiind coloana). Pe următoarele n linii se află câte n valori din mulţimea {0,1}, reprezentând configuraţia labirintului. Pe ultima linie se află un şir de caractere din mulţimea {′N′, ′S′, ′E′, ′V′}, reprezentând traseul roboţelului.

== Date de ieșire ==
Fişierul de ieşire traseu2out.txt va conţine o singură linie pe care vor fi scrise două numere naturale cuprinse între 1 şi n reprezentând linia, respectiv coloana poziţiei în care se află roboţelul după parcurgerea traseului. Dacă în timpul deplasării pe traseu roboţelul părăseşte labirintul, pe prima linie vor fi scrise linia, respectiv coloana ultimei poziţii pe care a avut-o roboţelul în labirint.

== Restricții și precizări ==
* 1 &les; '''n''' &les; 100
* Traseul are lungimea &les; 250
* Valorile numerice scrise pe aceeaşi linie în fişierul de intrare şi în fişierul de ieşire vor fi separate prin câte un spaţiu.
* Poziţia iniţială a roboţelului se află pe culoar.

== Exemplul 1 ==
; Intrare
; traseu2in.txt
: 5
: 2 1
: 1 0 0 0 1
: 0 0 1 0 1
: 1 0 0 0 0
: 1 0 0 1 1
: 1 1 0 0 0
: ENESES
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; traseu2out.txt
: 2 4

=== Explicație ===
Din poziţia (2,1) roboţelul face o deplasare spre Est şi ajunge în poziţia (2,2). Următoarea deplasare este spre Nord şi ajunge în poziţia (1,2). Următoarea deplasare este spre Est şi ajunge în poziţia (1,3). Următoarea deplasare ar fi trebuit să fie spre Sud, dar aceasta nu poate fi efectuată, fiindcă la sud este zid. Următoarea deplasare este spre Est şi ajunge în (1,4), apoi la Sud, şi ajunge în (2,4).

== Exemplul 2 ==
; Intrare
; traseu2in.txt
: 3
: 2 2
: 1 0 0
: 0 0 1
: 1 0 0
: VVV
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; traseu2out.txt
: 2 1

=== Explicație ===
Din poziţia (2,2) roboţelul se deplasează spre Vest, ajunge în poziţia (2,1).
La următoarea deplasare spre Vest, roboţelul părăseşte labirintul.

== Exemplul 3 ==
; Intrare
; traseu2in.txt
: 0
: 2 1
: 1 0 0 0 1
: 0 0 1 0 1
: 1 0 0 0 0
: 1 0 0 1 1
: 1 1 0 0 0
: ENESES
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2101 - Traseu2

def validare_date(n, l, c, labirint, traseu):
if not (1 <= n <= 100):
return False
if not (1 <= l <= n) or not (1 <= c <= n):
return False
if len(labirint) != n or any(len(row) != n for row in labirint):
return False
if len(traseu) > 250:
return False
return True

def determina_pozitie_finala(n, l, c, labirint, traseu):
directii = {'N': (-1, 0), 'S': (1, 0), 'E': (0, 1), 'V': (0, -1)}

x, y = l - 1, c - 1

for directie in traseu:
dx, dy = directii[directie]
nx, ny = x + dx, y + dy

if 0 <= nx < n and 0 <= ny < n and labirint[nx][ny] == 0:
x, y = nx, ny

return x + 1, y + 1

def main():
with open("traseu2in.txt", "r") as fin:
n = int(fin.readline().strip())
l, c = map(int, fin.readline().split())
labirint = [list(map(int, fin.readline().split())) for _ in range(n)]
traseu = fin.readline().strip()

if validare_date(n, l, c, labirint, traseu):
print("Datele de intrare corespund restricțiilor impuse")

rezultat = determina_pozitie_finala(n, l, c, labirint, traseu)

with open("traseu2out.txt", "w") as fout:
fout.write(f"{rezultat[0]} {rezultat[1]}\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
main()

</syntaxhighlight>

1486 - Gropi

2023-12-28T21:52:19Z

Vasiliu Costel Andrei:

== Enunț ==
Gigel a primit de la prietenul său Programatorul o hartă a grădinii acestuia. Grădina are forma dreptunghiulară şi harta pe care a primit-o Gigel conţine informaţii despre starea culturii de pomi fructiferi. Mai precis ea conţine înălţimile fiecărui copac şi zonele în care s-au săpat gropi dar încă nu au fost plantaţi copaci. Harta grădinii poate fi reprezentată sub forma unei table dreptunghiulare cu N linii, numerotate de la 1 la N de sus în jos, şi M coloane, numerotate de la 1 la M de la stânga la dreapta. În fiecare celulă se află un număr real corespunzător înălţimii copacului sau valoarea 0 corespunzătoare unei gropi.

== Cerința ==
Cunoscând coordonatele unui punct de pe hartă ajutaţi-l pe Gigel să determine pe care dintre cele 8 direcţii N, NE, E, SE, S, SV, V, NV corespunzătoare acestui punct se află cele mai multe gropi.

== Date de intrare ==
Fișierul de intrare gropiin.txt conține pe prima linie patru numere: N, M reprezentând dimensiunile grădinii şi X, Y reprezentând coordonatele unui punct de pe hartă – linie şi coloană. Pe următoarele N linii sunt şiruri de câte M numere corespunzătoare copacilor respectiv gropilor.

== Date de ieșire ==
Fișierul de ieșire gropiout.txt va conține pe prima linie direcţia pe care se află cele mai multe gropi şi numărul acestora separate printr-un spațiu. Direcţia este indicată prin una din următoarele valori: N, NE, E, SE, S, SV, V, NV. Dacă sunt două direcţii cu acelaşi număr de gropi se va afişa ultima direcţie considerând sensul orar.

== Restricții și precizări ==
* 1 &les; '''N, M''' &les; 1.000
* 1 &les; '''X''' &les; '''N''', 1 &les; '''Y''' &les; '''M'''

== Exemplul 1 ==
; Intrare
; gropiin.txt
: 4 6 3 3
: 2.2 4.5 0 4.3 0 8.5
: 6.8 0 9.4 0 7.5 9.3
: 1.7 0 2.6 4.7 0 0
: 0 3.2 6.3 8.1 5.2 2.2
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; gropiout.txt
: E 2

=== Explicație ===
Din punctul de coordonate 3 3 pe direcţiile: 

* SE, S, SV nu se află nicio groapă 
* N, V, NV se afla câte o groapă 
* NE, E se află câte 2 gropi. 
Se va afişa ultima direcţie considerând sensul orar.

== Exemplul 2 ==
; Intrare
; gropiin.txt
: 1001 6 3 3
: 2.2 4.5 0 4.3 0 8.5
: 6.8 0 9.4 0 7.5 9.3
: 1.7 0 2.6 4.7 0 0
: 0 3.2 6.3 8.1 5.2 2.2
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1486 - Gropi

def validare_date(n, m, x, y):
if not (1 <= n <= 1000) or not (1 <= m <= 1000):
return False
if not (1 <= x <= n) or not (1 <= y <= m):
return False
return True

def numar_gropi_directie(harta, directie, x, y):
directii = {
'N': (-1, 0),
'NE': (-1, 1),
'E': (0, 1),
'SE': (1, 1),
'S': (1, 0),
'SV': (1, -1),
'V': (0, -1),
'NV': (-1, -1)
}

dx, dy = directii[directie]
numar_gropi = 0

while 1 <= x <= len(harta) and 1 <= y <= len(harta[0]):
if harta[x - 1][y - 1] == 0:
numar_gropi += 1
x, y = x + dx, y + dy

return numar_gropi

def determina_directie_maxima(x, y, harta):
directii = ['N', 'NE', 'E', 'SE', 'S', 'SV', 'V', 'NV']
max_gropi = -1
directie_maxima = None

for directie in directii:
x_temp, y_temp = x, y
numar_gropi = numar_gropi_directie(harta, directie, x_temp, y_temp)

if numar_gropi > max_gropi or (numar_gropi == max_gropi and directie_maxima is not None and directii.index(directie) > directii.index(directie_maxima)):
max_gropi = numar_gropi
directie_maxima = directie

return directie_maxima, max_gropi

def main():
with open("gropiin.txt", "r") as f:
n, m, x, y = map(int, f.readline().split())
harta = [list(map(float, f.readline().split())) for _ in range(n)]

if validare_date(n, m, x, y):
print("Datele de intrare corespund restricțiilor impuse")

directie, numar_gropi = determina_directie_maxima(x, y, harta)

with open("gropiout.txt", "w") as f:
f.write(f"{directie} {numar_gropi}\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
main()

</syntaxhighlight>

1486 - Gropi

2023-12-28T21:32:23Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Gigel a primit de la prietenul său Programatorul o hartă a grădinii acestuia. Grădina are forma dreptunghiulară şi harta pe care a primit-o Gigel conţine informaţii despre starea culturii de pomi fructiferi. Mai precis ea conţine înălţimile fiecărui copac şi zonele în care s-au săpat gropi dar încă nu au fost plantaţi copaci. Harta grădinii poate fi reprezentată sub forma unei table dreptunghiulare cu N linii, numerotate de la 1 la N de sus...

== Enunț ==
Gigel a primit de la prietenul său Programatorul o hartă a grădinii acestuia. Grădina are forma dreptunghiulară şi harta pe care a primit-o Gigel conţine informaţii despre starea culturii de pomi fructiferi. Mai precis ea conţine înălţimile fiecărui copac şi zonele în care s-au săpat gropi dar încă nu au fost plantaţi copaci. Harta grădinii poate fi reprezentată sub forma unei table dreptunghiulare cu N linii, numerotate de la 1 la N de sus în jos, şi M coloane, numerotate de la 1 la M de la stânga la dreapta. În fiecare celulă se află un număr real corespunzător înălţimii copacului sau valoarea 0 corespunzătoare unei gropi.

== Cerința ==
Cunoscând coordonatele unui punct de pe hartă ajutaţi-l pe Gigel să determine pe care dintre cele 8 direcţii N, NE, E, SE, S, SV, V, NV corespunzătoare acestui punct se află cele mai multe gropi.

== Date de intrare ==
Fișierul de intrare gropiin.txt conține pe prima linie patru numere: N, M reprezentând dimensiunile grădinii şi X, Y reprezentând coordonatele unui punct de pe hartă – linie şi coloană. Pe următoarele N linii sunt şiruri de câte M numere corespunzătoare copacilor respectiv gropilor.

== Date de ieșire ==
Fișierul de ieșire gropiout.txt va conține pe prima linie direcţia pe care se află cele mai multe gropi şi numărul acestora separate printr-un spațiu. Direcţia este indicată prin una din următoarele valori: N, NE, E, SE, S, SV, V, NV. Dacă sunt două direcţii cu acelaşi număr de gropi se va afişa ultima direcţie considerând sensul orar.

== Restricții și precizări ==
* 1 &les; '''N, M''' &les; 1.000
* 1 &les; '''X''' &les; '''N''', 1 &les; '''Y''' &les; '''M'''

== Exemplul 1 ==
; Intrare
; gropiin.txt
: 4 6 3 3
: 2.2 4.5 0 4.3 0 8.5
: 6.8 0 9.4 0 7.5 9.3
: 1.7 0 2.6 4.7 0 0
: 0 3.2 6.3 8.1 5.2 2.2
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; gropiout.txt
: E 2

=== Explicație ===
Din punctul de coordonate 3 3 pe direcţiile: 

* SE, S, SV nu se află nicio groapă 
* N, V, NV se afla câte o groapă 
* NE, E se află câte 2 gropi. 
Se va afişa ultima direcţie considerând sensul orar.

== Exemplul 2 ==
; Intrare
; gropiin.txt
: 1001 6 3 3
: 2.2 4.5 0 4.3 0 8.5
: 6.8 0 9.4 0 7.5 9.3
: 1.7 0 2.6 4.7 0 0
: 0 3.2 6.3 8.1 5.2 2.2
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1486 - Gropi

def validare_date(n, m, x, y):
if not (1 <= n <= 1000) or not (1 <= m <= 1000):
return False
if not (1 <= x <= n) or not (1 <= y <= m):
return False
return True

def numar_gropi_directie(harta, directie, x, y):
directii = {
'n': (-1, 0),
'nE': (-1, 1),
'E': (0, 1),
'SE': (1, 1),
'S': (1, 0),
'SV': (1, -1),
'V': (0, -1),
'nV': (-1, -1)
}

dx, dy = directii[directie]
numar_gropi = 0

while 1 <= x <= len(harta) and 1 <= y <= len(harta[0]):
if harta[x - 1][y - 1] == 0:
numar_gropi += 1
x, y = x + dx, y + dy

return numar_gropi

def determina_directie_maxima(x, y, harta):
directii = ['n', 'nE', 'E', 'SE', 'S', 'SV', 'V', 'nV']
max_gropi = -1
directie_maxima = None

for directie in directii:
x_temp, y_temp = x, y
numar_gropi = numar_gropi_directie(harta, directie, x_temp, y_temp)

if numar_gropi > max_gropi or (numar_gropi == max_gropi and directie_maxima is not None and directii.index(directie) > directii.index(directie_maxima)):
max_gropi = numar_gropi
directie_maxima = directie

return directie_maxima, max_gropi

def main():
with open("gropiin.txt", "r") as f:
n, m, x, y = map(int, f.readline().split())
harta = [list(map(float, f.readline().split())) for _ in range(n)]

if validare_date(n, m, x, y):
print("Datele de intrare corespund restricțiilor impuse")

directie, numar_gropi = determina_directie_maxima(x, y, harta)

with open("gropiout.txt", "w") as f:
f.write(f"{directie} {numar_gropi}\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
main()

</syntaxhighlight>

1076 - Grupe

2023-12-28T21:11:31Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Se consideră un tablou bidimensional cu m linii, n coloane şi elemente numere naturale. Pentru fiecare element se determină numărul de divizori pozitivi. Se formează apoi grupe cu elementele tabloului care au acelaşi număr de divizori, grupe notate G1, G2, …, Gk. Se ordonează descrescător grupele după numărul de elemente ce le conţin. Se ştie că o grupă G1 se află în faţa unei alte grupe G2 dacă G1 are mai multe elemente decât G2 sau, în ca...

== Enunț ==
Se consideră un tablou bidimensional cu m linii, n coloane şi elemente numere naturale. Pentru fiecare element se determină numărul de divizori pozitivi. Se formează apoi grupe cu elementele tabloului care au acelaşi număr de divizori, grupe notate G1, G2, …, Gk. Se ordonează descrescător grupele după numărul de elemente ce le conţin. Se ştie că o grupă G1 se află în faţa unei alte grupe G2 dacă G1 are mai multe elemente decât G2 sau, în cazul în care cele două grupe conţin acelaşi număr de elemente, numărul de divizori ai elementelor din grupa G1 este mai mare decât numărul de divizori ai elementelor din grupa G2. După ordonarea descrescătoare a grupelor, notăm prima grupă cu A şi a doua grupă cu B. În cazul în care toate elementele vor avea acelaşi număr de divizori, va exista o singură grupă, grupa A.

== Cerința ==
Scrieţi un program care citeşte m, n, elementele tabloului şi afişează: 
a) numărul de divizori pozitivi pentru grupa A, numărul de elemente din grupă şi cea mai mare valoare din grupă; 
b) numărul de divizori pozitivi pentru grupa B, numărul de elemente din grupă şi cea mai mare valoare din grupă; în cazul în care nu există grupa a doua, se va afişa de trei ori valoarea 0.

== Date de intrare ==
Fișierul de intrare grupein.txt conține pe prima linie valorile lui m şi n separate printr-un spaţiu, iar pe celelalte m linii câte n elemente separate două câte două printr-un spaţiu, reprezentând elementele tabloului.

== Date de ieșire ==
Fișierul de ieșire grupeout.txt va conține: 

* pe prima linie valoarea numărului de divizori pozitivi din grupa A, numărul de elemente din grupa A şi cea mai mare valoare din grupa A, valori separate două câte două printr-un singur spaţiu;
* pe a doua linie valoarea numărului de divizori pozitivi din grupa B, numărul de elemente din grupa B şi cea mai mare valoare din grupa B, valori separate două câte două printr-un singur spaţiu.

== Restricții și precizări ==
* 1 &les; '''n, m''' &les; 100
* elementele tabloului bidimensional iniţial sunt mai mici sau egale decât 100.000 şi mai mari decât 1;
* o grupă poate fi compusă dintr-un singur element.

== Exemplul 1 ==
; Intrare
; grupein.txt
: 2 3
: 16 2 4
: 10 6 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; grupeout.txt
: 4 2 10
: 2 2 5

=== Explicație ===
Numărul divizorilor pentru fiecare element al tabloului: 5 divizori (pentru valoarea 16), 2 divizori (pentru valoarea 2), 3 divizori (pentru valoarea 4), 4 divizori (pentru valoarea 10), 4 divizori (pentru valoarea 6) şi 2 divizori (pentru valoarea 5).

Se pot forma grupele: cu 2 divizori (elementele 2, 5), cu 4 divizori (elementele 10, 6), cu 3 divizori (elementul 4) şi cu 5 divizori (elementul 16). După ordonarea descrescătoare a grupelor, grupele cu cele mai multe elemente sunt cele care conţin 2 elemente: (10, 6), respectiv (2, 5). Pentru că elementele 10 şi 6 au 4 divizori, ele vor face parte din grupa A, iar 2 şi 5, având doar 2 divizori fiecare, vor face parte din grupa B. Deci grupa A are 4 divizori, 2 elemente şi cel mai mare element din grupă este 10, iar grupa B are 2 divizori, 2 elemente şi cel mai mare element din grupă este 5.

== Exemplul 2 ==
; Intrare
; grupein.txt
: 2 3
: 2 15 4
: 10 6 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse
: 4 3 15
: 2 2 5

=== Explicație ===
Numărul divizorilor pentru fiecare element al tabloului: 2 divizori (pentru valoarea 2), 4 divizori (pentru valoarea 15), 3 divizori (pentru valoarea 4), 4 divizori (pentru valoarea 10), 4 divizori (pentru valoarea 6) şi 2 divizori (pentru valoarea 5).

După ordonarea descrescătoare a grupelor, grupa cu cele mai multe elemente este cea formată din elementele 10, 6, 15, fiecare element având exact 4 divizori. Aceasta va fi grupa A. Grupa B va fi cea formată din două elemente, celelaltă grupă având un singur element. Deci grupa A are 4 divizori, 3 elemente şi cel mai mare element din grupă este 15, iar grupa B are 2 divizori, 2 elemente şi cel mai mare element din grupă este 5.

== Exemplul 3 ==
; Intrare
; grupein.txt
: 2 101
: 16 2 4
: 10 6 5
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1076 - Grupe

def validare_input(m, n, elemente):
if not (0 < m < 101 and 0 < n < 101):
return False

if len(elemente) != m:
return False

for linie in elemente:
if len(linie) != n:
return False

for element in linie:
if not (1 < element <= 100000):
return False

return True

def numara_divizorii(numar):
divizori = 0
for i in range(1, numar + 1):
if numar % i == 0:
divizori += 1
return divizori

def main():
with open("grupein.txt", "r") as fisier:
m, n = map(int, fisier.readline().split())
elemente = [list(map(int, fisier.readline().split())) for _ in range(m)]

if validare_input(m, n, elemente):
print("Datele de intrare corespund restricțiilor impuse")

grupe = {}

for linie in elemente:
for element in linie:
divizori = numara_divizorii(element)
if divizori not in grupe:
grupe[divizori] = []
grupe[divizori].append(element)

grupe_sortate = sorted(grupe.items(), key=lambda x: (len(x[1]), max(x[1])), reverse=True)

grupa_a = grupe_sortate[0]
grupa_b = grupe_sortate[1] if len(grupe_sortate) > 1 else (0, [])

with open("grupeout.txt", "w") as fisier_iesire:
fisier_iesire.write(f"{grupa_a[0]} {len(grupa_a[1])} {max(grupa_a[1])}\n")
fisier_iesire.write(f"{grupa_b[0]} {len(grupa_b[1])} {max(grupa_b[1])}\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
main()

</syntaxhighlight>

1378 - Flori2

2023-12-27T22:17:32Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Fetiţele din grupa mare de la grădiniţă culeg flori şi vor să împletească coroniţe pentru festivitatea de premiere. În grădină sunt mai multe tipuri de flori. Fiecare dintre cele n fetiţe culege un buchet având acelaşi număr de flori, însă nu neapărat de acelaşi tip. Pentru a împleti coroniţele fetiţele se împart în grupe. O fetiţă se poate ataşa unui grup numai dacă are cel puţin o floare de acelaşi tip cu cel puţin o altă fetiţ...

== Enunț ==
Fetiţele din grupa mare de la grădiniţă culeg flori şi vor să împletească coroniţe pentru festivitatea de premiere. În grădină sunt mai multe tipuri de flori. Fiecare dintre cele n fetiţe culege un buchet având acelaşi număr de flori, însă nu neapărat de acelaşi tip. Pentru a împleti coroniţele fetiţele se împart în grupe. O fetiţă se poate ataşa unui grup numai dacă are cel puţin o floare de acelaşi tip cu cel puţin o altă fetiţă din grupul respectiv.

== Cerința ==
Fiind dat un număr natural n reprezentând numărul fetiţelor şi numărul natural m reprezentând numărul de flori dintr-un buchet, să se determine grupele care se formează.

== Date de intrare ==
Fişierul de intrare flori2in.txt conţine pe prima linie, separate printr-un spaţiu, numerele naturale n şi m, reprezentând numărul de fetiţe şi respectiv numărul de flori din fiecare buchet. Fiecare dintre următoarele n linii conţine, pentru fiecare fetiţă, câte m valori separate prin câte un spaţiu reprezentând tipurile de flori culese.

== Date de ieșire ==
Fişierul de ieşire flori2out.txt va conţine pe fiecare linie câte o grupă formată din numerele de ordine ale fetiţelor separate prin câte un spaţiu, în ordine crescătoare, ca în exemplu.

== Restricții și precizări ==
* 1 &les; '''n''' &les; 150
* 1 &les; '''m''' &les; 100
* Tipul unei flori este un număr întreg din intervalul [0,100].
* Într-o grupă numerele de ordine ale fetiţelor trebuie date în ordine strict crescătoare.
* În fişierul de ieşire grupele vor fi afişate în ordinea crescătoare a numărului de ordine al primei fetiţe din grupă.

== Exemplul 1 ==
; Intrare
; flori2in.txt
: 5 4
: 1 2 3 4
: 5 6 9 6
: 1 1 1 1
: 2 4 4 3
: 7 7 7 7
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; flori2out.txt
: 1 3 4
: 2
: 5

=== Explicație ===
Fetiţele 1 şi 3 au cules amândouă flori de tipul 1, iar fetiţele 1 şi 4 au cules amândouă flori de tipurile 2, 3 şi 4, deci toate cele trei fetiţe (1, 3, 4) se vor afla în aceiaşi grupă. Fetiţele 2 şi 5 vor forma fiecare câte o grupă deoarece nu au cules flori de acelaşi tip cu nici una dintre celelalte fetiţe.

== Exemplul 2 ==
; Intrare
; flori2in.txt
: 151 4
: 1 2 3 4
: 5 6 9 6
: 1 1 1 1
: 2 4 4 3
: 7 7 7 7
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1378 - Flori2

def valideaza_input(n, m, flori_fete):
if not (1 <= n <= 150 and 1 <= m <= 100):
return False

for lista_flori in flori_fete:
if len(lista_flori) != m:
return False
for tip_floare in lista_flori:
if not (0 <= tip_floare <= 100):
return False

return True

def citeste_date_intrare():
with open("flori2in.txt", "r") as file:
n, m = map(int, file.readline().split())
flori_fete = [list(map(int, file.readline().split())) for _ in range(n)]
return n, m, flori_fete

def grupare_fete(n, flori_fete):
grupuri = []
vizitat = [False] * n

def dfs(nod, grup):
vizitat[nod] = True
grup.append(nod + 1)

for i in range(n):
if not vizitat[i] and any(flor in flori_fete[nod] for flor in flori_fete[i]):
dfs(i, grup)

for i in range(n):
if not vizitat[i]:
grup = []
dfs(i, grup)
grupuri.append(sorted(grup))

return grupuri

def scrie_date_iesire(grupuri):
with open("flori2out.txt", "w") as file:
for grup in grupuri:
file.write(" ".join(map(str, grup)) + "\n")

if __name__ == "__main__":
n, m, flori_fete = citeste_date_intrare()
if valideaza_input(n, m, flori_fete):
print("Datele de intrare corespund restricțiilor impuse")
rezultat = grupare_fete(n, flori_fete)
scrie_date_iesire(rezultat)
else:
print("Datele de intrare NU corespund restricțiilor impuse")

</syntaxhighlight>

1515 - Gradina

2023-12-27T20:31:30Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Păcală a reușit să ducă la bun sfârșit înțelegerea cu boierul căruia-i fusese slugă și, conform învoielii, boierul trebuie să-l răsplătească dându-i o parte din livada sa cu pomi fructiferi. Boierul este un om foarte ordonat, așa că livada sa este un pătrat cu latura de N metri unde, pe vremuri, fuseseră plantate N rânduri cu câte N pomi fiecare. Orice pom fructifer putea fi identificat cunoscând numărul rândului pe care se află și po...

== Enunț ==
Păcală a reușit să ducă la bun sfârșit înțelegerea cu boierul căruia-i fusese slugă și, conform învoielii, boierul trebuie să-l răsplătească dându-i o parte din livada sa cu pomi fructiferi. Boierul este un om foarte ordonat, așa că livada sa este un pătrat cu latura de N metri unde, pe vremuri, fuseseră plantate N rânduri cu câte N pomi fiecare. Orice pom fructifer putea fi identificat cunoscând numărul rândului pe care se află și poziția sa în cadrul rândului respectiv. Cu timpul, unii pomi s-au uscat şi acum mai sunt doar P pomi. Păcală trebuie să-și delimiteze în livadă o grădină pătrată cu latura de K metri.

== Cerința ==
Cunoscând dimensiunile livezii și grădinii, numărul pomilor din livadă și poziția fiecăruia, determinați numărul maxim de pomi dintr-o grădină pătrată de latură K și numărul modurilor în care poate fi amplasată grădina cu numărul maxim de pomi.

== Date de intrare ==
Fișierul gradinain.txt conține: 

* pe prima linie numerele naturale N, P și K, separate prin câte un spațiu, cu semnificaţia din enunţ; 
* pe următoarele P linii câte 2 numere naturale Lin și Col, separate printr-un spațiu, reprezentând numărul rândului, respectiv poziția în rând a fiecărui pom din livadă.

== Date de ieșire ==
Fișierul gradinaout.txt va conține: 

* pe prima linie numărul maxim de pomi fructiferi dintr-o grădină pătrată cu latura de K metri; 
* pe a doua linie numărul de posibilități de a amplasa grădina astfel încât să conțină numărul maxim de pomi determinat.

== Restricții și precizări ==
* 2 &les; '''N''' &les; 1.000
* 1 &les; '''P''' &les; N*N
* 1 &les; '''K''' &les; N

== Exemplul 1 ==
; Intrare
; gradinain.txt
: 12 10 5
: 4 3
: 5 5
: 6 8
: 7 3
: 7 7
: 8 8
: 9 3
: 9 6
: 10 10
: 11 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; gradinaout.txt
: 5
: 5

=== Explicație ===
Grădina lui Păcală poate avea maximum 5 pomi fructiferi. Ea poate fi amplasată în 5 moduri, având colțul stânga-sus de coordonate: (5, 3), (5, 4), (5, 5), (6, 6), (7, 3).

== Exemplul 2 ==
; Intrare
; gradinain.txt
: 1 10 5
: 4 3
: 5 5
: 6 8
: 7 3
: 7 7
: 8 8
: 9 3
: 9 6
: 10 10
: 11 5
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1515 - Gradina

def validare_date(n, p, k, pomii):
if not (2 <= n <= 1000) or not (1 <= p <= n*n) or not (1 <= k <= n):
return False

for lin, col in pomii:
if not (1 <= lin <= n) or not (1 <= col <= n):
return False

return True

def numar_maxim_pomi(n, p, k, pomii):
matrice_pomi = [[0] * n for _ in range(n)]

for i in range(p):
lin, col = pomii[i]
matrice_pomi[lin - 1][col - 1] = 1

max_pomi = 0
numar_posibilitati = 0

for i in range(n - k + 1):
for j in range(n - k + 1):
suma_pomi = sum(sum(matrice_pomi[i + x][j + y] for y in range(k)) for x in range(k))
if suma_pomi > max_pomi:
max_pomi = suma_pomi
numar_posibilitati = 1
elif suma_pomi == max_pomi:
numar_posibilitati += 1

return max_pomi, numar_posibilitati

def citire_date_input():
with open("gradinain.txt", "r") as f:
n, p, k = map(int, f.readline().split())
pomii = [tuple(map(int, f.readline().split())) for _ in range(p)]
return n, p, k, pomii

def scriere_date_output(max_pomi, numar_posibilitati):
with open("gradinaout.txt", "w") as f:
f.write(str(max_pomi) + "\n")
f.write(str(numar_posibilitati) + "\n")

if __name__ == "__main__":
n, p, k, pomii = citire_date_input()

if validare_date(n, p, k, pomii):
print("Datele de intrare corespund restricțiilor impuse")
max_pomi, numar_posibilitati = numar_maxim_pomi(n, p, k, pomii)
scriere_date_output(max_pomi, numar_posibilitati)
else:
print("Datele de intrare NU corespund restricțiilor impuse")

</syntaxhighlight>

3370 - Amedie

2023-12-27T20:15:15Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Pentru o matrice A cu n linii şi m coloane, ce conţine numere naturale, se defineşte amedia matricei A ca fiind valoarea situată la mijlocul şirului ordonat crescător format din toate elementele matricei A, dacă numărul de elemente din acest şir este impar, respectiv cea mai mică valoare dintre cele două valori situate la mijloc, dacă numărul de elemente din acest şir este par. Se definesc trei tipuri de operaţii ce pot fi aplicate matricei A: <br...

== Enunț ==

Pentru o matrice A cu n linii şi m coloane, ce conţine numere naturale, se defineşte amedia matricei A ca fiind valoarea situată la mijlocul şirului ordonat crescător format din toate elementele matricei A, dacă numărul de elemente din acest şir este impar, respectiv cea mai mică valoare dintre cele două valori situate la mijloc, dacă numărul de elemente din acest şir este par. Se definesc trei tipuri de operaţii ce pot fi aplicate matricei A: 

* operaţia de tip 1, notată cu L x, ce constă în eliminarea liniei cu indicele x din matrice; 
* operaţia de tip 2, notată cu C y, ce constă în eliminarea coloanei cu indicele y din matrice; 
* operaţia de tip 3, notată cu Q, ce are ca rezultat determinarea valorii amediei matricei. 
Ami este pasionată de matematică şi trebuie să rezolve următoarea problemă: pentru o matrice A asupra căreia se aplică un şir de astfel de operaţii, să se stabilească răspunsurile la toate operaţiile de tip 3.

== Cerința ==
Scrieţi un program care determină valorile obţinute în urma efectuării operaţiilor de tip 3 din şirul de operaţii aplicate matricei A.

== Date de intrare ==
Fișierul de intrare amediein.txt conţine pe prima linie trei numere naturale n, m şi q despărţite prin câte un spaţiu, ce reprezintă, în ordine, numărul de linii din matricea A, numărul de coloane din matricea A şi numărul de operaţii ce se aplică matricei A. Pe fiecare dintre următoarele n linii din fişier se află câte m numere naturale, separate prin câte un spaţiu, ce reprezintă, în ordine, elementele aflate pe liniile matricei A. Fiecare dintre următoarele q linii din fişier conţine un şir de caractere ce reprezintă o operaţie ce se va aplica matricei A.

== Date de ieșire ==
Fișierul de ieșire amedieout.txt va conţine valorile obţinute, în ordine, la toate operaţiile Q din şirul de operaţii aplicate matricei A. Fiecare dintre valorile obţinute se va afişa pe câte o linie din fişier, în ordinea stabilită în şirul de operaţii.

== Restricții și precizări ==
* 2 &les; '''n, m''' &les; 800
* 1 &les; '''q''' &les; 2.000
* elementele matricei A sunt numere naturale nenule, strict mai mici decât 100.001
* indicii de linie şi coloană din matrice sunt notaţi începând cu 1
* operaţiile de tipul 1 şi 2 se aplică utilizând indicii liniilor şi coloanelor din matricea A iniţială;
* se garantează că orice operaţie din fişierul de intrare poate fi efectuată.

== Exemplul 1 ==
; Intrare
; amediein.txt
: 4 4 4
: 1 2 3 4
: 5 6 7 8
: 9 10 11 12
: 13 14 15 16
: L 2
: Q
: C 1
: Q
; Ieșire
; Datele de intrare corespund restricțiilor impuse
; amedieout.txt
: 10
: 11

=== Explicație ===
L 2

!!

Prin aplicarea operaţiei de tip 3 obţinem valoarea 10.

C 1

!!

Prin aplicarea operaţiei de tip 3 obţinem valoarea 11.

== Exemplul 2 ==
; Intrare
; amediein.txt
: 1 801 0
: 1 2 3 4
: 5 6 7 8
: 9 10 11 12
: 13 14 15 16
: L 2
: Q
: C 1
: Q
; Ieșire
; Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3370 - Amedie

def valideaza_input(n, m, q, matrice, operatii):
if not (2 <= n <= 800) or not (2 <= m <= 800) or not (0 < q <= 2000):
return False

for rand in matrice:
if len(rand) != m or any(not(0 < int(elem) < 100001) for elem in rand):
return False

for op in operatii:
if op[0] == 'L':
if not (1 <= int(op[1]) <= n):
return False
elif op[0] == 'C':
if not (1 <= int(op[1]) <= m):
return False

return True

def calculeaza_mediana(matrice):
amedie = sorted([elem for rand in matrice for elem in rand])
mijloc = len(amedie) // 2

if len(amedie) % 2 == 1:
return amedie[mijloc]
else:
return min(amedie[mijloc - 1], amedie[mijloc])

def aplica_operatii(matrice, operatii):
rezultate = []

for op in operatii:
if op[0] == 'L':
del matrice[int(op[1]) - 1]
elif op[0] == 'C':
for rand in matrice:
del rand[int(op[1]) - 1]

elif op[0] == 'Q':
rezultate.append(calculeaza_mediana(matrice))

return rezultate

def main():
with open('amediein.txt', 'r') as infile:
n, m, q = map(int, infile.readline().split())
matrice = [list(map(int, infile.readline().split())) for _ in range(n)]
operatii = [linie.strip().split() for linie in infile]

if valideaza_input(n, m, q, matrice, operatii):
print("Datele de intrare corespund restricțiilor impuse")
rezultate = aplica_operatii(matrice, operatii)

with open('amedieout.txt', 'w') as outfile:
for rezultat in rezultate:
outfile.write(str(rezultat) + '\n')
else:
print("Datele de intrare NU corespund restricțiilor impuse")

if __name__ == "__main__":
main()

</syntaxhighlight>

3788 - Matricea

2023-12-18T11:57:18Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Se consideră o matrice binară B (cu valori 0 sau 1) cu N linii şi M coloane, liniile şi coloanele fiind numerotate de la 1 la N, respectiv de la 1 la M. Matricea B este generată după regula B[i][j] = R[i] xor C[j], unde R şi C sunt vectori binari de lungime N, respectiv M. Numim dreptunghi de colţuri (x1,y1) (x2,y2) cu x1 ≤ x2 şi y1 ≤ y2, mulţimea elementelor B[i][j] cu x1 ≤ i ≤ x2 și y1 ≤ j ≤ y2. Aria unui astfel de dreptunghi este (x2 - x...

== Enunț ==
Se consideră o matrice binară B (cu valori 0 sau 1) cu N linii şi M coloane, liniile şi coloanele fiind numerotate de la 1 la N, respectiv de la 1 la M. Matricea B este generată după regula B[i][j] = R[i] xor C[j], unde R şi C sunt vectori binari de lungime N, respectiv M. Numim dreptunghi de colţuri (x1,y1) (x2,y2) cu x1 ≤ x2 şi y1 ≤ y2, mulţimea elementelor B[i][j] cu x1 ≤ i ≤ x2 și y1 ≤ j ≤ y2. Aria unui astfel de dreptunghi este (x2 - x1 + 1) * (y2 - y1 + 1).

== Cerința ==
Determinaţi numărul maxim de elemente egale cu 0 într-un dreptunghi a cărui arie este exact A, precum şi numărul de dreptunghiuri pentru care se obţine acest număr maxim.

== Date de intrare ==
Fișierul de intrare matricein.txt conține pe prima linie pe prima linie numerele naturale N, M, A separate prin câte un spaţiu. A doua linie va conţine N valori 0 sau 1 separate prin câte un spaţiu, reprezentând elementele vectorului R, iar a treia linie va conţine M valori 0 sau 1 separate prin câte un spaţiu, reprezentând elementele vectorului C.

== Date de ieșire ==
Fișierul de ieșire matriceout.txt va conține o singură linie pe care vor fi scrise două numere naturale separate printr-un singur spaţiu Zmax Nsol, reprezentând în ordine numărul maxim de elemente egale cu 0 într-un dreptunghi a cărui arie este exact A, precum şi numărul de dreptunghiuri pentru care se obţine acest număr maxim.

== Restricții și precizări ==
* 1 &les; '''N, M''' &les; 30.000
* 1 &les; '''A''' &les; 5.000.000
* Prin xor se înţelege operatorul sau exclusiv (^ în C++). Mai exact: x ^ y = 1 dacă și numai dacă un operand este 0, iar celălalt 1, deci 0 ^ 0 = 0, 1 ^ 1 = 0, 0 ^ 1 = 1, 1 ^ 0 = 1.

== Exemplul 1 ==
; Intrare
; matricein.txt
: 2 4 4
: 0 1
: 1 0 0 1
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; matriceout.txt
: 2 5

=== Explicație ===
Matricea B este: 

1 0 0 1 
0 1 1 0 

Numărul maxim de valori 0 dintr-un dreptunghi de arie 4 este 2. Cele 5 dreptunghiuri de arie 4 cu număr maxim de 0 sunt: 

(1,1) (1,4) 
(2,1) (2,4) 
(1,1) (2,2) 
(1,2) (2,3) 
(1,3) (2,4) 

== Exemplul 2 ==
; Intrare
; matricein.txt
: 30001 4 4
: 0 1
: 1 0 0 1
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3788 - Matricea

def validare_date(n, m, a, r, c):
if not (1 <= n <= 30000) or not (1 <= m <= 30000) or not (1 <= a <= 5000000):
return False
if len(r) != n or len(c) != m:
return False
if not all(bit in {0, 1} for bit in r) or not all(bit in {0, 1} for bit in c):
return False
return True

def rezolva_problema(n, m, a, r, c):
if validare_date(n, m, a, r, c):
print("Datele de intrare corespund restricțiilor impuse")
matrice = [[0] * m for _ in range(n)]

for i in range(n):
for j in range(m):
matrice[i][j] = r[i] ^ c[j]

max_zeros = 0
numar_dreptunghiuri = 0

for x1 in range(n):
for y1 in range(m):
for x2 in range(x1, n):
for y2 in range(y1, m):
arie = (x2 - x1 + 1) * (y2 - y1 + 1)
if arie == a:
num_zeros = sum(matrice[i][j] == 0 for i in range(x1, x2 + 1) for j in range(y1, y2 + 1))
if num_zeros > max_zeros:
max_zeros = num_zeros
numar_dreptunghiuri = 1
elif num_zeros == max_zeros:
numar_dreptunghiuri += 1

with open("matriceout.txt", "w") as f_out:
f_out.write(f"{max_zeros} {numar_dreptunghiuri}\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

with open("matricein.txt", "r") as f:
n, m, a = map(int, f.readline().split())
r = list(map(int, f.readline().split()))
c = list(map(int, f.readline().split()))

rezolva_problema(n, m, a, r, c)

</syntaxhighlight>

1629 - Qmat

2023-12-18T11:28:03Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Spunem că două matrice a și b sunt egale dacă au același număr de linii n și același număr de coloane m și pentru orice pereche de indici i, j (1 ≤ i ≤ n, 1 ≤ j ≤ m) a[i][j] = b[i][j]. == Cerința == Se dau două seturi de N, respectiv Q matrice binare (cu valori 0 sau 1), pentru fiecare matrice fiind precizat numărul de linii respectiv de coloane. Să se afișeze numărul aparițiilor matricelor din al doilea set în primul. == Date de intra...

== Enunț ==
Spunem că două matrice a și b sunt egale dacă au același număr de linii n și același număr de coloane m și pentru orice pereche de indici i, j (1 ≤ i ≤ n, 1 ≤ j ≤ m) a[i][j] = b[i][j].

== Cerința ==
Se dau două seturi de N, respectiv Q matrice binare (cu valori 0 sau 1), pentru fiecare matrice fiind precizat numărul de linii respectiv de coloane. Să se afișeze numărul aparițiilor matricelor din al doilea set în primul.

== Date de intrare ==
Fișierul de intrare qmatin.txt conține pe prima linie numărul N, urmat de N matrice, M1, M2, … Mn. Pentru fiecare matrice Mi este precizat, pe o linie, separate printr-un spațiu, numărul de linii li, respectiv de coloane ci, iar pe următoarele li linii câte ci cifre binare separate prin câte un spațiu. După cele N matrice se află și numărul Q urmat de asemenea de Q matrice descrise la fel ca și cele anterioare.

== Date de ieșire ==
Fișierul de ieșire qmatout.txt va conține pe prima linie numărul sol, reprezentând numărul de matrice din al doilea set ce apar în primul.

== Restricții și precizări ==
* 1 &les; '''n, q''' &les; 10.000
* pentru orice matrice dată 1 ≤ nr. de linii, nr. de coloane ≤ 10

== Exemplul 1 ==
; Intrare
; qmatin.txt
: 5
: 2 6
: 0 0 0 1 1 1
: 1 0 1 1 0 0
: 7 4
: 0 0 0 1
: 0 0 0 0
: 0 1 1 0
: 0 1 1 0
: 1 1 1 1
: 0 1 0 0
: 0 1 0 1
: 5 1
: 0
: 0
: 1
: 0
: 1
: 3 5
: 0 1 1 1 1
: 1 1 1 0 0
: 0 0 1 1 0
: 9 2
: 0 1
: 1 1
: 1 1
: 1 0
: 1 1
: 0 1
: 0 1
: 0 0
: 1 1
: 3
: 3 5
: 0 1 1 1 1
: 1 1 1 0 0
: 0 0 1 1 0
: 9 2
: 0 1
: 1 1
: 1 1
: 1 0
: 1 1
: 0 1
: 0 1
: 0 0
: 1 1
: 2 3
: 1 1 1
: 1 1 1
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; qmatout.txt
: 2

== Exemplul 2 ==
; Intrare
; qmatin.txt
: 5
: 2 6
: 2 0 0 1 1 1
: 1 0 1 1 0 0
: 7 4
: 0 0 0 1
: 0 0 0 0
: 0 1 1 0
: 0 1 1 0
: 1 1 1 1
: 0 1 0 0
: 0 1 0 1
: 5 1
: 0
: 0
: 1
: 0
: 1
: 3 5
: 0 1 1 1 1
: 1 1 1 0 0
: 0 0 1 1 0
: 9 2
: 0 1
: 1 1
: 1 1
: 1 0
: 1 1
: 0 1
: 0 1
: 0 0
: 1 1
: 3
: 3 5
: 0 1 1 1 1
: 1 1 1 0 0
: 0 0 1 1 0
: 9 2
: 0 1
: 1 1
: 1 1
: 1 0
: 1 1
: 0 1
: 0 1
: 0 0
: 1 1
: 2 3
: 1 1 1
: 1 1 1
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1629 - Qmat

def este_matrice_valida(matrice):
if len(matrice) == 0 or len(matrice[0]) == 0:
return False

lungime_rand = len(matrice[0])
if any(len(rand) != lungime_rand for rand in matrice):
return False

if any(element not in (0, 1) for rand in matrice for element in rand):
return False

return True

def citeste_matrice(fisier):
nr_randuri, nr_coloane = map(int, fisier.readline().split())
matrice = [list(map(int, fisier.readline().split())) for _ in range(nr_randuri)]
return matrice

def numara_aparitii(set_matrice_1, set_matrice_2):
numar_aparitii = 0
for matrice_2 in set_matrice_2:
for matrice_1 in set_matrice_1:
if matrice_1 == matrice_2:
numar_aparitii += 1
break
return numar_aparitii

def main():
with open("qmatin.txt", "r") as fisier:
n = int(fisier.readline())
set_matrice_1 = [citeste_matrice(fisier) for _ in range(n)]

q = int(fisier.readline())
set_matrice_2 = [citeste_matrice(fisier) for _ in range(q)]

if all(este_matrice_valida(matrice) for set_matrice in [set_matrice_1, set_matrice_2] for matrice in set_matrice):
print("Datele de intrare corespund restricțiilor impuse")
rezultat = numara_aparitii(set_matrice_1, set_matrice_2)
with open("qmatout.txt", "w") as fisier_out:
fisier_out.write(str(rezultat))
else:
print("Datele de intrare NU corespund restricțiilor impuse")

if __name__ == "__main__":
main()

</syntaxhighlight>

0969 - Culori1

2023-12-18T10:35:01Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Într-o cameră sunt aşezate n*m acvarii identice, pe n rânduri, câte m pe fiecare rând, unul lângă altul. În fiecare acvariu se află un singur peşte. Peştele poate fi de culoare roşie (culoare codificată cu r) sau albastră (codificată cu a). La fiecare moment de timp t=1,2,3,.., peştii îşi modifică simultan culoarea astfel: fiecare peşte se colorează în culoarea pe care au avut-o la momentul t-1 majoritatea peştilor din acvariile învecinat...

== Enunț ==
Într-o cameră sunt aşezate n*m acvarii identice, pe n rânduri, câte m pe fiecare rând, unul lângă altul. În fiecare acvariu se află un singur peşte. Peştele poate fi de culoare roşie (culoare codificată cu r) sau albastră (codificată cu a). La fiecare moment de timp t=1,2,3,.., peştii îşi modifică simultan culoarea astfel: fiecare peşte se colorează în culoarea pe care au avut-o la momentul t-1 majoritatea peştilor din acvariile învecinate (ca în desenul de mai jos, sunt cel mult 8 acvarii vecine notate cu V1, V2, V3,…, V8). În cazul în care numărul peştilor vecini roşii este egal cu numărul peştilor vecini albaştrii, peştele studiat îşi va păstra culoarea.

== Cerința ==
Scrieţi un program care să citească numerele naturale n, m, t şi cele n*m coduri ale culorilor peştilor (cele de la momentul iniţial t=0) şi care să determine şi să afişeze codurile culorilor peştilor de la momentul t.

== Date de intrare ==
Fișierul de intrare culori1in.txt conține

* pe prima linie numerele naturale n, m şi t, separate printr-un singur spaţiu, cu semnificaţia din enunț
* pe următoarele n linii se află câte m caractere r sau a, pentru fiecare rând de acvarii, format astfel:
**dacă peştele din acvariul cu numărul de ordine i (1≤i≤m) din rândul curent este roşu, atunci cel de-al i-lea caracter din linia fişierului de intrare, corespunzătoare rândului curent, este r
**dacă peştele din acvariul cu numărul de ordine i (1≤i≤m) din rândul curent este albastru atunci cel de-al i-lea caracter din linia fişierului de intrare, corespunzătoare rândului curent, este a

== Date de ieșire ==
Fișierul de ieșire culori1out.txt va conține n linii, fiecare linie va conţine câte m caractere r sau a, reprezentând codurile culorilor peştilor din rândul corespunzător numărului liniei curente din fişier.

== Restricții și precizări ==
* 2 &les; '''n, m''' &les; 49
* 1 &les; '''t''' &les; 2.300.000

== Exemplul 1 ==
; Intrare
; culori1in.txt
: 3 3 1
: rar
: rra
: arr
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; culori1out.txt
: rra
: rrr
: rrr

== Exemplul 2 ==
; Intrare
; culori1in.txt
: 4 5 3
: rrara
: aarra
: aarrr
: rrraa
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; culori1out.txt
: aarrr
: aarrr
: rrrrr
: rrrrr

== Exemplul 3 ==
; Intrare
; culori1in.txt
: 1 5 3
: rrara
: aarra
: aarrr
: rrraa
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0969 - Culori1

def validare_date_intrare(n, m, t, culori):
if not (2 <= n < 50 and 2 <= m < 50):
return False
if not (1 <= t <= 2300000):
return False
if len(culori) != n:
return False
for linie in culori:
if len(linie) != m:
return False
if not all(caracter in {'r', 'a'} for caracter in linie):
return False
return True

def modifica_culori(n, m, t, culori):
directii = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def numar_vecini(x, y):
vecini_rosii = 0
vecini_albastri = 0
for dx, dy in directii:
nx, ny = x + dx, y + dy
if 0 <= nx < n and 0 <= ny < m:
if culori[nx][ny] == 'r':
vecini_rosii += 1
elif culori[nx][ny] == 'a':
vecini_albastri += 1
return vecini_rosii, vecini_albastri

def actualizeaza_culoare(x, y):
vecini_rosii, vecini_albastri = numar_vecini(x, y)
if vecini_rosii > vecini_albastri:
return 'r'
elif vecini_rosii < vecini_albastri:
return 'a'
else:
return culori[x][y]

for _ in range(t):
noua_culoare = [[''] * m for _ in range(n)]
for i in range(n):
for j in range(m):
noua_culoare[i][j] = actualizeaza_culoare(i, j)
culori = [''.join(row) for row in noua_culoare]

return culori

if __name__ == "__main__":
with open("culori1in.txt", "r") as fin:
n, m, t = map(int, fin.readline().split())
culori = [fin.readline().strip() for _ in range(n)]

if validare_date_intrare(n, m, t, culori):
print("Datele de intrare corespund restricțiilor impuse")
rezultat = modifica_culori(n, m, t, culori)
with open("culori1out.txt", "w") as fout:
fout.write('\n'.join(rezultat))
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

2451 - Mexitate

2023-12-17T19:33:54Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Se dă o matrice A cu N linii și M coloane cu elemente numere naturale nu neapărat distincte. Pentru o submatrice definim mex-ul acesteia ca fiind cea mai mică valoare naturală nenulă care nu apare în aceasta. == Cerința == Să se calculeze produsul mex-urilor tuturor submatricelor având K linii și L coloane ale matricei A. == Date de intrare == Fișierul de intrare mexitatein.txt conține pe prima linie patru numere naturale N, M, K şi L separate pri...

== Enunț ==
Se dă o matrice A cu N linii și M coloane cu elemente numere naturale nu neapărat distincte. Pentru o submatrice definim mex-ul acesteia ca fiind cea mai mică valoare naturală nenulă care nu apare în aceasta.

== Cerința ==
Să se calculeze produsul mex-urilor tuturor submatricelor având K linii și L coloane ale matricei A.

== Date de intrare ==
Fișierul de intrare mexitatein.txt conține pe prima linie patru numere naturale N, M, K şi L separate printr-un spaţiu cu semnificația din enunț. Pe fiecare dintre următoarele N linii se află câte M numere naturale nenule, despărțite prin câte un spațiu, reprezentând valorile matricei.

== Date de ieșire ==
Fișierul de ieșire mexitateout.txt va conține un singur număr natural reprezentând produsul mex-urilor tuturor submatricelor având K linii și L coloane ale matricei modulo 1 000 000 007.

== Restricții și precizări ==
* 1 &les; '''N * M''' &les; 400.000
* 1 &les; '''K''' &les; N
* 1 &les; '''L''' &les; M
* 1 &les; '''A[i][j]''' &les; N * M, 1 &les; '''i''' &les; N, 1 &les; '''J''' &les; M

== Exemplul 1 ==
; Intrare
; mexitatein.txt
: 3 4 2 3
: 1 2 3 2
: 2 3 1 4
: 1 1 2 6
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; mexitateout.txt
: 400

=== Explicație ===
N = 3, M = 4, K = 2 și L = 3 
Submatricile cu două linii și trei coloane sunt: 
1 2 3 cu mex-ul 4 
2 3 1
 
2 3 2 cu mex-ul 5 
3 1 4
 
2 3 1 cu mex-ul 4 
1 1 2
 
3 1 4 cu mex-ul 5 
1 2 6

Produsul tuturor mex-urilor este: 4 * 5 * 4 * 5 = 400 
400 % 1 000 000 007 = 400

== Exemplul 2 ==
; Intrare
; mexitatein.txt
: 3 4 4 3
: 1 2 3 2
: 2 3 1 4
: 1 1 2 6
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2451 - Mexitate

MOD = 1000000007

def validare_date(n, m, nr_linii, nr_coloane, matrice):
if not (1 <= n * m <= 400000 and 1 <= nr_linii <= n and 1 <= nr_coloane <= m):
return False
for i in range(n):
for j in range(m):
if not (1 <= matrice[i][j] <= n * m):
return False
return True

def mex(n, m, nr_linii, nr_coloane, matrice):
result = 1
for i in range(n - nr_linii + 1):
for j in range(m - nr_coloane + 1):
submatrice = [linie[j:j+nr_coloane] for linie in matrice[i:i+nr_linii]]
valori = set()
for linie in submatrice:
valori.update(linie)
mex = 1
while mex in valori:
mex += 1
result = (result * mex) % MOD
return result

def main():
with open("mexitatein.txt", "r") as fin:
n, m, nr_linii, nr_coloane = map(int, fin.readline().split())
matrice = [list(map(int, fin.readline().split())) for _ in range(n)]

if validare_date(n, m, nr_linii, nr_coloane, matrice):
print("Datele de intrare corespund restricțiilor impuse")
result = mex(n, m, nr_linii, nr_coloane, matrice)
with open("mexitateout.txt", "w") as fout:
fout.write(str(result))
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
main()

</syntaxhighlight>

3290 - Mat D3

2023-12-17T19:09:09Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Fie o matrice cu L linii și C coloane care memorează numere naturale. O submatrice a sa având colțul stânga-sus (xs, ys) și colțul dreapta-jos (xd, yd) este formată din toate elementele din matrice având indicele liniei în intervalul [xs, xd] și indicele coloanei în intervalul [ys, yd]. O submatrice poate fi formată dintr-un singur element. == Cerința == Scrieți un program care determină numărul submatricelor care au suma elementelor divizibilă...

== Enunț ==
Fie o matrice cu L linii și C coloane care memorează numere naturale. O submatrice a sa având colțul stânga-sus (xs, ys) și colțul dreapta-jos (xd, yd) este formată din toate elementele din matrice având indicele liniei în intervalul [xs, xd] și indicele coloanei în intervalul [ys, yd]. O submatrice poate fi formată dintr-un singur element.

== Cerința ==
Scrieți un program care determină numărul submatricelor care au suma elementelor divizibilă cu 3.

== Date de intrare ==
Fișierul de intrare matd3in.txt conține pe prima linie numerele naturale L și C separate prin spațiu. Pe următoarele L linii se află câte C numere naturale separate prin câte un spațiu reprezentând câte o linie din matrice.

== Date de ieșire ==
Fișierul de ieșire matd3out.txt va conține pe prima linie un singur număr natural K, reprezentând numărul submatricelor care au suma divizibilă cu 3.

== Restricții și precizări ==
* 2 &les; '''L, C''' &les; 300
* elementele matricei sunt numere naturale cuprinse între 0 și 10.000
* numărul 0 este divizibil cu 3

== Exemplul 1 ==
; Intrare
; matd3in.txt
: 2 3
: 1 2 2
: 2 1 3
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; matd3out.txt
: 7

=== Explicație ===
Cele șapte submatrice sunt:

(1 2) 
(2 1) 
(2 1 3) 
(3) 
(1 2) 
(2 1) 
(1 2 2 1)

== Exemplul 2 ==
; Intrare
; matd3in.txt
: 1 3
: 1 2 2
: 2 1 3
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3290 - Matd3

def validare_date(linii, coloane, matrice):
if not (2 <= linii <= 300 and 2 <= coloane <= 300):
return False
for randuri in matrice:
if len(randuri) != coloane or any(not (0 <= numere <= 10000) for numere in randuri):
return False
return True

def numarare_submatrici(linii, coloane, matrice):
count = 0
for xs in range(linii):
for ys in range(coloane):
for xd in range(xs, linii):
for yd in range(ys, coloane):
submatrice_sum = sum(matrice[i][j] for i in range(xs, xd + 1) for j in range(ys, yd + 1))
if submatrice_sum % 3 == 0:
count += 1
return count

def main():
with open("matd3in.txt", "r") as file:
linii, coloane = map(int, file.readline().split())
matrice = [list(map(int, line.split())) for line in file]

if validare_date(linii, coloane, matrice):
print("Datele de intrare corespund restricțiilor impuse")
result = numarare_submatrici(linii, coloane, matrice)
with open("matd3out.txt", "w") as file_out:
file_out.write(str(result))
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
main()

</syntaxhighlight>

1209 - T Drept

2023-12-17T17:51:48Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Se consideră N puncte de coordonate întregi în sistemul de coordonate cartezian. == Cerința == Scrieţi un program care determină numărul de triunghiuri dreptunghice având vârfurile plasate în 3 dintre punctele date şi catetele respectiv paralele cu axele de coordonate. == Date de intrare == Fișierul de intrare tdreptin.txt conține pe prima linie numărul natural N, care reprezintă numărul de puncte. Pe următoarele N linii se află câte două nu...

== Enunț ==
Se consideră N puncte de coordonate întregi în sistemul de coordonate cartezian.

== Cerința ==
Scrieţi un program care determină numărul de triunghiuri dreptunghice având vârfurile plasate în 3 dintre punctele date şi catetele respectiv paralele cu axele de coordonate.

== Date de intrare ==
Fișierul de intrare tdreptin.txt conține pe prima linie numărul natural N, care reprezintă numărul de puncte. Pe următoarele N linii se află câte două numere naturale x y, separate prin spaţiu, reprezentând coordonatele carteziene ale celor N puncte (abscisa şi ordonata).

== Date de ieșire ==
Fișierul de ieșire tdreptout.txt va conține o singură linie pe care va fi scris un număr natural reprezentând numărul de triunghiuri dreptunghice care respectă condiţiile din enunţ. Deoarece numărul de soluţii poate fi foarte mare, rezultatul va fi afişat modulo 666013 (adică restul împărţirii rezultatului la 666013).

== Restricții și precizări ==
* 3 &les; '''N''' &les; 100.000
* 0 &les; '''x, y''' &les; 100.000
* Cele N puncte din fişierul de intrare sunt distincte două câte două.

== Exemplul 1 ==
; Intrare
; tdreptin.txt
: 8
: 1 1
: 1 4
: 10 8
: 4 1
: 9 1
: 5 5
: 7 4
: 7 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; tdreptout.txt
: 5

=== Explicație ===
Triunghiurile dreptunghice formate sunt:

(1,1) (1,4) (4,1) 
(1,1) (9,1) (1,4) 
(5,5) (7,4) (7,5) 
(1,4) (7,4) (7,5) 
(1,1) (1,4) (7,4) 

== Exemplul 2 ==
; Intrare
; tdreptin.txt
: 2
: 1 1
: 1 4
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1209 - TDrept

def validare_date(x, y):
return 3 <= len(x) <= 100000 and all(0 <= xi <= 100000 and 0 <= yi <= 100000 for xi, yi in zip(x, y))

def numar_triunghiuri_dreptunghice(x, y):
n = len(x)
rezultat = 0

for i in range(n):
for j in range(i + 1, n):
for k in range(j + 1, n):
if (x[i] == x[j] or x[j] == x[k] or x[i] == x[k]) and \
(y[i] == y[j] or y[j] == y[k] or y[i] == y[k]):
rezultat += 1
return rezultat % 666013

def citire_date():
with open("tdreptin.txt", "r") as f:
n = int(f.readline().strip())
x = []
y = []
for _ in range(n):
xi, yi = map(int, f.readline().split())
x.append(xi)
y.append(yi)
return n, x, y

def scrie_rezultat(rezultat):
with open("tdreptout.txt", "w") as f:
f.write(str(rezultat))

if __name__ == "__main__":
n, x, y = citire_date()

if validare_date(x, y):
print("Datele de intrare corespund restricțiilor impuse")
rezultat = numar_triunghiuri_dreptunghice(x, y)
scrie_rezultat(rezultat)
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

1637 - Split

2023-12-17T17:32:28Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Fie un şir a1,a2,…,an de numere naturale. Se împarte şirul în patru secvenţe astfel încât orice element din şir să aparţină unei singure secvenţe şi fiecare secvenţă să conţină cel puţin două elemente. Mai exact, se identifică trei indici i < j < k astfel încât prima secvenţă este formată din elementele a1,a2,…,ai, a doua din elementele ai+1,ai+2,…,aj, a treia din elementele aj+1,aj+2,…,ak şi ultima din elementele ak+1,ak+2,…,...

== Enunț ==
Fie un şir a1,a2,…,an de numere naturale. Se împarte şirul în patru secvenţe astfel încât orice element din şir să aparţină unei singure secvenţe şi fiecare secvenţă să conţină cel puţin două elemente. Mai exact, se identifică trei indici i < j < k astfel încât prima secvenţă este formată din elementele a1,a2,…,ai, a doua din elementele ai+1,ai+2,…,aj, a treia din elementele aj+1,aj+2,…,ak şi ultima din elementele ak+1,ak+2,…,an. Pentru fiecare secvenţă se determină costul ei ca fiind diferenţa dintre valoarea maximă şi cea minimă din acea secvenţă.

== Cerința ==
Să se determine o împărţire a şirului în patru secvenţe astfel încât suma costurilor celor patru secvenţe să fie maximă.

== Date de intrare ==
Fișierul de intrare splitin.txt conţine pe prima linie numărul natural N. Pe linia a doua se găsesc N numere naturale, separate prin câte un spaţiu, reprezentând elementele şirului a.

== Date de ieșire ==
Fișierul de ieșire splitout.txt conţine pe prima linie un singur număr natural reprezentând suma maximă a costurilor celor patru secvenţe. Pe linia a doua se află trei numere naturale i, j şi k, separate prin câte un spaţiu, cu semnificaţia din enunţ.

== Restricții și precizări ==
* 8 &les; '''N''' &les; 5.000
* 0 &les; '''Ai''' &les; 100.000.000
* O secvenţă poate avea costul 0 (valoarea maximă egală cu valoarea minimă)
* Dacă există mai multe soluţii cu aceeaşi sumă maximă, atunci se va alege soluţia cu i minim. Dacă există mai multe soluții cu acelaşi i minim, se alege aceea cu j minim, iar dacă există mai multe soluții cu acelaşi i și j minim, se alege aceea cu k minim.

== Exemplul 1 ==
; Intrare
; splitin.txt
: 11
: 9 7 3 0 2 1 8 6 0 11 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; splitout.txt
: 29
: 4 7 9

=== Explicație ===
Cele 4 secvențe sunt: 9 7 3 0 (cost 9 - 0 = 9) 
2 1 8 (cost 8 - 1 = 7) 
6 0 (cost 6 - 0 = 6) 
11 4 (cost 11 - 4 = 7). 
O altă soluţie care obţine tot suma maximă 29 este 5 7 9, dar nu are i minim.

== Exemplul 2 ==
; Intrare
; splitin.txt
: 5
: 9 7 3 0 2
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1637 - Split

def validare_date(n, sir):
if not (8 <= n <= 5000):
return False
if len(sir) != n:
return False
for elem in sir:
if not (0 <= elem <= 100000000):
return False
return True

def maximizeaza_suma(n, sir):
suma_maxima = float('-inf')
rezultat = (0, 0, 0)

for i in range(1, n - 1):
for j in range(i + 1, n):
for k in range(j + 1, n + 1):
secventa1 = sir[:i]
secventa2 = sir[i:j]
secventa3 = sir[j:k]
secventa4 = sir[k:]

if not secventa1 or not secventa2 or not secventa3 or not secventa4:
continue

cost1 = max(secventa1) - min(secventa1)
cost2 = max(secventa2) - min(secventa2)
cost3 = max(secventa3) - min(secventa3)
cost4 = max(secventa4) - min(secventa4)

suma_curenta = cost1 + cost2 + cost3 + cost4

if suma_curenta > suma_maxima:
suma_maxima = suma_curenta
rezultat = (i, j, k)

return suma_maxima, rezultat

with open("splitin.txt", "r") as f:
n = int(f.readline().strip())
sir = list(map(int, f.readline().split()))

if validare_date(n, sir):
print("Datele de intrare corespund restricțiilor impuse")
rezultat_suma, rezultat_secvente = maximizeaza_suma(n, sir)
with open("splitout.txt", "w") as g:
g.write(str(rezultat_suma) + "\n")
g.write(" ".join(map(str, rezultat_secvente)))
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

1695 - Oglinda

2023-12-17T16:45:58Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Pentru un număr natural N se consideră șirul a=(1,2,3...,N), deci a[i]=i pentru orice i, 1≤i≤N. Asupra acestui șir se pot aplica operații de două tipuri: a) la operația de tipul 1 se specifică două valori i și j, cu 1≤i≤j≤N. Efectul acestei operații asupra șirului este de oglindire a secvenței din șir care începe cu elementul de pe poziția i și se termină cu cel de pe poziția j. De exemplu, dacă în șirul a=(1,2,3,4,5,6,7) se apli...

== Enunț ==
Pentru un număr natural N se consideră șirul a=(1,2,3...,N), deci a[i]=i pentru orice i, 1≤i≤N.

Asupra acestui șir se pot aplica operații de două tipuri:

a) la operația de tipul 1 se specifică două valori i și j, cu 1≤i≤j≤N. Efectul acestei operații asupra șirului este de oglindire a secvenței din șir care începe cu elementul de pe poziția i și se termină cu cel de pe poziția j. De exemplu, dacă în șirul a=(1,2,3,4,5,6,7) se aplică operația 3 6, atunci șirul devine a=(1,2,6,5,4,3,7). Iar în șirul a=(1,4,3,2,5,6,7), dacă se aplică operația 4 6, atunci a=(1,4,3,6,5,2,7). 
b) Operația de tipul 2 conține un indice i, 1≤i≤N, și cere să afișăm valoarea elementului care se află în acel moment pe poziția i în șir.

Se consideră M astfel de operații într-o ordine dată.

== Cerința ==
Scrieți un program care să determine și să afișeze rezultatul pentru fiecare operație de tipul 2.

== Date de intrare ==
Fișierul de intrare oglindain.txt conține pe prima linie două numere naturale N și M, separate printr-un spațiu. Pe fiecare dintre următoarele M linii este specificată câte o operație de tipul 1 sau 2. O linie poate să conțină două sau trei numere, astfel: 1 i j (indicând o operație de tipul 1) respectiv 2 i (indicând o operație de tip 2). Valorile de pe aceeași linie sunt separate prin câte un spațiu.

== Date de ieșire ==
Fișierul de ieșire oglindaout.txt va conține un număr de linii egal cu numărul de operații de tipul 2 care sunt definite în fișierul de intrare. Pe fiecare linie este afișat câte un număr natural reprezintând rezultatul pentru o operație de tip 2 prezentă în fișierul de intrare, în ordinea în care acestea sunt definite.

== Restricții și precizări ==
* 1 &les; '''N''' &les; 1.000.000
* 1 &les; '''M''' &les; 2.000
* Se garantează că 1 ≤ i ≤ j ≤ N la operațiile de tipul 1 și că 1 ≤ i ≤ N la operațiile de tip 2.
* Se garantează că există cel puțin o operație de tipul 2.

== Exemplul 1 ==
; Intrare
; oglindain.txt
: 10 4
: 2 3
: 1 2 7
: 2 3
: 2 1
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; oglindaout.txt
: 3
: 6
: 1

=== Explicație ===
Șirul inițial este: 1 2 3 4 5 6 7 8 9 10 
Rezultatul operației 2 3 are ca efect afișarea elementului de pe poziția 3 (care este chiar 3). 
Rezultatul operației 1 2 7 are ca efect transformarea șirului în: 
1 7 6 5 4 3 2 8 9 10. 
Rezultatul operației 2 3 are ca efect afișarea elementului de pe poziția 3 (care acum este 6). 
Rezultatul operației 2 1 are ca efect afișarea elementului de pe poziția 1 (care acum are valoarea 1). 

== Exemplul 2 ==
; Intrare
; oglindain.txt
: 10 2023
: 2 3
: 1 2 7
: 2 3
: 2 1
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1695 - Oglinda

def oglinda(n, operatii):
sir = list(range(1, n + 1))
rezultate = []
for operatie in operatii:
tip = operatie[0]
if tip == 1:
i, j = operatie[1], operatie[2]
sir[i - 1:j] = reversed(sir[i - 1:j])
elif tip == 2:
i = operatie[1]
rezultate.append(sir[i - 1])
with open("oglindaout.txt", "w") as output_file:
for rezultat in rezultate:
output_file.write(str(rezultat) + "\n")

def validare_date(n, m, operatii):
if not (1 <= n <= 1000000):
return False
if not (1 <= m <= 2000):
return False
for operatie in operatii:
tip = operatie[0]
if tip == 1:
i, j = operatie[1], operatie[2]
if not (1 <= i <= j <= n):
return False
elif tip == 2:
i = operatie[1]
if not (1 <= i <= n):
return False
return True

if __name__ == "__main__":
with open("oglindain.txt", "r") as f:
n, m = map(int, f.readline().split())
operatii = [list(map(int, line.split())) for line in f]
if validare_date(n, m, operatii):
print("Datele de intrare corespund restricțiilor impuse")
oglinda(n, operatii)
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

1474 - Exponent

2023-12-17T16:13:19Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Softescu a învăţat azi la şcoală, la ora de informatică algoritmul determinării exponentului unui număr natural prim p în descompunerea în factori primi a lui n!. Softescu s-a gândit că ar fi interesant dacă ar putea să elaboreze un algoritm care să determine exponentul unui număr natural oarecare, a (a>1) în descompunerea în factori primi a lui n!. == Cerința == Dându-se două numere naturale n şi a, nenule, se cere să se determine exponen...

== Enunț ==
Softescu a învăţat azi la şcoală, la ora de informatică algoritmul determinării exponentului unui număr natural prim p în descompunerea în factori primi a lui n!.
Softescu s-a gândit că ar fi interesant dacă ar putea să elaboreze un algoritm care să determine exponentul unui număr natural oarecare, a (a>1) în descompunerea în factori primi a lui n!.

== Cerința ==
Dându-se două numere naturale n şi a, nenule, se cere să se determine exponentul numărului natural a în descompunerea lui n!.

== Date de intrare ==
Fişierul de intrare exponentin.txt conţine pe prima linie două numere naturale, nenule, n a separate printr-un spațiu.

== Date de ieșire ==
Fişierul de ieşire exponentout.txt va conţine pe prima linie un număr natural e, reprezentând exponentul numărului natural a în descompunerea în factori primi a lui n!

== Restricții și precizări ==
* 2 &les; '''n, a''' &les; 1000
* exponentul unui număr natural nenul x, nu neapărat prim, în descompunerea unui număr natural nenul y este cel mai mare număr natural e cu proprietatea că xe este divizor al lui y.

== Exemplul 1 ==
; Intrare
; exponentin.txt
: 6 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; exponentout.txt
: 2

=== Explicație ===
6!=1*2*3*4*5*6 = 1*3*3*4*4*5.

== Exemplul 2 ==
; Intrare
; exponentin.txt
: 1 4
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1474 - Exponent

def validare_date(n, a):
if not (2 <= n <= 1000 and 2 <= a <= 1000):
return False
return True

def exponent_in_descompunere(n, a):
if validare_date(n, a):
print("Datele de intrare corespund restricțiilor impuse")

def calculeaza_exponent(prima_putere, numar):
exponent = 0
while numar % prima_putere == 0:
exponent += 1
numar //= prima_putere
return exponent
factorial_n = 1
for i in range(2, n + 1):
factorial_n *= i
exponent_a = calculeaza_exponent(a, factorial_n)
return exponent_a
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

with open("exponentin.txt", "r") as file:
n, a = map(int, file.readline().split())

with open("exponentout.txt", "w") as file:
exponent_a = exponent_in_descompunere(n, a)
file.write(str(exponent_a))

</syntaxhighlight>

0261 - Intervale

2023-12-17T15:55:13Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Se dau n intervale [a,b], unde a şi b sunt numere întregi. Să se afişeze acele intervale care au proprietatea că intersecţia lor cu oricare dintre celelalte n-1 intervale este mulţimea vidă == Date de intrare == Fişierul de intrare intervalein.txt conţine pe prima linie numărul n, iar pe următoarele n linii câte două numere întregi, separate prin spaţii, reprezentând capetele unui interval. == Date de ieșire == Fişierul de ieşire intervale...

== Cerința ==
Se dau n intervale [a,b], unde a şi b sunt numere întregi. Să se afişeze acele intervale care au proprietatea că intersecţia lor cu oricare dintre celelalte n-1 intervale este mulţimea vidă

== Date de intrare ==
Fişierul de intrare intervalein.txt conţine pe prima linie numărul n, iar pe următoarele n linii câte două numere întregi, separate prin spaţii, reprezentând capetele unui interval.

== Date de ieșire ==
Fişierul de ieşire intervaleout.txt va conţine pe prima linie numărul k, reprezentând numărul de intervale care au proprietatea de mai sus. Urmează k linii, fiecare conţinând câte două numere întregi – capetele intervalelor determinate. Intervalele se vor afişa în ordinea în care au fost date în fişierul de intrare.

== Restricții și precizări ==
* 1 &les; '''n''' &les; 100
* pentru fiecare interval dat [a,b], -30.000 &les; '''a, b''' &les; 30.000

== Exemplul 1 ==
; Intrare
; intervalein.txt
: 4
: 8 16
: 17 20
: 2 6
: 10 15
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; intervaleout.txt
: 2
: 17 20
: 2 6

== Exemplul 2 ==
; Intrare
; intervalein.txt
: 101
: 8 16
: 17 20
: 2 6
: 10 15
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0261 - Intervale

def valideaza_date_intrare(n, intervale):
if not (1 <= n <= 100):
return False
for a, b in intervale:
if not (-30000 <= a <= 30000 and -30000 <= b <= 30000):
return False
return True

def gaseste_intervale_disjuncte(n, intervale):
intervale_disjuncte = []
for i in range(n):
interval_curent = intervale[i]
este_disjunct = True
for j in range(n):
if i != j:
alt_interval = intervale[j]
if not (interval_curent[1] < alt_interval[0] or interval_curent[0] > alt_interval[1]):
este_disjunct = False
break
if este_disjunct:
intervale_disjuncte.append(interval_curent)
return intervale_disjuncte

def scrie_fisier_iesire(intervale_disjuncte):
with open("intervaleout.txt", "w") as fisier_iesire:
k = len(intervale_disjuncte)
fisier_iesire.write(str(k) + "\n")

for interval in intervale_disjuncte:
fisier_iesire.write(" ".join(map(str, interval)) + "\n")

def main():
with open("intervalein.txt", "r") as fisier_intrare:
n = int(fisier_intrare.readline())
intervale = [tuple(map(int, fisier_intrare.readline().split())) for _ in range(n)]

if valideaza_date_intrare(n, intervale):
print("Datele de intrare corespund restricțiilor impuse")
intervale_disjuncte = gaseste_intervale_disjuncte(n, intervale)
scrie_fisier_iesire(intervale_disjuncte)
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
main()

</syntaxhighlight>

0663 - Lungime 1

2023-12-17T12:16:31Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Se dă un șir cu n elemente, numere naturale nenule, în care cel puţin un element se repetă. Să se determine lungimea maximă a unei secvenţe de elemente din şir, cu proprietatea că primul şi ultimul element din secvenţă au aceeaşi valoare. == Date de intrare == Fişierul de intrare lungime1in.txt conţine pe prima linie numărul n; urmează n numere naturale separate prin spaţii, reprezentând elementele şirului, ce pot fi dispuse pe mai multe l...

== Cerința ==
Se dă un șir cu n elemente, numere naturale nenule, în care cel puţin un element se repetă. Să se determine lungimea maximă a unei secvenţe de elemente din şir, cu proprietatea că primul şi ultimul element din secvenţă au aceeaşi valoare.

== Date de intrare ==
Fişierul de intrare lungime1in.txt conţine pe prima linie numărul n; urmează n numere naturale separate prin spaţii, reprezentând elementele şirului, ce pot fi dispuse pe mai multe linii.

== Date de ieșire ==
Fişierul de ieşire lungime1out.txt va conţine pe prima linie numărul L, reprezentând lungimea maximă determinată.

== Restricții și precizări ==
* 1 &les; '''n''' &les; 100.000
* elementele șirului sunt numere naturale nenule mai mici sau egale cu 100.000

== Exemplul 1 ==
; Intrare
; lungime1in.txt
: 12
: 2 13 10 5 10 12 6 7 5 10 12 8
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; lungime1out.txt
: 8

=== Explicație ===
Cea mai lungă secvenţă de elemente în care primul şi ultimul element sunt egale este 10 5 10 12 6 7 5 10, şi are lungimea 8.

== Exemplul 2 ==
; Intrare
; lungimein.txt
: 100001
: 2 13 10 5 10 12 6 7 5 10 12 8
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0663 - Lungime1

def validare_date_intrare(n, sir):
if not 1 <= n <= 100000:
return False
if len(sir) != n:
return False
for numar in sir:
if not 1 <= numar <= 99:
return False
return True

def lungime_maxima_secventa(n, sir):
if validare_date_intrare(n, sir):
print("Datele de intrare corespund restricțiilor impuse")
lungime_maxima = 0
for i in range(n):
for j in range(i, n):
if sir[i] == sir[j]:
lungime_curenta = j - i + 1
if lungime_curenta > lungime_maxima:
lungime_maxima = lungime_curenta
with open("lungime1out.txt", "w") as out_file:
out_file.write(str(lungime_maxima) + "\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
with open("lungime1in.txt", "r") as f:
n = int(f.readline())
sir = list(map(int, f.readline().split()))
lungime_maxima_secventa(n, sir)

</syntaxhighlight>

0260 - Lungime

2023-12-17T12:08:47Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Se dă un sir cu n elemente, numere naturale nenule cu cel mult 2 cifre fiecare, în care cel puţin un element se repetă. Să se determine lungimea maximă a unei secvenţe de elemente din şir, cu proprietatea că primul şi ultimul element din secvenţă au aceeaşi valoare. == Date de intrare == Fişierul de intrare lungimein.txt conţine pe prima linie numărul n; urmează n numere naturale separate prin spaţii, reprezentând elementele şirului, ce pot...

== Cerința ==
Se dă un sir cu n elemente, numere naturale nenule cu cel mult 2 cifre fiecare, în care cel puţin un element se repetă. Să se determine lungimea maximă a unei secvenţe de elemente din şir, cu proprietatea că primul şi ultimul element din secvenţă au aceeaşi valoare.

== Date de intrare ==
Fişierul de intrare lungimein.txt conţine pe prima linie numărul n; urmează n numere naturale separate prin spaţii, reprezentând elementele şirului, ce pot fi dispuse pe mai multe linii.

== Date de ieșire ==
Fişierul de ieşire lungimeout.txt va conţine pe prima linie numărul L, reprezentând lungimea maximă determinată.

== Restricții și precizări ==
* 1 &les; '''n''' &les; 100.000

== Exemplul 1 ==
; Intrare
; lungimein.txt
: 12
: 2 13 10 5 10 12 6 7 5 10 12 8
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; lungimeout.txt
: 8

=== Explicație ===
Cea mai lungă secvenţă de elemente în care primul şi ultimul element sunt egale este 10 5 10 12 6 7 5 10, şi are lungimea 8.

== Exemplul 2 ==
; Intrare
; lungimein.txt
: 100001
: 2 13 10 5 10 12 6 7 5 10 12 8
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0260 - Lungime

def validare_date_intrare(n, sir):
if not 1 <= n <= 100000:
return False
if len(sir) != n:
return False
for numar in sir:
if not 1 <= numar <= 99:
return False
return True

def lungime_maxima_secventa(n, sir):
if validare_date_intrare(n, sir):
print("Datele de intrare corespund restricțiilor impuse")
lungime_maxima = 0
for i in range(n):
for j in range(i, n):
if sir[i] == sir[j]:
lungime_curenta = j - i + 1
if lungime_curenta > lungime_maxima:
lungime_maxima = lungime_curenta
with open("lungimeout.txt", "w") as out_file:
out_file.write(str(lungime_maxima) + "\n")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

if __name__ == "__main__":
with open("lungimein.txt", "r") as f:
n = int(f.readline())
sir = list(map(int, f.readline().split()))
lungime_maxima_secventa(n, sir)

</syntaxhighlight>

0558 - Cartonase 2

2023-12-17T11:47:41Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Supărat că Gigel a reușit, cu ajutorul vostru ( vezi problema Cartonașe ), să refacă progresia aritmetică scrisă pe cele n cartonașe, maleficul Costel este hotărât să intervină din nou. Astfel, observă că Gigel a notat din nou pe n cartonașe cei n termeni consecutivi ai unei progresii aritmetice. Profitând de lipsa acestuia, Costel a ascuns un număr oarecare de cartonașe și le-a amestecat pe celelalte. La întoarcere, Gigel constată lipsa...

== Cerința ==
Supărat că Gigel a reușit, cu ajutorul vostru ( vezi problema Cartonașe ), să refacă progresia aritmetică scrisă pe cele n cartonașe, maleficul Costel este hotărât să intervină din nou.

Astfel, observă că Gigel a notat din nou pe n cartonașe cei n termeni consecutivi ai unei progresii aritmetice. Profitând de lipsa acestuia, Costel a ascuns un număr oarecare de cartonașe și le-a amestecat pe celelalte.

La întoarcere, Gigel constată lipsa a m cartonașe și vă roagă să-l ajutați să afle care sunt valorile scrise pe cartonașele care lipsesc.

== Date de intrare ==
Programul citește de la tastatură numerele n m, cu semnificația de mai sus, apoi n-m numere naturale, reprezentând valorile scrise pe cartonașele care nu au fost ascunse.

== Date de ieșire ==
Programul va afișa pe ecran m numere ordonate crescător, separate prin exact un spaţiu, reprezentând valorile scrise pe cartonașele ascunse.

== Restricții și precizări ==
* 4 &les; '''n''' &les; 1.000
* 1 &les; '''m''' &les; n-2
* valorile scrise de Gigel pe cele n cartonașe 1.000.000.000
* Costel nu va lua niciodată primul sau ultimul cartonaș

== Exemplul 1 ==
; Intrare
: 6 2
: 13 19 7 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse
: 10 16

=== Explicație ===
Cele șase numere scrise de Gigel erau 4 7 10 13 16 19. Dintre acestea, lipsesc două, și anume 10 și 16.

== Exemplul 2 ==
; Intrare
: 3 2
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0558 - Cartonase2

def validare_date(n, m):
if not (4 <= n <= 1000):
return False
if not (1 <= m <= n - 2):
return False
return True

def rezolva_problema(n, m, cartonase_scrise):
cartonase_scrise.sort()
diferenta = (cartonase_scrise[-1] - cartonase_scrise[0]) // (n - 1)
cartonase_lipsa = []
for i in range(cartonase_scrise[0], cartonase_scrise[-1], diferenta):
if i not in cartonase_scrise:
cartonase_lipsa.append(i)
return cartonase_lipsa[:m]

n, m = map(int, input("Introduceti n si m: ").split())
if validare_date(n, m):
cartonase_scrise = list(map(int, input(f"Introduceti {n-m} numere scrise pe cartonase: ").split()))
print("Datele de intrare corespund restricțiilor impuse")
rezultat = rezolva_problema(n, m, cartonase_scrise)
print(*rezultat)
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

2015 - Suma Gauss 1

2023-12-17T11:26:40Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Cei n copii din clasa a V-a şi-au ales câte un număr natural dintre numerele de la 1 la n, neavând doi copii acelaşi număr. Fiecare copil a calculat suma numerelor naturale mai mici sau egale cu numărul ales, apoi doamna de mate a calculat suma pătratelor rezultatelor obţinute de copii. Voi trebuie să aflaţi rezultatul obţinut de doamna de mate. == Date de intrare == Fișierul de intrare sumagauss1in.txt conține pe prima linie numărul n de copii...

== Cerința ==
Cei n copii din clasa a V-a şi-au ales câte un număr natural dintre numerele de la 1 la n, neavând doi copii acelaşi număr. Fiecare copil a calculat suma numerelor naturale mai mici sau egale cu numărul ales, apoi doamna de mate a calculat suma pătratelor rezultatelor obţinute de copii. Voi trebuie să aflaţi rezultatul obţinut de doamna de mate.

== Date de intrare ==
Fișierul de intrare sumagauss1in.txt conține pe prima linie numărul n de copii din clasă.

== Date de ieșire ==
Fișierul de ieșire sumagauss1out.txt va conține pe prima linie rezultatul obţinut de doamna de mate.

== Restricții și precizări ==
* 1 &les; '''n''' &les; 500.000.000

== Exemplul 1 ==
; Intrare
; sumagauss1in.txt
: 3
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; sumagauss1out.txt
: 46

=== Explicație ===
Numerele calculate de copii sunt 1, 3, 6. Numărul calculat de doamna de mate este 46.

== Exemplul 2 ==
; Intrare
; sumagauss1in.txt
: 500000001
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2015 - SumaGauss1

def validare_date(n):
if not (1 <= n <= 500000000):
return False
return True

def rezultat_doamna_de_mate(n):
suma = 0
suma_patrate = 0

for i in range(1, n + 1):
suma += i
suma_patrate += suma ** 2

return suma_patrate

with open("sumagauss1in.txt", "r") as file:
n = int(file.readline().strip())

if validare_date(n):
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

with open("sumagauss1out.txt", "w") as file:
rezultat = rezultat_doamna_de_mate(n)
file.write(str(rezultat) + "\n")

</syntaxhighlight>

1963 - OP

2023-12-17T09:22:41Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Șcuțu este un mare matematician. Într-o seară acesta a inventat operația ∆. Operația ∆ se aplică pe 2 numere naturale, astfel: 290 ∆ 345 = 290345 21 ∆ 12 = 2112 456 ∆ 0 = 4560 Mygo și Seba sunt la rândul lor foarte buni informaticieni. Aceștia au un vector A cu N elemente, numere naturale, indexate de la 1. Ei vor construi un nou vector V, acesta la rândul său indexat de la 1, ce conține fiecare valoare A[i] ∆ A[j] (1 ≤ i, j...

== Enunț ==
Șcuțu este un mare matematician. Într-o seară acesta a inventat operația ∆. Operația ∆ se aplică pe 2 numere naturale, astfel:

290 ∆ 345 = 290345 
21 ∆ 12 = 2112 
456 ∆ 0 = 4560

Mygo și Seba sunt la rândul lor foarte buni informaticieni. Aceștia au un vector A cu N elemente, numere naturale, indexate de la 1. Ei vor construi un nou vector V, acesta la rândul său indexat de la 1, ce conține fiecare valoare A[i] ∆ A[j] (1 ≤ i, j ≤ N) pe care îl vor sorta crescător.

== Cerința ==
Acum Șcuțu le va pune celor 2 câte două întrebări:

1. Câte valori din V sunt mai mici sau egale cu X ? 
2. Pentru X dat, ce valoare se află pe poziția X ?

Să se răspundă la cele 2 întrebări.

== Date de intrare ==
Fișierul de intrare opin.txt conține pe prima linie numărul t, având valoarea 1 sau 2, reprezentând tipul întrebării la care se cere răspunsul. Pe a doua linie linie se află numărul N și X iar pe a treia linie se vor afla N numere naturale nenule, reprezentând valorile vectorului A.

== Date de ieșire ==
Fișierul de ieșire opout.txt va conține pe prima linie numărul S, reprezentând răspunsul întrebării.

== Restricții și precizări ==
* 1 &les; '''N''' &les; 100.000
* numerele de pe a treia linie a fișierului de intrare vor fi mai mici decât 1.000.000.000

== Exemplul 1 ==
; Intrare
; opin.txt
: 1
: 3 23
: 1 2 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; opout.txt
: 5

=== Explicație ===
V = {11, 12, 14, 21, 22, 24, 41, 42, 44}. Sunt 5 numere mai mici decât 23.

== Exemplul 2 ==
; Intrare
; opin.txt
: 2
: 3 6
: 1 2 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; opout.txt
: 24

=== Explicație ===
V = {11, 12, 14, 21, 22, 24, 41, 42, 44}. Pe poziția 6 se află numărul 24.

== Exemplul 3 ==
; Intrare
; opin.txt
: 3
: 3 6
: 1 2 4
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1963 - Op

def valideaza_input(t, n, a):
if t not in [1, 2]:
return False
if not 1 <= n <= 100000:
return False
if not all(0 < ai < 1000000000 for ai in a):
return False
return True

def calculeaza_v(n, a):
v = []
for i in range(n):
for j in range(n):
v.append(int(str(a[i]) + str(a[j])))
return sorted(v)

def numara_valori_mai_mici_sau_egale_cu_x(v, x):
count = 0
for value in v:
if value <= x:
count += 1
return count

def gaseste_valoare_pe_pozitia_x(v, x):
return v[x - 1]

if __name__ == "__main__":
rezultat = 0
with open("opin.txt", "r") as file:
t = int(file.readline().strip())
n, x = map(int, file.readline().strip().split())
a = list(map(int, file.readline().strip().split()))

if valideaza_input(t, n, a):
print("Datele de intrare corespund restricțiilor impuse")
if t == 1:
v = calculeaza_v(n, a)
rezultat = numara_valori_mai_mici_sau_egale_cu_x(v, x)
elif t == 2:
v = calculeaza_v(n, a)
rezultat = gaseste_valoare_pe_pozitia_x(v, x)
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

with open("opout.txt", "w") as output_file:
output_file.write(str(rezultat))

</syntaxhighlight>

1436 - Distanta Maxima

2023-12-16T21:10:31Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Fie S un şir cu numere naturale nenule. Considerând distanţa dintre elementele Si şi Sj ca fiind egală cu |i−j|, scrieţi un program care determină distanţa maximă dintre două valori egale din şir. == Date de intrare == Fișierul de intrare distantain.txt conține pe prima linie maxim 100.000 de numere naturale, reprezentând elementele şirului S. == Date de ieșire == Fișierul de ieşire distantaout.txt va conţine pe prima linie distanţa maxi...

== Cerința ==
Fie S un şir cu numere naturale nenule. Considerând distanţa dintre elementele Si şi Sj ca fiind egală cu |i−j|, scrieţi un program care determină distanţa maximă dintre două valori egale din şir.

== Date de intrare ==
Fișierul de intrare distantain.txt conține pe prima linie maxim 100.000 de numere naturale, reprezentând elementele şirului S.

== Date de ieșire ==
Fișierul de ieşire distantaout.txt va conţine pe prima linie distanţa maximă dintre două valori egale din şir. Dacă şirul are toate elementele distincte, distanţa va fi egală cu 0.

== Restricții și precizări ==
* Fiecare element al şirului este un număr natural din intervalul [1,1000]
* Elementele şirului sunt numerotate de la 1

== Exemplul 1 ==
; Intrare
; distantain.txt
: 30 33 16 33 37 16 72 65 16 46
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; distantaout.txt
: 6

=== Explicație ===
S={30, 33, 16, 33, 37, 16, 72, 65, ;16, 46}. Distanţa maximă este cea dintre elementele subliniate (9−3=6).

== Exemplul 2 ==
; Intrare
; distantain.txt
: 1001 33 16 33 37 16 72 65 16 46
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1436 - Distanta maxima

def validare_sir(sir):
elemente = sir.split()

if len(elemente) > 100000:
return False

for elem in elemente:
if not (elem.isdigit() and 1 <= int(elem) <= 1000):
return False

return True

def distanta_maxima(sir):
elemente = sir.split()
pozitii = {}
max_distanta = 0

for i, elem in enumerate(elemente):
if elem in pozitii:
distanta = i - pozitii[elem]
max_distanta = max(max_distanta, distanta)
else:
pozitii[elem] = i

return max_distanta

def main():
with open("distantain.txt", "r") as f:
sir = f.readline().strip()

rezultat = 0

if validare_sir(sir):
print("Datele de intrare corespund restricțiilor impuse")
rezultat = distanta_maxima(sir)
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

with open("distantaout.txt", "w") as f:
f.write(str(rezultat) + "\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

3400 - culori5

2023-12-16T20:13:31Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == În jurul muzeului din orașul Smallville exista un gard ce conține N scânduri de înălțimi diferite. Putem spune că scândura i are înălțimea Hi. Directorul muzeului le-a cerut angajaților să vopsească acest gard cu un număr minim de culori, astfel încât să se respecte următoarea condiție: pentru un număr întreg K cunoscut, orice secvență de K scânduri consecutive nu trebuie să conțină două scânduri de aceeași înălțime, colorate id...

== Enunț ==
În jurul muzeului din orașul Smallville exista un gard ce conține N scânduri de înălțimi diferite. Putem spune că scândura i are înălțimea Hi. Directorul muzeului le-a cerut angajaților să vopsească acest gard cu un număr minim de culori, astfel încât să se respecte următoarea condiție: pentru un număr întreg K cunoscut, orice secvență de K scânduri consecutive nu trebuie să conțină două scânduri de aceeași înălțime, colorate identic.

== Cerința ==
Scrieţi un program care să găsească numărul minim de culori ce vor fi folosite pentru a colora gardul.

== Date de intrare ==
Fișierul de intrare culoriin.txt conține pe prima linie N K – două numere întregi reprezentând numărul de scânduri și lungimea secvenței. Pe următoarea linie, N numere naturale Hi reprezentand înălțimile celor N scânduri

== Date de ieșire ==
Fișierul de ieșire culoriout.txt va conține un număr întreg C reprezentând numărul minim de culori folosite.

== Restricții și precizări ==
* 1 &les; '''K''' &les; 200.000
* 1 &les;'''K'''&les; '''N''' &les; 1.000.000
* 1 &les; '''Hi''' &les; 1.000

== Exemplul 1 ==
; Intrare
; culoriin.txt
: 6 4
: 1 1 2 1 3 2
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; culoriout.txt
: 3

=== Explicație ===
O posibilă colorare a scândurilor folosind culorile 1, 2, 3 este: 1 2 1 3 1 2.
Există 3 secvențe: 1 1 2 1, 1 2 1 3 și 2 1 3 2 și orice secvență respectă condiția din enunț.

== Exemplul 2 ==
; Intrare
; culoriin.txt
: 4 6
: 1 1 2 1 3 2
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3400 - Culori5

def validare_date(n, k, hi):
if not (1 <= k <= 200000):
return False
if not (1 <= k <= n <= 1000000):
return False
if not all(1 <= h <= 1000 for h in hi):
return False
return True

def numar_minim_culori(n, k, hi):
culori = 0
culoare_actuala = {}

for i in range(n):
inaltime = hi[i]

if inaltime not in culoare_actuala:
culoare_actuala[inaltime] = 1
culori = max(culori, 1)
else:
culoare_actuala[inaltime] += 1
culori = max(culori, culoare_actuala[inaltime])

if i >= k - 1:
culoare_actuala[hi[i - k + 1]] -= 1

return culori

if __name__ == "__main__":
with open("culoriin.txt", "r") as fin:
n, k = map(int, fin.readline().split())
hi = list(map(int, fin.readline().split()))

if validare_date(n, k, hi):
print("Datele de intrare corespund restricțiilor impuse")
rezultat = numar_minim_culori(n, k, hi)
with open("culoriout.txt", "w") as fout:
fout.write(str(rezultat))
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

3583 - jetoane

2023-12-16T18:59:21Z

Vasiliu Costel Andrei: Pagină nouă: == Enunț == Ionel şi Georgel colecţionează jetoane care se găsesc în revistele Scooby-Doo. Jetoanele au înscrise pe ele diferite valori, numere naturale distincte, un copil neputând avea două sau mai multe jetoane cu aceeaşi valoare. Ei propun următorul joc: având în faţă jetoanele proprii, determină împreună care este jetonul de valoare comună cu cea mai mică valoare înscrisă şi jetonul de valoare comună cu cea mai mare valoare înscrisă. După ce au...

== Enunț ==
Ionel şi Georgel colecţionează jetoane care se găsesc în revistele Scooby-Doo. Jetoanele au înscrise pe ele diferite valori, numere naturale distincte, un copil neputând avea două sau mai multe jetoane cu aceeaşi valoare. Ei propun următorul joc: având în faţă jetoanele proprii, determină împreună care este jetonul de valoare comună cu cea mai mică valoare înscrisă şi jetonul de valoare comună cu cea mai mare valoare înscrisă. După ce au identificat aceste jetoane, câştigătorul este acela care va avea cele mai multe jetoane după eliminarea acelora cu valori cuprinse între minimul şi maximul comun, inclusiv minimul şi maximul.

== Cerința ==
Determinaţi valorile minimă şi maximă comune, precum şi câştigătorul jocului.

== Date de intrare ==
Fişierul de intrare jetoanein.txt conţine pe prima linie două numere naturale separate printr-un singur spaţiu, m şi n reprezentând numărul de jetoane ale primului copil şi respectiv numărul de jetoane ale celui de-al doilea copil. Pe următoarea linie sunt m+n valori separate prin câte un spaţiu, ce reprezintă jetoanele primului şi apoi jetoanele celui de-al doilea copil.

== Date de ieșire ==
Fişierul de ieșire jetoaneout.txt conţine pe prima linie trei valori întregi Min Max C separate prin câte un spaţiu, unde Min este valoarea minimă comună, Max este valoarea maximă comună, iar C va fi 0, dacă jocul se încheie la egalitate, 1 dacă va câştiga primul copil, sau 2, dacă va câştiga cel de-al doilea copil.

== Restricții și precizări ==
* 1 &les; '''n, m''' &les; 28.000
* 1 &les; '''valoarea de pe un jeton''' &les; 50.000
* Vor exista cel puţin două valori comune

== Exemplul 1 ==
; Intrare
; jetoanein.txt
: 10 6
: 1 3 2 4 7 5 8 19 27 9 3 8 80 6 18 19
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; jetoaneout.txt
: 3 19 1

=== Explicație ===
Jetonul comun cel mai mic este cel cu valoarea 3, iar cel mai mare are valoarea 19. Primul rămâne cu 3 jetoane (acestea sunt 1, 2, 27) şi al doilea rămâne cu unul singur (jetonul 80), deci jucătorul 1 este câştigător.

== Exemplul 2 ==
; Intrare
; jetoanein.txt
: 4 5
: 6 7 1 90 6 7 68 1 3
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; jetoaneout.txt
: 1 7 0

=== Explicație ===
Jetonul comun cel mai mic este cel cu valoarea 1, iar cel mai mare are valoarea 7. Primul rămâne cu un jeton (acesta este 90) şi al doilea rămâne cu unul singur (jetonul 68), deci egalitate.

== Exemplul 3 ==
; Intrare
; jetoanein.txt
: 4 28001
: 6 7 1 90 6 7 68 1 3
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3583 - Jetoane

def valideaza_input(m, n, jetoane):
# Funcție de validare a datelor de intrare conform restricțiilor
if not (0 < m <= 28000 and 0 < n <= 28000):
return False
if len(jetoane) != m + n:
return False
return all(0 < val <= 50000 for val in jetoane)

def gaseste_valori_comune(jetoane1, jetoane2):
# Funcție pentru găsirea valorilor comune dintre cei doi copii
valori_comune = set(jetoane1) & set(jetoane2)
return valori_comune

def determina_castigator(jetoane_copil1, jetoane_copil2, valori_comune):
# Funcție pentru determinarea câștigătorului
jetoane_ramase_copil1 = [val for val in jetoane_copil1 if val not in valori_comune]
jetoane_ramase_copil2 = [val for val in jetoane_copil2 if val not in valori_comune]

if len(jetoane_ramase_copil1) > len(jetoane_ramase_copil2):
return 1
elif len(jetoane_ramase_copil1) < len(jetoane_ramase_copil2):
return 2
else:
return 0

def main():
# Citirea datelor din fișierul de intrare
with open("jetoanein.txt", "r") as infile:
m, n = map(int, infile.readline().split())
jetoane = list(map(int, infile.readline().split()))

# Validare date de intrare
if valideaza_input(m, n, jetoane):
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

# Separarea jetoanelor pentru fiecare copil
jetoane_copil1 = jetoane[:m]
jetoane_copil2 = jetoane[m:]

# Găsirea valorilor comune
valori_comune = gaseste_valori_comune(jetoane_copil1, jetoane_copil2)

# Determinarea valorilor minimă și maximă comune
valoare_minima_comuna = min(valori_comune)
valoare_maxima_comuna = max(valori_comune)

# Determinarea câștigătorului și scrierea rezultatelor în fișierul de ieșire
castigator = determina_castigator(jetoane_copil1, jetoane_copil2, valori_comune)

with open("jetoaneout.txt", "w") as outfile:
outfile.write(f"{valoare_minima_comuna} {valoare_maxima_comuna} {castigator}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

2296 - gcd

2023-12-16T18:29:06Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == Se dau două șiruri de câte N numere naturale fiecare. Se cere să se găsească valoarea maximă a celui mai mare divizor comun a două numere A și B, astfel încât A să aparțină primului șir, iar B să aparțină celui de-al doilea șir. == Date de intrare == În fișierul gcdin.txt se va afla pe prima linie un număr reprezentând valoarea lui N. Pe cea de-a doua linie se vor afla N numere separate prin câte un spațiu, reprezentând elementele pri...

== Cerința ==
Se dau două șiruri de câte N numere naturale fiecare. Se cere să se găsească valoarea maximă a celui mai mare divizor comun a două numere A și B, astfel încât A să aparțină primului șir, iar B să aparțină celui de-al doilea șir.

== Date de intrare ==
În fișierul gcdin.txt se va afla pe prima linie un număr reprezentând valoarea lui N. Pe cea de-a doua linie se vor afla N numere separate prin câte un spațiu, reprezentând elementele primului șir. Pe cea de-a treia linie se vor afla N numere separate prin câte un spațiu, reprezentând elementele celui de-al doilea șir.

== Date de ieșire ==
În fișierul gcdout.txt se va afla pe primia linie un număr natural reprezentând valoarea maximă a celui mai mare divizor comun a două numere A și B, astfel încât A să aparțină primului șir, iar B să aparțină celui de-al doilea șir.

== Restricții și precizări ==
* '''N''' &les; 500.000
* Elementele celor două șiruri sunt mai mici sau egale cu 1.000.000

== Exemplul 1 ==
; Intrare
; gcdin.txt
: 5
: 3 1 4 2 8
: 5 2 12 8 3
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; gcdout.txt
: 8

=== Explicație ===
A = 8, B = 8, iar (A,B) = 8 este valoarea maximă a celui mai mare divizor comun a vreunei perechi.

== Exemplul 2 ==
; Intrare
; gcdin.txt
: 500001
: 3 1 4 2 8
: 5 2 12 8 3
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2296 - GCD

import math

def validare_date(n, sir1, sir2):
if not 1 <= n <= 500000:
return False
if any(not 1 <= x <= 1000000 for x in sir1 + sir2):
return False
return True

def gcd_maxim(sir1, sir2):
gcd_max = 0
for a in sir1:
for b in sir2:
gcd_max = max(gcd_max, math.gcd(a, b))
return gcd_max

# Citire date de intrare
with open('gcdin.txt', 'r') as f:
n = int(f.readline())
sir1 = list(map(int, f.readline().split()))
sir2 = list(map(int, f.readline().split()))

# Validare date de intrare
if validare_date(n, sir1, sir2):
print("Datele de intrare corespund restricțiilor impuse")
# Calcul și afișare rezultat
rezultat = gcd_maxim(sir1, sir2)
with open('gcdout.txt', 'w') as f:
f.write(str(rezultat) + '\n')
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

</syntaxhighlight>

4144 - Graffiti

2023-12-14T21:40:27Z

Vasiliu Costel Andrei: Pagină nouă: == Cerința == RAU-Gigel și-a descoperit o nouă pasiune: graffiti-ul. El simte o nevoie din ce în ce mai puternică de a-și manifesta spiritul artistic, de a exersa, de a explora, și de a încerca noi și noi tehnici … și pentru asta are nevoie de spațiu. Făcând o incursiune prin cartier, RAU-Gigel descoperă un depou părăsit împrejmuit de un gard format din plăci de beton de lățimi și înălțimi diferite, dispuse în linie continuă. „O pânză imaculat...

== Cerința ==
RAU-Gigel și-a descoperit o nouă pasiune: graffiti-ul. El simte o nevoie din ce în ce mai puternică de a-și manifesta spiritul artistic, de a exersa, de a explora, și de a încerca noi și noi tehnici … și pentru asta are nevoie de spațiu.

Făcând o incursiune prin cartier, RAU-Gigel descoperă un depou părăsit împrejmuit de un gard format din plăci de beton de lățimi și înălțimi diferite, dispuse în linie continuă. „O pânză imaculată” se gândește el. Și începe să măsoare plăcile de beton, una câte una, cu gândul ca, odată ajuns acasă, să schițeze următoarea sa creație artistică.

El vrea să aleagă câteva plăci de beton alăturate și pe dreptunghiul maximal delimitat de acestea, să își făurească creația. Care este suprafața maximă de desenare ? Ajutați-l pe RAU-Gigel să facă mai multe simulări.

Gardul format din plăci de beton, numerotate de la 1 la 5, de dimensiuni (lățime X înălțime): 4 X 8, 5 X 4, 7 X 2, 3 X 3, 8 X 10 unități de mărime. Prin interogări repetate de forma (x, y), RAU-Gigel vrea să afle cât de mare poate fi suprafața de desenare în formă dreptunghiulară ce va acoperi plăcile de beton alipite: x, x+1, ... , y.

De exemplu, la interogarea (2, 4), desenul va avea lățimea 5 + 7 + 3 = 15, și înălțimea minim (4, 2, 3) = 2, deci suprafața de desenare va fi de mărime 30. Se va folosi peste tot aceeași unitate de mărime.

== Date de intrare ==
Fișierul de intrare graffitiin.txt conține pe prima linie numărul natural N reprezentând numărul de plăci de beton, indexate de la 1 la N, apoi N linii care conțin perechi de forma L H, separate printr-un spațiu, reprezentând lățimea și înălțimea fiecărei plăci de beton. Urmează apoi un rând cu numărul natural Q ce reprezintă numărul de interogări, urmat de Q linii ce conțin interogările: perechi de forma x y, cu x ≤ y, separate printr-un spațiu.

== Date de ieșire ==
Fișierul de ieșire graffitiout.txt va conține răspunsurile la interogări, în ordinea solicitării, câte unul pe linie.

== Restricții și precizări ==
* 1 &les; '''N, Q, L, H''' &les; 100.000

== Exemplul 1 ==
; Intrare
; graffitiin.txt
: 5
: 4 8
: 5 4
: 7 2
: 3 3
: 8 10
: 2
: 2 4
: 4 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; graffitiout.txt
: 30
: 33

=== Explicație ===
Avem 5 plăci de beton cu dimensiunile 4 X 8, 5 X 4, 7 X 2, 3 X 3, 8 X 10 și 2 interogări.

La interogarea (2, 4), suprafața desenată va avea lățimea 5 + 7 + 3 = 15, și înălțimea minim (4, 2, 3) = 2, deci suprafața 30.

La interogarea (4, 5), suprafața desenată va avea lățimea 3 + 8 = 11, iar înălțimea sa va fi 3, deci suprafața 33.

== Exemplul 2 ==
; Intrare
; graffitiin.txt
: 5
: 4 8
: 5 4
: 7 2
: 3 3
: 8 10
: 100001
: 2 4
: 4 5
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#4144 - Graffiti

def validare_input(n, q, placi):
if not (1 <= n <= 100000 and 1 <= q <= 100000):
return False
if len(placi) != n:
return False
for L, H in placi:
if not (1 <= L <= 100000 and 1 <= H <= 100000):
return False
return True

def calcul_suprafata_desen(placi, interogari):
suprafete_desen = []
for interogare in interogari:
x, y = interogare
latime = sum(placi[i][0] for i in range(x - 1, y))
inaltime = min(placi[i][1] for i in range(x - 1, y))
suprafete_desen.append(latime * inaltime)
return suprafete_desen

def main():
with open("graffitiin.txt", "r") as fisier:
n = int(fisier.readline())
placi = [tuple(map(int, fisier.readline().split())) for _ in range(n)]
q = int(fisier.readline())
interogari = [tuple(map(int, fisier.readline().split())) for _ in range(q)]

if validare_input(n, q, placi):
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

suprafete_desen = calcul_suprafata_desen(placi, interogari)

with open("graffitiout.txt", "w") as fisier:
for suprafata in suprafete_desen:
fisier.write(str(suprafata) + "\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

2098 - Meteo

2023-12-11T09:58:53Z

Vasiliu Costel Andrei:

== Enunț ==
Centrul de meteorologie dintr-o ţară îndepărtată, aflată aproape de Polul Nord, doreşte să stabilească modul în care încălzirea globală afectează temperaturile din acea ţară. Ei notează pe parcursul a N zile consecutive temperaturile maxime zilnice şi sunt interesaţi să determine cea mai lungă perioadă continuă de timp în care temperaturile înregistrate în zile consecutive au alternat ca semn.

== Cerința ==
Scrieţi un program care, pe baza temperaturilor înregistrate pe parcursul a N zile consecutive, determină o succesiune de zile consecutive având lungime maximă pentru care temperaturile înregistrate au alternat ca semn. Dacă există mai multe astfel de secvenţe, meteorologii sunt interesaţi de cea mai recentă. Dacă nu există măcar două zile consecutive cu temperaturi alternante ca semn, ei vor înregistra rezultatul 0.

== Date de intrare ==
Fişierul de intrare meteoin.txt conţine pe prima linie numărul natural N, reprezentând numărul total de zile pentru care se efectuează studiul. Pe cea de-a doua linie vor fi scrise N numere întregi separate prin spaţii, al i-lea număr de pe linie fiind temperatura maximă zilnică înregistrată în ziua i a studiului (1≤i≤N).

== Date de ieșire ==
Fişierul de ieşire meteoout.txt va conţine pe prima linie un număr natural NrMax, reprezentând numărul maxim de zile consecutive pentru care temperaturile au alternat ca semn. Pe cea de a doua linie vor fi scrise NrMax valori întregi, separate prin spaţii, reprezentând temperaturile (alternante ca semn) înregistrate în cele NrMax zile. În cazul în care nu există nici măcar două zile consecutive cu temperaturi alternante ca semn, fişierul de ieşire va conţine o singură linie, pe care va fi scrisă valoarea 0.

== Restricții și precizări ==
* 4 &les; '''N''' &les; 1.000
* Temperaturile maxime zilnice sunt numere întregi ce aparţin intervalului [-50,50].
* Temperatura de 0 grade va fi considerată pozitivă.

== Exemplul 1 ==
; Intrare
; meteoin.txt
: 16
: 1 -5 -3 2 -1 7 -2 5 1 7 -9 0 -1 6 -1 -8
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; meteoout.txt
: 6
: -3 2 -1 7 -2 5

=== Explicație ===
Studiul a fost efectuat pe durata a 16 zile. În această perioadă au existat două secvenţe de zile consecutive având lungime maximă (6) şi în care temperaturile au alternat ca semn. În fişierul de ieşire a fost afişată prima dintre ele, cea mai recentă fiind 7 -9 0 -1 6 -1.

== Exemplul 2 ==
; Intrare
; meteoin.txt
: 2
: 0 1
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2098 - Meteo

def validare_date(n_zile_consecutive, temperaturi):
if not (3 < n_zile_consecutive <= 1000):
return False
if len(temperaturi) != n_zile_consecutive:
return False
for temp in temperaturi:
if not (-50 <= temp <= 50):
return False
return True

def determina_secventa(n_zile_consecutive, temperaturi):
secventa_maxima = []
lungime_maxima = 0
secventa_curenta = [temperaturi[0]]
lungime_curenta = 1

for i in range(1, n_zile_consecutive):
if temperaturi[i] * temperaturi[i - 1] < 0:
secventa_curenta.append(temperaturi[i])
lungime_curenta += 1
else:
secventa_curenta = [temperaturi[i]]
lungime_curenta = 1

if lungime_curenta > lungime_maxima:
lungime_maxima = lungime_curenta
secventa_maxima = secventa_curenta.copy()

return lungime_maxima, secventa_maxima

def main():
with open("meteoin.txt", "r") as f:
n_zile_consecutive = int(f.readline())
temperaturi = list(map(int, f.readline().split()))

if validare_date(n_zile_consecutive, temperaturi):
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

lungime_maxima, secventa_maxima = determina_secventa(n_zile_consecutive, temperaturi)

with open("meteoout.txt", "w") as f:
if lungime_maxima < 2:
f.write("0\n")
else:
f.write(f"{lungime_maxima}\n")
f.write(" ".join(map(str, secventa_maxima)))

if __name__ == "__main__":
main()

</syntaxhighlight>

3440 - Buldo

2023-12-11T09:50:39Z

Vasiliu Costel Andrei:

== Enunț ==
Dorești să nivelezi terenul pe care l-ai cumpărat, care are lățimea de 1 metru și lungimea de N metri, fiind alcătuit din N zone succesive, fiecare zonă având lungimea de 1 metru. Terenul se reprezintă ca un șir de N numere naturale h1, h2, h3, …, hN reprezentând înălțimile în metri pe care le au zonele din terenul inițial, privite de la stânga spre dreapta.

Pentru a nivela terenul ai închiriat un buldozer care funcționează astfel. Se alege o înălțime H (număr natural) la care ridicăm lama buldozerului. Inițial buldozerul are pe lamă o cantitate C=0 metri cubi de pământ. Buldozerul începe să mergă de la stânga la dreapta și când ajunge la zona i, în funcție de înălțimea hi a acesteia, se va afla în una dintre următoarele situații:

- dacă hi ≥ H atunci cantitatea suplimentară hi - H se adaugă la C și nivelul zonei ajunge la H.
- dacă hi < H atunci se scade din C diferența H - hi pentru a aduce nivelul zonei la nivelul H.
Remarcăm faptul că H trebuie ales inițial astfel încât de fiecare dată când buldozerul ajunge în a doua situație să aibă pe lamă suficient pământ (C ≥ H - hi). După ce buldozerul parcurge cele N zone de lungime 1 pe lama buldozerului e posibil să mai rămână pământ, dar asta nu te interesează, pentru că la capătul din dreapta al terenului este un râu, și pământul rămas se va vărsa acolo.

== Cerința ==
Scrieţi un program care calculează înălțimea maximă H la care poate fi ridicată lama, astfel încât terenul să poată fi nivelat la acea înălțime.

== Date de intrare ==
Fișierul de intrare buldoin.txt conține pe prima linie numărul natural N, iar pe a doua linie, separate prin câte un spațiu, cele N numere naturale h1, h2, h3, …, hN, cu semnificația din enunț.

== Date de ieșire ==
Fișierul de ieșire buldoout.txt va conține o singură linie, pe care va fi scris numărul natural H cerut.

== Restricții și precizări ==
* 1 &les; '''N''' &les; 100.000
* Înălțimile sunt numere naturale, 1 &les; '''hi''' &les; 1.000.000.000, pentru orice i, 1 &les; '''i''' &les; N

== Exemplul 1 ==
; Intrare
; buldoin.txt
: 4
: 5 2 1 6
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; buldoout.txt
: 2

=== Explicație ===
Dacă se fixează lama la înălțimea H=2, după ce se trece de zona 1 (primul metru pe lungime), această zonă rămâne la înălțimea 2 și C=3 metri cubi de pământ sunt duși de lamă la zona 2. Acolo se vor obține în total 2+3=5 metri cubi de pământ, dar se păstrează doar 2, iar restul de C=3 se transportă la zona 3. La zona 3 se vor obține în total 1+3=4 metri cubi de pământ, dar se păstrează doar 2, iar restul de C=2 se transportă la zona 4. La zona 4 se vor obține în total 6+2=8 metri cubi de pământ, dar se păstrează doar 2, iar restul de C=6 se aruncă în râu.

Dacă s-ar fixa lama la înălțimea H=3, la zona 3 se poate ajunge doar la înălțimea 2 și încercarea eșuează (fiind o înălțime mai mică decât cea propusă).

== Exemplul 2 ==
; Intrare
; buldoin.txt
: 100001
: 5 2 1 6
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3440 - Buldo

def validare_inaltime(h, H, C):
for hi in h:
if hi >= H:
C += hi - H
elif C < H - hi:
return False
else:
C -= H - hi
return True

def cautare_binara(h):
stanga, dreapta = 1, max(h)
rezultat = 0

while stanga <= dreapta:
mijloc = (stanga + dreapta) // 2

if validare_inaltime(h, mijloc, 0):
rezultat = mijloc
stanga = mijloc + 1
else:
dreapta = mijloc - 1

return rezultat

with open('buldoin.txt', 'r') as f:
N = int(f.readline())
h = list(map(int, f.readline().split()))

if 1 <= N <= 100000:
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

for hi in h:
if not 1 <= hi <= 1000000000:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

rezultat = cautare_binara(h)

with open('buldoout.txt', 'w') as g:
g.write(str(rezultat) + '\n')

</syntaxhighlight>

2900 - Joc 9

2023-12-11T09:39:33Z

Vasiliu Costel Andrei:

== Enunț ==
Amalia a adunat n cartonașe pe care le poate folosi în mai multe jocuri. Pe fiecare cartonaș este scris un singur număr care are cel puțin două cifre și cel mult nouă cifre. La jocul Numersum, ea utilizează cartonașele ce au numere pentru care prima cifră este egală cu suma celorlalte cifre din număr. Amalia dorește să aleagă cartonașele pentru acest joc și să le așeze în ordine crescătoare, după numerele scrise pe ele.

== Cerința ==
Scrieți un program care, cunoscând numărul de cartonașe n și numerele scrise pe cele n cartonașe, determină în ordine crescătoare numerele pe care Amalia le poate utiliza la jocul Numersum.

== Date de intrare ==
Fișierul de intrare jocin.txt conține pe prima linie numărul natural n ce reprezintă numărul de cartonașe. Pe a doua linie din fișier se află n numere naturale c1, c2, … cn, reprezentând numerele scrise pe cele n cartonașe.

== Date de ieșire ==
Fișierul de ieșire jocout.txt conține o singură linie pe care se află în ordine crescătoare numerele scrise pe cartonașele ce se pot utiliza la jocul Numersum, separate prin câte un spațiu.

== Restricții și precizări ==
* 2 &les; '''n''' &les; 40.000
* 10 &les; '''ci''' &les; 999.999.999
* În setul de cartonașe al Amaliei există cel puțin un cartonaș ce poate fi ales la jocul Numersum

== Exemplul 1 ==
; Intrare
; jocin.txt
: 7
: 211 58 55 514 101 9867 101
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; jocout.txt
: 55 101 101 211 514

=== Explicație ===
Numerele din șirul dat ce se pot utiliza la jocul Numersum sunt: 211 (2 = 1 + 1), 55 (5=5), 514, 101 (1 = 0 + 1), 101 și se vor afișa în ordine crescătoare.

== Exemplul 2 ==
; Intrare
; jocin.txt
: 2
: 9 511
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2900 - Joc9

def validare_date(n, cartonase):
if not (3 <= n <= 40000):
return False
for numar in cartonase:
if not (10 <= numar < 1000000000):
return False
return True

def numere_pentru_joc(cartonase):
rezultat = []
for numar in cartonase:
cifre = [int(digit) for digit in str(numar)]
if cifre[0] == sum(cifre[1:]):
rezultat.append(numar)
return sorted(rezultat)

def main():
with open("jocin.txt", "r") as f:
n = int(f.readline().strip())
cartonase = list(map(int, f.readline().split()))

if validare_date(n, cartonase):
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

rezultat = numere_pentru_joc(cartonase)

with open("jocout.txt", "w") as f:
f.write(" ".join(map(str, rezultat)))

if __name__ == "__main__":
main()

</syntaxhighlight>

1380 - Pluton

2023-12-11T09:33:54Z

Vasiliu Costel Andrei:

== Enunț ==
În timpul acţiunii “Furtuna în deşert” din cauza unei furtuni de nisip, n soldaţi s-au rătăcit de plutoanele lor. După trecerea furtunii se pune problema regrupării acestora pe plutoane. Pentru aceasta se folosesc plăcuţele de identificare pe care soldaţii le poartă la gât. Pe aceste plăcuţe sunt scrise numere care pot identifica fiecare soldat şi plutonul din care acesta face parte. Astfel, soldaţii din acelaşi pluton au numărul de identificare format din aceleaşi cifre, dispuse în altă ordine şi numerele de identificare sunt unice. De exemplu, numerele de identificare 78003433, 83043073, 33347008 indică faptul ca cei trei soldaţi care le poartă fac parte din acelaşi pluton.
== Cerința ==
Fiind date cele n numere de pe plăcuţele de identificare, să se regrupeze cei n soldaţi pe plutoane, indicându-se numărul de plutoane găsite (un pluton refăcut trebuie să aibă minimum un soldat), numărul de soldaţi din cel mai numeros pluton, numărul de plutoane care au acest număr maxim de soldaţi precum şi componenţa unui astfel de pluton (cu număr maxim de soldaţi regrupaţi).

== Date de intrare ==
Fişierul de intrare plutonin.txt conţine pe prima linie numărul n de soldaţi recuperaţi, iar pe fiecare dintre următoarele n linii câte un număr de identificare a celor n soldaţi.

== Date de ieșire ==
Fişierul de ieşire plutonout.txt va conţine pe prima linie numărul de plutoane refăcute. Linia a doua va conţine numărul de soldaţi din cel mai numeros pluton refăcut. Linia a treia va conţine numărul de plutoane care au numărul maxim de soldaţi recuperaţi. Linia a patra va conţine componenţa unui astfel de pluton, cu număr maxim de soldaţi recuperaţi, numerele de identificare ale soldaţilor din componenţă fiind scrise unul după altul separate prin câte un spaţiu.

== Restricții și precizări ==
* 0 &les; '''n''' &les; 4.000
* 0 &les; '''numar de identificare''' &les; 1.999.999.999

== Exemplul 1 ==
; Intrare
; plutonin.txt
: 10
: 1223
: 123
: 666
: 321
: 7890
: 2213
: 312
: 655
: 1000
: 1322
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; plutonout.txt
: 6
: 3
: 2
: 1223 2213 1322

=== Explicație ===

Au fost recuperaţi soldaţi din 6 plutoane distincte, cei mai mulţi soldaţi recuperaţi dintr-un pluton fiind în număr de 3. Există 2 plutoane cu număr maxim de soldaţi recuperaţi (3), unul dintre ele fiind format din soldaţii cu numerele 1223 2213 1322. De remarcat că şi soluţia 321 312 123 este corectă.

== Exemplul 2 ==
; Intrare
; plutonin.txt
: 11
: 1223
: 123
: 666
: 321
: 7890
: 2213
: 312
: 655
: 1000
: 1322
: 2000000000
; Ieșire
: Datele de intrare corespund restricțiilor impuse
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1380 - Pluton

def validare_date(n, identificari):
if 0 < n <= 4000:
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

for identificare in identificari:
if not 0 <= identificare < 2000000000:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

def regrupare_soldati(n, identificari):
plutoane = {}
for identificare in identificari:
key = tuple(sorted(str(identificare)))
plutoane.setdefault(key, []).append(identificare)

numar_plutoane = len(plutoane)
numar_max_soldati = max(len(soldati) for soldati in plutoane.values())
plutoane_max_soldati = [soldati for soldati in plutoane.values() if len(soldati) == numar_max_soldati]

with open("plutonout.txt", "w") as f:
f.write(str(numar_plutoane) + "\n")
f.write(str(numar_max_soldati) + "\n")
f.write(str(len(plutoane_max_soldati)) + "\n")
f.write(" ".join(map(str, plutoane_max_soldati[0])) + "\n")

if __name__ == "__main__":
with open("plutonin.txt", "r") as f:
n = int(f.readline().strip())
identificari = [int(f.readline().strip()) for _ in range(n)]

validare_date(n, identificari)
regrupare_soldati(n, identificari)

</syntaxhighlight>

1903 - V Terminal

2023-12-11T09:20:17Z

Vasiliu Costel Andrei:

== Enunț ==
Andrei a făcut într-o zi un șir de N numere. În a doua zi a lăsat în acel șir doar numerele prime. În a treia zi a calculat pentru fiecare număr rămas în șir suma cifrelor, iar apoi a adunat toate aceste sume în S. După ce a obținut numărul S a început să adune toate cifrele din care este format S și tot așa până când ajunge la o cifră terminală C.

== Cerința ==
Ajutați-l pe Andrei să calculeze cifra terminală C.

== Date de intrare ==
Fișierul de intrare vterminalin.txt 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 vterminalout.txt va conține pe prima linie numărul C, reprezentând valoarea cerută.

== Restricții și precizări ==
* 1 &les; '''N''' &les; 10.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât 1.000

== Exemplul 1 ==
; Intrare
; vterminalin.txt
: 5
: 4 11 24 13 97
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; vterminalout.txt
: 4

=== Explicație ===
Doar 11, 13 și 97 sunt prime, deci 11 + 13 + 97 = 121 
1 + 2 + 1 = 4, deci 4 este cifra terminală

== Exemplu 2 ==
; Intrare
; vterminalin.txt
: 105
: 4 11 24 13 97
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1903 - V Terminal

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

def suma_cifrelor(numar):
return sum(int(cifra) for cifra in str(numar))

def cifra_terminala(numar):
while numar >= 10:
numar = suma_cifrelor(numar)
return numar

def main():
with open("vterminalin.txt", "r") as fisier:
n = int(fisier.readline().strip())
numere = list(map(int, fisier.readline().split()))

if 1 <= n <= 100:
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")

for numar in numere:
if not (numar < 1000):
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

numere_prime = [num for num in numere if este_prim(num)]
suma_cifrelor_prime = sum(suma_cifrelor(num) for num in numere_prime)
rezultat = cifra_terminala(suma_cifrelor_prime)

with open("vterminalout.txt", "w") as fisier_out:
fisier_out.write(str(rezultat))

if __name__ == "__main__":
main()

</syntaxhighlight>

2017 - P2017

2023-12-10T21:43:01Z

Vasiliu Costel Andrei:

== Cerința ==
Să se răspundă la Q întrebări de forma: “Care este numărul natural minim x astfel încât cifra c să apară de cel puțin K ori în reprezentarea tuturor numerelor naturale nenule mai mici sau egale cu x?”

== Date de intrare ==
Fișierul de intrare 2017in.txt conține pe prima linie numărul Q, iar pe următoarele Q linii se află câte două numere naturale c și K separate printr-un spațiu, reprezentând întrebările.

== Date de ieșire ==
Fișierul de ieșire 2017out.txt va conține Q linii, pe linia i aflându-se răspunsul la întrebarea i.

== Restricții și precizări ==
* 1 &les; '''Q''' &les; 10.000
* 1 &les; '''c''' &les; 9
* 1 &les; '''K''' &les; 10^12

== Exemplu 1 ==
; Intrare
; 2017in.txt
: 5
: 1 7
: 5 5
: 5 11
: 1 1
: 6 13
; Ieșire
: Datele de intrare corespund restricțiilor impuse
: Datele de intrare corespund restricțiilor impuse
: Datele de intrare corespund restricțiilor impuse
: Datele de intrare corespund restricțiilor impuse
: Datele de intrare corespund restricțiilor impuse
; 2017out.txt
: 14
: 45
: 55
: 1
: 66

=== Explicație ===
Pentru prima întrebare cifra 1 apare de 7 ori în secvența 1, 10, 11, 12, 13, 14. Deci răspunsul va fi 14.

== Exemplu 2 ==
; Intrare
; 2017in.txt
: 5
: 10 7
: 5 5
: 5 11
: 1 1
: 6 13
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2017 - P2017

def validare_date(cifra, numar_aparitii):
if 1 <= cifra <= 9 and 1 <= numar_aparitii <= 10 ** 12:
return True
return False

def gaseste_numarul_minim(cifra, numar_aparitii):
numar = 1
aparitii = 0

while aparitii < numar_aparitii:
str_numar = str(numar)
aparitii += str_numar.count(str(cifra))
numar += 1

return numar - 1

def rezolva_problema(numar_intrebari, intrebari):
rezultate = []

for i in range(numar_intrebari):
cifra, numar_aparitii = intrebari[i]

if validare_date(cifra, numar_aparitii):
print("Datele de intrare corespund restricțiilor impuse")
rezultat = gaseste_numarul_minim(cifra, numar_aparitii)
rezultate.append(rezultat)
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)
return rezultate

# Citirea datelor de intrare
with open("2017in.txt", "r") as f:
numar_intrebari = int(f.readline().strip())
intrebari = [list(map(int, f.readline().strip().split())) for _ in range(numar_intrebari)]

# Rezolvarea problemei
rezultate = rezolva_problema(numar_intrebari, intrebari)

# Scrierea rezultatelor in fisierul de iesire
with open("2017out.txt", "w") as f:
for rezultat in rezultate:
f.write(str(rezultat) + "\n")

</syntaxhighlight>

1466 - Placare 1

2023-12-10T21:34:30Z

Vasiliu Costel Andrei:

== Enunț ==
Un perete dreptunghiular de lățime L și o înălțime foarte mare (teoretic infinită) trebuie să fie protejat la bază cu plăci dreptunghiulare de faianță, de dimensiuni A și respectiv B. Plăcile se monteză una lângă cealaltă, pe mai multe rânduri orizontale, de jos în sus, pe fiecare rând de la stânga la dreapta, TOATE plăcile fiind așezate ”în picioare” (cu latura de mărime A pe orizontală și cea de mărime B pe verticală) sau TOATE ”culcate” (cu latura de mărime B pe orizontală și cea de mărime A pe verticală). Pentru a nu se pierde material, dacă la capătul unui rând nu încape o placă întreagă, se taie din ea porțiunea necesară, porțiunea rămasă fiind folosită la începutul rândului următor.

De exemplu, dacă peretele are lungimea L=10, iar plăcile de dimensiune A=3 și B=4 sunt așezate în picioare, atunci primul rând se completează cu porțiunea de dimensiuni 1 și 4, iar porțiunea rămasă de dimensiuni 2 și 4 este folosită pe rândul al doilea.

Pe rândul al doilea se montează plăcile în continuare în același mod, completându-l la capăt cu o porțiune de placă, restul de placă fiind folosit pe rândul al treilea etc. până ce rândul se încheie cu o placă întreagă, nemaifiind necesară nicio completare cu o porțiune de placă. În acest moment procesul de placare se încheie.Dacă primul rând se încheie cu placă întreagă, atunci placarea se încheie cu un singur rând completat.

== Cerința ==
Cunoscând lățimea L a peretelui și dimensiunile A și B ale plăcilor de faianță, stabiliți înălțimea maximă placată care se poate obține după metoda descrisă mai sus.

== Date de intrare ==
Se citesc din fișierul placare1in.txt, în această ordine, L, A și B, numere naturale nenule.

== Date de ieșire ==
In fișierul placare1out.txt se va afișa numărul natural H reprezentând înălțimea maximă placată cu faianță.

== Restricții și precizări ==
* 1 &les; '''A, B''' &les; 20.000
* 1 &les; '''L''' &les; 1.000.000.000

== Exemplu 1 ==
; Intrare
; placare1in.txt
: 10 3 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; placare1out.txt
: 12

== Exemplu 2 ==
; Intrare
; placare1in.txt
: 10 3 20001
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1466 - Placare1

def verificare_restrictii(latime_perete, latime_placa, inaltime_placa):
if not (1 <= latime_placa <= 20000 and 1 <= inaltime_placa <= 20000):
return False
if not (1 <= latime_perete <= 1000000000):
return False
return True

def inaltime_maxima_placata(latime_perete, latime_placa, inaltime_placa):
if verificare_restrictii(latime_perete, latime_placa, inaltime_placa):
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

inaltime = 0
while latime_perete > 0:
if latime_perete >= latime_placa:
inaltime += inaltime_placa
latime_perete -= latime_placa
else:
latime_perete = 0
return inaltime

def main():
with open("placare1in.txt", "r") as f:
latime_perete, latime_placa, inaltime_placa = map(int, f.readline().split())

rezultat = inaltime_maxima_placata(latime_perete, latime_placa, inaltime_placa)

with open("placare1out.txt", "w") as f:
f.write(str(rezultat))

if __name__ == "__main__":
main()

</syntaxhighlight>

1125 - Overflow 2

2023-12-10T21:26:17Z

Vasiliu Costel Andrei:

== Cerința ==
După ce Gigel a rezolvat problema anterioară ( #Overflow ), profesorul nu a fost foarte mulțumit de metoda sa. Așadar, i-a dat următoarea problemă: se dau n numere naturale. Să se afle dacă numerele pot fi reprezentate pe 8 octeți, fără semn.

== Date de intrare ==
Programul citește de la tastatură numărul n. Pe următoarele n rânduri se vor afla numerele m, urmate de m perechi de numere a b, cu semnificația de mai sus.

== Date de ieșire ==
Programul va afișa pe ecran pentru fiecare din cele n cazuri rezultatul dacă numărul se încadrează în tipuri de date de 8 octeți, sau Overflow! în caz contrar.

== Restricții și precizări ==
* 1 &les; '''n*m''' &les; 1.000.000
* 0 &les; '''b''' &les; 64
* '''a+b''' ≠ 0

== Exemplul 1 ==
; Intrare
: 4
: 1 2 63
: 1 2 64
: 1 666013 2
: 2 2 63 2 62
; Ieșire
: Datele de intrare corespund restricțiilor impuse
: Datele de intrare corespund restricțiilor impuse
: Datele de intrare corespund restricțiilor impuse
: Datele de intrare corespund restricțiilor impuse
: 9223372036854775808
: Overflow!
: 443573316169
: 13835058055282163712

=== Explicație ===
2^64 = 18.446.744.073.709.551.616, care nu poate fi reprezentat pe 8 octeți.

== Exemplul 2 ==
; Intrare
: 4
: 1 0 0
: 1 2 64
: 1 666013 2
: 2 2 62 2 63
; Ieșire
: Datele de intrare corespund restricțiilor impuse
: Datele de intrare NU corespund restricțiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1125 - Overflow2

def este_rezultat_valid(rezultat):
max_intreg_fara_semn_64 = 2 ** 64 - 1
return 0 <= rezultat <= max_intreg_fara_semn_64

def sunt_date_intrare_valide(n, m, perechi):
if 1 <= n * m <= 1000000:
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

for i in range(0, 2 * m, 2):
a, b = perechi[i], perechi[i + 1]
if not (0 <= a <= 18446744073709551615) or not (0 <= b <= 64) or (a + b == 0):
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)
return True

def calculeaza_suma(n, date):
rezultate = []

for i in range(n):
m, *perechi = map(int, date[i])

if sunt_date_intrare_valide(n, m, perechi):
suma_totala = 0
for j in range(0, 2 * m, 2):
a, b = perechi[j], perechi[j + 1]
suma_totala += a ** b

if este_rezultat_valid(suma_totala):
rezultate.append(suma_totala)
else:
rezultate.append("Overflow!")

return rezultate

def main():
n = int(input())
date_intrare = [list(map(int, input().split())) for _ in range(n)]

rezultate = calculeaza_suma(n, date_intrare)

for rezultat in rezultate:
print(rezultat)

if __name__ == "__main__":
main()

</syntaxhighlight>

1943 - Bacterie

2023-12-10T21:00:24Z

Vasiliu Costel Andrei:

== Enunț ==
O echipă de arheologi a descoperit o hartă străveche a Ținutului de Nord, care era locuit de o civilizație condusă după reguli matematice foarte riguroase. Conform acestei hărți, Ținutul de Nord era împărțit în n rânduri a câte m comitate, fiecare comitat ocupând o suprafață pătrată de un hectar.

Însă descoperirile au mai arătat că această civilizație a fost atacată de la sud-vest de o bacterie periculoasă, ce a acționat astfel: în primul an, a infectat comitatul din colțul din stânga jos al hărții, în al doilea an a infectat cele două comitate vecine cu primul, în al treilea an a infectat cele trei comitate vecine cu anterioarele două și așa mai departe, infecția oprindu-se când bacteria a ajuns la marginea de sus sau la marginea din dreapta a hărții

== Cerința ==
Scrieţi un program care să determine numărul de comitate rămase neinfectate după oprirea expansiunii bacteriei.

== Date de intrare ==
Fișierul de intrare bacteriein.txt conține separate printr-un spaţiu, n și m, dimensiunile hărții.

== Date de ieșire ==
Fișierul de ieșire bacterieout.txt va conține numărul de comitate rămase neinfectate după oprirea expansiunii bacteriei.

== Restricții și precizări ==
* 1 &les; '''n''' &les; 1.000.000.000
* 1 &les; '''m''' &les; 1.000.000.000

== Exemplul 1 ==
; Intrare
; bacteriein.txt
: 3 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; bacterieout.txt
: 9

=== Explicație ===
Harta Ținutului de Nord cuprinde 3 rânduri a câte 5 comitate fiecare, având în total 15 comitate. Expansiunea bacteriei s-a oprit după 3 ani, deoarece a atins marginea de sus; au rămas 9 comitate neinfectate.

== Exemplul 2 ==
; Intrare
; bacteriein.txt
: 1000000001 1000000001
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1943 - Bacterie
def verifica_restrictii(n, m):
if 1 <= n <= 1000000000 and 1 <= m <= 1000000000:
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

def numar_comitate_ramase_neinfectate(n, m):
verifica_restrictii(n, m)

total_comitate = n * m
infectate = 0
an = 1

while an <= n:
infectate += an # comitate infectate într-un an
an += 1
comitate_ramase = total_comitate - infectate
return comitate_ramase

# Citire din fișierul de intrare
with open("bacteriein.txt", "r") as file_in:
n, m = map(int, file_in.readline().split())

# Calcul și scriere în fișierul de ieșire
with open("bacterieout.txt", "w") as file_out:
rezultat = numar_comitate_ramase_neinfectate(n, m)
file_out.write(str(rezultat))

</syntaxhighlight>

3734 - Formula1

2023-12-10T20:57:47Z

Vasiliu Costel Andrei:

== Enunț ==
La o cursă de Formula 1, fiecare echipă participantă își construiește propria mașină cu care va concura. Numerotarea mașinilor în concurs este realizată de organizatori cu ajutorul unor stegulețe pătrate ce conțin alternativ, pe fiecare rând (pe orizontală și verticală), pătrățele albe și negre de dimensiuni identice. În figura următoare sunt prezentate, în ordine, stegulețele primelor 4 mașini din concurs. Observăm că fiecare steguleț are cu două rânduri (pe orizontală și verticală) mai mult decât stegulețul precedent, iar în toate cele patru colțuri ale oricărui steguleț se află un pătrățel negru.

== Cerința ==
Scrieți un program care citește două numere naturale K și N și determină: 
1. Câte pătrățele albe și negre sunt în total pe stegulețul mașinii cu numărul K; 
2. Notând cu A numărul total de pătrățele albe de pe stegulețele primelor N mașini din concurs, câte pătrățele albe și negre sunt în total pe cel mai mare steguleț care conține cel mult A pătrățele albe.

== Date de intrare ==
Fișierul de intrare formula1in.txt conține pe prima linie un număr natural C. Pentru toate testele de intrare, numărul C poate avea doar valoarea 1 sau valoarea 2 și reprezintă numărul cerinței care trebuie rezolvată. Pe a doua linie a fișierului formula1.in se găsesc, în ordine, numerele naturale K și N.

== Date de ieșire ==
Dacă C = 1, se va rezolva cerința 1. În acest caz, fișierul de ieșire formula1.out va conține pe prima linie un număr natural reprezentând numărul total de pătrățele existente pe stegulețul mașinii cu numărul K. Dacă C = 2, se va rezolva cerința 2. În acest caz, fișierul de ieșire formula1out.txt va conține pe prima linie un număr natural reprezentând numărul total de pătrățele existente pe cel mai mare steguleț ce conține cel mult A pătrățele albe.

== Restricții și precizări ==
* 1 &les; '''K''' &les; 100.000
* 1 &les; '''N''' &les; 500.000

== Exemplu 1 ==
; Intrare
; formula1in.txt
: 1
: 3 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; formula1out.txt
: 25

=== Explicație ===
Se rezolvă prima cerință și se va folosi doar valoarea K. Stegulețul celei de-a treia mașini are în total 25 de pătrățele albe și negre.

== Exemplu 2 ==
; Intrare
; formula1in.txt
: 2
: 3 4
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; formula1out.txt
: 81

=== Explicație ===
Se rezolvă a doua cerință și se va folosi doar valoarea N. Pe stegulețele primelor 4 mașini apar în total 0 + 4 + 12 + 24 = 40 pătrățele albe. Cel mai mare steguleț care conține cel mult 40 de pătrățele albe aparține mașinii cu numărul 5 care are în total 81 de pătrățele.

== Exemplu 3 ==
; Intrare
; formula1in.txt
: 1
: 100001 500001
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3734 - Formula1

def verifica_restrictii(numarul_masinii, primele_masini_din_concurs):
if 1 <= numarul_masinii <= 100000 and 1 <= primele_masini_din_concurs <= 500000:
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

def numar_patratele(numarul_masinii):
return (numarul_masinii+(numarul_masinii-1))**2

def cel_mai_mare_stegulet(numarul_de_patratele_albe):
i = 1
while numar_patratele(i) <= numarul_de_patratele_albe:
i += 1
return numar_patratele(i-1)

def rezolva_cerinta_1(numarul_masinii):
return numar_patratele(numarul_masinii)

def rezolva_cerinta_2(primele_masini_din_concurs):
total_patrate_albe = 0
for i in range(1, primele_masini_din_concurs + 1):
total_patrate_albe += numar_patratele(i)
return cel_mai_mare_stegulet(total_patrate_albe)

if __name__ == "__main__":
rezultat = 0
with open("formula1in.txt", "r") as file_in:
caz = int(file_in.readline().strip())
numarul_masinii, primele_masini_din_concurs = map(int, file_in.readline().split())

verifica_restrictii(numarul_masinii, primele_masini_din_concurs)

if caz == 1:
rezultat = rezolva_cerinta_1(numarul_masinii)
elif caz == 2:
rezultat = rezolva_cerinta_2(primele_masini_din_concurs)

with open("formula1out.txt", "w") as file_out:
file_out.write(str(rezultat))

</syntaxhighlight>

1943 - Bacterie

2023-12-10T20:47:04Z

Vasiliu Costel Andrei:

== Cerința ==
O echipă de arheologi a descoperit o hartă străveche a Ținutului de Nord, care era locuit de o civilizație condusă după reguli matematice foarte riguroase. Conform acestei hărți, Ținutul de Nord era împărțit în n rânduri a câte m comitate, fiecare comitat ocupând o suprafață pătrată de un hectar.

Însă descoperirile au mai arătat că această civilizație a fost atacată de la sud-vest de o bacterie periculoasă, ce a acționat astfel: în primul an, a infectat comitatul din colțul din stânga jos al hărții, în al doilea an a infectat cele două comitate vecine cu primul, în al treilea an a infectat cele trei comitate vecine cu anterioarele două și așa mai departe, infecția oprindu-se când bacteria a ajuns la marginea de sus sau la marginea din dreapta a hărții

;Scrieţi un program care să determine numărul de comitate rămase neinfectate după oprirea expansiunii bacteriei.

== Date de intrare ==
Fișierul de intrare bacteriein.txt conține separate printr-un spaţiu, n și m, dimensiunile hărții.

== Date de ieșire ==
Fișierul de ieșire bacterieout.txt va conține numărul de comitate rămase neinfectate după oprirea expansiunii bacteriei.

== Restricții și precizări ==
* 1 &les; '''n''' &les; 1.000.000.000
* 1 &les; '''m''' &les; 1.000.000.000

== Exemplu 1 ==
; Intrare
; bacteriein.txt
: 3 5
; Ieșire
: Datele de intrare corespund restricțiilor impuse
; bacterieout.txt
: 9
 
== Exemplu 2 ==
; Intrare
; bacteriein.txt
: 1000000001 1000000001
; Ieșire
: Datele de intrare NU corespund restricțiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1943 - Bacterie
def verifica_restrictii(n, m):
if 1 <= n <= 1000000000 and 1 <= m <= 1000000000:
print("Datele de intrare corespund restricțiilor impuse")
else:
print("Datele de intrare NU corespund restricțiilor impuse")
exit(0)

def numar_comitate_ramase_neinfectate(n, m):
verifica_restrictii(n, m)

total_comitate = n * m
infectate = 0
an = 1

while an <= n:
infectate += an # comitate infectate într-un an
an += 1
comitate_ramase = total_comitate - infectate
return comitate_ramase

# Citire din fișierul de intrare
with open("bacteriein.txt", "r") as file_in:
n, m = map(int, file_in.readline().split())

# Calcul și scriere în fișierul de ieșire
with open("bacterieout.txt", "w") as file_out:
rezultat = numar_comitate_ramase_neinfectate(n, m)
file_out.write(str(rezultat))

</syntaxhighlight>