Bitnami MediaWiki - User contributions [en]

E:15345

2025-01-11T20:54:14Z

Tita Marian: Created page with "'''E:15345 (Călin Dănuț Hossu, Baia Mare)''' ''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>.'' '''Soluție''' Ecuația se scrie: <math> x^y \cdot x^z + x^y + x^z = 584</math>, sau <math>x^y \cdot x^z + x^y + x^z= 585.</math> De aici <math>x^y \cdot(x^z+1) + (x^z + 1) = 585</math> sau <math>(x^y + 1) \cdot (x^z + 1) = 585.</math> Deoarece <math>585</math> este numă..."

'''E:15345 (Călin Dănuț Hossu, Baia Mare)'''

''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>.''

'''Soluție'''

Ecuația se scrie:

<math> x^y \cdot x^z + x^y + x^z = 584</math>,
sau <math>x^y \cdot x^z + x^y + x^z= 585.</math>

De aici
<math>x^y \cdot(x^z+1) + (x^z + 1) = 585</math>
sau <math>(x^y + 1) \cdot (x^z + 1) = 585.</math>

Deoarece <math>585</math> este număr impar deducem că cele două paranteze sunt numere impare; mai mult <math>x</math> este număr par. Cum <math> 585 = 3 \cdot 195 = 5 \cdot 117 = 9 \cdot 65 = 13 \cdot 45 = 15 \cdot 39</math> putem avea <math>x^y + 1 = 3</math> și <math> x^z + 1 = 195; x^y + 1 = 5 </math> și <math> x^z + 1 = 117; x^y + 1 = 9 </math> și <math> x^z + 1 = 65; x^y + 1 = 13 </math> și <math> x^z + 1 = 45; x^y + 1 = 15 </math> și <math> x^z + 1 = 39 </math>, sau invers. Soluții naturale obținem numai pentru <math> x^y + 1 = 9 </math> sau <math> x^y + 1 = 65 </math>.
Găsim <math> x = 2, y = 3, z = 6 </math>, sau <math> x = 2, y = 6, z = 3 </math>

E:15344

2025-01-11T20:04:12Z

Tita Marian: Created page with "'''E:15344 (Teodora Zetea și Bogdan Zetea, Sighetu Marmației)''' ''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. '''Soluție''' Cifrele prime sunt <math>2</math>, <math>3</math>, <math>5</math> și <math>7</math>. a) La un număr format din trei cifre diferite, cifrele sutelor se pot alege din <math>4</math>..."

'''E:15344 (Teodora Zetea și Bogdan Zetea, Sighetu Marmației)'''

''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.

'''Soluție'''

Cifrele prime sunt <math>2</math>, <math>3</math>, <math>5</math> și <math>7</math>.

a) La un număr format din trei cifre diferite, cifrele sutelor se pot alege din <math>4</math> valori, cifra zecilor cu <math>3</math> valori și cifra unităților cu <math>2</math> valori. În aceste condiții, obținem:
<math>4 \cdot 3 \cdot 2 = 24</math> de numere.

b) La numerele primiale de o cifră, cifra unităților este o dată <math>2</math>, o dată <math>3</math>, o dată <math>5</math> și o dată <math>7</math>.

La numerele primiale de două cifre, cifra unităților este de trei ori <math>2</math>, de trei ori <math>3</math>, de trei ori <math>5</math> și de trei ori <math>7</math>.

La numerele primiale de trei cifre, cifra unităților este de <math>6</math> ori <math>2</math>, de <math>6</math> ori <math>3</math>, de <math>6</math> ori <math>5</math> și de <math>6</math> ori <math>7</math>.

La numerele primiale de patru cifre, cifra unităților este de <math>6</math> ori <math>2</math>, de <math>6</math> ori <math>3</math>, de <math>6</math> ori <math>5</math> și de <math>6</math> ori <math>7</math>

Atunci, cifra unităților sumei este cifra unităților numărului
<math>16 \cdot ( 2 + 3 + 5 + 7),</math> adică <math>2</math>. Un pătrat perfect nu poate avea cifra unităților <math>2</math>.

E:15343

2025-01-11T19:50:23Z

Tita Marian: Created page with "'''E:15343 (Mihaela Berindeanu, București)''' ''Determinați numerele naturale a, b, c pentru care <math>3^a + 3^b + 3^c = 81 \cdot 2018</math>.'' '''Soluție''' Presupunem, fără a restrânge generalitatea problemei, că <math>a \leq b \leq c</math>. Ecuația devine <math>3^a \cdot (1 + 3^{b-a} + 3^{c-a}) = 3^{8072}.</math> Numărul <math>3^{8072}</math> se divide numai cu puteri ale lui 3. Dacă <math>b - a \neq 0</math> sau <math> c - a \neq 0 </math>, atunci..."

'''E:15343 (Mihaela Berindeanu, București)'''

''Determinați numerele naturale a, b, c pentru care <math>3^a + 3^b + 3^c = 81 \cdot 2018</math>.''

'''Soluție'''

Presupunem, fără a restrânge generalitatea problemei, că <math>a \leq b \leq c</math>. Ecuația devine
<math>3^a \cdot (1 + 3^{b-a} + 3^{c-a}) = 3^{8072}.</math>
Numărul <math>3^{8072}</math> se divide numai cu puteri ale lui 3. Dacă <math>b - a \neq 0</math> sau <math> c - a \neq 0 </math>, atunci <math>1 + 3^{b-a} + 3^{c-a}</math> este un număr care nu se divide cu 3, dar care divide <math>3^{8072}</math>, imposibil.

Deducem că <math>b - a = 0</math> și <math>c - a = 0</math>, adică <math>a = b = c.</math> Cu aceasta, ecuația devine
<math>3^a \cdot 3 = 3^{8072}</math> sau <math>3^{a+1} = 3^{8072},</math>
de unde <math>a = 8071</math> și atunci <math>a = b = c = 8071.</math>

E:15342

2025-01-11T18:24:22Z

Tita Marian: Created page with "'''E:15342 (Marian Haiducu, Pitești)''' ''Determinați restul împărțirii numărului 1234567898999 la 8.'' '''Soluție''' Putem scrie: <math>1234567898999 = 1234567898 \cdot 1000 + 999 = 1234567898 \cdot 125 \cdot 8 + 124 \cdot 8 + 7 =</math> <math>= 8 \cdot (1234567898 \cdot 125 + 124) + 7.</math> Cum <math>7 < 8</math>, rezultă că restul împărțirii este 7."

'''E:15342 (Marian Haiducu, Pitești)'''

''Determinați restul împărțirii numărului 1234567898999 la 8.''

'''Soluție'''

Putem scrie:

<math>1234567898999 = 1234567898 \cdot 1000 + 999 = 1234567898 \cdot 125 \cdot 8 + 124 \cdot 8 + 7 =</math>

<math>= 8 \cdot (1234567898 \cdot 125 + 124) + 7.</math>

Cum <math>7 < 8</math>, rezultă că restul împărțirii este 7.

3811 - Bisectoare1

2024-01-10T20:27:24Z

Tita Marian: /* Exemplu 2 */

== Cerinţa ==
Se dau lungimile laturilor unui triunghi ''' ABC'''. Aflati lungimile bisectoarelor duse din ''' C, A, B'''.
== Date de intrare ==
Programul citește de la tastatură numerele ''' a, b, c''', reprezentand lungimile laturilor ''' AB, BC, AC'''.
== Date de ieșire ==
Programul va afișa pe ecran lungimile bisectoarelor cu 2 zecimale exacte daca triunghiul este valid, altfel se afiseaza mesajul ''' Imposibil'''.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu respecta cerintele impuse." , iar daca se indeplinesc, se afiseaza mesajul "Datele de intrare respecta cerintele impuse."
== Restricţii şi precizări ==
* 1 &les; '''a, b, c''' &les; 100
== Exemplul 1 ==
; Intrare
3
5
4
; Ieșire
Datele de intrare respectă cerințele impuse.
3.20
2.14
2.54

 
== Exemplul 2 ==
; Intrare
0
1
2
; Ieșire
Imposibil
Datele de intrare nu respectă cerințele impuse.

== Rezolvare ==
<syntaxhighlight lang="python" line>
def citeste_laturi():
a = float(input()) # Citirea valorii pentru latura AB
b = float(input()) # Citirea valorii pentru latura BC
c = float(input()) # Citirea valorii pentru latura AC
return a, b, c

def sunt_lungimi_valide(a, b, c):
return 1 <= a <= 100 and 1 <= b <= 100 and 1 <= c <= 100

def este_triunghi_valid(a, b, c):
return a + b > c and a + c > b and b + c > a

def calculeaza_bisectoare(a, b, c):
s = (a + b + c) / 2
bisectoare_c = 2 * (s * b * c / (2 * s * s - b * b)) ** 0.5
bisectoare_a = 2 * (s * a * c / (2 * s * s - a * a)) ** 0.5
bisectoare_b = 2 * (s * a * b / (2 * s * s - c * c)) ** 0.5
return bisectoare_c, bisectoare_a, bisectoare_b

if __name__ == "__main__":
a, b, c = citeste_laturi()

if sunt_lungimi_valide(a, b, c) and este_triunghi_valid(a, b, c):
bisectoare_c, bisectoare_a, bisectoare_b = calculeaza_bisectoare(a, b, c)
print("{:.2f} {:.2f} {:.2f}".format(bisectoare_c, bisectoare_a, bisectoare_b))
print("Datele de intrare respectă cerințele impuse.")
else:
print("Imposibil")
print("Datele de intrare nu respectă cerințele impuse.")

</syntaxhighlight>

== Explicație rezolvare ==
Primul pas implică citirea lungimilor laturilor triunghiului (a, b, c) de la tastatură
Funcția '''sunt_lungimi_valide(a, b, c) ''' returnează True dacă lungimile sunt valide și False în caz contrar.
Funcția '''este_triunghi_valid''' (a, b, c) returnează True dacă acestea formează un triunghi valid și False în caz contrar.
Pasul 4 presupune calculul lungimilor bisectoarelor și le returnează sub formă de tuplă (bisectoare_c, bisectoare_a, bisectoare_b).
Ultimul pas implică afișarea lungimilor bisectoarelor cu 2 zecimale exacte.

3811 - Bisectoare1

2024-01-10T20:27:06Z

Tita Marian:

== Cerinţa ==
Se dau lungimile laturilor unui triunghi ''' ABC'''. Aflati lungimile bisectoarelor duse din ''' C, A, B'''.
== Date de intrare ==
Programul citește de la tastatură numerele ''' a, b, c''', reprezentand lungimile laturilor ''' AB, BC, AC'''.
== Date de ieșire ==
Programul va afișa pe ecran lungimile bisectoarelor cu 2 zecimale exacte daca triunghiul este valid, altfel se afiseaza mesajul ''' Imposibil'''.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu respecta cerintele impuse." , iar daca se indeplinesc, se afiseaza mesajul "Datele de intrare respecta cerintele impuse."
== Restricţii şi precizări ==
* 1 &les; '''a, b, c''' &les; 100
== Exemplul 1 ==
; Intrare
3
5
4
; Ieșire
Datele de intrare respectă cerințele impuse.
3.20
2.14
2.54

 
== Exemplu 2 ==
; Intrare
0
1
2
; Ieșire
Imposibil
Datele de intrare nu respectă cerințele impuse.

== Rezolvare ==
<syntaxhighlight lang="python" line>
def citeste_laturi():
a = float(input()) # Citirea valorii pentru latura AB
b = float(input()) # Citirea valorii pentru latura BC
c = float(input()) # Citirea valorii pentru latura AC
return a, b, c

def sunt_lungimi_valide(a, b, c):
return 1 <= a <= 100 and 1 <= b <= 100 and 1 <= c <= 100

def este_triunghi_valid(a, b, c):
return a + b > c and a + c > b and b + c > a

def calculeaza_bisectoare(a, b, c):
s = (a + b + c) / 2
bisectoare_c = 2 * (s * b * c / (2 * s * s - b * b)) ** 0.5
bisectoare_a = 2 * (s * a * c / (2 * s * s - a * a)) ** 0.5
bisectoare_b = 2 * (s * a * b / (2 * s * s - c * c)) ** 0.5
return bisectoare_c, bisectoare_a, bisectoare_b

if __name__ == "__main__":
a, b, c = citeste_laturi()

if sunt_lungimi_valide(a, b, c) and este_triunghi_valid(a, b, c):
bisectoare_c, bisectoare_a, bisectoare_b = calculeaza_bisectoare(a, b, c)
print("{:.2f} {:.2f} {:.2f}".format(bisectoare_c, bisectoare_a, bisectoare_b))
print("Datele de intrare respectă cerințele impuse.")
else:
print("Imposibil")
print("Datele de intrare nu respectă cerințele impuse.")

</syntaxhighlight>

== Explicație rezolvare ==
Primul pas implică citirea lungimilor laturilor triunghiului (a, b, c) de la tastatură
Funcția '''sunt_lungimi_valide(a, b, c) ''' returnează True dacă lungimile sunt valide și False în caz contrar.
Funcția '''este_triunghi_valid''' (a, b, c) returnează True dacă acestea formează un triunghi valid și False în caz contrar.
Pasul 4 presupune calculul lungimilor bisectoarelor și le returnează sub formă de tuplă (bisectoare_c, bisectoare_a, bisectoare_b).
Ultimul pas implică afișarea lungimilor bisectoarelor cu 2 zecimale exacte.

0418 - Subgraf

2024-01-10T20:12:19Z

Tita Marian:

== Cerinţa ==
Se dă lista muchiilor unui graf neorientat cu '''n''' vârfuri, etichetate de la 1 la n. Din acest graf se elimină toate vârfurile etichetate cu valori prime. Să se determine câte muchii va avea subgraful obținut.
== Date de intrare ==
Fişierul de intrare '''subgrafin.txt''' conţine pe prima linie numărul '''n''', reprezentând numărul de vârfuri ale grafului. Fiecare dintre următoarele linii conține câte o pereche de numere '''i j''', cu semnificația că există muchie între '''i''' și '''j'''.
== Date de ieșire ==
Pe ecran se va afișa mesajul: '''"Datele de intrare respectă cerințele impuse"''' daca se respecta datele de intrare iar in caz contrar se afiseaza mesajul ''' “Datele de intrare nu respectă cerințele impuse” '''
Fişierul de ieşire '''subgrafout.txt'''va conţine pe prima linie numărul '''M''' de muchii ale subgrafului obținut.
== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 100
* 1 &les; '''i, j''' &les; n
* muchiile se pot repeta în fișierul de intrare

== Exemplul 1 ==
;Subgrafin.txt
5
1 4
2 5
2 3
2 1
4 5
3 2
4 3
;Subgrafout.txt
Datele de intrare respectă cerințele impuse
1

==Explicație==
Se elimină vârfurile 2 3 5. Subgraful va conține vârfurile 1 4, cu o singură muchie.

 
== Exemplul 2 ==
;Subgrafin.txt
0
;Subgrafout.txt
Datele de intrare nu respectă cerințele impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def is_prime(num):
if num < 2:
return False
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True

def count_edges_after_prime_removal(graph, n):
primes = [i for i in range(2, n + 1) if is_prime(i)]
vertices_to_remove = set(primes)

# Eliminăm vârfurile etichetate cu valori prime din graful original
new_graph = [(i, j) for (i, j) in graph if i not in vertices_to_remove and j not in vertices_to_remove]

# Numărăm câte muchii rămân în subgraful obținut
return len(new_graph)

def is_adjacency_matrix(matrix, dimensiune):
# Verificăm dacă matricea este pătratică
if len(matrix) != dimensiune:
return False

# Verificăm dacă matricea este simetrică
for i in range(dimensiune):
for j in range(i + 1, dimensiune):
if matrix[i][j] != matrix[j][i]:
return False

return True

def main():
try:
# Citim datele de intrare din fișierul "subgraf.in"
with open("subgrafin.txt", "r") as fin:
n = int(fin.readline().strip())
graph = [tuple(map(int, line.split())) for line in fin.readlines()]

# Verificăm respectarea restricțiilor
if not (1 <= n <= 100) or any(not (1 <= i <= n and 1 <= j <= n) for i, j in graph):
with open("subgrafout.txt", "w", encoding="utf-8") as fout:
fout.write("Datele de intrare nu respectă cerințele impuse\n")
return
else:
with open("subgrafout.txt", "w", encoding="utf-8") as fout:
fout.write("Datele de intrare respectă cerințele impuse\n")

# Calculăm numărul de muchii în subgraful obținut
result_edges = count_edges_after_prime_removal(graph, n)

# Scriem rezultatul în fișierul "subgrafout.txt"
with open("subgrafout.txt", "a", encoding="utf-8") as fout:
fout.write(f"{result_edges}\n")

except Exception as e:
with open("subgrafout.txt", "w", encoding="utf-8") as fout:
fout.write(f"Datele de intrare nu respectă cerințele impuse: {e}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

0418 - Subgraf

2024-01-10T20:11:44Z

Tita Marian:

== Cerinţa ==
Se dă lista muchiilor unui graf neorientat cu '''n''' vârfuri, etichetate de la 1 la n. Din acest graf se elimină toate vârfurile etichetate cu valori prime. Să se determine câte muchii va avea subgraful obținut.
== Date de intrare ==
Fişierul de intrare '''subgrafin.txt''' conţine pe prima linie numărul '''n''', reprezentând numărul de vârfuri ale grafului. Fiecare dintre următoarele linii conține câte o pereche de numere '''i j''', cu semnificația că există muchie între '''i''' și '''j'''.
== Date de ieșire ==
Pe ecran se va afișa mesajul: '''"Datele de intrare respectă cerințele impuse"''' daca se respecta datele de intrare iar in caz contrar se afiseaza mesajul ''' “Datele de intrare nu respectă cerințele impuse” '''
Fişierul de ieşire '''subgrafout.txt'''va conţine pe prima linie numărul '''M''' de muchii ale subgrafului obținut.
== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 100
* 1 &les; '''i, j''' &les; n
* muchiile se pot repeta în fișierul de intrare

== Exemplul 1 ==
Subgrafin.txt
5
1 4
2 5
2 3
2 1
4 5
3 2
4 3
Subgrafout.txt
Datele de intrare respectă cerințele impuse
1

==Explicație==
Se elimină vârfurile 2 3 5. Subgraful va conține vârfurile 1 4, cu o singură muchie.

 
== Exemplul 2 ==
Subgrafin.txt
0
Subgrafout.txt
Datele de intrare nu respectă cerințele impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def is_prime(num):
if num < 2:
return False
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True

def count_edges_after_prime_removal(graph, n):
primes = [i for i in range(2, n + 1) if is_prime(i)]
vertices_to_remove = set(primes)

# Eliminăm vârfurile etichetate cu valori prime din graful original
new_graph = [(i, j) for (i, j) in graph if i not in vertices_to_remove and j not in vertices_to_remove]

# Numărăm câte muchii rămân în subgraful obținut
return len(new_graph)

def is_adjacency_matrix(matrix, dimensiune):
# Verificăm dacă matricea este pătratică
if len(matrix) != dimensiune:
return False

# Verificăm dacă matricea este simetrică
for i in range(dimensiune):
for j in range(i + 1, dimensiune):
if matrix[i][j] != matrix[j][i]:
return False

return True

def main():
try:
# Citim datele de intrare din fișierul "subgraf.in"
with open("subgrafin.txt", "r") as fin:
n = int(fin.readline().strip())
graph = [tuple(map(int, line.split())) for line in fin.readlines()]

# Verificăm respectarea restricțiilor
if not (1 <= n <= 100) or any(not (1 <= i <= n and 1 <= j <= n) for i, j in graph):
with open("subgrafout.txt", "w", encoding="utf-8") as fout:
fout.write("Datele de intrare nu respectă cerințele impuse\n")
return
else:
with open("subgrafout.txt", "w", encoding="utf-8") as fout:
fout.write("Datele de intrare respectă cerințele impuse\n")

# Calculăm numărul de muchii în subgraful obținut
result_edges = count_edges_after_prime_removal(graph, n)

# Scriem rezultatul în fișierul "subgrafout.txt"
with open("subgrafout.txt", "a", encoding="utf-8") as fout:
fout.write(f"{result_edges}\n")

except Exception as e:
with open("subgrafout.txt", "w", encoding="utf-8") as fout:
fout.write(f"Datele de intrare nu respectă cerințele impuse: {e}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

3163 - Secv Max Val

2024-01-10T19:54:28Z

Tita Marian:

== Cerinţa ==
Se dă un șir de '''numar_elemente''' numere naturale și un număr natural '''valoare_maxima'''. Determinați lungimea maximă a unei secvențe cu proprietatea că suma numerelor din aceasta este mai mică sau egală cu '''valoare_maxima'''.
== Date de intrare ==
Fișierul de intrare '''secvmaxvalin.txt''' conține pe prima linie numerele '''numar_elemente''' și '''valoare_maxima''', iar pe a două linie '''numar_elemente''' numere naturale separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''secvmaxvalout.txt''' va conține pe prima linie lungimea maximă a unei secvențe care satisface proprietatea dată.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund cerintelor impuse." , iar daca se indeplinesc, se afiseaza mesajul "Datele de intrare corespund cerintelor impuse."
== Restricţii şi precizări ==
* 1 &les; '''numar_elemente''' &les; 200000
* numerele de pe a două linie a fișierului de intrare vor fi mai mici decât 1.000.000.000
* 1 &les; '''valoare_maxima''' &les; 2^63

== Exemplu 1 ==
; secvmaxvalin.txt
5 11
4 5 2 3 9

; secvmaxvalout.txt
Datele de intrare corespund cerintelor impuse.
3

==Explicatie==
O secvență de lungime maximă cu suma elementelor mai mică sau egală cu 11 este 5 2 3.

 
== Exemplu 2 ==
; secvmaxvalin.txt
5 10
1000000001 8 5 19 1
; secvmaxvalout.txt
Datele de intrare nu corespund cerintelor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def lungime_maxima_secventa(numar_elemente, valoare_maxima, numere):
# Verificare restricții date de intrare
if not (1 <= numar_elemente <= 200000 and 1 <= valoare_maxima <= 263 and all(1 <= num <= 1000000000 for num in numere)):
with open("secvmaxvalout.txt", "w", encoding="utf-8") as output_file:
output_file.write("Datele de intrare nu corespund restricțiilor impuse.")
return

suma_actuala = 0
lungime_maxima = 0
stanga = 0

for dreapta in range(numar_elemente):
suma_actuala += numere[dreapta]

while suma_actuala > valoare_maxima:
suma_actuala -= numere[stanga]
stanga += 1

lungime_maxima = max(lungime_maxima, dreapta - stanga + 1)

# Scrierea mesajului în fișierul de ieșire
with open("secvmaxvalout.txt", "w", encoding="utf-8") as output_file:
output_file.write("Datele de intrare corespund restricțiilor impuse.\n")
output_file.write(str(lungime_maxima))

def main():
# Citirea datelor din fișierul de intrare
with open("secvmaxvalin.txt", "r", encoding="utf-8") as input_file:
numar_elemente, valoare_maxima = map(int, input_file.readline().split())
numere = list(map(int, input_file.readline().split()))

# Determinarea lungimii maxime a unei secvențe
lungime_maxima_secventa(numar_elemente, valoare_maxima, numere)

if __name__ == "__main__":
main()

</syntaxhighlight>

1608 - Sortare Divizori

2024-01-10T19:31:26Z

Tita Marian: /* Exemplul 1 */

== Cerinţa ==
Se dau '''n''' numere naturale nenule. Ordonați descrescător cele '''n''' numere după numărul lor de divizori.
== Date de intrare ==
Fișierul de intrare '''sortare_divizoriin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale nenule separate prin câte un spațiu.
== Date de ieșire ==
Fișierul de ieșire '''sortare_divizoriout.txt''' va conține cele n numere aflate pe a doua linie a fișierului de intrare ordonate descrescător după numărul de divizori.
== Restricţii şi precizări ==
* 1 ≤ '''n''' &les; 1.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât 1.000.000.000
* dacă există mai multe numere care au același număr de divizori, acestea vor fi ordonate crescător

== Exemplul 1 ==
; sortare_divizoriin.txt
5
12 20 4 100 13
;sortare_divizoriout.txt
Datele de intrare respectă cerințele impuse.
100 12 20 4 13

==Explicație==
12 are 6 divizori, 20 are 6 divizori, 4 are 3 divizori, 100 are 9 divizori, 13 are 2 divizori, 12 și 20 au același număr de divizori. Așadar ordinea va fi 100 12 20 4 13.
==Exemplul2==
; sortare_divizoriin.txt
5
12 20 4 100 1000000001
; sortare_divizoriout.txt
Datele de intrare nu respectă cerințele impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_divizori(numar):
divizori = 0
for i in range(1, numar + 1):
if numar % i == 0:
divizori += 1
return divizori

def sortare_divizori(n, numere):
# Calculează numărul de divizori pentru fiecare număr și creează o listă de tupluri (număr, număr_divizori)
numere_divizori = [(nr, numar_divizori(nr)) for nr in numere]

# Sortează lista de tupluri în funcție de numărul de divizori descrescător și apoi după valoarea numărului crescător
numere_divizori.sort(key=lambda x: (-x[1], x[0]))

return [nr for nr, _ in numere_divizori]

def main():
try:
with open("sortare_divizoriin.txt", "r", encoding="utf-8") as f:
n = int(f.readline())
if not 1 <= n <= 1000:
raise ValueError
numere = list(map(int, f.readline().split()))
if not all(1 <= nr < 1000000000 for nr in numere):
raise ValueError

with open("sortare_divizoriout.txt", "w", encoding="utf-8") as f_out:
f_out.write("Datele de intrare respectă cerințele impuse.\n")

rezultat = sortare_divizori(n, numere)
f_out.write(" ".join(map(str, rezultat)))
except Exception as e:
with open("sortare_divizoriout.txt", "w", encoding="utf-8") as f_out:
f_out.write(f"Datele de intrare nu respectă cerințele impuse.")

if __name__ == "__main__":
main()

</syntaxhighlight>

1608 - Sortare Divizori

2024-01-10T19:30:43Z

Tita Marian:

== Cerinţa ==
Se dau '''n''' numere naturale nenule. Ordonați descrescător cele '''n''' numere după numărul lor de divizori.
== Date de intrare ==
Fișierul de intrare '''sortare_divizoriin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale nenule separate prin câte un spațiu.
== Date de ieșire ==
Fișierul de ieșire '''sortare_divizoriout.txt''' va conține cele n numere aflate pe a doua linie a fișierului de intrare ordonate descrescător după numărul de divizori.
== Restricţii şi precizări ==
* 1 ≤ '''n''' &les; 1.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât 1.000.000.000
* dacă există mai multe numere care au același număr de divizori, acestea vor fi ordonate crescător

== Exemplul 1 ==
; sortare_divizoriin.txt
5
12 20 4 100 13
;sortare_divizoriout.txt
100 12 20 4 13

==Explicație==
12 are 6 divizori, 20 are 6 divizori, 4 are 3 divizori, 100 are 9 divizori, 13 are 2 divizori, 12 și 20 au același număr de divizori. Așadar ordinea va fi 100 12 20 4 13.
==Exemplul2==
; sortare_divizoriin.txt
5
12 20 4 100 1000000001
; sortare_divizoriout.txt
Datele de intrare nu respectă cerințele impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_divizori(numar):
divizori = 0
for i in range(1, numar + 1):
if numar % i == 0:
divizori += 1
return divizori

def sortare_divizori(n, numere):
# Calculează numărul de divizori pentru fiecare număr și creează o listă de tupluri (număr, număr_divizori)
numere_divizori = [(nr, numar_divizori(nr)) for nr in numere]

# Sortează lista de tupluri în funcție de numărul de divizori descrescător și apoi după valoarea numărului crescător
numere_divizori.sort(key=lambda x: (-x[1], x[0]))

return [nr for nr, _ in numere_divizori]

def main():
try:
with open("sortare_divizoriin.txt", "r", encoding="utf-8") as f:
n = int(f.readline())
if not 1 <= n <= 1000:
raise ValueError
numere = list(map(int, f.readline().split()))
if not all(1 <= nr < 1000000000 for nr in numere):
raise ValueError

with open("sortare_divizoriout.txt", "w", encoding="utf-8") as f_out:
f_out.write("Datele de intrare respectă cerințele impuse.\n")

rezultat = sortare_divizori(n, numere)
f_out.write(" ".join(map(str, rezultat)))
except Exception as e:
with open("sortare_divizoriout.txt", "w", encoding="utf-8") as f_out:
f_out.write(f"Datele de intrare nu respectă cerințele impuse.")

if __name__ == "__main__":
main()

</syntaxhighlight>

1608 - Sortare Divizori

2024-01-10T19:01:52Z

Tita Marian:

== Cerinţa ==
Se dau '''n''' numere naturale nenule. Ordonați descrescător cele '''n''' numere după numărul lor de divizori.
== Date de intrare ==
Fișierul de intrare '''sortare_divizoriin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale nenule separate prin câte un spațiu.
== Date de ieșire ==
Fișierul de ieșire '''sortare_divizoriout.txt''' va conține cele n numere aflate pe a doua linie a fișierului de intrare ordonate descrescător după numărul de divizori.
== Restricţii şi precizări ==
* 1 ≤ '''n''' &les; 1.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât 1.000.000.000
* dacă există mai multe numere care au același număr de divizori, acestea vor fi ordonate crescător

== Exemplu 1 ==
; sortare_divizoriin.txt
: 5
: 12 20 4 100 13
;sortare_divizoriout.txt
: 100 12 20 4 13
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_divizori(numar):
divizori = 0
for i in range(1, numar + 1):
if numar % i == 0:
divizori += 1
return divizori

if __name__ == "__main__":
# Citim numărul n și lista de numere din fișierul de intrare
with open("sortare_divizoriin.txt", "r") as f:
n = int(f.readline().strip())
numere = list(map(int, f.readline().strip().split()))

# Verificăm restricțiile impuse pentru numere
numere = [numar for numar in numere if numar < 1000000000]

# Calculăm numărul de divizori pentru fiecare număr și sortăm numerele în ordine descrescătoare după numărul de divizori,
# iar în caz de egalitate, sortăm crescător
numere.sort(key=lambda x: (numar_divizori(x), -x), reverse=True)

# Scriem rezultatul în fișierul de ieșire
with open("sortare_divizoriout.txt", "w") as f:
for numar in numere:
f.write(str(numar) + " ")
</syntaxhighlight>
==Explicație==
12 are 6 divizori, 20 are 6 divizori, 4 are 3 divizori, 100 are 9 divizori, 13 are 2 divizori, 12 și 20 au același număr de divizori. Așadar ordinea va fi 100 12 20 4 13.

1608 - Sortare Divizori

2024-01-10T18:59:58Z

Tita Marian:

== Cerinţa ==
Se dau '''n''' numere naturale nenule. Ordonați descrescător cele '''n''' numere după numărul lor de divizori.
== Date de intrare ==
Fișierul de intrare '''sortare_divizoriin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale nenule separate prin câte un spațiu.
== Date de ieșire ==
Fișierul de ieșire '''sortare_divizoriout.txt''' va conține cele n numere aflate pe a doua linie a fișierului de intrare ordonate descrescător după numărul de divizori.
== Restricţii şi precizări ==
* 1 ≤ '''n''' &les; 1.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât 1.000.000.000
* dacă există mai multe numere care au același număr de divizori, acestea vor fi ordonate crescător

== Exemplu 1 ==
; sortare_divizoriin.txt
: 5
: 12 20 4 100 13
;sortare_divizoriout.txt
: 100 12 20 4 13
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_divizori(numar):
divizori = 0
for i in range(1, numar + 1):
if numar % i == 0:
divizori += 1
return divizori

if __name__ == "__main__":
# Citim numărul n și lista de numere din fișierul de intrare
with open("sortare_divizori.in", "r") as f:
n = int(f.readline().strip())
numere = list(map(int, f.readline().strip().split()))

# Verificăm restricțiile impuse pentru numere
numere = [numar for numar in numere if numar < 1000000000]

# Calculăm numărul de divizori pentru fiecare număr și sortăm numerele în ordine descrescătoare după numărul de divizori,
# iar în caz de egalitate, sortăm crescător
numere.sort(key=lambda x: (numar_divizori(x), -x), reverse=True)

# Scriem rezultatul în fișierul de ieșire
with open("sortare_divizori.out", "w") as f:
for numar in numere:
f.write(str(numar) + " ")
</syntaxhighlight>
==Explicație==
12 are 6 divizori, 20 are 6 divizori, 4 are 3 divizori, 100 are 9 divizori, 13 are 2 divizori, 12 și 20 au același număr de divizori. Așadar ordinea va fi 100 12 20 4 13.

2224 - Mset

2024-01-09T20:06:08Z

Tita Marian:

== Context ==
Se consideră un șir '''A''', inițial vid. Se definesc următoarele operații:
*'''1 x''' – introduce valoarea '''x''' în șirul '''A'''
*'''2 x''' – șterge toate aparițiile lui '''x '''din '''A ''' (dacă '''x '''nu apare deloc în '''A''', operația nu se execută)
*'''3 '''– interogare: care este cea mai mică valoare din '''A '''și de câte ori apare (dacă '''A '''este șir vid, se va afișa doar valoarea '''-1''')

== Cerinţa ==
Dându-se '''N''' operații, trebuie să afișați răspunsul la fiecare operație de tip '''3'''.

==Date de intrare==
Fișierul de intrare '''msetin.txt''' conține pe prima linie '''N'''. Pe următoarele '''N''' linii sunt date cele '''N''' operații.
== Date de ieșire ==
În fișierul de ieșire '''msetout.txt''' se vor afișa pe câte o linie răspunsurile la operațiile de tip 3.În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*'''1 ≤ N ≤ 200 000'''
* Va exista cel puțin o operație de tip '''3'''
* Valorile care se introduc în mulțime sunt numere naturale mai mici decât '''2 000 000 000'''
== Exemplul 1 ==
; msetin.txt
14
3
1 55
1 55
3
1 40
3
1 7
1 7
3
2 7
1 50
3
2 40
3
; msetout.txt
Datele de intrare respecta cerintele impuse.
-1 0
55 2
40 1
7 2
40 1
50 1
 
== Exemplul 2 ==
; msetin.txt
3
1 4
2 3
2 5
; msetout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def process_operations(operations):
result = []
values = []

for op, *args in operations:
if op == 1:
x, = args
values.append(x)
elif op == 2:
x, = args
values = [val for val in values if val != x]
elif op == 3:
if values:
min_value = min(values)
count = values.count(min_value)
result.append((min_value, count))
else:
result.append((-1, 0))

return result

def validate_input(operations):
for op, *args in operations:
if op == 3:
return True
return False

def main():
with open("msetin.txt", "r") as file:
n = int(file.readline())
operations = [list(map(int, line.split())) for line in file]

if not validate_input(operations):
with open("msetout.txt", "w") as output_file:
output_file.write("Datele de intrare nu respecta cerintele impuse.")
return

results = process_operations(operations)

with open("msetout.txt", "w") as output_file:
output_file.write("Datele de intrare respecta cerintele impuse.\n")
for min_value, count in results:
output_file.write(f"{min_value} {count}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

1794 - Aint

2024-01-09T20:05:17Z

Tita Marian:

== Cerinţa ==
Se dă un vector cu '''N''' elemente numere naturale numerotate de la '''1''' la '''N''' și '''M''' operații de forma:
*'''1 x y''', cu semnificația: elementul de poziția '''x''' ia valoarea valoarea '''y'''.
*'''2 x y''': se determină valoarea minimă a elementelor cu indici cuprinși între '''x''' și '''y'''.
Afișați rezultatele operațiilor de tipul '''2'''.
==Date de intrare==
Fișierul de intrare '''aintin.txt''' conține pe prima linie numerele '''N''' și '''M'''. Pe următoarea linie se află '''N''' elemente ce reprezintă elementele vectorului. Pe următoarele '''M''' linii se află operațiile efectuate pe vector.
== Date de ieșire ==
Fișierul de ieșire '''aintout.txt''' va conține răspunsurile operațiilor de tipul '''2''', în ordinea în care apar în fișierul de intrare.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*'''1 ≤ N,M ≤ 100000'''
*Elementele vectorului sunt '''≤ 1000000000'''
*Pentru operațiile de tipul 1, '''1 ≤ x ≤ N, 0 ≤ y ≤ 1000000000'''
*Pentru operațiile de tipul 2, '''1 ≤ x ≤ y ≤ N'''
== Exemplul 1 ==
; aintin.txt
7 4
2 3 4 1 2 7 2
1 2 3
1 4 6
2 2 6
2 1 7
; aintout.txt
2
2
Datele de intrare respecta cerintele impuse.
 
== Exemplul 2 ==
; aintin.txt
8 3
2 3 4 1 2 7 2
1 2 3
1 10 6
2 2 6
; aintout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
with open("aintin.txt", "r") as infile, open("aintout.txt", "w") as outfile:
N, M = map(int, infile.readline().split())
nums = list(map(int, infile.readline().split()))

for _ in range(M):
op, x, y = map(int, infile.readline().split())

if not (1 <= N <= 100000 and 1 <= M <= 100000 and all(1 <= num <= 1000000000 for num in nums) and
(op == 1 and 1 <= x <= N and 0 <= y <= 1000000000 or op == 2 and 1 <= x <= y <= N)):
outfile.write("Datele de intrare nu respecta cerintele impuse.\n")
return

if op == 1:
nums[x - 1] = y
elif op == 2:
subvec = nums[x - 1:y]
subvec.sort()
outfile.write(f"{subvec[0]}\n")

outfile.write("Datele de intrare respecta cerintele impuse.\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

3589 - probleme

2024-01-09T19:35:49Z

Tita Marian:

== Cerinţa ==
O culegere de probleme de informatică conține '''n''' probleme, dintre care '''m''' sunt probleme ușoare. Bubu dorește să rezolve '''k''' probleme din culegere. În câte moduri poate alege Bubu cele '''k''' probleme, astfel încât între cele '''k''' probleme alese să existe cel puțin '''s''' probleme ușoare? Deoarece numărul obținut poate fi foarte mare, valoarea acestuia trebuie precizată modulo '''1000003'''.
== Date de intrare ==
Fișierul de intrare '''problemein.txt''' conține patru numere naturale '''n''' (numărul problemelor din culegere), '''m''' (numărul problemelor ușoare), '''k''' (numărul de probleme care trebuie rezolvate) și '''s''' (numărul minim de probleme ușoare din cele '''k'''), despărțite prin câte un spațiu.
== Date de ieșire ==
Fișierul de ieșire '''problemeout.txt''' va conține pe prima linie un număr natural reprezentând numărul de moduri în care poate alege Bubu cele '''k''' probleme, astfel încât între acestea să existe cel puțin '''s''' probleme ușoare. Acestă valoare trebuie precizată modulo '''1000003'''.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*1 ≤ s ≤ m ≤ n ≤ 100000 (numere naturale)
*1 ≤ k ≤ n
== Exemplul 1 ==
; problemein.txt
6 4 3 2

; problemeout.txt
Datele de intrare respecta cerintele impuse.
16

 
== Exemplul 2 ==
; problemein.txt
4 5 3 2

; problemeout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def combinari_modulo(n, k, modulo):
result = 1
for i in range(k):
result = (result * (n - i)) % modulo
result = (result * pow(i + 1, -1, modulo)) % modulo # calculul inversului modular

return result

def moduri_alegere_probleme(n, m, k, s, modulo):
result = 0

for i in range(s, min(m, k) + 1):
result = (result + combinari_modulo(m, i, modulo) * combinari_modulo(n - m, k - i, modulo)) % modulo

return result

def main():
try:
with open("problemein.txt", "r") as f:
n, m, k, s = map(int, f.readline().split())

# Verificare dacă datele respectă cerințele impuse
if 1 <= s <= m <= n <= 100000 and 1 <= k <= n:
# Afisare mesaj inainte de rezolvare
with open("problemeout.txt", "w") as f_out:
f_out.write("Datele de intrare respecta cerintele impuse.\n")

result = moduri_alegere_probleme(n, m, k, s, 1000003)
f_out.write(f"{result}\n")

else:
with open("problemeout.txt", "w") as f_out:
f_out.write("Datele de intrare nu respecta cerintele impuse.\n")

except Exception as e:
print(f"O eroare a apărut: {e}")

if __name__ == "__main__":
main()

</syntaxhighlight>

1297 - triunghiul

2024-01-09T19:35:08Z

Tita Marian:

== Cerinţa ==
Se dă următoarul triunghi de numere:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
..........
Deduceți regula după care a fost format triunghiul si afișați numerele aflate pe a '''n'''-lea linie a triunghiului.
== Date de intrare ==
Fișierul de intrare '''triunghiulin.txt''' conține pe prima linie numărul '''n'''.
== Date de ieșire ==
Fișierul de ieșire '''triunghiulout.txt''' va conține pe prima linie numerele care se află pe a '''n'''-lea linie din triunghi, separate prin câte un spațiu.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*0 ≤ n ≤ 19
*prima linie din triunghi se numerotează cu 0
== Exemplul 1 ==
; triunghiulin.txt
5

; triunghiulout.txt
Datele de intrare respecta cerintele impuse.
1 5 10 10 5 1

 
== Exemplul 2 ==
; triunghiulin.txt
20

; triunghiulout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def combinari(n, k):
if k == 0 or k == n:
return 1
else:
return combinari(n-1, k-1) + combinari(n-1, k)

def linie_triunghi(n):
return [combinari(n, k) for k in range(n + 1)]

def main():
try:
with open("triunghiulin.txt", "r") as f:
n = int(f.readline().strip())

# Verificare dacă datele respectă cerințele impuse
if 0 <= n <= 19:
# Afisare mesaj inainte de rezolvare
with open("triunghiulout.txt", "w") as f_out:
f_out.write("Datele de intrare respecta cerintele impuse.\n")
f_out.write(" ".join(map(str, linie_triunghi(n))) + "\n")
else:
with open("triunghiulout.txt", "w") as f_out:
f_out.write("Datele de intrare nu respecta cerintele impuse.")

except Exception as e:
print(f"O eroare a apărut: {e}")

if __name__ == "__main__":
main()

</syntaxhighlight>

2034 - Archpsod

2024-01-09T19:34:15Z

Tita Marian:

==Context==
Vrăjitorul Arpsod s-a plictisit groaznic așa că s-a gândit să își cheme prietenii (vrăjitori din regatele vecine) la un joc. Deoarece nu crede în “noroc”, Arpsod i-a provocat la tir cu arcul. Câștigătorul va fi cel ce va avea distanța maximă între două săgeți aflate pe țintă
== Cerinţa ==
Arpsod vă roagă să faceți un program care, pentru un număr '''N''' cunoscut de trageri și poziția fiecărei săgeți pe țintă, determină distanța maximă dintre două săgeți.
== Date de intrare ==
În fișierul '''archpsodin.txt''', pe prima linie, se va afla numărul natural '''N''', reprezentând numărul de trageri. Pe fiecare din următoarele '''N''' linii, se află două numere întregi '''x''' și '''y''', reprezentând coordonatele săgeților pe țintă.
== Date de ieșire ==
În fișierul '''archpsodout.txt''', pe prima și singura linie se va afișa un număr real reprezentând distanța maximă dintre două săgeți. Răspunsul este considerat corect dacă diferența față de răspunsul oficial este mai mică de '''10-6'''.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*2 ≤ '''N''' ≤ 100.000
*-1.000 ≤ '''x, y''' ≤ 1.000
*Se garantează că toate cele '''N''' săgeți sunt pe țintă.
*Coordonatele planului sunt carteziene
*Originea planului este considerată centrul țintei.
== Exemplul 1 ==
; archpsodin.txt
2
2 2
-1 -2

; archpsodout.txt
Datele de intrare respecta cerintele impuse.
5.0000
 
== Exemplul 2 ==
; archpsodin.txt
5
-4 1
-100 0
0 4
2 -3
2 300

; archpsodout.txt
Datele de intrare respecta cerintele impuse.
316.865902
==Explicatie==
În exemplul al doilea, distanța maximă este dată de punctele ''' (-100, 0) ''' și ''' (2, 300) '''
== Exemplul 3 ==
; Intrare
1
2 3
; Ieșire
Datele de intrare nu respecta cerintele impuse.

 

== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def distanta_euclidiana(p1, p2):
return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)

def distanta_maxima_sagetilor(N, sageți):
distanta_maxima = 0.0

for i in range(N):
for j in range(i + 1, N):
distanta = distanta_euclidiana(sageți[i], sageți[j])
distanta_maxima = max(distanta_maxima, distanta)

return distanta_maxima

# Citire date de intrare
try:
with open("archpsodin.txt", "r") as f:
N = int(f.readline().strip())
sageți = [tuple(map(float, f.readline().strip().split())) for _ in range(N)]

# Verificare dacă datele respectă cerințele impuse
if 2 <= N <= 100000 and all(-1000 <= x <= 1000 and -1000 <= y <= 1000 for x, y in sageți):
# Afisare mesaj inainte de rezolvare
with open("archpsodout.txt", "w") as f:
f.write("Datele de intrare respecta cerintele impuse.\n")
f.write(f"{distanta_maxima_sagetilor(N, sageți):.6f}\n")
else:
with open("archpsodout.txt", "w") as f:
f.write("Datele de intrare nu respecta cerintele impuse.")

except Exception as e:
print(f"O eroare a apărut: {e}")

</syntaxhighlight>

0934 - Distanta Punct Segment

2024-01-09T19:32:25Z

Tita Marian:

== Cerinţa ==
Se dau în plan, un punct și un segment. Să se determine distanța minimă de la punctul dat la un punct aparținând segmentului.
== Date de intrare ==
Fișierul de intrare '''distantapunctsegmentin.txt''' conține pe prima linie 6 numere naturale separate prin spații, respectiv: '''X1, Y1, X2, Y2, X3, Y3'''. Se cere determinarea distanței minime de la punctul de coordonate '''(X1, Y1)''' la un punct aparținând segmentului cu capetele în punctele '''(X2, Y2)''' și '''(X3, Y3)'''.
== Date de ieșire ==
Fișierul de ieșire '''distantapunctsegmentout.txt''' va conține pe prima linie un număr real cu exact două zecimale exacte (fără rotunjire).
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*Numerele din fișierul de intrare sunt întregi cuprinse între -1001 și 1001.
*Punctele care determină segmentul sunt distincte.
== Exemplul 1 ==
; distantapunctsegmentin.txt
0 1 0 0 1 0
; distantapunctsegmentout.txt
Datele de intrare respecta cerintele impuse.
1.00
 
== Exemplul 2 ==
; distantapunctsegmentin.txt
1 2 3 4 3 4

; distantapunctsegmentout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def distanta_punct_la_segment(X1, Y1, X2, Y2, X3, Y3):
# Calculează distanța de la punct la linia dreaptă
numer = (X3 - X2) * (X2 - X1) + (Y3 - Y2) * (Y2 - Y1)
denom = (X3 - X2)**2 + (Y3 - Y2)**2
u = numer / denom

# Determină punctul cel mai apropiat de dreaptă
if u < 0:
xp, yp = X2, Y2
elif u > 1:
xp, yp = X3, Y3
else:
xp = X2 + u * (X3 - X2)
yp = Y2 + u * (Y3 - Y2)

# Calculează distanța de la punct la punctul cel mai apropiat de dreaptă
distanta = math.sqrt((X1 - xp)**2 + (Y1 - yp)**2)
return distanta

# Citire date de intrare
try:
with open("distantapunctsegmentin.txt", "r") as f:
X1, Y1, X2, Y2, X3, Y3 = map(int, f.readline().strip().split())

# Verificare dacă datele respectă cerințele impuse
if (-1001 <= X1 <= 1001) and (-1001 <= Y1 <= 1001) and (-1001 <= X2 <= 1001) and (-1001 <= Y2 <= 1001) and (-1001 <= X3 <= 1001) and (-1001 <= Y3 <= 1001) and (X2, Y2) != (X3, Y3):
# Afisare mesaj inainte de rezolvare
with open("distantapunctsegmentout.txt", "w") as f:
f.write("Datele de intrare respecta cerintele impuse.\n")
f.write(f"{distanta_punct_la_segment(X1, Y1, X2, Y2, X3, Y3):.2f}\n")
else:
with open("distantapunctsegmentout.txt", "w") as f:
f.write("Datele de intrare nu respecta cerintele impuse.")

except Exception as e:
print(f"O eroare a apărut: {e}")

</syntaxhighlight>

0934 - Distanta Punct Segment

2024-01-09T19:31:48Z

Tita Marian:

== Cerinţa ==
Se dau în plan, un punct și un segment. Să se determine distanța minimă de la punctul dat la un punct aparținând segmentului.
== Date de intrare ==
Fișierul de intrare '''distantapunctsegmentin.txt''' conține pe prima linie 6 numere naturale separate prin spații, respectiv: '''X1, Y1, X2, Y2, X3, Y3'''. Se cere determinarea distanței minime de la punctul de coordonate '''(X1, Y1)''' la un punct aparținând segmentului cu capetele în punctele '''(X2, Y2)''' și '''(X3, Y3)'''.
== Date de ieșire ==
Fișierul de ieșire '''distantapunctsegmentout.txt''' va conține pe prima linie un număr real cu exact două zecimale exacte (fără rotunjire).
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*Numerele din fișierul de intrare sunt întregi cuprinse între -1001 și 1001.
*Punctele care determină segmentul sunt distincte.
== Exemplul 1 ==
; distantapunctsegmentin.txt
0 1 0 0 1 0
; distantapunctsegmentout.txt
Datele de intrare respecta cerintele impuse.
1.00
 
== Exemplul 2 ==
; distantapunctsegmentin
1 2 3 4 3 4

; distantapunctsegmentout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def distanta_punct_la_segment(X1, Y1, X2, Y2, X3, Y3):
# Calculează distanța de la punct la linia dreaptă
numer = (X3 - X2) * (X2 - X1) + (Y3 - Y2) * (Y2 - Y1)
denom = (X3 - X2)**2 + (Y3 - Y2)**2
u = numer / denom

# Determină punctul cel mai apropiat de dreaptă
if u < 0:
xp, yp = X2, Y2
elif u > 1:
xp, yp = X3, Y3
else:
xp = X2 + u * (X3 - X2)
yp = Y2 + u * (Y3 - Y2)

# Calculează distanța de la punct la punctul cel mai apropiat de dreaptă
distanta = math.sqrt((X1 - xp)**2 + (Y1 - yp)**2)
return distanta

# Citire date de intrare
try:
with open("distantapunctsegmentin.txt", "r") as f:
X1, Y1, X2, Y2, X3, Y3 = map(int, f.readline().strip().split())

# Verificare dacă datele respectă cerințele impuse
if (-1001 <= X1 <= 1001) and (-1001 <= Y1 <= 1001) and (-1001 <= X2 <= 1001) and (-1001 <= Y2 <= 1001) and (-1001 <= X3 <= 1001) and (-1001 <= Y3 <= 1001) and (X2, Y2) != (X3, Y3):
# Afisare mesaj inainte de rezolvare
with open("distantapunctsegmentout.txt", "w") as f:
f.write("Datele de intrare respecta cerintele impuse.\n")
f.write(f"{distanta_punct_la_segment(X1, Y1, X2, Y2, X3, Y3):.2f}\n")
else:
with open("distantapunctsegmentout.txt", "w") as f:
f.write("Datele de intrare nu respecta cerintele impuse.")

except Exception as e:
print(f"O eroare a apărut: {e}")

</syntaxhighlight>

0933 - Distanta Punct Dreapta

2024-01-09T19:30:07Z

Tita Marian:

== Cerinţa ==
Se dau în plan, un punct și o dreaptă. Să se determine distanța de la punct la dreaptă.
== Date de intrare ==
Fișierul de intrare '''distantapunctdreapta.in''' conține pe prima linie 6 numere naturale separate prin spații, respectiv: '''X1, Y1, X2, Y2, X3, Y3'''. Se cere determinarea distanței de la punctul de coordonate '''(X1, Y1)''' la dreapta care trece prin punctele de coordonate '''(X2, Y2)''' și '''(X3, Y3)'''.
== Date de ieșire ==
Fișierul de ieșire '''distantapunctdreapta.out''' va conține pe prima linie un număr real cu exact două zecimale exacte (fără rotunjire), distanţa cerută.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*Numerele din fișierul de intrare sunt întregi cuprinse între '''-1001''' și '''1001'''.
*Punctele care determină dreapta sunt distincte.
== Exemplul 1 ==
; distantapunctdreapta.in
0 1 0 0 1 0

; distantapunctdreapta.out
Datele de intrare respecta cerintele impuse.
1.00
 
== Exemplul 2 ==
; distantapunctdreapta.in
1 2 3 4 3 4

; distantapunctdreapta.out
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def distanta_punct_la_dreapta(X1, Y1, X2, Y2, X3, Y3):
numitor = math.sqrt((X2 - X3) ** 2 + (Y2 - Y3) ** 2)
numarator = abs(X1 * Y2 + X2 * Y3 + X3 * Y1 - Y1 * X2 - Y2 * X3 - Y3 * X1)
distanta = numarator / numitor
return distanta

# Citire date de intrare
try:
with open("distantapunctdreaptain.txt", "r") as f:
X1, Y1, X2, Y2, X3, Y3 = map(int, f.readline().strip().split())

# Verificare dacă datele respectă cerințele impuse
if (-1001 <= X1 <= 1001) and (-1001 <= Y1 <= 1001) and (-1001 <= X2 <= 1001) and (-1001 <= Y2 <= 1001) and (-1001 <= X3 <= 1001) and (-1001 <= Y3 <= 1001) and (X2, Y2) != (X3, Y3):
# Afisare mesaj inainte de rezolvare
with open("distantapunctdreaptaout.txt", "w") as f:
f.write("Datele de intrare respecta cerintele impuse.\n")
f.write(f"{distanta_punct_la_dreapta(X1, Y1, X2, Y2, X3, Y3):.2f}\n")
else:
with open("distantapunctdreaptaout.txt", "w") as f:
f.write("Datele de intrare nu respecta cerintele impuse.")

except Exception as e:
print(f"O eroare a apărut: {e}")

</syntaxhighlight>

0978 - Coliniare

2024-01-09T19:29:33Z

Tita Marian:

== Cerinţa ==
Se dau '''n''' puncte distincte în plan prin coordonatele lor. Determinați numărul maxim de puncte coliniare.
== Date de intrare ==
Fișierul de intrare '''coliniarein.txt''' conține pe prima linie numărul '''n''' de puncte, iar pe următoarele '''n''' linii coordonatele acestor puncte separate prin spațiu (abscisa și ordonata).
== Date de ieșire ==
Fișierul de ieșire '''coliniareout.txt''' va conține pe prima linie numărul '''m''', reprezentând numărul maxim de puncte coliniare aflate printre punctele date.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*3 ≤ '''n''' ≤ 1000
*coordonatele celor '''n''' puncte sunt numere naturale mai mici decât 50.
*nu există două puncte identice printre cele date.
== Exemplul 1 ==
; coliniarein.txt
7
1 2
2 4
3 6
1 4
2 5
4 7
6 1
; coliniareout.txt
4
Datele de intrare respecta cerintele impuse.
 
== Exemplul 2 ==
; coliniarein.txt
4
5 10
12 20
8 4
5 10

; coliniareout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_puncte_coliniare(n, puncte):
if n < 3:
return n # Dacă avem mai puțin de 3 puncte, toate sunt coliniare

max_puncte_coliniare = 2 # Inițializăm cu minim 2 puncte coliniare (cele două puncte inițiale)

for i in range(n - 1):
for j in range(i + 1, n):
coliniare = 2 # Inițializăm cu cele două puncte inițiale
for k in range(n):
if k != i and k != j:
# Verificăm dacă punctul k se află pe dreapta formată de punctele i și j
if (puncte[j][1] - puncte[i][1]) * (puncte[k][0] - puncte[i][0]) == (puncte[k][1] - puncte[i][1]) * (puncte[j][0] - puncte[i][0]):
coliniare += 1

max_puncte_coliniare = max(max_puncte_coliniare, coliniare)

return max_puncte_coliniare

# Citire date de intrare
try:
with open("coliniarein.txt", "r") as f:
n = int(f.readline().strip())
puncte = [tuple(map(int, f.readline().strip().split())) for _ in range(n)]

# Verificare dacă datele respectă cerințele impuse
if 3 <= n <= 1000 and all(0 <= x[0] < 50 and 0 <= x[1] < 50 for x in puncte) and len(set(puncte)) == n:
# Calcul și afișare rezultat în fișierul de ieșire
with open("coliniareout.txt", "w") as f:
f.write(f"{numar_puncte_coliniare(n, puncte)}\n")
f.write("Datele de intrare respecta cerintele impuse.")
else:
with open("coliniarein.txt", "w") as f:
f.write("Datele de intrare nu respecta cerintele impuse.")

except Exception as e:
print(f"O eroare a apărut: {e}")

</syntaxhighlight>

0930 - Intersectie Segmente

2024-01-09T19:28:20Z

Tita Marian:

== Cerinţa ==
Se dau două segmente în plan, specificate prin coordonatele capetelor. Să se verifice dacă au cel puțin un punct comun.

== Date de intrare ==
Fișierul de intrare '''intersectiesegmentein.txt''' conține pe prima linie '''8''' numere naturale separate prin spații, respectiv: '''X1''', '''Y1''', '''X2''', '''Y2''', '''X3''', '''Y3''', '''X4''', '''Y4'''. Primul segment are capetele ''' (X1, Y1) ''' și ''' (X2, Y2) '''.

== Date de ieșire ==
Fișierul de ieșire '''intersectiesegmenteout.txt''' va conține pe prima linie '''DA''' (când segmentele se intersectează) sau '''NU''' (în caz contrar).

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*Numerele din fișierul de intrare sunt întregi cuprinse între '''-1001''' și '''1001'''.
*Ambele segmente au lungimea nenulă.
== Exemplul 1 ==
; intersectiesegmentein.txt
-1 -1 1 1 -1 1 1 -1

; intersectiesegmenteout.txt
Datele de intrare respecta cerintele impuse.
DA
 
== Exemplul 2 ==
; intersectiesegmentein.txt
-1500 500 1000 800 -1500 500 -1500 500

; intersectiesegmenteout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def verifica_intersectie_segmente(x1, y1, x2, y2, x3, y3, x4, y4):
# Verifica daca segmentele au cel putin un punct comun
if (min(x1, x2) <= max(x3, x4) and min(x3, x4) <= max(x1, x2) and
min(y1, y2) <= max(y3, y4) and min(y3, y4) <= max(y1, y2)):
return "DA"
else:
return "NU"

def verificare_restricții(x1, y1, x2, y2, x3, y3, x4, y4):
return (-1001 <= x1 <= 1001 and -1001 <= y1 <= 1001 and
-1001 <= x2 <= 1001 and -1001 <= y2 <= 1001 and
-1001 <= x3 <= 1001 and -1001 <= y3 <= 1001 and
-1001 <= x4 <= 1001 and -1001 <= y4 <= 1001 and
(x1, y1) != (x2, y2) and (x3, y3) != (x4, y4))

# Citirea datelor de intrare din fisier
with open('intersectiesegmentein.txt', 'r') as file:
input_data = list(map(int, file.readline().split()))

# Verificare restricții
if verificare_restricții(*input_data):
# Extrage coordonatele capetelor segmentelor din lista de intrare
x1, y1, x2, y2, x3, y3, x4, y4 = input_data

# Verificare intersectie segmente
rezultat = verifica_intersectie_segmente(x1, y1, x2, y2, x3, y3, x4, y4)

# Scrie rezultatul in fisierul de iesire
with open('intersectiesegmenteout.txt', 'w') as file:
file.write("Datele de intrare respecta cerintele impuse.\n")
file.write(rezultat + "\n")
else:
# Scrie mesajul de eroare in fisierul de iesire
with open('intersectiesegmenteout.txt', 'w') as file:
file.write("Datele de intrare nu respecta cerintele impuse.\n")

</syntaxhighlight>

0929 - Punct Segment

2024-01-09T19:27:14Z

Tita Marian:

== Cerinţa ==
Se dau un punct și un segment în plan. Să se verifice dacă punctul se găsește pe segment.
== Date de intrare ==
Fișierul de intrare '''punctsegmentin.txt''' conține pe prima linie '''6''' numere naturale separate prin spații, respectiv: '''X1''', '''Y1''', '''X2''', '''Y2''', '''X3''', '''Y3'''. Segmentul are capetele ''' (X2, Y2)'''și ''' (X3, Y3) '''.
== Date de ieșire ==
Fișierul de ieșire '''punctsegmentout.txt''' va conține pe prima linie '''DA ''' (dacă punctul de coordonate ''' (X1, Y1) ''' se găsește pe segment) sau '''NU''' (în caz contrar).
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*Numerele din fișierul de intrare sunt întregi cuprinse între '''-1001''' și '''1001'''.
*Segmentul are lungimea nenulă.
== Exemplul 1 ==
; punctsegmentin.txt
2 2 1 1 3 3

; punctsegmentout.txt
Datele de intrare respecta cerintele impuse.
DA
 
== Exemplul 2 ==
; punctsegmentin.txt
-1500 500 -1500 500 1000 800

; punctsegmentout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def punct_pe_segment(x1, y1, x2, y2, x3, y3):
# Verifica daca punctul (x1, y1) se afla pe segmentul determinat de punctele (x2, y2) si (x3, y3)
if min(x2, x3) <= x1 <= max(x2, x3) and min(y2, y3) <= y1 <= max(y2, y3):
return "DA"
else:
return "NU"

def verificare_restricții(x1, y1, x2, y2, x3, y3):
return (-1001 <= x1 <= 1001 and -1001 <= y1 <= 1001 and
-1001 <= x2 <= 1001 and -1001 <= y2 <= 1001 and
-1001 <= x3 <= 1001 and -1001 <= y3 <= 1001 and
(x2, y2) != (x3, y3))

# Citirea datelor de intrare din fisier
with open('punctsegmentin.txt', 'r') as file:
input_data = list(map(int, file.readline().split()))

# Verificare restricții
if verificare_restricții(*input_data):
# Extrage coordonatele punctelor din lista de intrare
x1, y1, x2, y2, x3, y3 = input_data

# Verificare daca punctul se afla pe segment
rezultat = punct_pe_segment(x1, y1, x2, y2, x3, y3)

# Scrie rezultatul in fisierul de iesire
with open('punctsegmentout.txt', 'w') as file:
file.write("Datele de intrare respecta cerintele impuse.\n")
file.write(rezultat + "\n")
else:
# Scrie mesajul de eroare in fisierul de iesire
with open('punctsegmentout.txt', 'w') as file:
file.write("Datele de intrare nu respecta cerintele impuse.\n")

</syntaxhighlight>

0927 - Distanta Puncte

2024-01-09T19:26:36Z

Tita Marian:

== Cerinţa ==
Se dau coordonatele în plan a două puncte. Să se afișeze pătratul distanței dintre ele.

== Date de intrare ==
Fișierul de intrare '''distantapunctein.txt''' conține pe prima linie '''4'''numere naturale, respectiv: abscisa primului punct, ordonata primului punct, abscisa celui de-al doilea punct, ordonata celui de-al doilea punct.

== Date de ieșire ==
Fișierul de ieșire '''distantapuncteout.txt''' va conține pe prima linie un număr natural reprezentând valoarea cerută.În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''

== Restricţii şi precizări ==
*Numerele din fișierul de intrare sunt întregi cuprinse între '''-1001''' și '''1001'''.
== Exemplul 1 ==
; distantapunctein.txt
1 0 5 4

; distantapuncteout.txt
Datele de intrare respecta cerintele impuse.
32
 
== Exemplul 2 ==
; distantapunctein.txt
-1500 500 1000 800
; distantapuncteout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def calculeaza_distanta_patratica(x1, y1, x2, y2):
return (x2 - x1)**2 + (y2 - y1)**2

def verificare_restricții(x1, y1, x2, y2):
return (-1001 <= x1 <= 1001 and -1001 <= y1 <= 1001 and
-1001 <= x2 <= 1001 and -1001 <= y2 <= 1001)

# Citirea datelor de intrare din fisier
with open('distantapunctein.txt', 'r') as file:
input_data = list(map(int, file.readline().split()))

# Verificare restricții
if verificare_restricții(*input_data):
# Extrage coordonatele punctelor din lista de intrare
x1, y1, x2, y2 = input_data

# Calculeaza patratul distantei dintre puncte
distanta_patratica = calculeaza_distanta_patratica(x1, y1, x2, y2)

# Scrie rezultatul in fisierul de iesire
with open('distantapuncteout.txt', 'w') as file:
file.write("Datele de intrare respecta cerintele impuse.\n")
file.write("{}\n".format(distanta_patratica))
else:
# Scrie mesajul de eroare in fisierul de iesire
with open('distantapuncteout.txt', 'w') as file:
file.write("Datele de intrare nu respecta cerintele impuse.\n")
</syntaxhighlight>

0928 - Aria Triunghi

2024-01-09T19:26:00Z

Tita Marian:

== Cerinţa ==
Se dau coordonatele în plan a trei puncte. Să se afișeze valoarea ariei triunghiului pe care îl formează.
== Date de intrare ==
Fișierul de intrare '''ariatriunghiin.txt''' conține pe prima linie '''6''' numere naturale, respectiv: abscisa primului punct, ordonata primului punct, abscisa celui de-al doilea punct, ordonata celui de-al doilea punct, abscisa celui de-al treilea punct, ordonata celui de-al treilea punct.
== Date de ieșire ==
Fișierul de ieșire '''ariatriunghiout.txt''' va conține pe prima linie un număr real, cu exact o zecimală, reprezentând valoarea cerută.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse."''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*Numerele din fișierul de intrare sunt întregi cuprinse între '''-1001''' și '''1001'''.
*Punctele nu sunt coliniare.
== Exemplul 1 ==
; ariatriunghiin.txt
0 1 1 0 2 1

; ariatriunghiout.txt
Datele de intrare respecta cerintele impuse.
1.0
 
== Exemplul 2 ==
; ariatriunghiin.txt
0 0 1 1 2 2
; ariatriunghiout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def calculeaza_aria_triunghi(x1, y1, x2, y2, x3, y3):
return abs((x1*(y2-y3) + x2*(y3-y1) + x3*(y1-y2)) / 2.0)

def verificare_restricții(x1, y1, x2, y2, x3, y3):
return (-1001 <= x1 <= 1001 and -1001 <= y1 <= 1001 and
-1001 <= x2 <= 1001 and -1001 <= y2 <= 1001 and
-1001 <= x3 <= 1001 and -1001 <= y3 <= 1001 and
(x1, y1) != (x2, y2) and (x2, y2) != (x3, y3) and (x1, y1) != (x3, y3))

# Citirea datelor de intrare din fisier
with open('ariatriunghiin.txt', 'r') as file:
input_data = list(map(int, file.readline().split()))

# Extrage coordonatele punctelor din lista de intrare
x1, y1, x2, y2, x3, y3 = input_data

# Verificare restricții
if verificare_restricții(x1, y1, x2, y2, x3, y3):
# Calculeaza aria triunghiului
aria_triunghi = calculeaza_aria_triunghi(x1, y1, x2, y2, x3, y3)

# Scrie rezultatul in fisierul de iesire
with open('ariatriunghiout.txt', 'w') as file:
file.write("Datele de intrare respecta cerintele impuse.\n")
file.write("{:.1f}\n".format(aria_triunghi))
else:
# Scrie mesajul de eroare in fisierul de iesire
with open('ariatriunghiout.txt', 'w') as file:
file.write("Datele de intrare nu respecta cerintele impuse.\n")
</syntaxhighlight>

2996 – Paritar

2024-01-09T19:23:10Z

Tita Marian:

Un șir format din '''2•numar_elemente''' numere naturale se numește paritar dacă fiecare dintre primii săi '''numar_elemente''' termeni fie are aceeași paritate cu oricare dintre ultimii săi '''numar_elemente''' termeni, fie este strict mai mic decât oricare număr de paritate diferită aflat printre aceștia.
== Cerinţa ==
Dându-se un șir de '''2•numar_elemente''' numere naturale, să se afișeze mesajul '''DA''', în cazul în care șirul aflat în fișier este paritar, sau mesajul '''NU''', în caz contrar. Proiectați un algoritm eficient din punctul de vedere al timpului de executare și al memoriei utilizate.
== Date de intrare ==
Fișierul de intrare '''paritarin.txt''' conține pe prima linie numărul '''numar_elemente''', iar pe a doua linie '''2•numar_elemente''' numere naturale separate prin spații reprezentând elementele șirului.
== Date de ieșire ==
Fișierul de ieșire '''paritarout.txt''' va conține pe prima linie mesajul '''DA''', dacă șirul este paritar, sau mesajul '''NU''' dacă șirul nu este paritar.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu respecta cerintele impuse." , iar daca se indeplinesc, se afiseaza mesajul "Datele de intrare respecta cerintele impuse."
== Restricţii şi precizări ==
* 1 &les; '''numar_elemente''' &les; 250000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1.000.000'''

== Exemplul 1 ==
; paritarin.txt
5
20 3 11 4 15 25 49 18 53 16

; paritarout.txt
Datele de intrare respecta cerintele impuse.
DA
 

== Exemplul 2 ==
; paritarin.txt
3
8 6 4 10 7 6

; paritarout.txt
Datele de intrare respecta cerintele impuse.
NU
 
== Exemplul 3 ==
; paritarin.txt
0
2 4 5 6 8 10
; paritarout.txt
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def este_paritar(numar_elemente, numere):
numere_pare = 0
numere_impare = 0

if len(numere) != 2 * numar_elemente:
return False

for numar in numere:
if numar % 2 == 0:
numere_pare += 1
else:
numere_impare += 1

return numere_pare % 2 == 0 and numere_impare % 2 == 0

if __name__ == "__main__":
with open("paritarin.txt", "r") as f_input, open("paritarout.txt", "w") as f_output:
numar_elemente = int(f_input.readline().strip())
numere = list(map(int, f_input.readline().split()))

if not (1 <= numar_elemente <= 250000) or any(x >= 1000000 for x in numere):
f_output.write("Datele de intrare nu respecta cerintele impuse.")
elif este_paritar(numar_elemente, numere):
f_output.write("Datele de intrare respecta cerintele impuse.\nDA\n")
else:
f_output.write("Datele de intrare respecta cerintele impuse.\nNU\n")

</syntaxhighlight>
==Explicație==
În primele '''numar_elemente''' numere sunt două numere pare, iar în ultimele '''numar_elemnte''' numere nu există numere impare. Vom presupune deci că 20 și 30 sunt mai mici decât orice număr impar.

2901 – Data Pal

2024-01-09T19:21:00Z

Tita Marian:

==Context==
În vacanța de iarnă Adelina a decis să renunțe la teme și a ales să citească o parte din cărțile aduse de Moș Crăciun: cele cu teme istorice sau SF. Pe măsură ce citea își nota în caiet datele calendaristice ale acelor evenimente care au impresionat-o. După vacanță îi povestește colegului de bancă despre aceste evenimente și remarcă faptul că unele date calendaristice au o formă specială, de palindrom: citite de la dreapta la stânga reprezintă aceeași dată ca atunci când se citesc obișnuit, de la stânga la dreapta.
==Cerința==
Pentru cele '''nr_date''' date calendaristice din agenda Adelinei numărați și afișați câte date palindromice au fost găsite iar apoi precizați secolele cu cele mai multe date palindromice.
== Date de intrare ==
Fișierul de intrare '''datapalin.txt''' conține următoarele informații :
- pe prima linie un număr '''nr_date''' reprezentând numărul de date calendaristice;
- pe fiecare dintre următoarele '''nr_date''' linii câte o dată calendaristică de forma '''zz/ll/aaaa''' (două cifre pentru zi, două cifre pentru lună, patru cifre pentru an) .
== Date de ieșire ==
Fișierul de ieșire '''datapalout.txt''' va conține pe prima linie numărul de date calendaristice palindrom iar pe a doua linie secolele cu cele mai multe date palindrom, în ordine cronologică.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse.", iar daca indeplinesc cerintele enuntate se va afisa mesajul Datele de intrare corespund restricțiilor impuse."
== Restricţii şi precizări ==
* 0 < '''nr_date'''&les; 1000
* toate datele calendaristice sunt valide;
* în colecția de date de test există întotdeauna cel puțin o dată palindromică
* anii aparțin perioadei 10-9999 și sunt d.Hr.

== Exemplu 1 ==
; datapalin.txt
5
01122110
11111111
19111111
09122190
12111121

; datapalout.txt
Datele de intrare corespund cerintelor impuse
4
12 22
 
== Exemplu 2 ==
; datapalin.txt
5
01122110
11111111
19111111
0912190
12111121
; datapalout.txt
Datele de intrare nu corespund cerintelor impuse

 

== Rezolvare ==
<syntaxhighlight lang="python" line>
from collections import defaultdict

def este_palindrom(data):
return data == data[::-1]

def citeste_date_din_fisier(cale_fisier):
try:
with open(cale_fisier, "r") as f:
nr_date = int(f.readline().strip())
date_agenda = [f.readline().strip() for _ in range(nr_date)]
except (ValueError, FileNotFoundError):
return None # Returnăm None dacă nu se pot citi datele din fișier

return date_agenda

def gaseste_secole_cu_cele_mai_multe_date_palindromice(date_palindromice):
secole_aparitii = defaultdict(list)

for data in date_palindromice:
an = int(data[4:])
secol = an // 100 + 1
secole_aparitii[secol].append(an)

max_count = max(len(aparitii) for aparitii in secole_aparitii.values())
secole_max_count = sorted([secol for secol, aparitii in secole_aparitii.items() if len(aparitii) == max_count])

return secole_max_count

def main():
date_agenda = citeste_date_din_fisier("datapalin.txt")

if date_agenda is None or any(len(data) != 8 for data in date_agenda):
with open("datapalout.txt", "w") as f_output:
f_output.write("Datele de intrare nu corespund cerintelor impuse\n")
else:
# Câte date palindromice au fost găsite
date_palindromice = [data for data in date_agenda if este_palindrom(data)]
numar_date_palindromice = len(date_palindromice)

# Găsește secolele cu cele mai multe date palindromice
secole_max_count = gaseste_secole_cu_cele_mai_multe_date_palindromice(date_palindromice)

# Scrie rezultatele în fișierul de ieșire
with open("datapalout.txt", "w") as f_output:
f_output.write("Datele de intrare corespund cerintelor impuse\n")
f_output.write(str(numar_date_palindromice) + "\n")
f_output.write(" ".join(map(str, secole_max_count)))

if __name__ == "__main__":
main()

</syntaxhighlight>
==Explicație==
Sunt 4 date palindromice: două în secolul 12 și două în secolul 22

3178 - Copii2

2024-01-09T19:19:45Z

Tita Marian:

== Cerinţa ==
Într-o clasă sunt '''numar_fete''' Fete și '''numar_baieti''' băieți. Fiecare fată citește 3 pagini pe zi și fiecare băiat citește 2 pagini pe zi. Câte pagini vor citi copiii în '''numar_zile''' zile?
== Date de intrare ==
Programul citește de la tastatură numerele naturale '''numar_fete''', '''numar_baieti''', '''numar_zile'''.
== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse.", urmat pe rândul următor sa fie afișat pe ecran numărul total de pagini citite.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* 1 &les; '''numar_fete''', '''numar_baieti''', '''numar_zile''' &les; 1000
== Exemplul 1 ==
; Intrare
7
5
3
; Ieșire
Datele introduse corespund restricțiilor impuse.
93
 
== Exemplul 2 ==
; Intrare
0
5
8
; Ieșire
Datele de intrare nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3178 - Copii2
def copii2():
fete = int(input("Introduceti numarul de fete: "))
baieti = int(input("Introduceti numarul de baieti: "))
zile = int(input("Introduceti numarul de zile: "))
if fete >= 1 and baieti >=1 and zile <= 1000:
solutie = (fete * 3 + baieti * 2) * zile
print("Datele de intrare corespund restricțiilor impuse.")
print((fete * 3 + baieti * 2) * zile)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

if __name__ == '__main__':
copii2()
</syntaxhighlight>

==Explicatie==
Sunt 7 fete, 5 băieți și citesc 3 zile. Împreună vor citi 93 de pagini.

0332 - Expresie2

2024-01-09T19:18:53Z

Tita Marian:

Sursa: [https://www.pbinfo.ro/probleme/332/expresie2]
== Cerinţa ==
Să se scrie un program care citește numărul natural '''numar''' și determină '''suma'''=1*2+2*3+3*4+...+'''numar'''*('''numar'''+1).

== Date de intrare ==
Programul citește de la tastatură numărul '''numar'''.

== Date de ieșire ==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."
În următorul rând se va afișa pe ecran mesajul “Rezultatul este '''suma'''“ unde '''suma''' reprezintă valoarea calculată.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* 0 < '''numar''' &les; 100
== Exemplul 1 ==
; Intrare
4
; Ieșire
Datele introduse corespund restricțiilor impuse.
Rezultatul este 40
 

== Exemplul 2 ==
; Intrare
0
; Ieșire
Datele de intrare nu corespund restricțiilor impuse.
 
== Exemplul 3 ==
; Intrare
6
; Ieșire
Datele introduse corespund restricțiilor impuse.
Rezultatul este 112
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0332 – Expresie2
def expresie2():
numar = int(input())
suma = 0
if numar > 0 and numar <= 100:
print("Datele introduse corespund restricțiilor impuse.")
for i in range(1, numar+1):
suma += i * (i + 1)
print("Rezultatul este",suma)
else:
print("Datele introduse nu corespund restricțiilor impuse")
if __name__ == '__main__':
expresie2()
</syntaxhighlight>

0249 - PozitieX

2024-01-09T19:14:59Z

Tita Marian:

== Cerinţa ==
Se dă un număr natural '''X''' şi un şir cu '''n''' numere naturale distincte două câte două. Să se determine poziţia pe care s-ar afla numărul '''X''' în şirul ordonat crescător.
== Date de intrare ==
Fişierul de intrare '''pozitiexin.txt''' conţine pe prima linie numerele '''X''' şi '''n'''. Urmează '''n''' numere naturale, dispuse pe mai multe linii, separate prin spaţii.
== Date de ieșire ==
Fişierul de ieşire '''pozitiexout.txt''' va conţine pe prima linie numărul '''p''', reprezentând poziţia în şirul ordonat crescător a primului element din şirul dat. Dacă numărul '''X''' nu apare în şir, se va afişa mesajul '''NU EXISTA'''.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse.", iar daca se indeplinesc se afiseaza mesajul "Datele de intrare corespund restricțiilor impuse."
== Restricţii şi precizări ==
* 1 ≤ '''n''' &les; 1.0000
* '''X''' şi elementele şirului vor avea cel mult 9 cifre

== Exemplul 1 ==
; pozitiexin.txt
79 6
267 13 45 628 7 79
; pozitiexout.txt
Datele de intrare corespund restrictilor impuse.
4
== Exemplul 2 ==
; pozitiexin.txt
79 0
; pozitiexout.txt
Datele de intrare nu corespund restrictilor impuse.

 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def gaseste_pozitie(X, sir):
sir.sort()
for i in range(len(sir)):
if sir[i] == X:
return i + 1 # Returnăm poziția (pornind de la 1)
return -1 # Dacă nu găsim X în șir, returnăm -1

if __name__ == "__main__":
try:
# Citim X și n din fișierul de intrare
with open("pozitiexin.txt", "r") as f:
X, n = map(int, f.readline().strip().split())
sir = list(map(int, f.read().split()))

# Verificăm restricțiile impuse
if 1 <= n <= 10000 and all(1 <= num <= 999999999 for num in sir) and 1 <= X <= 999999999:
# Găsim poziția lui X în șir
pozitie = gaseste_pozitie(X, sir)

# Scriem rezultatul în fișierul de ieșire
with open("pozitiexout.txt", "w") as f:
if pozitie != -1:
f.write(str(pozitie) + "\n")
else:
f.write("NU EXISTA\n")
print("Datele de intrare corespund restricțiilor impuse.")
else:
# Dacă datele de intrare nu respectă restricțiile, afișăm mesaj de eroare în fișierul de ieșire
with open("pozitiexout.txt", "w") as f:
f.write("Date de intrare invalide\n")
except Exception as e:
# Dacă apar erori neprevăzute, afișăm mesajul de eroare în fișierul de ieșire
with open("pozitiexout.txt", "w") as f:
f.write(f"O eroare a apărut: {str(e)}\n")

</syntaxhighlight>
==Explicație==

Şirul sortat este '''7 13 45 79 267 628'''. În acest şir, valoarea '''79''' se află pe poziţia a '''4'''-a.

2337 - Coadă2

2024-01-09T19:13:51Z

Tita Marian:

== Cerinţa ==
Andrei și Mihai stau la coada la magazin pentru a-și cumpăra bomboane. Andrei este în fața lui Mihai la coadă, iar între cei doi se afla alte '''x''' persoane. Mihai a observat că în total, în fata lui , se afla '''y''' persoane, iar Andrei a observat că în spatele lui se află '''z''' persoane.
Știind numerele '''x y z''' , aflați câte persoane sunt la coadă în total. Uneori, însă, e posibil ca aceștia să fi numărat greșit numărul de persoane, și să nu se poată calcula numărul total de persoane din coada. În acest caz trebuie sa afișați '''-1'''.
== Date de intrare ==
Pe prima linie a fișierului de intrare '''coada2in.txt''' se vor afla 3 numere naturale '''x y z'''.
== Date de ieșire ==
În fișierul de ieșire '''coada2out.txt''' se va afișa un singur număr, reprezentând lungimea cozii la care stau copiii. Dacă datele sunt incorecte, atunci afișați '''-1'''.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse.", iar daca se indeplinesc se afiseaza mesajul "Datele de intrare corespund restricțiilor impuse."
== Restricţii şi precizări ==
* 0 ≤ '''x, y, z''' &les; 1.000.000.000.000.000.000
== Exemplul 1 ==
; coada2in.txt
0 1 1
; coada2out.txt
Datele de intrare corespund restricțiilor impuse.
2
== Exemplul 2 ==
; coada2in.txt
-1 1 1
; coada2out.txt
Datele de intrare nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def calculeaza_numar_persoane(x, y, z):
if not (0 <= x <= 1000000000000000000 and 0 <= y <= 1000000000000000000 and 0 <= z <= 1000000000000000000):
raise ValueError("Datele de intrare nu corespund restricțiilor impuse.")
elif x >= y or x >= z:
return -1
else:
return y + z - x

if __name__ == "__main__":
try:
# Citim datele din fișierul de intrare
with open("coada2in.txt", "r") as f:
x, y, z = map(int, f.readline().strip().split())

# Calculăm numărul total de persoane în linie utilizând funcția
numar_persoane = calculeaza_numar_persoane(x, y, z)

# Scriem rezultatul în fișierul de ieșire
with open("coada2out.txt", "w") as f:
f.write(str(numar_persoane))
print("Datele de intrare corespund restricțiilor impuse.")
except ValueError as ve:
print(ve)

</syntaxhighlight>

==Explicație==

La coada se afla doar Andrei și Mihai. Între cei doi nu este nicio persoană. în fața lui Mihai este doar o persoana – Andrei. În spatele lui Andrei este de asemenea o singura persoana – Mihai.

2876 - Zmeu

2024-01-09T19:13:07Z

Tita Marian:

== Cerinţa ==
În vacanță, Andrei și cu prietenii lui doresc să construiască împreună cât mai multe zmeie. Analizând materialele au constatat că au la dispoziție doar '''N''' metri de sfoară.
Au căutat pe internet tutoriale și au aflat că pentru fiecare zmeu sunt necesare câte două bucăți de sfoară de '''M''' metri. Astfel, având la dispoziție cei '''N''' metri de sfoară, pot construi maxim '''Z''' zmeie.
Scrieți un program care să determine:
a) Care este numărul maxim de zmeie care se pot construi;
b) Câți metri de sfoară le-ar mai fi trebuit lui Andrei și prietenilor să poată construi încă un zmeu.
== Date de intrare ==
Fișierul de intrare '''zmeuin.txt''' conține pe prima linie numărul natural '''N''', iar pe următoarea linie numărul natural '''M'''

== Date de ieșire ==
Fișierul de ieșire '''zmeuout.txt''' va conține
• pe prima linie: numărul maxim de zmeie care se pot construi; dacă nu se poate construi niciun zmeu, pe prima linie se va scrie '''0'''.
• pe cea de-a doua linie: câți metri de sfoară le-ar mai fi trebuit să mai poată construi încă un zmeu.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse.", iar daca se indeplinesc se afiseaza mesajul "Datele de intrare corespund restricțiilor impuse."
== Restricţii şi precizări ==
* 1 ≤ '''N, M''' &les; 100.000.000.000
== Exemplu 1 ==
; zmeuin.txt
72
10
; zmeuout.txt
Datele de intrare corespund restricțiilor impuse.
3
8
 

== Exemplu 2 ==
; zmeuin.txt
100
50
; zmeuout.txt
Datele de intrare corespund restricțiilor impuse.
1
100
== Exemplu 3 ==
; zmeuin.txt
0
50
; zmeuout.txt
Datele de intrare nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def calculeaza_zmeie(N, M):
if not (1 <= N <= 100000000000 and 1 <= M <= 1000000000):
raise ValueError("Datele de intrare nu corespund restricțiilor impuse.")
numar_zmeie = N // (2 * M)
sfoara_ramasa = N % (2 * M)
return numar_zmeie, max(0, 2 * M - sfoara_ramasa)

if __name__ == "__main__":
try:
# Citim datele din fișierul de intrare
with open("zmeu.in", "r") as f:
N = int(f.readline().strip()) # Numărul de metri de sfoară disponibili
M = int(f.readline().strip()) # Lungimea a două bucăți de sfoară necesare pentru un zmeu

# Calculăm numărul maxim de zmeie și câți metri de sfoară mai sunt necesari
numar_zmeie, sfoara_ramasa = calculeaza_zmeie(N, M)

# Scriem rezultatele în fișierul de ieșire
with open("zmeu.out", "w") as f:
f.write(str(numar_zmeie) + "\n") # Scriem numărul maxim de zmeie
f.write(str(sfoara_ramasa) + "\n") # Scriem câți metri de sfoară mai sunt necesari pentru un zmeu suplimentar

print("Datele de intrare corespund restricțiilor impuse.")
except ValueError as ve:
print(ve)

</syntaxhighlight>

==Explicație==

Andrei și prietenii lui au la dispoziție 72m de sfoară. Pentru fiecare zmeu sunt necesare câte 2 bucăți de sfoară de 10m.
a) Se pot construi maxim 3 zmeie, din cei 72m de sfoară
b) Dacă ar mai avea 8m de sfoară ar mai putea construi încă un zmeu.

2917 - Catalan

2024-01-04T19:25:23Z

Tita Marian:

== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
==Date de ieșire==
Programul va afișa pe ecran al '''n'''-lea număr Catalan.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse." iar daca se indeplinesc se afiseaza "Datele de intrare corespund restricțiilor impuse."
== Restricţii şi precizări ==
* 0 &les; '''n''' &les; 1000
== Exemplul 1 ==
; Intrare
5
; Ieșire
Datele de intrare corespund restricțiilor impuse
42
 
== Exemplul 2 ==
; Intrare
-2
; Ieșire
Datele de intrare nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def calculeaza_numar_catalan(n):
return math.factorial(2 * n) // (math.factorial(n + 1) * math.factorial(n))

if __name__ == "__main__":
try:
n = int(input())
if 0 <= n <= 1000:
rezultat = calculeaza_numar_catalan(n)
print("Datele de intrare corespund restrictiilor impuse.")
print(rezultat)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")
except ValueError:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

3329 - NumarareAnagrame

2024-01-04T19:24:47Z

Tita Marian: /* Date de ieșire */

== Cerinţa ==
Se dă un cuvânt format numai din litere mici ale alfabetului englez. Determinați câte cuvinte distincte se pot forma cu literele sale – numărul de anagrame ale sale.
== Date de intrare ==
Programul citește de la tastatură un cuvânt.
== Date de ieșire ==
Programul va afișa pe ecran numărul '''cuvant''', reprezentând numărul cerut.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu corespund restricțiilor impuse."''' iar daca se indeplinesc se afiseaza '''"Datele de intrare corespund restricțiilor impuse."'''
== Restricţii şi precizări ==
* cuvântul dat va avea cel mult 20 de litere;
== Exemplul 1 ==
; Intrare
ababa
; Ieșire
Datele de intrare corespund restricțiilor impuse.
10

==Explicatie==
Cele 10 cuvinte sunt: aaabb, aabab, aabba, abaab, ababa, abbaa, baaab, baaba, babaa, bbaaa.

== Exemplul 2 ==
; Intrare
mucopolizaharidozelor
; Ieșire
Datele de intrare nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def numar_anagrame(cuvant):
lungime_cuvant = len(cuvant)
factoriale_duplicate = 1

for litera in set(cuvant):
frecventa = cuvant.count(litera)
factoriale_duplicate *= math.factorial(frecventa)

return math.factorial(lungime_cuvant) // factoriale_duplicate

if __name__ == "__main__":
cuvant = input()

if cuvant.isalpha() and cuvant.islower() and len(cuvant) <= 20:
rezultat = numar_anagrame(cuvant)
print("Datele de intrare corespund restricțiilor impuse.")
print(rezultat)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
</syntaxhighlight>

3871 - Xor Pyramid

2024-01-04T19:22:15Z

Tita Marian:

== Cerinţa ==
Considerăm o piramida xor unde fiecare valoare este egală cu xorul valorilor din stânga jos și dreapta jos. Dându-se cel mai de jos nivel, care este valoarea din vârf?
== Date de intrare ==
Programul citește de la tastatură numărul '''numar_valori''', iar apoi '''numar_valori''' numere naturale. '''numar_valori''' este mărimea bazei piramidei iar numerele naturale sunt valorile de la bază în ordinea în care sunt date.
== Date de ieșire ==
Programul va afișa pe ecran numărul '''rezultat_xor_piramida''', reprezentând valoarea din vârful piramidei.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse." iar daca se indeplinesc se afiseaza "Datele de intrare nu corespund restricțiilor impuse."
== Restricţii şi precizări ==
* 1 &les; '''numar_valori''' &les; 200000
* cele '''numar_valori''' numere citite vor fi mai mici sau egale cu 1.000.000.000.

== Exemplul 1 ==
;Intrare
8
2 10 5 12 9 5 1 5
;Ieșire
Datele de intrare corespund restricțiilor impuse.
9
 
== Exemplul 2 ==
; Intrare
5
2 10 5 12 1000000001
;Ieșire
Datele de intrare nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def calcul_xor_piramida(baza_piramida):
valori_intermediare = baza_piramida.copy()
while len(valori_intermediare) > 1:
valori_noi = []
for i in range(len(valori_intermediare) - 1):
valori_noi.append(valori_intermediare[i] ^ valori_intermediare[i + 1])
valori_intermediare = valori_noi
return valori_intermediare[0]

if __name__ == "__main__":
try:
numar_valori = int(input())
if not (1 <= numar_valori <= 200000):
print("Datele de intrare nu corespund restricțiilor impuse.")
exit()

valori_baza_piramida = list(map(int, input().split()))

if len(valori_baza_piramida) != numar_valori or any(val > 1000000000 for val in valori_baza_piramida):
print("Datele de intrare nu corespund restricțiilor impuse.")
exit()

rezultat_xor_piramida = calcul_xor_piramida(valori_baza_piramida)
print("Datele de intrare corespund restricțiilor impuse.")
print(rezultat_xor_piramida)
except ValueError:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicatie==
Problema implică calcularea valorii din vârful unei piramide XOR, având ca bază un șir de numere. Operația XOR este aplicată iterativ pe liniile piramidei, astfel încât valoarea din vârf să fie rezultatul final. Soluția propusă constă într-o funcție (calcul_xor_piramida) care primește lista de valori de la baza piramidei și aplică operația XOR iterativ până când rămâne doar o singură valoare, care reprezintă valoarea din vârf. Programul citește mărimea bazei piramidei și valorile de la bază, efectuând verificări pentru a se asigura că datele de intrare respectă cerințele. Dacă există discrepanțe, se afișează un mesaj corespunzător.

3329 - NumarareAnagrame

2024-01-04T19:17:22Z

Tita Marian:

== Cerinţa ==
Se dă un cuvânt format numai din litere mici ale alfabetului englez. Determinați câte cuvinte distincte se pot forma cu literele sale – numărul de anagrame ale sale.
== Date de intrare ==
Programul citește de la tastatură un cuvânt.
== Date de ieșire ==
Programul va afișa pe ecran numărul '''cuvant''', reprezentând numărul cerut.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu corespund restricțiilor impuse."''' iar daca se indeplinesc se afiseaza '''"Datele de intrare nu corespund restricțiilor impuse."'''
== Restricţii şi precizări ==
* cuvântul dat va avea cel mult 20 de litere;
== Exemplul 1 ==
; Intrare
ababa
; Ieșire
Datele de intrare corespund restricțiilor impuse.
10

==Explicatie==
Cele 10 cuvinte sunt: aaabb, aabab, aabba, abaab, ababa, abbaa, baaab, baaba, babaa, bbaaa.

== Exemplul 2 ==
; Intrare
mucopolizaharidozelor
; Ieșire
Datele de intrare nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def numar_anagrame(cuvant):
lungime_cuvant = len(cuvant)
factoriale_duplicate = 1

for litera in set(cuvant):
frecventa = cuvant.count(litera)
factoriale_duplicate *= math.factorial(frecventa)

return math.factorial(lungime_cuvant) // factoriale_duplicate

if __name__ == "__main__":
cuvant = input()

if cuvant.isalpha() and cuvant.islower() and len(cuvant) <= 20:
rezultat = numar_anagrame(cuvant)
print("Datele de intrare corespund restricțiilor impuse.")
print(rezultat)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
</syntaxhighlight>

1472 - Castel

2024-01-04T19:10:13Z

Tita Marian:

==Context==
Andrei vizitează un vechi castel cu mai multe camere. El are la dispoziţie un număr '''nr_coduri''' de coduri de acces. Fiecare cod este un număr natural format din cel mult 9 cifre. Pentru a deschide uşa unei camere, Andrei trebuie să afle ce cheie să aleagă, dintr-un set dat. Fiecare cheie este notată cu o cifră. Cheia ce deschide uşa din prima cameră este notată cu cifra ce se repetă de cele mai multe ori în codurile de acces.
== Cerinţa ==
Scrieţi un program care determină cheia ce va deschide prima uşă, cunoscându-se numărul '''nr_coduri''', cele '''nr_coduri''' coduri de acces, numărul de chei, notat cu '''coduri_acces''' și valorile celor '''coduri_acces''' chei primite.
== Date de intrare ==
Fişierul de intrare ''' castelin.txt''' conţine pe prima linie numărul '''nr_coduri'''. Linia a doua din fişier conţine '''nr_coduri''' numere naturale, ce reprezintă codurile de acces. Linia a treia conţine numărul natural '''coduri_acces''' ce reprezinta numărul de chei primite. Linia a patra din fişier conţine '''coduri_acces''' cifre, ce reprezintă valorile cheilor.
== Date de ieșire ==
Fişierul de ieşire ''' castelout.txt''' conţine pe prima linie două numere naturale, separate printr-un singur spaţiu. Primul număr din fişier reprezintă cheia ce va deschide uşa din prima cameră si al doilea număr reprezinta numărul de repetări al cheii în şirul codurilor de acces.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta conditiile impuse.”''' iar daca datele introduse de la tastatură îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare respecta conditiile impuse.”'''

== Restricţii şi precizări ==
* 1 &les; '''coduri_acces''' &les; 10
* 1 &les; '''nr_coduri''' &les; 1000
* Fiecare cod de acces este un număr cu cel mult 9 cifre
* Fiecare cheie este notată cu o cifră
* Cheile au valori distincte şi sunt date în ordine crescătoare
* O uşă poate fi deschisă de o singură cheie
== Exemplul 1 ==
; castelin.txt
5
1243 527 89722 6232 678
3
2 5 7

; castelout.txt
Datele de intrare respecta conditiile impuse.
2 6

==Explicatie==
:Dintre cele 3 chei date, cheia ce apare de cele mai multe ori, în şirul codurilor de pe linia a doua, este 2 şi apare de 6 :ori.Cheia 5 apare o dată, iar cheia 7 apare de 3 ori.

== Exemplul 2 ==
; castelin.txt
1001
; castelout.txt
Datele de intrare nu respecta conditiile impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def gaseste_cheie_si_repetari(nr_coduri, coduri_acces):
frecvente_chei = {}

# Calculează frecvența fiecărei chei în codurile de acces
for cod in coduri_acces:
for cifra in str(cod):
frecvente_chei[cifra] = frecvente_chei.get(cifra, 0) + 1

# Găsește cheia cu cea mai mare frecvență
cheie_maxima = max(frecvente_chei, key=frecvente_chei.get)
repetari_cheie_maxima = frecvente_chei[cheie_maxima]

return cheie_maxima, repetari_cheie_maxima

def main():
# Citirea din fișierul de intrare
try:
with open("castelin.txt", "r") as file:
nr_coduri = int(file.readline().strip())
coduri_acces = list(map(int, file.readline().split()))
except FileNotFoundError:
print("Fisierul de intrare nu exista.")
return
except ValueError:
print("Datele de intrare nu respecta conditiile impuse.")
return

# Verificare restricții
if not (1 <= nr_coduri <= 1000):
with open("castelout.txt", "w") as file_output:
file_output.write("Datele de intrare nu respecta conditiile impuse.\n")
return

# Calculul cheii și repetărilor
cheie, repetari = gaseste_cheie_si_repetari(nr_coduri, coduri_acces)

# Scrierea în fișierul de ieșire
with open("castelout.txt", "w") as file_output:
file_output.write("Datele de intrare corespund conditiilor impuse.\n")
file_output.write(f"{cheie} {repetari}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

1931 - Fantastice

2024-01-04T18:55:51Z

Tita Marian:

== Cerinţa ==
Definim un număr ca fiind fantastic dacă numărul de numere la care acesta se împarte exact este un număr prim.
Dându-se un șir cu '''numar_elemente''' numere întregi strict pozitive, să se afișeze numărul de numere fantastice din șir.
== Date de intrare ==
Fișierul de intrare '''fantasticein.txt''' conține pe prima linie numărul '''numar_elemente''' de numere, iar pe cea de-a doua linie, separate prin câte un spaţiu, cele '''numar_elemente''' numere.
== Date de ieșire ==
Fișierul de ieșire '''fantasticeout.txt''' va conține pe prima linie numărul de numere fantastice din șir.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund ceerintelor impuse.", iar daca indeplinesc cerintele enuntate se va afisa mesajul "Datele de intrare corespund cerintelor impuse."
== Restricţii şi precizări ==
* 1 &les; '''numar_elemente''' &les; 1000000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici sau egale cu 1.000.000
== Exemplul 1 ==
; fantasticein.txt
6
21 19 25 16 27 729

; fantasticeout.txt
Datele de intrare corespund cerintelor impuse.

4

==Explicatie==
21 are divizorii 1, 3, 7, 21
19 are divizorii 1, 19
25 are divizorii 1, 5, 25
16 are divizorii 1, 2, 4, 8, 16
27 are divizorii 1, 3, 9, 27
729 are divizorii 1, 3, 9, 27, 81, 243, 729
Deci sunt 4 numere fantastice: 19 25 16 729

 
== Exemplul 2 ==
; fantastice.in
5
1000001 500000 700000 900000 1200000
; fantastice.out
Datele de intrare nu corespund cerintelor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
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 numere_fantastice(șir):
count_fantastice = 0

for numar in șir:
if numar <= 0 or numar > 1000000:
return -1 # Datele de intrare nu respectă condițiile

numar_divizori = 0
for i in range(1, numar + 1):
if numar % i == 0:
numar_divizori += 1

if este_prim(numar_divizori):
count_fantastice += 1

return count_fantastice

def main():
# Citirea din fișierul de intrare
try:
with open("fantasticein.txt", "r") as file:
numar_elemente = int(file.readline().strip())
numere = list(map(int, file.readline().split()))
except FileNotFoundError:
print("Fisierul de intrare nu exista.")
return
except ValueError:
print("Datele de intrare nu corespund cerintelor impuse.")
return

# Verificarea restricțiilor și calculul numărului de numere fantastice
rezultat = numere_fantastice(numere)

# Scrierea în fișierul de ieșire sau afișarea mesajului de eroare
with open("fantasticeout.txt", "w") as file:
if rezultat == -1:
file.write("Datele de intrare nu corespund cerintelor impuse.\n")
else:
file.write("Datele de intrare corespund cerintelor impuse.\n")
file.write(str(rezultat) + "\n")

if __name__ == "__main__":
main()
</syntaxhighlight>

2273 - Ssplit

2024-01-04T18:36:28Z

Tita Marian:

==Context==
Se consideră un șir '''a[1], a[2], …, a[n] ''' de numere naturale nenule. Pentru doi indici '''1 ≤ i < j < n''', notăm cu '''X = a[1] + a[2] + ... + a[i], Y = a[i+1] + a[i+2] + ... + a[j] ''' și '''Z = a[j+1] + a[j+2] + ... + a[n] '''.
== Cerinţa ==
Să se determine doi indici '''i''' și '''j''' astfel încât diferența '''max(X, Y, Z) - min(X, Y, Z) ''' să fie minimă.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi șirul de '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Programul va afișa pe ecran valorile indicilor '''i''' și '''j'''. Dacă sunt mai multe soluții, se va afișa aceea pentru care '''i''' este minim, iar dacă sunt mai multe soluții cu același '''i''' minim, se va afișa aceea cu indicele '''j''' minim.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse.", iar daca indeplinesc cerintele enuntate se va afisa mesajul Datele de intrare corespund restricțiilor impuse."
== Restricţii şi precizări ==
* 1 &les; '''n''' &les; 200000
* 1 &les; ''' a[i] ''' &les; 10000
== Exemplu 1 ==
; Intrare
10
1 3 4 2 1 2 10 5 8 6

; Ieșire
6 8

==Explicație==
'''i = 6''' și '''j = 8'''. În acest caz '''X = 13''', '''Y = 15''', '''Z = 14'''. Diferența este '''max(X, Y, Z) - min(X, Y, Z) = 15-13 = 2'''. Nu există o împărțire pentru care diferența să fie mai mică.

 
== Exemplu 2 ==
; Intrare
3
4000 12000 5000
; Ieșire
Datele de intrare nu indeplinesc cerintele impuse

 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def gaseste_indici_minim_diferenta(arr):
n = len(arr)
suma_totala = sum(arr)
X = 0
minim_diff = float('inf') # Inițializăm cu infinit pentru a asigura găsirea unui minim
rezultat_i = -1
rezultat_j = -1

for i in range(1, n - 1):
X += arr[i - 1]
Y = suma_totala - X - arr[i]
Z = suma_totala - Y - X

max_xyz = max(X, Y, Z)
min_xyz = min(X, Y, Z)

diferenta = max_xyz - min_xyz

if diferenta < minim_diff:
minim_diff = diferenta
rezultat_i = i
rezultat_j = i + 1

return rezultat_i, rezultat_j

if __name__ == "__main__":
# Citirea șirului de numere
n = int(input())

if not (1 <= n <= 200000):
print("Datele de intrare nu indeplinesc cerintele impuse")
exit()

arr = list(map(int, input().split()))

if any(not (1 <= x <= 10000) for x in arr):
print("Datele de intrare nu indeplinesc cerintele impuse")
exit()

# Inițializarea rezultatelor cu valori mari
rezultat_i = n
rezultat_j = n
minim_diff = float('inf') # Inițializăm cu infinit pentru a asigura găsirea unui minim

# Căutarea tuturor posibilităților și găsirea celei mai bune
for i in range(1, n - 1):
for j in range(i + 1, n):
X = sum(arr[:i])
Y = sum(arr[i:j])
Z = sum(arr[j:])

max_xyz = max(X, Y, Z)
min_xyz = min(X, Y, Z)

diferenta = max_xyz - min_xyz

if diferenta < minim_diff:
minim_diff = diferenta
rezultat_i = i
rezultat_j = j

# Afișarea mesajului și a rezultatului
print("Datele de intrare indeplinesc cerintele impuse")
print(rezultat_i, rezultat_j)

</syntaxhighlight>

2901 – Data Pal

2024-01-04T18:28:47Z

Tita Marian:

==Context==
În vacanța de iarnă Adelina a decis să renunțe la teme și a ales să citească o parte din cărțile aduse de Moș Crăciun: cele cu teme istorice sau SF. Pe măsură ce citea își nota în caiet datele calendaristice ale acelor evenimente care au impresionat-o. După vacanță îi povestește colegului de bancă despre aceste evenimente și remarcă faptul că unele date calendaristice au o formă specială, de palindrom: citite de la dreapta la stânga reprezintă aceeași dată ca atunci când se citesc obișnuit, de la stânga la dreapta.
==Cerința==
Pentru cele '''nr_date''' date calendaristice din agenda Adelinei numărați și afișați câte date palindromice au fost găsite iar apoi precizați secolele cu cele mai multe date palindromice.
== Date de intrare ==
Fișierul de intrare '''datapalin.txt''' conține următoarele informații :
- pe prima linie un număr '''nr_date''' reprezentând numărul de date calendaristice;
- pe fiecare dintre următoarele '''nr_date''' linii câte o dată calendaristică de forma '''zz/ll/aaaa''' (două cifre pentru zi, două cifre pentru lună, patru cifre pentru an) .
== Date de ieșire ==
Fișierul de ieșire '''datapalout.txt''' va conține pe prima linie numărul de date calendaristice palindrom iar pe a doua linie secolele cu cele mai multe date palindrom, în ordine cronologică.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse.", iar daca indeplinesc cerintele enuntate se va afisa mesajul Datele de intrare corespund restricțiilor impuse."
== Restricţii şi precizări ==
* 0 < '''nr_date'''&les; 1000
* toate datele calendaristice sunt valide;
* în colecția de date de test există întotdeauna cel puțin o dată palindromică
* anii aparțin perioadei 10-9999 și sunt d.Hr.

== Exemplu 1 ==
; Intrare
5
01122110
11111111
19111111
09122190
12111121

; Ieșire
Datele de intrare corespund cerintelor impuse
4
12 22
 
== Exemplu 2 ==
; Intrare
5
01122110
11111111
19111111
0912190
12111121
; Ieșire
Datele de intrare nu corespund cerintelor impuse

 

== Rezolvare ==
<syntaxhighlight lang="python" line>
from collections import defaultdict

def este_palindrom(data):
return data == data[::-1]

def citeste_date_din_fisier(cale_fisier):
try:
with open(cale_fisier, "r") as f:
nr_date = int(f.readline().strip())
date_agenda = [f.readline().strip() for _ in range(nr_date)]
except (ValueError, FileNotFoundError):
return None # Returnăm None dacă nu se pot citi datele din fișier

return date_agenda

def gaseste_secole_cu_cele_mai_multe_date_palindromice(date_palindromice):
secole_aparitii = defaultdict(list)

for data in date_palindromice:
an = int(data[4:])
secol = an // 100 + 1
secole_aparitii[secol].append(an)

max_count = max(len(aparitii) for aparitii in secole_aparitii.values())
secole_max_count = sorted([secol for secol, aparitii in secole_aparitii.items() if len(aparitii) == max_count])

return secole_max_count

def main():
date_agenda = citeste_date_din_fisier("datapalin.txt")

if date_agenda is None or any(len(data) != 8 for data in date_agenda):
with open("datapalout.txt", "w") as f_output:
f_output.write("Datele de intrare nu corespund cerintelor impuse\n")
else:
# Câte date palindromice au fost găsite
date_palindromice = [data for data in date_agenda if este_palindrom(data)]
numar_date_palindromice = len(date_palindromice)

# Găsește secolele cu cele mai multe date palindromice
secole_max_count = gaseste_secole_cu_cele_mai_multe_date_palindromice(date_palindromice)

# Scrie rezultatele în fișierul de ieșire
with open("datapalout.txt", "w") as f_output:
f_output.write("Datele de intrare corespund cerintelor impuse\n")
f_output.write(str(numar_date_palindromice) + "\n")
f_output.write(" ".join(map(str, secole_max_count)))

if __name__ == "__main__":
main()

</syntaxhighlight>
==Explicație==
Sunt 4 date palindromice: două în secolul 12 și două în secolul 22

2224 - Mset

2024-01-03T23:06:09Z

Tita Marian: /* Cerinţa */

== Context ==
Se consideră un șir '''A''', inițial vid. Se definesc următoarele operații:
*'''1 x''' – introduce valoarea '''x''' în șirul '''A'''
*'''2 x''' – șterge toate aparițiile lui '''x '''din '''A ''' (dacă '''x '''nu apare deloc în '''A''', operația nu se execută)
*'''3 '''– interogare: care este cea mai mică valoare din '''A '''și de câte ori apare (dacă '''A '''este șir vid, se va afișa doar valoarea '''-1''')

== Cerinţa ==
Dându-se '''N''' operații, trebuie să afișați răspunsul la fiecare operație de tip '''3'''.

==Date de intrare==
Fișierul de intrare '''msetin.txt''' conține pe prima linie '''N'''. Pe următoarele '''N''' linii sunt date cele '''N''' operații.
== Date de ieșire ==
În fișierul de ieșire '''msetout.txt''' se vor afișa pe câte o linie răspunsurile la operațiile de tip 3.În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*'''1 ≤ N ≤ 200 000'''
* Va exista cel puțin o operație de tip '''3'''
* Valorile care se introduc în mulțime sunt numere naturale mai mici decât '''2 000 000 000'''
== Exemplul 1 ==
; Intrare
14
3
1 55
1 55
3
1 40
3
1 7
1 7
3
2 7
1 50
3
2 40
3
; Ieșire
Datele de intrare respecta cerintele impuse.
-1 0
55 2
40 1
7 2
40 1
50 1
 
== Exemplul 2 ==
; Intrare
3
1 4
2 3
2 5
; Ieșire
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def process_operations(operations):
result = []
values = []

for op, *args in operations:
if op == 1:
x, = args
values.append(x)
elif op == 2:
x, = args
values = [val for val in values if val != x]
elif op == 3:
if values:
min_value = min(values)
count = values.count(min_value)
result.append((min_value, count))
else:
result.append((-1, 0))

return result

def validate_input(operations):
for op, *args in operations:
if op == 3:
return True
return False

def main():
with open("msetin.txt", "r") as file:
n = int(file.readline())
operations = [list(map(int, line.split())) for line in file]

if not validate_input(operations):
with open("msetout.txt", "w") as output_file:
output_file.write("Datele de intrare nu respecta cerintele impuse.")
return

results = process_operations(operations)

with open("msetout.txt", "w") as output_file:
output_file.write("Datele de intrare respecta cerintele impuse.\n")
for min_value, count in results:
output_file.write(f"{min_value} {count}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

2224 - Mset

2024-01-03T23:05:45Z

Tita Marian: Pagină nouă: == Context == Se consideră un șir '''A''', inițial vid. Se definesc următoarele operații: *'''1 x''' – introduce valoarea '''x''' în șirul '''A''' *'''2 x''' – șterge toate aparițiile lui '''x '''din '''A ''' (dacă '''x '''nu apare deloc în '''A''', operația nu se execută) *'''3 '''– interogare: care este cea mai mică valoare din '''A '''și de câte ori apare (dacă '''A '''este șir vid, se va afișa doar valoarea '''-1''') == Cerinţa == Dându-se N op...

== Context ==
Se consideră un șir '''A''', inițial vid. Se definesc următoarele operații:
*'''1 x''' – introduce valoarea '''x''' în șirul '''A'''
*'''2 x''' – șterge toate aparițiile lui '''x '''din '''A ''' (dacă '''x '''nu apare deloc în '''A''', operația nu se execută)
*'''3 '''– interogare: care este cea mai mică valoare din '''A '''și de câte ori apare (dacă '''A '''este șir vid, se va afișa doar valoarea '''-1''')

== Cerinţa ==
Dându-se N operații, trebuie să afișați răspunsul la fiecare operație de tip '''3'''.
==Date de intrare==
Fișierul de intrare '''msetin.txt''' conține pe prima linie '''N'''. Pe următoarele '''N''' linii sunt date cele '''N''' operații.
== Date de ieșire ==
În fișierul de ieșire '''msetout.txt''' se vor afișa pe câte o linie răspunsurile la operațiile de tip 3.În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*'''1 ≤ N ≤ 200 000'''
* Va exista cel puțin o operație de tip '''3'''
* Valorile care se introduc în mulțime sunt numere naturale mai mici decât '''2 000 000 000'''
== Exemplul 1 ==
; Intrare
14
3
1 55
1 55
3
1 40
3
1 7
1 7
3
2 7
1 50
3
2 40
3
; Ieșire
Datele de intrare respecta cerintele impuse.
-1 0
55 2
40 1
7 2
40 1
50 1
 
== Exemplul 2 ==
; Intrare
3
1 4
2 3
2 5
; Ieșire
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def process_operations(operations):
result = []
values = []

for op, *args in operations:
if op == 1:
x, = args
values.append(x)
elif op == 2:
x, = args
values = [val for val in values if val != x]
elif op == 3:
if values:
min_value = min(values)
count = values.count(min_value)
result.append((min_value, count))
else:
result.append((-1, 0))

return result

def validate_input(operations):
for op, *args in operations:
if op == 3:
return True
return False

def main():
with open("msetin.txt", "r") as file:
n = int(file.readline())
operations = [list(map(int, line.split())) for line in file]

if not validate_input(operations):
with open("msetout.txt", "w") as output_file:
output_file.write("Datele de intrare nu respecta cerintele impuse.")
return

results = process_operations(operations)

with open("msetout.txt", "w") as output_file:
output_file.write("Datele de intrare respecta cerintele impuse.\n")
for min_value, count in results:
output_file.write(f"{min_value} {count}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

1794 - Aint

2024-01-03T22:46:23Z

Tita Marian: Pagină nouă: == Cerinţa == Se dă un vector cu '''N''' elemente numere naturale numerotate de la '''1''' la '''N''' și '''M''' operații de forma: *'''1 x y''', cu semnificația: elementul de poziția '''x''' ia valoarea valoarea '''y'''. *'''2 x y''': se determină valoarea minimă a elementelor cu indici cuprinși între '''x''' și '''y'''. Afișați rezultatele operațiilor de tipul '''2'''. ==Date de intrare== Fișierul de intrare '''aintin.txt''' conține pe prima linie numerele '...

== Cerinţa ==
Se dă un vector cu '''N''' elemente numere naturale numerotate de la '''1''' la '''N''' și '''M''' operații de forma:
*'''1 x y''', cu semnificația: elementul de poziția '''x''' ia valoarea valoarea '''y'''.
*'''2 x y''': se determină valoarea minimă a elementelor cu indici cuprinși între '''x''' și '''y'''.
Afișați rezultatele operațiilor de tipul '''2'''.
==Date de intrare==
Fișierul de intrare '''aintin.txt''' conține pe prima linie numerele '''N''' și '''M'''. Pe următoarea linie se află '''N''' elemente ce reprezintă elementele vectorului. Pe următoarele '''M''' linii se află operațiile efectuate pe vector.
== Date de ieșire ==
Fișierul de ieșire '''aintout.txt''' va conține răspunsurile operațiilor de tipul '''2''', în ordinea în care apar în fișierul de intrare.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*'''1 ≤ N,M ≤ 100000'''
*Elementele vectorului sunt '''≤ 1000000000'''
*Pentru operațiile de tipul 1, '''1 ≤ x ≤ N, 0 ≤ y ≤ 1000000000'''
*Pentru operațiile de tipul 2, '''1 ≤ x ≤ y ≤ N'''
== Exemplul 1 ==
; Intrare
7 4
2 3 4 1 2 7 2
1 2 3
1 4 6
2 2 6
2 1 7
; Ieșire
2
2
Datele de intrare respecta cerintele impuse.
 
== Exemplul 2 ==
; Intrare
8 3
2 3 4 1 2 7 2
1 2 3
1 10 6
2 2 6
; Ieșire
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
with open("aintin.txt", "r") as infile, open("aintout.txt", "w") as outfile:
N, M = map(int, infile.readline().split())
nums = list(map(int, infile.readline().split()))

for _ in range(M):
op, x, y = map(int, infile.readline().split())

if not (1 <= N <= 100000 and 1 <= M <= 100000 and all(1 <= num <= 1000000000 for num in nums) and
(op == 1 and 1 <= x <= N and 0 <= y <= 1000000000 or op == 2 and 1 <= x <= y <= N)):
outfile.write("Datele de intrare nu respecta cerintele impuse.\n")
return

if op == 1:
nums[x - 1] = y
elif op == 2:
subvec = nums[x - 1:y]
subvec.sort()
outfile.write(f"{subvec[0]}\n")

outfile.write("Datele de intrare respecta cerintele impuse.\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

3474 - Squary

2024-01-03T22:26:47Z

Tita Marian: Pagină nouă: == Cerinţa == Se dau '''n''' numere naturale. Aflați numărul subsecventelor care au produsul pătrat perfect. ==Date de intrare== Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații. == Date de ieșire == Programul va afișa pe ecran numărul subsecventelor care respectă condiția. În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de...

== Cerinţa ==
Se dau '''n''' numere naturale. Aflați numărul subsecventelor care au produsul pătrat perfect.
==Date de intrare==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Programul va afișa pe ecran numărul subsecventelor care respectă condiția.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*'''1 ≤ n ≤ 100.000'''
*cele '''n''' numere citite vor fi mai mici decât '''300'''
== Exemplul 1 ==
; Intrare
5
1 2 4 8 16
; Ieșire
Datele de intrare respecta cerintele impuse.
7
 
== Exemplul 2 ==
; Intrare
3
1 2 500
; Ieșire
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
from math import isqrt

def numar_subsecvente_patrat_perfect(n, numere):
numar_subsecvente = 0
prefixe_produs = [1]

for numar in numere:
prefixe_produs.append(prefixe_produs[-1] * numar)

for i in range(n):
for j in range(i, n):
produs = prefixe_produs[j + 1] // prefixe_produs[i]

if isqrt(produs) ** 2 == produs:
numar_subsecvente += 1

return numar_subsecvente

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

if 1 <= n <= 100000 and len(numere) == n and all(1 <= numar <= 300 for numar in numere):
print("Datele de intrare respecta cerintele impuse.")
rezultat = numar_subsecvente_patrat_perfect(n, numere)
print(rezultat)
else:
print("Datele de intrare nu respecta cerintele impuse.")

except ValueError:
print("Datele de intrare nu respecta cerintele impuse.")

</syntaxhighlight>

3660 - Unghi Drept

2024-01-03T22:19:09Z

Tita Marian: Pagină nouă: == Cerinţa == Se dau n puncte în plan. O operație constă în alegerea unui triunghi dreptunghic și adăugarea unui punct, astfel încât cele '''3''' puncte alese și cel adăugat să formeze un nou dreptunghi. Aflați numărul maxim de operații ce se pot efectua. ==Date de intrare== Programul citește de la tastatură numărul '''n''', iar apoi '''n''' linii cu câte '''2''' numere naturale. == Date de ieșire == Programul va afișa pe ecran numărul cerut. În cazul...

== Cerinţa ==
Se dau n puncte în plan. O operație constă în alegerea unui triunghi dreptunghic și adăugarea unui punct, astfel încât cele '''3''' puncte alese și cel adăugat să formeze un nou dreptunghi. Aflați numărul maxim de operații ce se pot efectua.
==Date de intrare==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' linii cu câte '''2''' numere naturale.
== Date de ieșire ==
Programul va afișa pe ecran numărul cerut.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*'''1 ≤ n ≤ 200.000'''
*celelalte numere citite vor fi mai mici decât '''2.000.000.000'''
== Exemplul 1 ==
; Intrare
4
1 3
2 3
1 2
3 3
; Ieșire
Datele de intrare respecta cerintele impuse.
2
==Explicație==
La prima operație, alegem triungiul cu coordonatele ''' (1, 2), (1, 3), (2, 3) ''' și adăugăm punctul ''' (2, 2) '''. La al doilea, alegem triunghiul cu coordonatele ''' (2, 2), (2, 3), (3, 3) ''' și adăugăm punctul ''' (3, 2) '''. De aici, nu mai putem efectua nicio operație.
 
== Exemplul 2 ==
; Intrare
0
; Ieșire
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_maxim_operatii(puncte):
coordonate_x = {}
coordonate_y = {}

for x, y in puncte:
if x in coordonate_x:
coordonate_x[x] += 1
else:
coordonate_x[x] = 1

if y in coordonate_y:
coordonate_y[y] += 1
else:
coordonate_y[y] = 1

numar_operatii = 0

for x, y in puncte:
numar_operatii += (coordonate_x[x] - 1) * (coordonate_y[y] - 1)

return numar_operatii

if __name__ == "__main__":
try:
n = int(input())

if 1 <= n <= 200000:
puncte = [tuple(map(int, input().split())) for _ in range(n)]

if all(1 <= x <= 2000000000 and 1 <= y <= 2000000000 for x, y in puncte):
rezultat = numar_maxim_operatii(puncte)
print("Datele de intrare respecta cerintele impuse.")
print(rezultat)
else:
print("Datele de intrare nu respecta cerintele impuse.")
else:
print("Datele de intrare nu respecta cerintele impuse.")

except ValueError:
print("Datele de intrare nu respecta cerintele impuse.")

</syntaxhighlight>

2631 - H4

2024-01-03T21:56:53Z

Tita Marian: Pagină nouă: ==Context== Spunem că două cuvinte sunt anagrame dacă au aceleași litere, eventual în altă ordine. De exemplu, '''abac''' și '''baca''' sunt anagrame, dar '''abac''' și '''abbc''' nu sunt. Dându-se un șir de cuvinte separate prin spații sau enter, vom considera că dacă mai multe cuvinte sunt anagrame, atunci ele fac parte din același grup. == Cerinţa == Să se determine numărul maxim de cuvinte dintr-un grup. ==Date de intrare== Programul citește de la tastat...

==Context==
Spunem că două cuvinte sunt anagrame dacă au aceleași litere, eventual în altă ordine. De exemplu, '''abac''' și '''baca''' sunt anagrame, dar '''abac''' și '''abbc''' nu sunt. Dându-se un șir de cuvinte separate prin spații sau enter, vom considera că dacă mai multe cuvinte sunt anagrame, atunci ele fac parte din același grup.
== Cerinţa ==
Să se determine numărul maxim de cuvinte dintr-un grup.
==Date de intrare==
Programul citește de la tastatură o succesiune de cuvinte separate prin spații.
== Date de ieșire ==
Programul va afișa pe ecran un singur număr reprezentând numărul maxim de cuvinte dintr-un grup.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*Cuvintele au lungimea cel mult '''14''' și conțin numai litere mici.
*Vor exista cel mult '''100.000''' de cuvinte în șir.
== Exemplul 1 ==
; Intrare
alee leee elea car rac eela eeel elee elee
; Ieșire
Datele de intrare respecta cerintele impuse.
4
==Explicație==
Grupul maximal este format din cuvintele '''leee, eeel, elee, elee'''.
 
== Exemplul 2 ==
; Intrare
Alee leee elea car

; Ieșire
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_maxim_anagrame(cuvinte):
grupuri_anagrame = {}

for cuvant in cuvinte:
cheie = ''.join(sorted(cuvant))
if cheie in grupuri_anagrame:
grupuri_anagrame[cheie].append(cuvant)
else:
grupuri_anagrame[cheie] = [cuvant]

numar_maxim = max(len(grup) for grup in grupuri_anagrame.values())

return numar_maxim

if __name__ == "__main__":
try:
input_str = input()
cuvinte = input_str.split()

if all(1 <= len(cuvant) <= 14 and cuvant.islower() for cuvant in cuvinte) and 1 <= len(cuvinte) <= 100000:
rezultat = numar_maxim_anagrame(cuvinte)
print("Datele de intrare respecta cerintele impuse.")
print(rezultat)
else:
print("Datele de intrare nu respecta cerintele impuse.")
except ValueError:
print("Datele de intrare nu respecta cerintele impuse.")

</syntaxhighlight>

2628 - H2

2024-01-03T20:56:46Z

Tita Marian: Pagină nouă: ==Context== În urma referendumului a rămas doar un șir de numere naturale '''a[1], a[2], …, a[n] '''. == Cerinţa == Să se determine cel mai mic număr care apare exact o dată în șir. ==Date de intrare== Programul citește de la tastatură numărul '''n''', apoi șirul '''n''' numere naturale, separate prin spații. == Date de ieșire == Programul va afișa pe ecran numărul '''m''', reprezentând numărul minim care apare exact o dată în șir. În cazul în care...

==Context==
În urma referendumului a rămas doar un șir de numere naturale '''a[1], a[2], …, a[n] '''.
== Cerinţa ==
Să se determine cel mai mic număr care apare exact o dată în șir.
==Date de intrare==
Programul citește de la tastatură numărul '''n''', apoi șirul '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Programul va afișa pe ecran numărul '''m''', reprezentând numărul minim care apare exact o dată în șir.
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*'''10 ≤ n ≤ 1 000 000'''
*'''0 ≤ a[i] ≤ 2.000.000.000'''
*Se garantează că există cel puțin un număr care apare o singură dată.
== Exemplul 1 ==
; Intrare
10
5 3 8 7 3 3 2 5 9 5

; Ieșire
Datele de intrare respecta cerintele impuse.
2
==Explicație==
Numerele care apar o singură dată în șir sunt: '''8, 7, 2, 9'''. Cel mai mic este '''2'''.
 
== Exemplul 2 ==
; Intrare
9
5 3 8 7 3 3 2 5 9 5

; Ieșire
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
try:
n = int(input())
sir = list(map(int, input().split()))

if len(sir) == n and all(0 <= numar <= 2000000000 for numar in sir):
if 10 <= n <= 1000000:
frecvente = {}
aparitii = set()

for numar in sir:
if numar in frecvente:
aparitii.discard(frecvente[numar])
else:
frecvente[numar] = 0
aparitii.add(numar)

if aparitii:
numar_minim = min(aparitii)
print(f"Datele de intrare respecta cerintele impuse.")
print(f"Numărul minim care apare exact o dată în șir este: {numar_minim}")
else:
print("Nu există niciun număr care să apară exact o dată în șir.")
else:
print("Datele de intrare nu respecta cerintele impuse.")
else:
print("Datele de intrare nu respecta cerintele impuse.")
except ValueError:
print("Datele de intrare nu respecta cerintele impuse.")

if __name__ == "__main__":
main()

</syntaxhighlight>

2937 - Ora

2024-01-03T20:39:42Z

Tita Marian: Pagină nouă: ==Context== Gigel este la ora de informatică, iar profesorul i-a cerut să sorteze numele celor '''n ''' colegi ai săi după o regulă specială. Fiecărui nume i se asociază un număr care iniţial este '''0 ''' și crește cu '''1 ''' pentru fiecare pereche de vocale consecutive și scade cu 1 pentru fiecare pereche de consoane consecutive din nume. Dacă perechea este formată dintr-o vocală și o consoană, numărul nu se modifică. == Cerinţa == Dându-se cele '''n...

==Context==
Gigel este la ora de informatică, iar profesorul i-a cerut să sorteze numele celor '''n ''' colegi ai săi după o regulă specială. Fiecărui nume i se asociază un număr care iniţial este '''0 ''' și crește cu '''1 ''' pentru fiecare pereche de vocale consecutive și scade cu 1 pentru fiecare pereche de consoane consecutive din nume. Dacă perechea este formată dintr-o vocală și o consoană, numărul nu se modifică.

== Cerinţa ==
Dându-se cele '''n ''' nume ale colegilor, să se sorteze crescător după numerele asociate. La numere egale, se vor sorta alfabetic.
== Date de intrare ==
Programul citește de la tastatură numărul '''n ''', iar apoi '''n ''' nume, fiecare pe câte o linie nouă.

== Date de ieșire ==
Programul va afișa pe ecran cele '''n ''' nume sortate, pe linii separate.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
* '''1 ≤ n ≤ 300.000 ''';
*numele conțin cel mult '''20 ''' de caractere;
*numele copiilor sunt distincte două câte două.
== Exemplul 1 ==
; Intrare
5
George
Steve
Jotaro
Aeioubc
Star

; Ieșire
Datele de intrare respecta cerintele impuse.
Star
Steve
George
Jotaro
Aeioubc
 
== Exemplul 2 ==
; Intrare
0

; Ieșire
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def calculeaza_numar(nume):
numar = 0
vocale = "aeiouAEIOU"

for i in range(len(nume) - 1):
pereche = nume[i:i + 2]
if pereche[0] in vocale and pereche[1] in vocale:
numar += 1
elif pereche[0] not in vocale and pereche[1] not in vocale:
numar -= 1

return numar

if __name__ == "__main__":
try:
n = int(input("Introdu numărul de colegi: "))
if 1 <= n <= 300000:
colegi = [input() for _ in range(n)]

if len(set(colegi)) == n and all(1 <= len(nume) <= 20 for nume in colegi):
print("Datele de intrare respecta cerintele impuse.")

# Sortare utilizând funcția cal0uleaza_numar și apoi numele în caz de egalitate
colegi_sortati = sorted(colegi, key=lambda x: (calculeaza_numar(x), x))

# Afișare rezultat
for coleg in colegi_sortati:
print(coleg)
else:
print("Datele de intrare nu respecta cerintele impuse.")
else:
print("Datele de intrare nu respecta cerintele impuse.")
except ValueError:
print("Datele de intrare nu respecta cerintele impuse.")

</syntaxhighlight>

2268 - Colegi

2024-01-03T20:32:04Z

Tita Marian: Pagină nouă: == Cerinţa == Dirigu’ vrea să știe care este cel mai frecvent prenume printre elevii din clasa noastră. Pentru aceasta a realizat o listă cu cele '''n''' prenume ale elevilor din clasă și acum vă cere să determinați prenumele cel mai frecvent și numărul său de apariții. Dacă sunt mai multe prenume cu număr maxim de apariții se va determina primul în ordine alfabetică. . == Date de intrare == Programul citește de la tastatură numărul '''n''', iar apoi...

== Cerinţa ==
Dirigu’ vrea să știe care este cel mai frecvent prenume printre elevii din clasa noastră. Pentru aceasta a realizat o listă cu cele '''n''' prenume ale elevilor din clasă și acum vă cere să determinați prenumele cel mai frecvent și numărul său de apariții.
Dacă sunt mai multe prenume cu număr maxim de apariții se va determina primul în ordine alfabetică.
.

== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi cele '''n''' prenume ale colegilor.

== Date de ieșire ==
Programul va afișa pe ecran '''S k''', separate printr-un spațiu, reprezentând prenumele determinat și numărul de apariții a acestuia.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul '''"Datele de intrare nu respecta cerintele impuse." ''', iar daca se indeplinesc, se afiseaza mesajul '''"Datele de intrare respecta cerintele impuse."'''
== Restricţii şi precizări ==
*'''1 ≤ n ≤ 100.000''' – mda, este o clasă cam mare…
== Exemplul 1 ==
; Intrare
8
Maria Tudor Andrei Tudor George Andrei Ioana Andrei

; Ieșire
Datele de intrare respecta cerintele impuse.
Andrei 3
 
== Exemplul 2 ==
; Intrare
0

; Ieșire
Datele de intrare nu respecta cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def cel_mai_frecvent_prenume(n, prenume):
frecventa = {}

for nume in prenume:
if nume in frecventa:
frecventa[nume] += 1
else:
frecventa[nume] = 1

prenume_max_frecventa = max(frecventa, key=lambda x: (frecventa[x], x))
numar_aparitii = frecventa[prenume_max_frecventa]

return prenume_max_frecventa, numar_aparitii

if __name__ == "__main__":
try:
n = int(input("Introdu numărul de prenume: "))
if 1 <= n <= 100000:
prenume = input("Introdu lista de prenume separate de spațiu: ").split()

if len(prenume) != n or any(not nume.isalpha() for nume in prenume):
print("Datele de intrare nu respecta cerintele impuse.")
else:
print("Datele de intrare respecta cerintele impuse.")
rezultat = cel_mai_frecvent_prenume(n, prenume)
print(" ".join(map(str, rezultat)))
else:
print("Datele de intrare nu respecta cerintele impuse.")
except ValueError:
print("Datele de intrare nu respecta cerintele impuse.")

</syntaxhighlight>