Bitnami MediaWiki - User contributions [en]

16402

2024-12-11T10:18:37Z

AntalKrisztian: Created page with "'''16402 (Cristina Vijdeluc, Salonic și Mihai Vijdeluc, Baia Mare)''' ''Fie <math>n \in \mathbb{N}^*</math> și numerele pozitive <math>x_1, x_2, \dots, x_n</math> care verifică relația <math>\frac{1}{x_1} + \frac{1}{x_2} + \dots + \frac{1}{x_n} = \frac{n}{n+1}.</math> Arătați că <math>\frac{1}{x_1 + 2} + \frac{1}{x_2 + 6} + \dots + \frac{1}{x_n + n(n+1)} \leq \frac{n}{2(n+1)}.</math>'' '''Soluție:''' Din inegalitatea mediilor armonică și aritmetică,..."

'''16402 (Cristina Vijdeluc, Salonic și Mihai Vijdeluc, Baia Mare)'''

''Fie <math>n \in \mathbb{N}^*</math> și numerele pozitive <math>x_1, x_2, \dots, x_n</math> care verifică relația

<math>\frac{1}{x_1} + \frac{1}{x_2} + \dots + \frac{1}{x_n} = \frac{n}{n+1}.</math>

Arătați că

<math>\frac{1}{x_1 + 2} + \frac{1}{x_2 + 6} + \dots + \frac{1}{x_n + n(n+1)} \leq \frac{n}{2(n+1)}.</math>''

'''Soluție:'''

Din inegalitatea mediilor armonică și aritmetică,
<math>\frac{1}{a+b} \leq \frac{1}{4}\left(\frac{1}{a} + \frac{1}{b}\right),</math>
pentru oricare <math>a, b > 0.</math> Aplicând succesiv această inegalitate obținem
<math>\frac{1}{x_1 + 2} + \frac{1}{x_2 + 6} + \dots + \frac{1}{x_n + n(n+1)} \leq
\frac{1}{4} \left( \frac{1}{x_1} + \frac{1}{x_2} + \dots + \frac{1}{x_n} +
\frac{1}{1 \cdot 2} + \frac{1}{2 \cdot 3} + \dots + \frac{1}{n(n+1)} \right) =</math>
<math>\frac{1}{4} \left( \frac{n}{n+1} + 1 - \frac{1}{2} + \frac{1}{2} - \frac{1}{3} + \dots + \frac{1}{n} - \frac{1}{n+1} \right) =
\frac{n}{2(n+1)}.</math>

16393

2024-12-11T10:01:47Z

AntalKrisztian: Created page with "'''16393 (Cristina Vijdeluc și Mihai Vijdeluc)''' ''Determinați numerele naturale nenule <math>n</math> pentru care numărul <math>a(n) = \sqrt{(1 \cdot 2 \cdot 3 \cdots n)^5 + 145}</math> este natural.'' '''Soluție:''' Calculând valorile lui <math>a(n)</math> pentru <math>n \in \{1, 2, 3, 4\},</math> găsim că doar pentru <math>n = 3,</math> <math>a(n) = 89</math> verifică cerința. Pentru <math>n \geq 5,</math> <math>(1 \cdot 2 \cdot 3 \cdots n)^5 + 145</ma..."

'''16393 (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Determinați numerele naturale nenule <math>n</math> pentru care numărul <math>a(n) = \sqrt{(1 \cdot 2 \cdot 3 \cdots n)^5 + 145}</math> este natural.''

'''Soluție:'''

Calculând valorile lui <math>a(n)</math> pentru <math>n \in \{1, 2, 3, 4\},</math> găsim că doar pentru <math>n = 3,</math> <math>a(n) = 89</math> verifică cerința.

Pentru <math>n \geq 5,</math> <math>(1 \cdot 2 \cdot 3 \cdots n)^5 + 145</math> este divizibil cu <math>5,</math> dar nu este divizibil cu <math>25,</math> deci nu este pătrat perfect.

0472 - Bipartit 1

2023-12-29T18:44:18Z

AntalKrisztian: Pagină nouă: == Cerinţa == Se dă lista muchiilor unui graf neorientat cu '''n''' vârfuri, etichetate de la '''1''' la '''n'''. Să se verifice dacă graful este bipartit. == Date de intrare == Fişierul de intrare '''bipartit1in.txt''' conţine pe prima linie numerele '''n''' și '''m''', reprezentând numărul de vârfuri ale grafului și numărul de muchii. Fiecare dintre următoarele '''m''' linii conține câte o pereche de numere '''i j''', cu semnificația că există muchie înt...

== Cerinţa ==
Se dă lista muchiilor unui graf neorientat cu '''n''' vârfuri, etichetate de la '''1''' la '''n'''. Să se verifice dacă graful este bipartit.
== Date de intrare ==
Fişierul de intrare '''bipartit1in.txt''' conţine pe prima linie numerele '''n''' și '''m''', reprezentând numărul de vârfuri ale grafului și numărul de muchii. Fiecare dintre următoarele '''m''' 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 ==
Fişierul de ieşire '''bipartit1out.txt''' va conţine pe prima linie mesajul '''DA''', dacă graful este bipartit, respectiv '''NU''' în caz contrar.

Dacă mesajul este '''DA''', următoarele două linii vor conţine două mulţimi care formează partiţia vârfurilor. Elementele fiecărei mulţimi vor fi afişate în ordine crescătoare, separate prin exact un spaţiu. Prima mulţime va fi cea care conţine vârful '''1'''
== Restricții și precizări ==
* '''1 < n &les; 15'''
* '''1 &les; i , j &les; n'''
== Exemplul 1 ==
; bipartit1in.txt
7 6
1 4
1 6
6 5
3 2
3 5
3 7
; bipartit1out.txt
Datele de intrare corespund restrictiilor impuse.
DA
1 2 5 7
3 4 6
 
== Exemplul 2 ==
; bipartit1in.txt
ijtijgijrigmfg
; bipartit1out.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, muchii_validare):
# Verificăm dacă n este în intervalul 1-15
if n_validare < 1 or n_validare > 15:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-15
for muchie in muchii_validare: # Parcurgem lista de muchii
# Verificăm dacă valoarea absolută a fiecărui vârf este în intervalul 1-n
if abs(muchie[0]) < 1 or abs(muchie[0]) > n_validare or abs(muchie[1]) < 1 or abs(muchie[1]) > n_validare:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# Funcția este_bipartit verifică dacă graful este bipartit
def este_bipartit(n_bipartit, muchii_bipartit):
# Inițializăm culorile vârfurilor cu -1
culoare_bipartit = [-1] * (n_bipartit + 1)
# Construim lista de adiacență a grafului
lista_adiacenta = [[] for _ in range(n_bipartit + 1)]
for muchie in muchii_bipartit:
lista_adiacenta[muchie[0]].append(muchie[1])
lista_adiacenta[muchie[1]].append(muchie[0])
# Parcurgem vârfurile grafului
for i in range(1, n_bipartit + 1):
# Dacă vârful nu a fost colorat și nu poate fi colorat, atunci graful nu este bipartit
if culoare_bipartit[i] == -1 and not colorare(i, 1, culoare_bipartit, lista_adiacenta):
return False, culoare_bipartit
return True, culoare_bipartit

# Funcția colorare încearcă să coloreze vârfurile grafului astfel încât să fie bipartit
def colorare(v, c, culoare_color, lista_adiacenta):
# Colorăm vârful v cu culoarea c
culoare_color[v] = c
# Parcurgem vecinii vârfului v
for u in lista_adiacenta[v]:
# Dacă vecinul u are aceeași culoare cu v, atunci graful nu poate fi bipartit
if culoare_color[u] == c:
return False
# Dacă vecinul u nu a fost colorat și nu poate fi colorat, atunci graful nu poate fi bipartit
if culoare_color[u] == -1 and not colorare(u, 1 - c, culoare_color, lista_adiacenta):
return False
return True

if __name__ == '__main__':
file_in = open("bipartit1in.txt", "r")
file_out = open("bipartit1out.txt", "w")

try:
# Citim numărul de vârfuri și de muchii
n_main, m_main = map(int, file_in.readline().split())
# Citim muchiile
muchii_main = [list(map(int, linie.split())) for linie in file_in.readlines()]
# Validăm datele de intrare
validare(n_main, muchii_main)
# Verificăm dacă graful este bipartit
bipartit, culoare = este_bipartit(n_main, muchii_main)
if bipartit:
file_out.write("DA\n")
# Construim listele de vârfuri pentru cele două mulțimi
lista1 = [i for i in range(1, n_main + 1) if culoare[i] == 1]
lista2 = [i for i in range(1, n_main + 1) if culoare[i] == 0]
file_out.write(' '.join(map(str, lista1)) + '\n')
file_out.write(' '.join(map(str, lista2)) + '\n')
else:
file_out.write("NU\n")

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

0422 - Graf Partial 2

2023-12-29T18:31:43Z

AntalKrisztian: Pagină nouă: == 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 muchiile cu o extremitate într-un vârf de grad maxim. Să se determine numărul de muchii eliminate și să se afișeze matricea de adiacență a grafului parțial obținut. == Date de intrare == Fişierul de intrare '''graf_partial_2in.txt''' conţine pe prima linie numărul '''n''', reprezentând numărul de vârfuri ale gra...

== 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 muchiile cu o extremitate într-un vârf de grad maxim. Să se determine numărul de muchii eliminate și să se afișeze matricea de adiacență a grafului parțial obținut.
== Date de intrare ==
Fişierul de intrare '''graf_partial_2in.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 ==
Fişierul de ieşire '''graf_partial_2out.txt''' va conţine pe prime linie numărul de muchii eliminate, iar pe următoarele linii matricea de adiacență a grafului parțial obținut, câte o linie a matricei pe o linie a fișierului, elementele de pe fiecare linie fiind separate prin exact un spațiu.
== 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 ==
; graf_partial_2in.txt
6
1 2
6 2
2 3
4 3
5 3
4 5
3 6
6 4
; graf_partial_2out.txt
Datele de intrare corespund restrictiilor impuse.
4
0 1 0 0 0 0
1 0 0 0 0 1
0 0 0 0 0 0
0 0 0 0 1 1
0 0 0 1 0 0
0 1 0 1 0 0
 
== Explicație ==
Se elimină muchiile '''(2 3), (4 3), (5 3), (3 6)'''.
== Exemplul 2 ==
; graf_partial_2in.txt
jgirjiurmgrog
; graf_partial_2out.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, muchii_validare):
# Verificăm dacă n este în intervalul 1-100
if n_validare < 1 or n_validare > 100:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-100
for muchie_validare in muchii_validare: # Parcurgem lista de muchii
# Verificăm dacă valoarea absolută a fiecărui vârf este în intervalul 1-n
if (abs(muchie_validare[0]) < 1 or abs(muchie_validare[0]) > n_validare
or abs(muchie_validare[1]) < 1 or abs(muchie_validare[1]) > n_validare):
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# Funcția elimina_muchii elimină muchiile cu o extremitate într-un vârf de grad maxim
def elimina_muchii(n_elimina, muchii_elimina):
# Calculăm gradele vârfurilor
grade = [0] * (n_elimina + 1)
for muchie_eliminare in muchii_elimina:
grade[muchie_eliminare[0]] += 1
grade[muchie_eliminare[1]] += 1
# Determinăm gradul maxim
grad_max = max(grade)
# Eliminăm muchiile cu o extremitate într-un vârf de grad maxim
muchii_eliminate_ = 0
muchii_noi_creat = []
for muchie_eliminare in muchii_elimina:
if grade[muchie_eliminare[0]] == grad_max or grade[muchie_eliminare[1]] == grad_max:
muchii_eliminate_ += 1
else:
muchii_noi_creat.append(muchie_eliminare)
return muchii_eliminate_, muchii_noi_creat

if __name__ == '__main__':
file_in = open("graf_partial_2in.txt", "r")
file_out = open("graf_partial_2out.txt", "w")

try:
# Citim numărul de vârfuri
n_main = int(file_in.readline())
# Citim muchiile
muchii_main = [list(map(int, linie.split())) for linie in file_in.readlines()]
# Validăm datele de intrare
validare(n_main, muchii_main)
# Eliminăm muchiile cu o extremitate într-un vârf de grad maxim
muchii_eliminate, muchii_noi = elimina_muchii(n_main, muchii_main)
# Scriem numărul de muchii eliminate în fișierul de ieșire
file_out.write(str(muchii_eliminate) + '\n')
# Scriem matricea de adiacență a grafului parțial obținut în fișierul de ieșire
matrice_adiacenta = [[0] * n_main for _ in range(n_main)]
for muchie in muchii_noi:
matrice_adiacenta[muchie[0]-1][muchie[1]-1] = 1
matrice_adiacenta[muchie[1]-1][muchie[0]-1] = 1
for linie in matrice_adiacenta:
file_out.write(' '.join(map(str, linie)) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

0353 - Spectacole

2023-12-29T18:01:46Z

AntalKrisztian: Pagină nouă: == Cerinţa == La un festival sunt programate '''n''' spectacole. Pentru fiecare se cunoaște momentul de început și momentul de sfârșit, exprimate prin numere naturale. Un spectator dorește să urmărească cât mai multe spectacole în întregime. Determinați numărul maxim de spectacole care pot fi urmărite, fără ca acestea să se suprapună. == Date de intrare == Fişierul de intrare '''spectacolein.txt''' conţine pe prima linie numărul '''n'''. Pe fiecare din...

== Cerinţa ==
La un festival sunt programate '''n''' spectacole. Pentru fiecare se cunoaște momentul de început și momentul de sfârșit, exprimate prin numere naturale. Un spectator dorește să urmărească cât mai multe spectacole în întregime.

Determinați numărul maxim de spectacole care pot fi urmărite, fără ca acestea să se suprapună.
== Date de intrare ==
Fişierul de intrare '''spectacolein.txt''' conţine pe prima linie numărul '''n'''. Pe fiecare dintre următoarele '''n''' linii se află câte două numere naturale '''X Y''', reprezentând momentul de început și momentul de sfârșit al unui spectacol.
== Date de ieşire ==
Fişierul de ieşire '''spectacoleout.txt''' va conţine pe prima linie numărul '''S''', reprezentând numărul maxim de spectacole care pot fi urmărite, fără să se suprapună.
== Restricții și precizări ==
* '''1 &les; n &les; 100'''
* momentele de început și sfârșit ale spectacolelor sunt numere naturale mai mici decât '''1.000.000'''
* pentru fiecare spectacol, '''X < Y'''
* dacă momentul de început al unui spectacol și momentul de sfârșit al altui spectacol coincid, pot fi urmărite ambele spectacole
== Exemplul 1 ==
; spectacolein.txt
10
5 14
14 17
8 13
13 15
15 17
3 6
4 7
6 9
11 14
10 11
; spectacoleout.txt
Datele de intrare corespund restrictiilor impuse.
5
 
== Explicație ==
Pot fi alese, de exemplu, spectacolele: '''3 6''', '''6 9''', '''10 11''', '''11 14''' și '''14 17'''.
 
== Exemplul 2 ==
; spectacolein.txt
igrij
; spectacoleout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, spectacole_validare):
# Verificăm dacă n este în intervalul 1-100
if n_validare < 1 or n_validare > 100:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-100
for spectacol in spectacole_validare: # Parcurgem lista de spectacole
# Verificăm dacă momentele de început și sfârșit ale spectacolelor sunt în intervalul specificat
if spectacol[0] >= 1000000 or spectacol[1] >= 1000000 or spectacol[0] >= spectacol[1]:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# Funcția numar_spectacole determină numărul maxim de spectacole care pot fi urmărite, fără ca acestea să se suprapună
def numar_spectacole(n_numar, spectacole_numar):
# Sortăm spectacolele în funcție de momentul de sfârșit
spectacole_numar.sort(key=lambda x: x[1])
# Inițializăm numărul de spectacole cu 1
nr_spectacole = 1
# Inițializăm momentul de sfârșit al ultimului spectacol urmărit
sfarsit_ultim = spectacole_numar[0][1]
# Parcurgem lista de spectacole
for i in range(1, n_numar):
if spectacole_numar[i][0] >= sfarsit_ultim:
# Urmărim spectacolul curent
nr_spectacole += 1
sfarsit_ultim = spectacole_numar[i][1]
return nr_spectacole

if __name__ == '__main__':
file_in = open("spectacolein.txt", "r")
file_out = open("spectacoleout.txt", "w")

try:
# Citim numărul de spectacole
n_main = int(file_in.readline())
# Citim momentele de început și sfârșit ale spectacolelor
spectacole_main = [list(map(int, file_in.readline().split())) for _ in range(n_main)]
# Validăm datele de intrare
validare(n_main, spectacole_main)
# Determinăm numărul maxim de spectacole care pot fi urmărite
nr_spectacole_main = numar_spectacole(n_main, spectacole_main)
# Scriem numărul maxim de spectacole care pot fi urmărite în fișierul de ieșire
file_out.write(str(nr_spectacole_main) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

0398 - Plopi 2

2023-12-29T17:39:34Z

AntalKrisztian: Pagină nouă: == Cerinţa == De-a lungul principalei străzi din orașul nostru există '''n''' plopi, pentru fiecare cunoscându-se înălțimea. Primarul orașului dorește ca plopii să aibă înălțimile în ordine descrescătoare. Pentru aceasta, este posibilă tăierea dintr-un plop a unei bucăți – este o tehnică ecologică, nevătămătoare, în urma căreia plopul nu are de suferit. Plopii nu pot fi înălțați în niciun fel. Determinați numărul minim de plopi din care s...

== Cerinţa ==
De-a lungul principalei străzi din orașul nostru există '''n''' plopi, pentru fiecare cunoscându-se înălțimea. Primarul orașului dorește ca plopii să aibă înălțimile în ordine descrescătoare. Pentru aceasta, este posibilă tăierea dintr-un plop a unei bucăți – este o tehnică ecologică, nevătămătoare, în urma căreia plopul nu are de suferit. Plopii nu pot fi înălțați în niciun fel.

Determinați numărul minim de plopi din care se va tăia și lungimea totală minimă a bucăților tăiate.
== Date de intrare ==
Fișierul de intrare '''plopi2in.txt''' conține pe prima linie numărul de plopi '''n'''. Urmează '''n''' numere naturale nenule, separate prin spaţii, care pot fi dispuse pe mai multe linii, reprezentând înălțimile plopilor.
== Date de ieşire ==
Fișierul de ieșire '''plopi2out.txt''' va conține pe prima linie numerele '''C T''', separate prin exact un spațiu, reprezentând numărul minim de plopi din care se va tăia și lungimea totală minimă a bucăților tăiate.
== Restricții și precizări ==
* '''2 &les; n &les; 100'''
* înălțimile plopilor vor fi mai mici decât '''10000'''
== Exemplul 1 ==
; plopi2in.txt
8
5 7 3 6 4 4 2 6
; plopi2out.txt
Datele de intrare corespund restrictiilor impuse.
5 11
 
== Explicație ==
Vom tăia din plopii numerotați cu '''2 4 5 6 8''', astfel încât înălțimile să devină '''5 5 3 3 3 3 2 2'''. Lungimea totală a bucăților tăiate este: '''2 + 3 + 1 + 1 +4 = 11'''
 
== Exemplul 2 ==
; plopi2in.txt
yrteofmnrf
; plopi2out.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, inaltimi_validare):
# Verificăm dacă n este în intervalul 2-100
if n_validare < 2 or n_validare > 100:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 2-100
for inaltime in inaltimi_validare: # Parcurgem lista de înălțimi
# Verificăm dacă înălțimea este mai mică decât 10000
if inaltime >= 10000:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# Funcția taie_plopi taie plopii astfel încât să aibă înălțimile în ordine descrescătoare
def taie_plopi(n_taie, inaltimi_taie):
# Inițializăm numărul de plopi din care se va tăia și lungimea totală a bucăților tăiate
nr_plopi, lungime_totala = 0, 0
# Parcurgem lista de înălțimi
for i in range(1, n_taie):
# Dacă înălțimea plopului curent este mai mare decât înălțimea plopului anterior
if inaltimi_taie[i] > inaltimi_taie[i-1]:
# Tăiem din plop
lungime_totala += inaltimi_taie[i] - inaltimi_taie[i-1]
inaltimi_taie[i] = inaltimi_taie[i-1]
nr_plopi += 1
return nr_plopi, lungime_totala

if __name__ == '__main__':
file_in = open("plopi2in.txt", "r")
file_out = open("plopi2out.txt", "w")

try:
# Citim numărul de plopi
n_main = int(file_in.readline())
# Citim înălțimile plopilor
inaltimi_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(n_main, inaltimi_main)
# Tăiem plopii
nr_plopi_main, lungime_totala_main = taie_plopi(n_main, inaltimi_main)
# Scriem numărul de plopi din care se va tăia și lungimea totală a bucăților tăiate în fișierul de ieșire
file_out.write(str(nr_plopi_main) + ' ' + str(lungime_totala_main) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

1004 - Eureni

2023-12-29T17:31:31Z

AntalKrisztian: Pagină nouă: == Cerinţa == Pentru cadourile pe care Moş Crăciun urmează să le cumpere copiilor cuminţi, Consiliul Polului Nord a alocat suma de '''S''' eureni. Ştiind că în comerţul polar se utilizează '''n+1''' tipuri de bancnote de valori '''1''', '''e1 , e2, e3''',…, '''en''' şi faptul că Moşul trebuie să primească un număr minim de bancnote pentru suma aprobată, să se determine numărul de bancnote din fiecare tip utiliz...

== Cerinţa ==
Pentru cadourile pe care Moş Crăciun urmează să le cumpere copiilor cuminţi, Consiliul Polului Nord a alocat suma de '''S''' eureni. Ştiind că în comerţul polar se utilizează '''n+1''' tipuri de bancnote de valori '''1''', '''e1 , e2, e3''',…, '''en''' şi faptul că Moşul trebuie să primească un număr minim de bancnote pentru suma aprobată, să se determine numărul de bancnote din fiecare tip utilizat în plata sumei şi numărul total de bancnote care i s-au alocat.
== Date de intrare ==
Fișierul de intrare '''eureniin.txt''' conține pe prima linie numerele naturale '''S n e'''.
== Date de ieşire ==
Fișierul de ieșire '''eureniout.txt''' va conține mai multe linii: pe fiecare linie va fi scrisă valoare unei bancnote folosită în plata sumei '''S''' și numărul de bancnote folosite, separate printr-un spațiu, în ordinea descrescătoare a valorilor bancnotelor folosite. Pe ultima linie se va scrie numai numărul total de bancnote folosite.
== Restricții și precizări ==
* '''1 < S < 2 000 000 000'''
* '''1 < n < 10'''
* '''1 < e < 10'''
* se presupune că există un număr nelimitat de bancnote de fiecare tip
== Exemplul 1 ==
; eureniin.txt
107 4 5
; eureniout.txt
Datele de intrare corespund restrictiilor impuse.
25 4
5 1
1 2
7
 
== Explicație ==
Sunt '''5''' tipuri de bancnote, cu valorile: '''1''', '''5''', '''25''', '''125''', '''625''' eureni. Pentru a plăti suma de '''107''' eureni se folosesc '''4''' bancnote de '''25''' eureni, '''1''' bancnotă de '''5''' eureni și '''2''' bancnote de '''1''' euren, în total '''7''' bancnote.
 
== Exemplul 2 ==
; eureniin.txt
grudmgvyem
; eureniout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(s_validare, n_validare, e_validare):
# Verificăm dacă S, n și e sunt în intervalul specificat
if (s_validare <= 1 or s_validare > 2000000000 or
n_validare <= 1 or n_validare > 10 or e_validare <= 1 or e_validare > 10):
raise ValueError # Ridicăm o eroare dacă S, n sau e nu sunt în intervalul specificat
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

def calculeaza_bancnote(s_calc, n_calc, e_calc):
# Calculăm valorile bancnotelor
bancnote = [e_calc ** index for index in range(n_calc + 1)]
# Inițializăm numărul de bancnote din fiecare tip cu 0
nr_bancnote = [0] * (n_calc+1)
# Calculăm numărul de bancnote din fiecare tip
for index in range(n_calc, -1, -1):
nr_bancnote[index] = s_calc // bancnote[index]
s_calc %= bancnote[index]
return nr_bancnote

if __name__ == '__main__':
file_in = open("eureniin.txt", "r")
file_out = open("eureniout.txt", "w")

try:
# Citim S, n și e
S_main, n_main, e_main = map(int, file_in.readline().split())
# Validăm datele de intrare
validare(S_main, n_main, e_main)
# Calculăm numărul de bancnote din fiecare tip
nr_bancnote_main = calculeaza_bancnote(S_main, n_main, e_main)
# Scriem numărul de bancnote din fiecare tip în fișierul de ieșire
for i in range(n_main, -1, -1):
if nr_bancnote_main[i] > 0:
file_out.write(str(e_main ** i) + ' ' + str(nr_bancnote_main[i]) + '\n')
# Scriem numărul total de bancnote în fișierul de ieșire
file_out.write(str(sum(nr_bancnote_main)) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

1580 - Schimb

2023-12-26T16:43:41Z

AntalKrisztian: Pagină nouă: == Cerinţa == Se dau trei numere naturale '''n''', '''k''' și '''p''' și '''n''' șiruri formate din litere mici ale alfabetului englez. Înlocuiți a '''k'''-a literă din fiecare șir cu a '''p'''-a literă din alfabet. Dacă șirul are mai puțin de '''k''' litere se va scrie oglinditul lui. == Date de intrare == Pe prima linie a fișierului '''schimbin.txt''' se află trei numere naturale '''n''', '''k''' și '''p'''. Pe următoarele '''n''' linii se află '''n''' șir...

== Cerinţa ==
Se dau trei numere naturale '''n''', '''k''' și '''p''' și '''n''' șiruri formate din litere mici ale alfabetului englez. Înlocuiți a '''k'''-a literă din fiecare șir cu a '''p'''-a literă din alfabet. Dacă șirul are mai puțin de '''k''' litere se va scrie oglinditul lui.
== Date de intrare ==
Pe prima linie a fișierului '''schimbin.txt''' se află trei numere naturale '''n''', '''k''' și '''p'''. Pe următoarele '''n''' linii se află '''n''' șiruri.
== Date de ieşire ==
În fișierul '''schimbout.txt''' se vor scrie noile șiruri, fiecare pe un rând nou.
== Restricții și precizări ==
* '''1 &les; n, k &les; 10000'''
* '''1 &les; p &les; 26'''
* șirurile au cel mult '''500''' de caractere
== Exemplul 1 ==
; schimbin.txt
2 4 7
abcde
efg
; schimbout.txt
Datele de intrare corespund restrictiilor impuse.
abcge
gfe
 
== Exemplul 2 ==
; schimbin.txt
3 2 3
wqysd
s
sj
; schimbout.txt
Datele de intrare corespund restrictiilor impuse.
wcysd
s
sc
 
== Exemplul 3 ==
; schimbin.txt
2 4 999599995
; schimbout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, k_validare, p_validare, siruri_validare):
# Verificăm dacă n, k și p sunt în intervalul specificat
if (n_validare <= 0 or n_validare > 10000 or
k_validare <= 0 or k_validare > 10000 or p_validare <= 0 or p_validare > 26):
raise ValueError # Ridicăm o eroare dacă n, k sau p nu sunt în intervalul specificat
for sir_validare in siruri_validare: # Parcurgem lista de șiruri
# Verificăm dacă lungimea șirului este mai mică decât 500
if len(sir_validare) > 500:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# Funcția schimb_sir schimbă a k-a literă din fiecare șir cu a p-a literă din alfabet sau scrie oglinditul șirului
# dacă șirul are mai puțin de k litere
def schimb_sir(k_schimb, p_schimb, siruri_schimb):
# Definim alfabetul
alfabet = 'abcdefghijklmnopqrstuvwxyz'
# Parcurgem lista de șiruri
for i in range(len(siruri_schimb)):
# Verificăm dacă șirul are mai puțin de k litere
if len(siruri_schimb[i]) < k_schimb:
# Scriem oglinditul șirului
siruri_schimb[i] = siruri_schimb[i][::-1]
else:
# Înlocuim a k-a literă din șir cu a p-a literă din alfabet
siruri_schimb[i] = siruri_schimb[i][:k_schimb-1] + alfabet[p_schimb-1] + siruri_schimb[i][k_schimb:]
return siruri_schimb

if __name__ == '__main__':
file_in = open("schimbin.txt", "r")
file_out = open("schimbout.txt", "w")

try:
# Citim numărul de șiruri, k și p
n_main, k_main, p_main = map(int, file_in.readline().split())
# Citim șirurile
siruri_main = [file_in.readline().strip() for _ in range(n_main)]
# Validăm datele de intrare
validare(n_main, k_main, p_main, siruri_main)
# Schimbăm șirurile
siruri_schimbate = schimb_sir(k_main, p_main, siruri_main)
# Scriem șirurile schimbate în fișierul de ieșire
for sir in siruri_schimbate:
file_out.write(sir + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

2441 - Pereche descentrata

2023-12-26T16:31:51Z

AntalKrisztian: Pagină nouă: == Cerinţa == O pereche de cuvinte, unul cu număr par de litere, iar celălalt cu număr impar de litere, se numește descentrată dacă se poate obține cuvântul cu număr par de litere din celălalt, prin duplicarea caracterului din mijlocul acestuia. '''Exemplu''': perechile '''crezi''' și '''creezi''', respectiv '''a''' și '''aa''' sunt descentrate. == Date de intrare == Programul citește de la tastatură un text. == Date de ieşire == Programul va afișa pe ecran...

== Cerinţa ==
O pereche de cuvinte, unul cu număr par de litere, iar celălalt cu număr impar de litere, se numește descentrată dacă se poate obține cuvântul cu număr par de litere din celălalt, prin duplicarea caracterului din mijlocul acestuia.

'''Exemplu''':
perechile '''crezi''' și '''creezi''', respectiv '''a''' și '''aa''' sunt descentrate.
== Date de intrare ==
Programul citește de la tastatură un text.
== Date de ieşire ==
Programul va afișa pe ecran mesajul '''DA''', dacă acesta conține cel puțin o pereche descentrată, sau mesajul '''NU''' în caz contrar.
== Restricții și precizări ==
* textul are cel mult '''100''' de caractere
* cuvintele sunt formate din litere mici ale alfabetului englez
* cuvintele sunt separate prin câte un spațiu
== Exemplul 1 ==
; Intrare
crezi ca poti sa creezi ceva original
; Ieșire
Datele introduse corespund restricțiilor impuse.
DA
 
== Explicație ==
Perechea descentrată de cuvinte este '''crezi – creezi'''.
== Exemplul 2 ==
; Intrare
242434545
; Ieșire
Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Definim funcția de verificare a valorilor s
def verificare(s_val):
# Verificăm dacă s respectă restricțiile problemei
if 1 <= len(s_val) <= 100 and all(c.islower() or c.isspace() for c in s_val):
# Dacă valorile sunt valide, returnăm True
return True
else:
# Dacă valorile nu sunt valide, ridicăm o excepție
raise ValueError

# Definim funcția pentru verificarea dacă există cel puțin o pereche descentrată
def exista_pereche_descentrata(s_cuv):
# Transformăm șirul în listă de cuvinte
cuvinte = s_cuv.split()
# Pentru fiecare cuvânt cu număr impar de litere
for cuvant in cuvinte:
if len(cuvant) % 2 == 1:
# Calculăm cuvântul descentrat
mijloc = len(cuvant) // 2
cuvant_descentrat = cuvant[:mijloc] + cuvant[mijloc] * 2 + cuvant[mijloc+1:]
# Verificăm dacă cuvântul descentrat se află în listă
if cuvant_descentrat in cuvinte:
return 'DA'
return 'NU'

# Verificăm dacă acest script este rulat direct (nu este importat ca modul)
if __name__ == '__main__':
try:
# Citim șirul de caractere
s = input("Introduceti sirul de caractere: ")

# Verificăm dacă datele introduse sunt valide
if verificare(s):
# Dacă datele sunt valide, afișăm un mesaj de confirmare
print("Datele introduse corespund restricțiilor impuse.")

# Verificăm dacă există cel puțin o pereche descentrată și afișăm rezultatul
print(exista_pereche_descentrata(s))

# Tratăm cazul în care datele introduse nu sunt valide
except ValueError:
# Afișăm un mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0893 - Cuvinte0

2023-12-26T16:16:44Z

AntalKrisztian: Pagină nouă: == Cerinţa == Se dă un șir de caractere format din cuvinte, separate prin spații. Cuvintele conțin doar litere mici ale alfabetului englez. Afișați, în ordine lexicografică, cuvintele distincte din șir. == Date de intrare == Programul citește de la tastatură șirul dat. == Date de ieşire == Programul va afișa pe ecran cuvintele în ordinea cerută, câte un cuvânt pe o linie. == Restricții și precizări == * șirul dat va avea cel mult '''255''' de caractere...

== Cerinţa ==
Se dă un șir de caractere format din cuvinte, separate prin spații. Cuvintele conțin doar litere mici ale alfabetului englez. Afișați, în ordine lexicografică, cuvintele distincte din șir.
== Date de intrare ==
Programul citește de la tastatură șirul dat.
== Date de ieşire ==
Programul va afișa pe ecran cuvintele în ordinea cerută, câte un cuvânt pe o linie.
== Restricții și precizări ==
* șirul dat va avea cel mult '''255''' de caractere și va conține cel mult '''100''' de cuvinte
* lungimea unui cuvânt este de cel mult '''15''' caractere
== Exemplul 1 ==
; Intrare
maria are doua pere si ana are doua mere
; Ieșire
Datele introduse corespund restricțiilor impuse.
ana
are
doua
maria
mere
pere
si
 
== Exemplul 2 ==
; Intrare
acesttextaremaimultde15caractere
; Ieșire
Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Definim funcția de verificare a valorilor s
def verificare(s_val):
# Verificăm dacă s respectă restricțiile problemei
if 1 <= len(s_val) <= 255 and all(c.islower() or c.isspace() for c in s_val):
# Dacă valorile sunt valide, returnăm True
return True
else:
# Dacă valorile nu sunt valide, ridicăm o excepție
raise ValueError

# Definim funcția pentru afișarea cuvintelor în ordine lexicografică
def afisare_cuvinte(s_afisare):
# Transformăm șirul în listă de cuvinte
cuvinte = s_afisare.split()
# Eliminăm dublurile și ordonăm cuvintele
cuvinte = sorted(set(cuvinte))
return cuvinte

if __name__ == '__main__':
try:
# Citim șirul de caractere
s = input("Introduceti sirul de caractere: ")

# Verificăm dacă datele introduse sunt valide
if verificare(s):
# Dacă datele sunt valide, afișăm un mesaj de confirmare
print("Datele introduse corespund restricțiilor impuse.")

# Afișăm cuvintele în ordine lexicografică
for cuvant in afisare_cuvinte(s):
print(cuvant)

# Tratăm cazul în care datele introduse nu sunt valide
except ValueError:
# Afișăm un mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0863 - Parole

2023-12-26T15:20:02Z

AntalKrisztian: Pagină nouă: Parolele sunt cele mai utilizate modalități de stabilire a identității unei persoane. În IT este necesară utilizarea unor parole tari, care să nu poată fi ghicite cu ajutorul unor programe specializate. În continuare, prin parolă tare înțelegem un sir de caractere care respectă următoarele condiții: * conține cel puțin '''8''' caractere * conține cel puțin o literă mică * conține cel puțin o literă mare * conține cel puțin o cifră * conține cel p...

Parolele sunt cele mai utilizate modalități de stabilire a identității unei persoane. În IT este necesară utilizarea unor parole tari, care să nu poată fi ghicite cu ajutorul unor programe specializate.

În continuare, prin parolă tare înțelegem un sir de caractere care respectă următoarele condiții:

* conține cel puțin '''8''' caractere
* conține cel puțin o literă mică
* conține cel puțin o literă mare
* conține cel puțin o cifră
* conține cel puțin un caracter dintre '''.,?!;:_@#'''
== Cerinţa ==
Se dă '''n''' o listă cu '''n''' parole. Să se determine câte dintre ele sunt '''parole tari'''.
== Date de intrare ==
Fișierul de intrare '''parolein.txt''' conține pe prima linie numărul '''n''', iar pe fiecare dintre următoarele '''n''' linii câte o parolă.
== Date de ieşire ==
Fișierul de ieșire '''paroleout.txt''' va conține pe prima linie de parole tari '''C'''.
== Restricții și precizări ==
* '''1 &les; n &les; 1000'''
* fiecare linie fișierului de intrare va avea cel mult '''50''' de caractere
== Exemplul 1 ==
; parolein.txt
5
al!ABe1Ar
alfabetar
a:1A
Alfabetar
qHj5K#.1NN
; paroleout.txt
Datele de intrare corespund restrictiilor impuse.
2
 
== Explicație ==
Cele două parole tari din listă sunt: '''al!ABe1Ar''' și '''qHj5K#.1NN'''.
 
== Exemplul 2 ==
; parolein.txt
aceastalinedecoddepasestecele50decaractereimpuse
; paroleout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# functia de validare verifica daca datele de intrare sunt in intervalul specificat
def validare(n_validare, parole_validare):
# verificam daca n este in intervalul 1-1000
if not (1 <= n_validare <= 1000):
raise ValueError # ridicam o eroare daca n nu este in intervalul 1-1000
for parola in parole_validare: # parcurgem lista de parole
# verificam daca lungimea parolei este mai mica sau egala cu 50
if len(parola) > 50:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# functia este_parola_tare verifica daca o parola este tare
def este_parola_tare(parola):
# verificam daca parola contine cel putin 8 caractere,
# cel putin o litera mica, cel putin o litera mare, cel putin o cifra si cel putin un caracter special
return (len(parola) >= 8 and any(caracter.islower() for caracter in parola)
and any(caracter.isupper() for caracter in parola) and any(
caracter.isdigit() for caracter in parola) and any(caracter in ".,?!;:_@#" for caracter in parola))

if __name__ == '__main__':
file_in = open("parolein.txt", "r")
file_out = open("paroleout.txt", "w")

try:
# citim numarul de parole
n_main = int(file_in.readline())
# citim parolele
parole_main = [file_in.readline().strip() for _ in range(n_main)]
# validam datele de intrare
validare(n_main, parole_main)
# numaram cate parole sunt tari si scriem rezultatul in fisierul de iesire
file_out.write(str(sum(este_parola_tare(parola) for parola in parole_main)) + '\n')

# daca datele de intrare nu sunt valide, afisam un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# daca datele de intrare sunt incomplete, afisam un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

0856 - Valori

2023-12-26T14:56:49Z

AntalKrisztian: Pagină nouă: == Cerinţa == Gigel se joacă cu cuvinte (scrise cu litere din alfabetul englez, mari sau mici). El a asociat fiecărei litere din alfabet o valoare număr natural, pe care a numit-o valoarea literei. Apoi a definit valoarea unui cuvânt astfel: se calculează suma '''S1''' a valorilor literelor mici din cuvânt şi suma '''S2''' a valorilor literelor mari din cuvânt. Valoarea cuvântului va fi '''S1 - S2'''. Cunoscându-se valoarea fiecărei litere din alfabet şi o list...

== Cerinţa ==
Gigel se joacă cu cuvinte (scrise cu litere din alfabetul englez, mari sau mici). El a asociat fiecărei litere din alfabet o valoare număr natural, pe care a numit-o valoarea literei. Apoi a definit valoarea unui cuvânt astfel: se calculează suma '''S1''' a valorilor literelor mici din cuvânt şi suma '''S2''' a valorilor literelor mari din cuvânt. Valoarea cuvântului va fi '''S1 - S2'''.

Cunoscându-se valoarea fiecărei litere din alfabet şi o listă de cuvinte, să se determine cuvântul cu valoarea maximă. Dacă există mai multe cuvinte de valoare maximă, se vor determina toate, în ordinea din lista dată.
== Date de intrare ==
Fișierul de intrare '''valoriin.txt''' conține pe prima linie numărul '''26''' de numere, reprezentând, în ordine, valorile literelor din alfabet, pe a doua linie numărul de cuvinte '''n''' iar pe următoarele '''n''' linii câte un cuvânt format din litere mari şi mici ale alfabetului englez.
== Date de ieşire ==
Fișierul de ieșire '''valoriout.txt''' va conține cuvintele de valoare maximă din lista dată, în ordinea din listă, fiecare cuvânt pe câte o linie.
== Restricții și precizări ==
* valorile literelor sunt numere naturale mai mici decât '''1000'''
* '''1 &les; n &les; 1000'''
* fiecare dintre cuvintele date conţine cel mult '''255''' caractere
== Exemplul 1 ==
; valoriin.txt
2 7 7 3 9 8 9 6 3 9 6 6 6 5 5 8 2 6 6 1 5 6 9 4 7 3
4
BaciL
AbAc
Aba
AbEcEdAr
; valoriout.txt
Datele de intrare corespund restrictiilor impuse.
AbAc
 
== Observaţie ==
Valoarea unui cuvânt poate fi negativă. De exemplu, valoarea cuvântului '''BaciL''' este '''(2+7+3)-(7+6)=-1'''
 
== Exemplul 2 ==
; valoriin.txt
4 6 7 8
fdfdfdf
; valoriout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# functia de validare verifica daca datele de intrare sunt in intervalul specificat
def validare(n_validare, cuvinte_validare):
# verificam daca n este in intervalul 1-1000
if not (1 <= n_validare <= 1000):
raise ValueError # ridicam o eroare daca n nu este in intervalul 1-1000
for cuvant in cuvinte_validare: # parcurgem lista de cuvinte
# verificam daca lungimea cuvantului este mai mica sau egala cu 255
if len(cuvant) > 255:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# functia valoare_cuvant calculeaza valoarea unui cuvant
def valoare_cuvant(cuvant, valori_litere):
# calculam suma valorilor literelor mici si mari din cuvant
s1 = sum(valori_litere[ord(litera) - ord('a')] for litera in cuvant if litera.islower())
s2 = sum(valori_litere[ord(litera) - ord('A')] for litera in cuvant if litera.isupper())
# returnam diferenta dintre sumele calculate
return s1 - s2

if __name__ == '__main__':
file_in = open("valoriin.txt", "r")
file_out = open("valoriout.txt", "w")

try:
# citim valorile literelor
valori_litere_main = list(map(int, file_in.readline().split()))
# citim numarul de cuvinte
n_main = int(file_in.readline())
# citim cuvintele
cuvinte_main = [file_in.readline().strip() for _ in range(n_main)]
# validam datele de intrare
validare(n_main, cuvinte_main)
# calculam valorile cuvintelor
valori_cuvinte = [valoare_cuvant(cuvant, valori_litere_main) for cuvant in cuvinte_main]
# determinam valoarea maxima
valoare_max = max(valori_cuvinte)
# scriem cuvintele de valoare maxima in fisierul de iesire
for i in range(n_main):
if valori_cuvinte[i] == valoare_max:
file_out.write(cuvinte_main[i] + '\n')

# daca datele de intrare nu sunt valide, afisam un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# daca datele de intrare sunt incomplete, afisam un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

1454 - Permutare Cuvant

2023-12-14T15:09:39Z

AntalKrisztian: Pagină nouă: == Cerinţa == Se dă un cuvânt format din litere ale alfabetului englez și cifre. Afișați toate permutările circulare spre stânga ale sale. == Date de intrare == Fișierul de intrare '''permutarecuvantin.txt''' conține cuvântul pentru care se vor afișa permutările circulare spre stânga. == Date de ieşire == Fișierul de ieșire '''permutarecuvantout.txt''' va conține pe o singura linie toate permutările circulare ale cuvântului, separate prin câte un spațiu....

== Cerinţa ==
Se dă un cuvânt format din litere ale alfabetului englez și cifre. Afișați toate permutările circulare spre stânga ale sale.
== Date de intrare ==
Fișierul de intrare '''permutarecuvantin.txt''' conține cuvântul pentru care se vor afișa permutările circulare spre stânga.
== Date de ieşire ==
Fișierul de ieșire '''permutarecuvantout.txt''' va conține pe o singura linie toate permutările circulare ale cuvântului, separate prin câte un spațiu.
== Restricții și precizări ==
* Cuvântul va avea maximum '''20''' de caractere.
== Exemplul 1 ==
; permutarecuvantin.txt
Hello
; permutarecuvantout.txt
Datele de intrare corespund restrictiilor impuse.
Hello elloH lloHe loHel oHell
 
== Exemplul 2 ==
; permutarecuvantin.txt
car
; permutarecuvantout.txt
Datele de intrare corespund restrictiilor impuse.
car arc rca
 
== Exemplul 3 ==
; permutarecuvantin.txt
acestcuvantesteprealung
; permutarecuvantout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# functia de validare verifica daca datele de intrare sunt in intervalul specificat
def validare(cuvant_validare):
# verificam daca lungimea cuvantului este mai mica sau egala cu 20
if len(cuvant_validare) > 20:
raise ValueError # ridicam o eroare daca lungimea cuvantului nu este in intervalul 0-20
for caracter in cuvant_validare: # parcurgem fiecare caracter din cuvant
# verificam daca caracterul este o litera a alfabetului englezesc sau o cifra
if not caracter.isalpha() and not caracter.isdigit():
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# functia permutari_circulare genereaza toate permutarile circulare ale unui cuvant
def permutari_circulare(cuvant):
# generam toate permutarile circulare ale cuvantului
return [cuvant[i:] + cuvant[:i] for i in range(len(cuvant))]

if __name__ == '__main__':
file_in = open("permutarecuvantin.txt", "r")
file_out = open("permutarecuvantout.txt", "w")

try:
# citim cuvantul
cuvant_main = file_in.readline().strip()
# validam datele de intrare
validare(cuvant_main)
# generam toate permutarile circulare ale cuvantului si scriem rezultatul in fisierul de iesire
file_out.write(' '.join(permutari_circulare(cuvant_main)) + '\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

1346 - PbInfo

2023-12-14T14:51:59Z

AntalKrisztian: Pagină nouă: == Cerinţa == Hacker-ul Gogu și-a neglijat serios activitatea în ultima vreme, așa că și-a propus să mai spargă încă un site, care, din întâmplare, este chiar www.pbinfo.ro. == Date de intrare == Pe prima linie se citește un șir reprezentând un link al site-ului PbInfo. Pe linia a doua, se citește un număr întreg '''n''' ('''1 <= n <= 20'''), iar pe următoarele '''n''' linii se citesc '''n''' cuvinte cheie. Scopul vostru este să aflați dacă hacker-ul Gog...

== Cerinţa ==
Hacker-ul Gogu și-a neglijat serios activitatea în ultima vreme, așa că și-a propus să mai spargă încă un site, care, din întâmplare, este chiar www.pbinfo.ro.
== Date de intrare ==
Pe prima linie se citește un șir reprezentând un link al site-ului PbInfo. Pe linia a doua, se citește un număr întreg '''n''' ('''1 <= n <= 20'''), iar pe următoarele '''n''' linii se citesc '''n''' cuvinte cheie. Scopul vostru este să aflați dacă hacker-ul Gogu s-a infiltrat și a schimbat link-ul original.
== Date de ieşire ==
Dacă link-ul dat conține unul din cuvintele cheie precizate în fișierul de intrare sau conține cuvântul “virus”, afișați '''DA''', altfel afișați '''NU'''.
== Restricții și precizări ==
* cuvintele vor fi mai scurte decât link-ul precizat, iar link-ul va avea maxim '''100''' de caractere;
* hacker-ul Gogu nu este profesionist, așa că nu este nevoie să va alarmați;
* input-ul va conține numai litere mici ale alfabetului englez și separatorii ''',.!?/:'''.
== Exemplul 1 ==
; pbinfoin.txt
//htttp:www.pbinfo.ro
3
hacked
gogu
htttp
; pbinfoout.txt
Datele de intrare corespund restrictiilor impuse.
DA
 
== Exemplul 2 ==
; pbinfoin.txt
//http:www.pbinfo.ro
3
hacked
gogu
htttp
; pbinfoout.txt
Datele de intrare corespund restrictiilor impuse.
NU
 
== Exemplul 3 ==
; pbinfoin.txt
//http:www.pbinfo.virus.ro
1
gogu
; pbinfoout.txt
Datele de intrare corespund restrictiilor impuse.
DA
 
== Exemplul 4 ==
; pbinfoin.txt
//http:www.pbinfo.virus.ro
223
hacked
gogu
; pbinfoout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# functia de validare verifica daca datele de intrare sunt in intervalul specificat
def validare(n_validare, link_validare, cuvinte_cheie_validare):
# verificam daca n este in intervalul 1-20
if n_validare <= 0 or n_validare > 20:
raise ValueError # ridicam o eroare daca n nu este in intervalul 1-20
# verificam daca lungimea link-ului este mai mica sau egala cu 100
if len(link_validare) > 100:
raise ValueError
for cuvant in cuvinte_cheie_validare: # parcurgem lista de cuvinte cheie
# verificam daca lungimea cuvantului este mai mica decat lungimea link-ului
if len(cuvant) >= len(link_validare):
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# functia is_hacked verifica daca link-ul a fost spart
def is_hacked(link, cuvinte_cheie):
# verificam daca link-ul contine unul din cuvintele cheie sau cuvantul "virus"
return any(cuvant in link for cuvant in cuvinte_cheie) or "virus" in link

if __name__ == '__main__':
file_in = open("pbinfoin.txt", "r")
file_out = open("pbinfoout.txt", "w")

try:
# citim link-ul
link_main = file_in.readline().strip()
# citim numarul de cuvinte cheie
n_main = int(file_in.readline())
# citim cuvintele cheie
cuvinte_cheie_main = [file_in.readline().strip() for _ in range(n_main)]
# validam datele de intrare
validare(n_main, link_main, cuvinte_cheie_main)
# verificam daca link-ul a fost spart si scriem rezultatul in fisierul de iesire
file_out.write('DA\n' if is_hacked(link_main, cuvinte_cheie_main) else 'NU\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

0892 - Pasareste 1

2023-12-14T14:29:40Z

AntalKrisztian:

== Cerinţa ==
Limba păsărească este foarte simplă; și asemănătoare cu limba română! Un text scris în română se traduce în păsărește astfel: după fiecare vocală se inserează litera '''p''' și vocala respectivă.

Se dă o propoziție scrisă în limba păsărească. Să se traducă în limba română.
== Date de intrare ==
Programul citește de la tastatură un șir de caractere '''s'''.
== Date de ieşire ==
Programul va afișa pe ecran șirul '''t''', reprezentând traducerea în română a șirului '''s'''.
== Restricții și precizări ==
* șirurile '''s''' și '''t''' vor avea cel mult '''255''' de caractere
* șirul '''s''' va conține litere mici ale alfabetului englez și spații
* vocalele sunt: '''aeiou'''
* '''șirul dat în limba păsărească este corect'''
== Exemplul 1 ==
; Intrare
apanapa aparepe meperepe
; Ieșire
Datele introduse corespund restricțiilor impuse.
ana are mere
 
== Exemplul 2 ==
; Intrare
78675878576875
; Ieșire
Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Definim funcția de verificare a valorilor s
def verificare(s_val):
# Verificăm dacă s respectă restricțiile problemei
if 1 <= len(s_val) <= 255 and all(c.islower() or c.isspace() for c in s_val):
# Dacă valorile sunt valide, returnăm True
return True
else:
# Dacă valorile nu sunt valide, ridicăm o excepție
raise ValueError

# Definim funcția pentru traducerea din limba păsărească în română
def traducere_pasareasca(s_pasareasca):
vocale = 'aeiou'
t = ''
i = 0
while i < len(s_pasareasca):
if s_pasareasca[i] in vocale:
t += s_pasareasca[i]
i += 3
else:
t += s_pasareasca[i]
i += 1
return t

if __name__ == '__main__':
try:
# Citim șirul de caractere
s = input("Introduceti sirul de caractere: ")

# Verificăm dacă datele introduse sunt valide
if verificare(s):
# Dacă datele sunt valide, afișăm un mesaj de confirmare
print("Datele introduse corespund restricțiilor impuse.")

# Traducem șirul din limba păsărească în română și îl afișăm
print(traducere_pasareasca(s))

# Tratăm cazul în care datele introduse nu sunt valide
except ValueError:
# Afișăm un mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2693 - Voc Sort Desc

2023-12-14T14:28:58Z

AntalKrisztian:

== Cerinţa ==
Se dă un șir de caractere în care cuvintele sunt formate din litere mici și mari ale alfabetului englez și sunt separate prin spații. Să se afișeze cuvintele în ordine descrescătoare după numărul de vocale și să se afișeze fiecare cuvânt pe câte o linie. Dacă două cuvinte au același număr de vocale atunci ele se vor ordona descrescător după lungime, iar dacă au aceeași lungime atunci se vor ordona lexicografic.
== Date de intrare ==
Programul citește de la tastatură un șir de caractere.
== Date de ieşire ==
Programul va afișa pe ecran cuvintele din text, în ordinea cerută, câte unul pe linie.
== Restricții și precizări ==
* șirul va conține maximum '''255''' de caractere.
== Exemplul 1 ==
; Intrare
ana are mere
; Ieșire
Datele introduse corespund restricțiilor impuse.
mere
ana
are
 
== Exemplul 2 ==
; Intrare
977483
; Ieșire
Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Definim funcția de verificare a valorilor s
def verificare(s_val):
# Verificăm dacă s respectă restricțiile problemei
if 1 <= len(s_val) <= 255 and all(c.isalpha() or c.isspace() for c in s_val):
# Dacă valorile sunt valide, returnăm True
return True
else:
# Dacă valorile nu sunt valide, ridicăm o excepție
raise ValueError

# Definim funcția pentru numărarea vocalelor într-un cuvânt
def numar_vocale(cuvant_vocale):
return sum(1 for c in cuvant_vocale if c.lower() in 'aeiou')

# Definim funcția pentru sortarea cuvintelor
def sortare_cuvinte(s_sort):
cuvinte = s_sort.split()
cuvinte.sort(key=lambda cuvant_sort: (-numar_vocale(cuvant_sort), -len(cuvant_sort), cuvant_sort))
return cuvinte

if __name__ == '__main__':
try:
# Citim șirul de caractere
s = input("Introduceti sirul de caractere: ")

# Verificăm dacă datele introduse sunt valide
if verificare(s):
# Dacă datele sunt valide, afișăm un mesaj de confirmare
print("Datele introduse corespund restricțiilor impuse.")

# Sortăm cuvintele și le afișăm
for cuvant in sortare_cuvinte(s):
print(cuvant)

# Tratăm cazul în care datele introduse nu sunt valide
except ValueError:
# Afișăm un mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2584 - Insert Invers

2023-12-14T14:28:34Z

AntalKrisztian:

== Cerinţa ==
Se dă un șir de caractere care conține cuvinte formate doar din litere mici și mari ale alfabetului englez, separate printr-un spațiu. Să se afișeze cuvintele din șir, fiecare fiind urmat de inversul său. Cuvintele afișate sunt separate printr-un spațiu.
== Date de intrare ==
Programul citește de la tastatură un șir de caractere.
== Date de ieşire ==
Programul va afișa pe ecran cuvintele conform cerinței.
== Restricții și precizări ==
* șirul conține maximum 255 de caractere
== Exemplul 1 ==
; Intrare
ana are mere
; Ieșire
Datele introduse corespund restricțiilor impuse.
ana ana are era mere erem
 
== Exemplul 2 ==
; Intrare
99573483
; Ieșire
Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Definim funcția de verificare a valorilor s
def verificare(s_val):
# Verificăm dacă s respectă restricțiile problemei
if 1 <= len(s_val) <= 255 and all(c.isalpha() or c.isspace() for c in s_val):
# Dacă valorile sunt valide, returnăm True
return True
else:
# Dacă valorile nu sunt valide, ridicăm o excepție
raise ValueError

# Definim funcția pentru afișarea cuvintelor și a inverselor lor
def afisare_cuvinte_si_inversee(s_afisare):
cuvinte = s_afisare.split()
rezultat = []
for cuvant in cuvinte:
rezultat.append(cuvant)
rezultat.append(cuvant[::-1])
return ' '.join(rezultat)

if __name__ == '__main__':
try:
# Citim șirul de caractere
s = input("Introduceti sirul de caractere: ")

# Verificăm dacă datele introduse sunt valide
if verificare(s):
# Dacă datele sunt valide, afișăm un mesaj de confirmare
print("Datele introduse corespund restricțiilor impuse.")

# Afișăm cuvintele și inversele lor
print(afisare_cuvinte_si_inversee(s))

# Tratăm cazul în care datele introduse nu sunt valide
except ValueError:
# Afișăm un mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0093 - Numar Maxim Cuvinte

2023-12-14T14:21:33Z

AntalKrisztian: Pagină nouă: == Cerinţa == Să se scrie un program care citește mai multe propoziții și determină propoziția cu cele mai multe cuvinte. == Date de intrare == Fișierul de intrare '''cuvmaxin.txt''' conține pe prima linie un număr natural '''n''', iar pe următoarele '''n''' linii câte o propoziție alcătuită din litere mici ale alfabetului englez și spații. == Date de ieşire == Fișierul de ieșire '''cuvmaxout.txt''' va conține pe prima linie propoziția cu cele mai multe...

== Cerinţa ==
Să se scrie un program care citește mai multe propoziții și determină propoziția cu cele mai multe cuvinte.
== Date de intrare ==
Fișierul de intrare '''cuvmaxin.txt''' conține pe prima linie un număr natural '''n''', iar pe următoarele '''n''' linii câte o propoziție alcătuită din litere mici ale alfabetului englez și spații.
== Date de ieşire ==
Fișierul de ieșire '''cuvmaxout.txt''' va conține pe prima linie propoziția cu cele mai multe cuvinte.
== Restricții și precizări ==
* '''0<n<100'''
* fiecare propoziție va conține cel mult '''255''' de caractere
== Exemplul 1 ==
; cuvmaxin.txt
4
somnoroase pasarele
pe la cuiburi se aduna
se ascund in ramurele
noapte buna noapte buna
; cuvmaxout.txt
Datele de intrare corespund restrictiilor impuse.
pe la cuiburi se aduna
 
== Exemplul 2 ==
; cuvmaxin.txt
205ALA
; cuvmaxout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# functia de validare verifica daca datele de intrare sunt in intervalul specificat
def validare(n_validare, propozitii_validare):
# verificam daca n este in intervalul 0-100
if n_validare <= 0 or n_validare > 100:
raise ValueError # ridicam o eroare daca n nu este in intervalul 0-100
for propozitie in propozitii_validare: # parcurgem lista de propozitii
# verificam daca lungimea propozitiei este mai mica sau egala cu 255
if len(propozitie) > 255:
raise ValueError
for caracter in propozitie: # parcurgem fiecare caracter din propozitie
# verificam daca caracterul este o litera mica a alfabetului englezesc sau un spatiu
if not caracter.islower() and not caracter.isspace():
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# functia max_words_proposition determina propozitia cu cele mai multe cuvinte
def numar_max_cuvinte(propozitii):
# determinam propozitia cu cele mai multe cuvinte
propozitie_max_cuvinte = max(propozitii, key=lambda propozitie: len(propozitie.split()))
return propozitie_max_cuvinte

if __name__ == '__main__':
file_in = open("cuvmaxin.txt", "r")
file_out = open("cuvmaxout.txt", "w")

try:
# citim numarul de propozitii
n_main = int(file_in.readline())
# citim propozitiile
propozitii_main = [linie.strip() for linie in file_in]
# validam datele de intrare
validare(n_main, propozitii_main)
# determinam propozitia cu cele mai multe cuvinte
propozitie_max = numar_max_cuvinte(propozitii_main)
# scriem propozitia cu cele mai multe cuvinte in fisierul de iesire
file_out.write(propozitie_max + '\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

2584 - Insert Invers

2023-12-14T14:12:46Z

AntalKrisztian: Pagină nouă: == Cerinţa == Se dă un șir de caractere care conține cuvinte formate doar din litere mici și mari ale alfabetului englez, separate printr-un spațiu. Să se afișeze cuvintele din șir, fiecare fiind urmat de inversul său. Cuvintele afișate sunt separate printr-un spațiu. == Date de intrare == Programul citește de la tastatură un șir de caractere. == Date de ieşire == Programul va afișa pe ecran cuvintele conform cerinței. == Restricții și precizări == * șir...

== Cerinţa ==
Se dă un șir de caractere care conține cuvinte formate doar din litere mici și mari ale alfabetului englez, separate printr-un spațiu. Să se afișeze cuvintele din șir, fiecare fiind urmat de inversul său. Cuvintele afișate sunt separate printr-un spațiu.
== Date de intrare ==
Programul citește de la tastatură un șir de caractere.
== Date de ieşire ==
Programul va afișa pe ecran cuvintele conform cerinței.
== Restricții și precizări ==
* șirul conține maximum 255 de caractere
== Exemplul 1 ==
; Intrare
ana are mere
; Ieșire
Datele introduse corespund restricțiilor impuse.
ana ana are era mere erem
 
== Exemplul 2 ==
; Intrare
99573483
; Ieșire
Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Definim funcția de verificare a valorilor s
def verificare(s_val):
# Verificăm dacă s respectă restricțiile problemei
if 1 <= len(s_val) <= 255 and all(c.isalpha() or c.isspace() for c in s_val):
# Dacă valorile sunt valide, returnăm True
return True
else:
# Dacă valorile nu sunt valide, ridicăm o excepție
raise ValueError

# Definim funcția pentru afișarea cuvintelor și a inverselor lor
def afisare_cuvinte_si_inversee(s_afisare):
cuvinte = s_afisare.split()
rezultat = []
for cuvant in cuvinte:
rezultat.append(cuvant)
rezultat.append(cuvant[::-1])
return ' '.join(rezultat)

# Verificăm dacă acest script este rulat direct (nu este importat ca modul)
if __name__ == '__main__':
try:
# Citim șirul de caractere
s = input("Introduceti sirul de caractere: ")

# Verificăm dacă datele introduse sunt valide
if verificare(s):
# Dacă datele sunt valide, afișăm un mesaj de confirmare
print("Datele introduse corespund restricțiilor impuse.")

# Afișăm cuvintele și inversele lor
print(afisare_cuvinte_si_inversee(s))

# Tratăm cazul în care datele introduse nu sunt valide
except ValueError:
# Afișăm un mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2693 - Voc Sort Desc

2023-12-14T14:05:47Z

AntalKrisztian: Pagină nouă: == Cerinţa == Se dă un șir de caractere în care cuvintele sunt formate din litere mici și mari ale alfabetului englez și sunt separate prin spații. Să se afișeze cuvintele în ordine descrescătoare după numărul de vocale și să se afișeze fiecare cuvânt pe câte o linie. Dacă două cuvinte au același număr de vocale atunci ele se vor ordona descrescător după lungime, iar dacă au aceeași lungime atunci se vor ordona lexicografic. == Date de intrare == Pro...

== Cerinţa ==
Se dă un șir de caractere în care cuvintele sunt formate din litere mici și mari ale alfabetului englez și sunt separate prin spații. Să se afișeze cuvintele în ordine descrescătoare după numărul de vocale și să se afișeze fiecare cuvânt pe câte o linie. Dacă două cuvinte au același număr de vocale atunci ele se vor ordona descrescător după lungime, iar dacă au aceeași lungime atunci se vor ordona lexicografic.
== Date de intrare ==
Programul citește de la tastatură un șir de caractere.
== Date de ieşire ==
Programul va afișa pe ecran cuvintele din text, în ordinea cerută, câte unul pe linie.
== Restricții și precizări ==
* șirul va conține maximum '''255''' de caractere.
== Exemplul 1 ==
; Intrare
ana are mere
; Ieșire
Datele introduse corespund restricțiilor impuse.
mere
ana
are
 
== Exemplul 2 ==
; Intrare
977483
; Ieșire
Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Definim funcția de verificare a valorilor s
def verificare(s_val):
# Verificăm dacă s respectă restricțiile problemei
if 1 <= len(s_val) <= 255 and all(c.isalpha() or c.isspace() for c in s_val):
# Dacă valorile sunt valide, returnăm True
return True
else:
# Dacă valorile nu sunt valide, ridicăm o excepție
raise ValueError

# Definim funcția pentru numărarea vocalelor într-un cuvânt
def numar_vocale(cuvant_vocale):
return sum(1 for c in cuvant_vocale if c.lower() in 'aeiou')

# Definim funcția pentru sortarea cuvintelor
def sortare_cuvinte(s_sort):
cuvinte = s_sort.split()
cuvinte.sort(key=lambda cuvant_sort: (-numar_vocale(cuvant_sort), -len(cuvant_sort), cuvant_sort))
return cuvinte

# Verificăm dacă acest script este rulat direct (nu este importat ca modul)
if __name__ == '__main__':
try:
# Citim șirul de caractere
s = input("Introduceti sirul de caractere: ")

# Verificăm dacă datele introduse sunt valide
if verificare(s):
# Dacă datele sunt valide, afișăm un mesaj de confirmare
print("Datele introduse corespund restricțiilor impuse.")

# Sortăm cuvintele și le afișăm
for cuvant in sortare_cuvinte(s):
print(cuvant)

# Tratăm cazul în care datele introduse nu sunt valide
except ValueError:
# Afișăm un mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0089 - Palindrom Propozitie

2023-12-14T13:55:15Z

AntalKrisztian: Pagină nouă: Un cuvânt este palindrom dacă se citește la fel în ambele direcții. De exemplu, '''capac''' este palindrom. O propoziție este palindromică dacă prin eliminarea spațiilor și a altor semne de punctuație devine palindrom. De exemplu, propoziția '''ele fac cafele''' este palindromică. == Cerinţa == Să se scrie un program care citește mai multe propoziții și determină despre fiecare dacă este palindromică. == Date de intrare == Fișierul de intrare '''palindr...

Un cuvânt este palindrom dacă se citește la fel în ambele direcții. De exemplu, '''capac''' este palindrom.

O propoziție este palindromică dacă prin eliminarea spațiilor și a altor semne de punctuație devine palindrom. De exemplu, propoziția '''ele fac cafele''' este palindromică.
== Cerinţa ==
Să se scrie un program care citește mai multe propoziții și determină despre fiecare dacă este palindromică.
== Date de intrare ==
Fișierul de intrare '''palindromin.txt''' conține pe prima linie un număr natural '''n''', iar pe următoarele '''n''' linii câte o propoziție alcătuita din litere mici ale alfabetului englez și spații.
== Date de ieşire ==
Fișierul de ieșire '''palindromout.txt''' va conține '''n''' linii. Linia '''i''' va conține valoarea '''1''' dacă pe linia '''i+1''' din fișierul de intrare se află o propoziție palindromică, și '''0''' în caz contrar.
== Restricții și precizări ==
* '''0<n<100'''
* fiecare propoziție va conține cel mult '''200''' de caractere.
== Exemplul 1 ==
; palindromin.txt
4
capac
ele fac cafele
ale nu fac cafele
aerare
; palindromout.txt
Datele de intrare corespund restrictiilor impuse.
1
1
0
0
 
== Exemplul 2 ==
; palindromin.txt
101KKGKKG
; palindromout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# functia de validare verifica daca datele de intrare sunt in intervalul specificat
def validare(n_validare, propozitii_validare):
# verificam daca n este in intervalul 0-100
if n_validare <= 0 or n_validare > 100:
raise ValueError # ridicam o eroare daca n nu este in intervalul 0-100
for propozitie_validare in propozitii_validare: # parcurgem lista de propozitii
# verificam daca lungimea propozitiei este mai mica sau egala cu 200
if len(propozitie_validare) > 200:
raise ValueError
for caracter in propozitie_validare: # parcurgem fiecare caracter din propozitie
# verificam daca caracterul este o litera mica a alfabetului englezesc
if not caracter.islower() and not caracter.isspace():
raise ValueError
file_out.write("datele de intrare corespund restrictiilor impuse\n")

# functia is_palindrome verifica daca o propozitie este palindromica
def este_palindrom(propozitie_palindrom):
# eliminam spatiile din propozitie si verificam daca este palindrom
propozitie_fara_spatii = propozitie_palindrom.replace(' ', '')
return propozitie_fara_spatii == propozitie_fara_spatii[::-1]

if __name__ == '__main__':
file_in = open("palindromin.txt", "r")
file_out = open("palindromout.txt", "w")

try:
# citim numarul de propozitii
n_main = int(file_in.readline())
# citim propozitiile
propozitii_main = [linie.strip() for linie in file_in]
# validam datele de intrare
validare(n_main, propozitii_main)
# pentru fiecare propozitie, verificam daca este palindromica si scriem rezultatul in fisierul de iesire
for propozitie in propozitii_main:
file_out.write('1\n' if este_palindrom(propozitie) else '0\n')

# daca datele de intrare nu sunt valide, afisam un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# daca datele de intrare sunt incomplete, afisam un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

0990 - Sortare Cuvinte 1

2023-12-14T13:30:08Z

AntalKrisztian: Pagină nouă: == Cerinţa == Să se scrie un program care citește o listă de cuvinte şi le afişează în ordine alfabetică. == Date de intrare == Fișierul de intrare '''sortarecuvinte1in.txt''' conține mai multe cuvinte, câte unul pe o linie. == Date de ieşire == Fișierul de ieșire '''sortarecuvinte1out.txt''' va conține cuvintele date, ordonate alfabetic, fiecare pe câte o linie. == Restricții și precizări == * în listă sunt cel mult '''200''' de cuvinte, fiecare având...

== Cerinţa ==
Să se scrie un program care citește o listă de cuvinte şi le afişează în ordine alfabetică.
== Date de intrare ==
Fișierul de intrare '''sortarecuvinte1in.txt''' conține mai multe cuvinte, câte unul pe o linie.
== Date de ieşire ==
Fișierul de ieșire '''sortarecuvinte1out.txt''' va conține cuvintele date, ordonate alfabetic, fiecare pe câte o linie.
== Restricții și precizări ==
* în listă sunt cel mult '''200''' de cuvinte, fiecare având cel mult '''30''' litere
== Exemplul 1 ==
; sortarecuvinte1in.txt
Dana
Are
Bomboane
; sortarecuvinte1out.txt
Datele de intrare corespund restrictiilor impuse.
Are
Bomboane
Dana
 
== Exemplul 2 ==
; sortarecuvinte1in.txt
acestcuvantarepreamultelitereincuvant
; sortarecuvinte1out.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# functia de validare verifica daca datele de intrare sunt in intervalul specificat
def validare(cuvinte_validare):
# verificam daca numarul de cuvinte este in intervalul 0-200
if len(cuvinte_validare) <= 0 or len(cuvinte_validare) > 200:
raise ValueError # ridicam o eroare daca numarul de cuvinte nu este in intervalul 0-200
for cuvant_validare in cuvinte_validare: # parcurgem lista de cuvinte
# verificam daca lungimea cuvantului este mai mica sau egala cu 30
if len(cuvant_validare) > 30:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# functia sort_words sorteaza cuvintele in functie de ordinea alfabetica
def sort_words(cuvinte):
# sortam cuvintele in functie de ordinea alfabetica
cuvinte.sort()
return cuvinte

if __name__ == '__main__':
file_in = open("sortarecuvinte1in.txt", "r")
file_out = open("sortarecuvinte1out.txt", "w")

try:
# citim cuvintele
cuvinte_main = [linie.strip() for linie in file_in]
# validam datele de intrare
validare(cuvinte_main)
# sortam cuvintele in functie de ordinea alfabetica
cuvinte_sortate = sort_words(cuvinte_main)
# scriem cuvintele sortate in fisierul de iesire
for cuvant in cuvinte_sortate:
file_out.write(cuvant + '\n')

# daca datele de intrare nu sunt valide, afisam un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# daca datele de intrare sunt incomplete, afisam un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

0101 - Sortare Cuvinte

2023-12-14T13:20:59Z

AntalKrisztian: Pagină nouă: == Cerinţa == Să se scrie un program care citește o propoziţie şi afişează cuvintele din propoziţie ordonate alfabetic. == Date de intrare == Fișierul de intrare '''sortcuvin.txt''' conține pe prima linie o propoziție alcătuită din litere mici ale alfabetului englez și spații. == Date de ieşire == Fișierul de ieșire '''sortcuvout''' va conține cuvintele din propoziție, ordonate alfabetic, fiecare pe câte o linie. == Restricții și precizări == * propozi...

== Cerinţa ==
Să se scrie un program care citește o propoziţie şi afişează cuvintele din propoziţie ordonate alfabetic.
== Date de intrare ==
Fișierul de intrare '''sortcuvin.txt''' conține pe prima linie o propoziție alcătuită din litere mici ale alfabetului englez și spații.
== Date de ieşire ==
Fișierul de ieșire '''sortcuvout''' va conține cuvintele din propoziție, ordonate alfabetic, fiecare pe câte o linie.
== Restricții și precizări ==
* propoziția va conține cel mult '''250''' de caractere;
* fiecare cuvânt din propoziție are cel mult '''20''' litere
== Exemplul 1 ==
; sortcuvin.txt
dreptunghiul este un paralelogram cu un unghi drept
; sortcuvout.txt
Datele de intrare corespund restrictiilor impuse.
cu
drept
dreptunghiul
este
paralelogram
un
un
unghi
 
== Exemplul 2 ==
; sortcuvin.txt
acestcuvantaremaimulteliteredecatestepermis
; sortcuvout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# functia de validare verifica daca datele de intrare sunt in intervalul specificat
def validare(propozitie_validare):
# verificam daca lungimea propozitiei este in intervalul 0-250
if len(propozitie_validare) <= 0 or len(propozitie_validare) > 250:
raise ValueError # ridicam o eroare daca lungimea propozitiei nu este in intervalul 0-250
for cuvant_validare in propozitie_validare.split(): # parcurgem lista de cuvinte
# verificam daca lungimea cuvantului este mai mica sau egala cu 20
if len(cuvant_validare) > 20:
raise ValueError
# verificam daca cuvantul contine doar litere mici ale alfabetului englezesc
if not cuvant_validare.islower():
raise ValueError
# verificam daca cuvantul contine numere
if any(char.isdigit() for char in cuvant_validare):
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# functia sort_words sorteaza cuvintele in functie de ordinea alfabetica
def sort_words(cuvinte):
# sortam cuvintele in functie de ordinea alfabetica
cuvinte.sort()
return cuvinte

if __name__ == '__main__':
file_in = open("sortcuvin.txt", "r")
file_out = open("sortcuvout.txt", "w")

try:
# citim propozitia
propozitie_main = file_in.readline().strip()
# validam datele de intrare
validare(propozitie_main)
# sortam cuvintele in functie de ordinea alfabetica
cuvinte_sortate = sort_words(propozitie_main.split())
# scriem cuvintele sortate in fisierul de iesire
for cuvant in cuvinte_sortate:
file_out.write(cuvant + '\n')

# daca datele de intrare nu sunt valide, afisam un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# daca datele de intrare sunt incomplete, afisam un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

0892 - Pasareste 1

2023-12-13T16:21:58Z

AntalKrisztian:

== Cerinţa ==
Limba păsărească este foarte simplă; și asemănătoare cu limba română! Un text scris în română se traduce în păsărește astfel: după fiecare vocală se inserează litera '''p''' și vocala respectivă.

Se dă o propoziție scrisă în limba păsărească. Să se traducă în limba română.
== Date de intrare ==
Programul citește de la tastatură un șir de caractere '''s'''.
== Date de ieşire ==
Programul va afișa pe ecran șirul '''t''', reprezentând traducerea în română a șirului '''s'''.
== Restricții și precizări ==
* șirurile '''s''' și '''t''' vor avea cel mult '''255''' de caractere
* șirul '''s''' va conține litere mici ale alfabetului englez și spații
* vocalele sunt: '''aeiou'''
* '''șirul dat în limba păsărească este corect'''
== Exemplul 1 ==
; Intrare
apanapa aparepe meperepe
; Ieșire
Datele introduse corespund restricțiilor impuse.
ana are mere
 
== Exemplul 2 ==
; Intrare
78675878576875
; Ieșire
Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Definim funcția de verificare a valorilor s
def verificare(s_val):
# Verificăm dacă s respectă restricțiile problemei
if 1 <= len(s_val) <= 255 and all(c.islower() or c.isspace() for c in s_val):
# Dacă valorile sunt valide, returnăm True
return True
else:
# Dacă valorile nu sunt valide, ridicăm o excepție
raise ValueError

# Definim funcția pentru traducerea din limba păsărească în română
def traducere_pasareasca(s_pasareasca):
vocale = 'aeiou'
t = ''
i = 0
while i < len(s_pasareasca):
if s_pasareasca[i] in vocale:
t += s_pasareasca[i]
i += 3
else:
t += s_pasareasca[i]
i += 1
return t

# Verificăm dacă acest script este rulat direct (nu este importat ca modul)
if __name__ == '__main__':
try:
# Citim șirul de caractere
s = input("Introduceti sirul de caractere: ")

# Verificăm dacă datele introduse sunt valide
if verificare(s):
# Dacă datele sunt valide, afișăm un mesaj de confirmare
print("Datele introduse corespund restricțiilor impuse.")

# Traducem șirul din limba păsărească în română și îl afișăm
print(traducere_pasareasca(s))

# Tratăm cazul în care datele introduse nu sunt valide
except ValueError:
# Afișăm un mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0892 - Pasareste 1

2023-12-13T16:17:46Z

AntalKrisztian: Pagină nouă: == Cerinţa == Se dă un vector cu '''n''' elemente, numere naturale și un număr '''k'''. Ordonați crescător primele '''k''' elemente ale vectorului și descrescător ultimele '''n-k''' elemente.Pentru sortare se va folosit metoda '''QuickSort''' sau '''MergeSort'''. == Date de intrare == Programul citește de la tastatură numerele '''n''' și '''k''', iar apoi '''n''' numere naturale, reprezentând elementele vectorului. == Date de ieşire == Programul va afișa pe ecra...

== Cerinţa ==
Se dă un vector cu '''n''' elemente, numere naturale și un număr '''k'''. Ordonați crescător primele '''k''' elemente ale vectorului și descrescător ultimele '''n-k''' elemente.Pentru sortare se va folosit metoda '''QuickSort''' sau '''MergeSort'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' și '''k''', iar apoi '''n''' numere naturale, reprezentând elementele vectorului.
== Date de ieşire ==
Programul va afișa pe ecran elementele vectorului, separate prin exact un spațiu, după efectuarea operațiilor cerute.
== Restricții și precizări ==
* '''1 &les; k < n &les; 200 000'''
* cele '''n''' numere citite vor fi mai mici decât '''1 000 000 000'''
== Exemplul 1 ==
; Intrare
7 3
13 1 10 15 3 7 11
; Ieșire
Datele introduse corespund restricțiilor impuse.
1 10 13 15 11 7 3
 
== Exemplul 2 ==
; Intrare
fhgjfhgfgj
; Ieșire
Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Definim funcția de verificare a valorilor n, k și a elementelor vectorului
def verificare(n_val, k_val, vector_verificare):
# Verificăm dacă n și k respectă restricțiile problemei
if 1 <= k_val < n_val <= 200000:
# Verificăm dacă toate elementele vectorului sunt mai mici decât 1 000 000 000
if all(x < 1000000000 for x in vector_verificare):
# Dacă toate condițiile sunt îndeplinite, returnăm True
return True
return False

# Definim funcția pentru sortarea vectorului
def sortare_vector(k_val, vector_sortare):
# Sortăm primele k elemente în ordine crescătoare
vector_sortare[:k_val] = sorted(vector_sortare[:k_val])
# Sortăm ultimele elemente în ordine descrescătoare
vector_sortare[k_val:] = sorted(vector_sortare[k_val:], reverse=True)
# Returnăm vectorul sortat
return vector_sortare

if __name__ == '__main__':

try:
# Citim numărul de elemente din vector
n = int(input("Introduceti numarul de elemente din vector: "))
# Citim numărul k
k = int(input("Introduceti numarul k: "))
# Citim elementele vectorului
vector = list(map(int, input("Introduceti elementele vectorului: ").split()))

# Verificăm dacă datele introduse sunt valide
if verificare(n, k, vector):
# Dacă datele sunt valide, afișăm un mesaj de confirmare
print("Datele introduse corespund restricțiilor impuse.")
# Sortăm vectorul și afișăm rezultatul
print(' '.join(map(str, sortare_vector(k, vector))))
else:
print("Datele introduse nu corespund restricțiilor impuse.")
# Tratăm cazul în care datele introduse nu sunt numere
except ValueError:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

1157 - KSort2

2023-12-12T22:17:17Z

0637 – Frunze

2023-12-10T13:38:46Z

AntalKrisztian: Pagină nouă: == Cerinţa == Se dă vectorul de tați al unui arbore cu rădăcină cu '''n''' noduri. Determinați rădăcina arborelui și frunzele acestuia. == Date de intrare == Fișierul de intrare '''frunzein.txt''' conține pe prima linie numărul de noduri '''n'''. Pe linia următoare se află vectorul de tați al arborelui, valorile fiind separate prin spații. == Date de ieşire == Fișierul de ieșire '''frunzeout.txt''' va conține pe prima linie rădăcina arborelui. A doua li...

== Cerinţa ==
Se dă vectorul de tați al unui arbore cu rădăcină cu '''n''' noduri. Determinați rădăcina arborelui și frunzele acestuia.
== Date de intrare ==
Fișierul de intrare '''frunzein.txt''' conține pe prima linie numărul de noduri '''n'''. Pe linia următoare se află vectorul de tați al arborelui, valorile fiind separate prin spații.
== Date de ieşire ==
Fișierul de ieșire '''frunzeout.txt''' va conține pe prima linie rădăcina arborelui. A doua linia va conține numărul de frunze din arbore, iar următoarea linie frunzele, în ordine crescătoare și separate printr-un spațiu.
== Restricții și precizări ==
* '''1 &les; n &les; 100'''
* în vectorul de tați rădăcina este marcată cu '''0'''
== Exemplul 1 ==
; frunzein.txt
7
4 1 7 0 7 7 1
; frunzeout.txt
Datele de intrare corespund restrictiilor impuse.
4
4
2 3 5 6
 
== Exemplul 2 ==
; frunzein.txt
jjgrgjrfrf
; frunzeout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, tati_validare):
# Verificăm dacă n este în intervalul 1-100
if n_validare < 1 or n_validare > 100:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-100
# Verificăm dacă rădăcina este marcată cu 0 în vectorul de tați
if 0 not in tati_validare:
raise ValueError # Ridicăm o eroare dacă rădăcina nu este marcată cu 0
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# Funcția radacina_frunze determină rădăcina arborelui și frunzele acestuia
def radacina_frunze(n, tati):
# Rădăcina arborelui este nodul care are tatăl 0
radacina_tati = tati.index(0) + 1
# Frunzele arborelui sunt nodurile care nu sunt tați pentru niciun nod
frunze_tati = sorted(set(range(1, n + 1)) - set(tati))
return radacina_tati, frunze_tati

if __name__ == '__main__':
file_in = open("frunzein.txt", "r")
file_out = open("frunzeout.txt", "w")

try:
# Citim numărul de noduri
n_main = int(file_in.readline())
# Citim vectorul de tați
tati_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(n_main, tati_main)
# Determinăm rădăcina arborelui și frunzele acestuia
radacina, frunze = radacina_frunze(n_main, tati_main)
# Scriem rădăcina și frunzele în fișierul de ieșire
file_out.write(str(radacina) + '\n')
file_out.write(str(len(frunze)) + '\n')
file_out.write(' '.join(map(str, frunze)) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1906 - Memory 007

2023-12-10T13:18:46Z

AntalKrisztian: Pagină nouă: == Cerinţa == Agentul 007 a uitat cifrul seifului în care păstra documentele, însă ştie cum poate fi aflat. Are nişte cartonaşe pe care sunt notate '''n''' numere naturale distincte din intervalul [ '''a,b''' ]. Mai are o listă cu '''m''' numere naturale distincte care reprezintă anumite poziţii din şirul ordonat crescător al numerelor de pe cartonaşe. Însumând numerele aflate pe poziţiile din listă se determină un număr natural care reprezintă cifrul sei...

== Cerinţa ==
Agentul 007 a uitat cifrul seifului în care păstra documentele, însă ştie cum poate fi aflat. Are nişte cartonaşe pe care sunt notate '''n''' numere naturale distincte din intervalul [ '''a,b''' ]. Mai are o listă cu '''m''' numere naturale distincte care reprezintă anumite poziţii din şirul ordonat crescător al numerelor de pe cartonaşe. Însumând numerele aflate pe poziţiile din listă se determină un număr natural care reprezintă cifrul seifului. Cum Agentul 007 nu a mai programat din liceu, vă roagă pe voi să găsiţi cifrul în schimbul a 100 de … puncte.
== Date de intrare ==
Fișierul de intrare '''memory007in.txt''' conține pe prima linie numerele '''n,m,a,b''', pe a doua linie '''n''' numere naturale distincte separate prin spații reprezentând numerele de pe cartonaşe, iar pe a treia linie '''m''' numere naturale distincte reprezentând poziţiile din listă.
== Date de ieşire ==
Fișierul de ieșire '''memory007out.txt''' va conține pe prima linie cifrul seifului.
== Restricții și precizări ==
* '''1 &les; m &les; n &les; 500.000'''
* numerele de pe cartonaşe vor fi distincte şi mai mici decât '''1.000.000.000'''
* numerele din listă vor fi naturale nenule, distincte şi mai mici sau egale cu '''n''', ordonate crescător
* '''1 &les; a &les; b &les; 1.000.000.000'''
* '''n &les; b - a &les; 700.000'''
== Exemplul 1 ==
; memory007in.txt
5 3 30 80
78 56 34 45 61
1 2 5
; memory007out.txt
Datele de intrare corespund restrictiilor impuse.
157
 
== Explicație ==
Numerele de pe cartonaşe sunt '''78,56,34,45,61''' şi sunt din intervalul [ '''30,80''' ]. Ordonate crescător formează şirul '''34,45,56,61,78'''. Numerele din listă, adică '''1,2,5''', ne spun că cifrul se obţine însumând numerele de pe poziţiile '''1''', '''2''' şi '''5''' din şirul ordonat crescător al numerelor de pe cartonaşe, adică cifrul este '''34+45+78=157'''.
 
== Exemplul 2 ==
; memory007in.txt
rhgurhkfgrjg
; memory007out.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, m_validare, a_validare, b_validare, cartonase_validare, pozitii_validare):
# Verificăm dacă n este în intervalul 1-500000
if n_validare < 1 or n_validare > 500000:
raise ValueError
# Verificăm dacă m este în intervalul 1-n
if m_validare < 1 or m_validare > n_validare:
raise ValueError
# Verificăm dacă a este în intervalul 1-1000000000
if a_validare < 1 or a_validare > 1000000000:
raise ValueError
# Verificăm dacă b este în intervalul a-1000000000
if b_validare < a_validare or b_validare > 1000000000:
raise ValueError
if n_validare > b_validare - a_validare or b_validare - a_validare > 700000:
raise ValueError # Ridicăm o eroare dacă aceste condiții nu sunt îndeplinite
# Parcurgem lista de valori de pe cartonașe
for valoare in cartonase_validare:
# Verificăm dacă valoarea este în intervalul a-b
if valoare < a_validare or valoare > b_validare:
raise ValueError
for pozitie in pozitii_validare: # Parcurgem lista de poziții
# Verificăm dacă poziția este în intervalul 1-n
if pozitie < 1 or pozitie > n_validare:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# Funcția cifru_seif calculează cifrul seifului
def cifru_seif(cartonase, pozitii):
cartonase.sort()
cifru_calcul = sum(cartonase[pozitie - 1] for pozitie in pozitii)
return cifru_calcul

if __name__ == '__main__':
file_in = open("memory007in.txt", "r")
file_out = open("memory007out.txt", "w")

try:
# Citim numărul de cartonașe, numărul de poziții, limita inferioară și limita superioară a intervalului
n_main, m_main, a_main, b_main = map(int, file_in.readline().split())
# Citim valorile de pe cartonașe
cartonase_main = list(map(int, file_in.readline().split()))
# Citim pozițiile
pozitii_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(n_main, m_main, a_main, b_main, cartonase_main, pozitii_main)
# Calculăm cifrul seifului
cifru = cifru_seif(cartonase_main, pozitii_main)
# Scriem cifrul în fișierul de ieșire
file_out.write(str(cifru) + '\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

4301 - Gustare

2023-12-09T15:43:09Z

AntalKrisztian: Pagină nouă: == Cerinţa == A venit ora mesei pentru Por Costel (masa dintre prânz și cină). Scormonind printr-o grădină, el descoperă un număr de '''N''' coceni de porumb și '''M''' mere. Masa lui Por Costel va consta în exact un cocean și un măr. Însă, mai nou, fanii săi l-au atenționat că trebuie să aibă grijă ce mănâncă. Fiecare cocean și fiecare măr are o valoare nutritivă. Valoarea nutritivă a mesei va fi valoarea nutritivă a coceanului ales + valoarea nut...

== Cerinţa ==
A venit ora mesei pentru Por Costel (masa dintre prânz și cină). Scormonind printr-o grădină, el descoperă un număr de '''N''' coceni de porumb și '''M''' mere. Masa lui Por Costel va consta în exact un cocean și un măr. Însă, mai nou, fanii săi l-au atenționat că trebuie să aibă grijă ce mănâncă. Fiecare cocean și fiecare măr are o valoare nutritivă. Valoarea nutritivă a mesei va fi valoarea nutritivă a coceanului ales + valoarea nutritiva a mărului ales. Dându-se valorile nutritive ale cocenilor și ale merelor, Por Costel vă întreabă dacă există o masă pe care o poate lua cu valoare nutritivă '''X'''. Pentru că Por Costel vrea sa mănânce de mai multe ori între prânz și cină, el va vă pune '''T''' întrebări de forma aceasta.
(Întrebările sunt independente între ele, a nu se considera că după o întrebare se elimină perechea cocean-mar aleasă).
== Date de intrare ==
Pe prima linie a fișierului '''gustarein.txt''' se găsește un număr natural '''N''': numărul de coceni. Pe a doua linie se găsește o secvență de '''N''' numere naturale separate prin câte un spațiu (valorile nutritive ale cocenilor). Pe a treia linie se găsește un număr natural '''M''': numărul de mere. Pe a patra linie se găsește o secvență de '''M''' numere naturale separate prin câte un spațiu (valorile nutritive ale merelor). Pe a cincea linie se găsește un număr natural '''T''', numărul de întrebări ale lui Por Costel. Pe a sasea linie se gasește o secvență de '''T''' numere naturale separate prin câte un spațiu, al '''i'''-lea număr fiind valoarea dorită pentru cea de a i-a masă.
== Date de ieşire ==
În fișierul '''gustareout.txt''' se vor scrie '''T''' linii corespunzătoare celor '''T''' întrebări. A '''i'''-a linie va conține mesajul '''DA''' dacă se poate forma valoarea nutritivă pentru a '''i'''-a masă și '''NU''' în caz contrar.
== Restricții și precizări ==
* '''N, M ≤ 500.000'''
* '''T ≤ 100'''
* '''0 ≤''' valoare nutritiva a unui aliment '''≤ 1.000.000.000'''
* '''0 ≤''' valoarea X a unei intrebari '''≤ 2.000.000.000'''
* Pentru '''20''' de puncte, '''N, M ≤ 1000'''
* Pentru alte '''50''' de puncte, '''T ≤ 20'''
== Exemplul 1 ==
; gustarein.txt
4
2 2 3 5
3
2 4 6
5
6 20 10 11 7
; gustareout.txt
Datele de intrare corespund restrictiilor impuse
DA
NU
NU
DA
DA
 
== Exemplul 2 ==
; gustarein.txt
jgjikfikm
; gustareout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, m_validare, t_validare, coceni_validare, mere_validare, intrebari_validare):
if n_validare < 1 or n_validare > 500000:
raise ValueError
if m_validare < 1 or m_validare > 500000:
raise ValueError
if t_validare < 1 or t_validare > 100:
raise ValueError
for valoare in coceni_validare + mere_validare:
if valoare < 0 or valoare > 1000000000:
raise ValueError
for x in intrebari_validare:
if x < 0 or x > 2000000000:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# Funcția exista_masa verifică dacă există o masă cu valoare nutritivă X
def exista_masa(coceni, mere, intrebari):
raspunsuri_creare = []
for x in intrebari:
exista = 'NU'
for cocean in coceni:
if x - cocean in mere:
exista = 'DA'
break
raspunsuri_creare.append(exista)
return raspunsuri_creare

if __name__ == '__main__':
file_in = open("gustarein.txt", "r")
file_out = open("gustareout.txt", "w")

try:
# Citim numărul de coceni, numărul de mere și numărul de întrebări
n_main = int(file_in.readline())
coceni_main = list(map(int, file_in.readline().split()))
m_main = int(file_in.readline())
mere_main = list(map(int, file_in.readline().split()))
t_main = int(file_in.readline())
intrebari_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(n_main, m_main, t_main, coceni_main, mere_main, intrebari_main)
# Verificăm dacă există o masă cu valoare nutritivă X pentru fiecare întrebare
raspunsuri = exista_masa(coceni_main, mere_main, intrebari_main)
# Scriem răspunsurile în fișierul de ieșire
for raspuns in raspunsuri:
file_out.write(raspuns + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

4300 - Secv Fb

2023-12-09T15:24:45Z

AntalKrisztian: Pagină nouă: == Cerinţa == Se citește un număr '''N''', un număr '''K''' și apoi un șir cu '''N''' numere naturale. Determinați câte secvențe de lungime exact '''K''' au elementele distincte. Prin secvență înțelegem un set de elemente aflate pe poziții consecutive. == Date de intrare == Pe prima linie a fișierului '''secv_fbin.txt''' se găsesc două numere naturale, separate prin exact un spațiu, '''N''' și '''K'''. Pe linia a doua se găsesc cele '''N''' numere ale șir...

== Cerinţa ==
Se citește un număr '''N''', un număr '''K''' și apoi un șir cu '''N''' numere naturale. Determinați câte secvențe de lungime exact '''K''' au elementele distincte. Prin secvență înțelegem un set de elemente aflate pe poziții consecutive.
== Date de intrare ==
Pe prima linie a fișierului '''secv_fbin.txt''' se găsesc două numere naturale, separate prin exact un spațiu, '''N''' și '''K'''. Pe linia a doua se găsesc cele '''N''' numere ale șirului, separate prin câte un spațiu.numere întregi separate prin spaţii.
== Date de ieşire ==
Pe prima linie a fișierului '''secv_fbout.txt''' se găsește un număr natural ce reprezintă valoarea cerută.
== Restricții și precizări ==
* '''2 &les; N &les; 100.000''';
* Pentru '''20''' de puncte '''K = 2''';
* Pentru alte '''20''' de puncte '''K = 3''';
* Pentru alte '''20''' de puncte '''4 &les; K &les; 10''';
* Pentru alte '''20''' de puncte, '''10 < K &les; n-1''' și valorile din șir '''&les; 100.000''';
* Pentru restul testelor '''10 < K &les; n-1''' și valorile din șir '''&les; 2.000.000.000''';
== Exemplul 1 ==
; secv_fbin.txt
8 3
3 2 4 3 4 5 6 7
; sortcif2out.txt
Datele de intrare corespund restrictiilor impuse
5
== Exemplul 2 ==
; secv_fbin.txt
jfgjfkljd
; sortcif2out.txt
Datele de intrare nu corespund restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, k_validare, numere_validare):
if n_validare < 2 or n_validare > 100000:
raise ValueError
if k_validare < 2 or k_validare > n_validare:
raise ValueError
if k_validare == 2 or k_validare == 3 or (4 <= k_validare <= 10) or (10 < k_validare <= n_validare - 1):
for numar in numere_validare:
if numar < 1 or numar > 100000:
raise ValueError
else:
for numar in numere_validare:
if numar < 1 or numar > 2000000000:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

# Funcția secvente_distincte calculează câte secvențe de lungime exact K au elementele distincte
def secvente_distincte(numere, k):
raspunsuri = 0
for i in range(len(numere) - k + 1):
if len(set(numere[i:i+k])) == k:
raspunsuri += 1
return raspunsuri

if __name__ == '__main__':
file_in = open("secv_fbin.txt", "r")
file_out = open("secv_fbout.txt", "w")

try:
# Citim numărul de numere și lungimea secvenței
n_main, k_main = map(int, file_in.readline().split())
# Citim numerele
numere_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(n_main, k_main, numere_main)
# Calculăm câte secvențe de lungime exact K au elementele distincte
raspuns = secvente_distincte(numere_main, k_main)
# Scriem răspunsul în fișierul de ieșire
file_out.write(str(raspuns) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

2789 - Cb3

2023-12-09T14:57:56Z

AntalKrisztian: Pagină nouă: Se consideră un șir de numere naturale nenule '''a[1], a[2], ..., a[n]'''. Asupra șirului se efectuează '''Q''' interogări de forma: '''care este numărul maxim de elemente ale șirului a căror sumă nu depășește valoarea S''' ? == Cerinţa == Trebuie să răspundeți la cele '''Q''' interogări. == Date de intrare == Fișierul de intrare '''cb3in.txt''' conține pe prima linie numerele '''n''' și '''Q'''. Pe a doua linie '''n''' numere naturale nenule, separate pri...

Se consideră un șir de numere naturale nenule '''a[1], a[2], ..., a[n]'''. Asupra șirului se efectuează '''Q''' interogări de forma: '''care este numărul maxim de elemente ale șirului a căror sumă nu depășește valoarea S''' ?
== Cerinţa ==
Trebuie să răspundeți la cele '''Q''' interogări.
== Date de intrare ==
Fișierul de intrare '''cb3in.txt''' conține pe prima linie numerele '''n''' și '''Q'''. Pe a doua linie '''n''' numere naturale nenule, separate prin spații, ce reprezintă elementele șirului. Pe următoarele '''Q''' linii se află sumele aferente celor '''Q''' interogări.
== Date de ieşire ==
Fișierul de ieșire '''cb3out.txt''' va conține pe câte o linie răspunsurile la cele '''Q''' interogări.
== Restricții și precizări ==
* 1 &les; n &les; 10.000
* 1 &les; Q &les; 100.000
* 1 &les; S &les; 2.000.000.000
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1.000.000'''
== Exemplul 1 ==
; cb3in.txt
5 3
1 2 3 4 5
6
17
5
; cb3out.txt
Datele de intrare corespund restrictiilor impuse
3
5
2
 
== Exemplul 2 ==
; cb3in.txt
fhfthtfhft
; cb3out.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, q_validare, numere_validare, sume_validare):
# Verificăm dacă n este în intervalul 1-10000
if n_validare < 1 or n_validare > 10000:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-10000
# Verificăm dacă Q este în intervalul 1-100000
if q_validare < 1 or q_validare > 100000:
raise ValueError # Ridicăm o eroare dacă Q nu este în intervalul 1-100000
for numar in numere_validare: # Parcurgem lista de numere
# Verificăm dacă numărul este mai mic decât 1000000
if numar >= 1000000:
raise ValueError
for suma in sume_validare: # Parcurgem lista de sume
# Verificăm dacă suma este în intervalul 1-2000000000
if suma < 1 or suma > 2000000000:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

# Funcția max_elemente calculează numărul maxim de elemente ale șirului a căror sumă nu depășește valoarea S
def max_elemente(numere, sume):
numere.sort() # Sortăm numerele în ordine crescătoare
raspunsuri_elemente = [] # Inițializăm lista de răspunsuri
for S in sume: # Pentru fiecare sumă S
suma = 0
nr_elemente = 0
for numar in numere: # Pentru fiecare număr din șir
if suma + numar <= S: # Dacă suma curentă plus numărul curent nu depășește S
suma += numar # Adăugăm numărul la sumă
nr_elemente += 1 # Creștem numărul de elemente
else: # Dacă suma curentă plus numărul curent depășește S
break # Întrerupem bucla
raspunsuri_elemente.append(nr_elemente) # Adăugăm numărul de elemente la lista de răspunsuri
return raspunsuri_elemente

if __name__ == '__main__':
file_in = open("cb3in.txt", "r")
file_out = open("cb3out.txt", "w")

try:
# Citim numărul de numere și numărul de interogări
n_main, Q_main = map(int, file_in.readline().split())
# Citim numerele
numere_main = list(map(int, file_in.readline().split()))
# Citim sumele
sume_main = [int(file_in.readline()) for _ in range(Q_main)]
# Validăm datele de intrare
validare(n_main, Q_main, numere_main, sume_main)
# Calculăm numărul maxim de elemente ale șirului a căror sumă nu depășește valoarea S pentru fiecare interogare
raspunsuri = max_elemente(numere_main, sume_main)
# Scriem răspunsurile în fișierul de ieșire
for raspuns in raspunsuri:
file_out.write(str(raspuns) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

0131 - Sort Cif 2

2023-11-27T15:16:50Z

AntalKrisztian:

Se dă un vector cu '''n''' elemente numere întregi.
== Cerinţa ==
Să se ordoneze crescător elementele unui vector crescător după prima cifră.
== Date de intrare ==
Fişierul de intrare '''sortcif2in.txt''' conţine pe prima linie numărul '''n''' si pe a doua linie '''n''' numere întregi separate prin spaţii.
== Date de ieşire ==
Fişierul de ieşire '''sortcif2out.txt''' va conţine pe prima linie cele '''n''' elemente ale vectorului, ordonate conform cerinței, separate printr-un spațiu.
== Restricții și precizări ==
* 0 < n &les; 100
* valoarea absolută a numerelor de pe a doua linie a fişierului de intrare va fi mai mică decât '''2 30 '''
== Exemplul 1 ==
; sortcif2in.txt
6
89 2246 91 4005 51 721
; sortcif2out.txt
Datele de intrare corespund restrictiilor impuse
2246 4005 51 721 89 91
== Exemplul 2 ==
; sortcif2in.txt
-1
101
; sortcif2out.txt
Datele de intrare nu corespund restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(validare_cif, numere_validare):
# Verificăm dacă n este în intervalul 0-100
if validare_cif <= 0 or validare_cif > 100:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 0-100
for numar in numere_validare: # Parcurgem lista de numere
# Verificăm dacă valoarea absolută a numărului este mai mică decât 2^30
if abs(numar) >= 2**30:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

# Funcția sort_numbers sortează numerele în funcție de prima cifră
def sort_numbers(numere):
# Sortăm numerele în funcție de prima cifră
numere.sort(key=lambda x: int(str(abs(x))[0]))
return numere

if __name__ == '__main__':
file_in = open("sortcif2in.txt", "r")
file_out = open("sortcif2out.txt", "w")

try:
# Citim numărul de numere
n_main = int(file_in.readline())
# Citim numerele
numere_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(n_main, numere_main)
# Sortăm numerele în funcție de prima cifră
numere_sortate = sort_numbers(numere_main)
# Scriem numerele sortate în fișierul de ieșire
file_out.write(' '.join(map(str, numere_sortate)) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

0269 - Puteri K

2023-11-27T15:09:05Z

AntalKrisztian:

== Cerinţa ==
Se dau '''n''' numere naturale şi un număr natural '''k'''. Afişaţi în ordine crescătoare acele numere date care sunt puteri ale lui '''k'''.
== Date de intrare ==
Fişierul de intrare '''puterikin.txt''' conţine pe prima linie numerele '''n''' şi '''k''', iar pe a doua linie '''n''' numere naturale separate prin spaţii.
== Date de ieşire ==
Fişierul de ieşire '''puterikout.txt''' va conţine pe prima linie numerele care sunt puteri ale lui '''k''', separate printr-un spaţiu, în ordine crescătoare.
== Restricții și precizări ==
* 1 &les; n &les; 100
* 2 &les; k &les; 10
* numerele de pe a doua linie a fişierului de intrare vor avea cel mult '''8''' cifre
== Exemplul 1 ==
; puterikin.txt
8 2
32 56 317 809 256 2 1 60
; puterikout.txt
Datele de intrare corespund restrictiilor impuse
1 2 32 256
 
== Exemplul 2 ==
; puterikin.txt
gjkfjgkfjgkfgf
; puterikout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, k_validare, numere_validare):
# Verificăm dacă n este în intervalul 1-100
if n_validare < 1 or n_validare > 100:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-100
# Verificăm dacă k este în intervalul 2-10
if k_validare < 2 or k_validare > 10:
raise ValueError # Ridicăm o eroare dacă k nu este în intervalul 2-10
for numar in numere_validare: # Parcurgem lista de numere
# Verificăm dacă numărul are cel mult 8 cifre
if len(str(numar)) > 8:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

# Funcția puterik calculează numerele care sunt puteri ale lui k
def puterik(k, numere):
import math # Importăm modulul math pentru a folosi funcția log
# Verificăm dacă fiecare număr este o putere a lui k și creăm o listă cu aceste numere
puteri_k = [num for num in numere if (num != 0 and ((math.log(num, k) % 1) == 0))]
puteri_k.sort() # Sortăm lista în ordine crescătoare
return puteri_k

if __name__ == '__main__':
file_in = open("puterikin.txt", "r")
file_out = open("puterikout.txt", "w")

try:
# Citim numărul de numere și k
n_main, k_main = map(int, file_in.readline().split())
# Citim numerele
numere_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(n_main, k_main, numere_main)
# Calculăm numerele care sunt puteri ale lui k
puteri_k_main = puterik(k_main, numere_main)
# Scriem numerele care sunt puteri ale lui k în fișierul de ieșire
file_out.write(' '.join(map(str, puteri_k_main)) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1900 - Numere 16

2023-11-26T14:07:42Z

AntalKrisztian:

== Cerinţa ==
Se citește un număr natural '''n''' cu cel mult '''16''' cifre. Fie '''q''' numărul de cifre ale numărului '''n'''. Prin eliminarea unei singure cifre din scrierea numărului '''n''' se obține un șir de '''q''' numere. Să se afișeze în ordine crescătoare, numerele nenule din acest șir care sunt prime cu numărul '''n'''.
== Date de intrare ==
Fișierul de intrare '''numere16in.txt''' conține pe prima linie numărul '''n'''.
== Date de ieşire ==
Fișierul de ieșire '''numere16out.txt''' va conține pe prima linie separate printr-un spațiu, numerele care respectă proprietatea din cerință.
== Restricții și precizări ==
* 2 &les; q &les; 16
* dacă nu avem niciun număr care respectă cerința afișăm mesajul '''NU EXISTA'''
== Exemplul 1 ==
; numere16in.txt
342477
; numere16out.txt
Datele de intrare corespund restrictiilor impuse
32477 34247 34247 34277 34477
== Exemplul 2 ==
; numere16in.txt
gjkjrji
; numere16out.txt
Datele de intrare nu corespund restrictiilor impuse
== Explicație ==
Numerele 32477 34247 34247 34277 34477 sunt afișate în ordine crescătoare și sunt prime cu numărul 342477
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare):
# Verificăm dacă n are cel puțin 2 cifre și cel mult 16 cifre
if len(str(n_validare)) < 2 or len(str(n_validare)) > 16:
raise ValueError # Ridicăm o eroare dacă n nu are cel puțin 2 cifre sau mai mult de 16 cifre
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

# Funcția numere_prime_cu_n calculează numerele prime cu n
def numere_prime_cu_n(n):
from math import gcd
# Convertim numărul în șir de caractere pentru a putea elimina ușor fiecare cifră
n_str = str(n)
q = len(n_str)
# Inițializăm lista de numere prime cu n
numereprime_calcul = []
# Generăm toate numerele prin eliminarea unei singure cifre
for i in range(q):
numar = int(n_str[:i] + n_str[i+1:])
# Verificăm dacă numărul este prim cu n și îl adăugăm în listă dacă este
if numar != 0 and gcd(numar, n) == 1:
numereprime_calcul.append(numar)
# Sortăm lista și o returnăm
numereprime_calcul.sort()
return numereprime_calcul

if __name__ == '__main__':
file_in = open("numere16in.txt", "r")
file_out = open("numere16out.txt", "w")

try:
# Citim numărul
n_main = int(file_in.readline())
# Validăm datele de intrare
validare(n_main)
# Calculăm numerele prime cu n
numere_prime = numere_prime_cu_n(n_main)
# Scriem numerele prime cu n în fișierul de ieșire
if numere_prime:
file_out.write(' '.join(map(str, numere_prime)) + '\n')
else:
file_out.write('NU EXISTA\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

4299 - Gravitatie

2023-11-26T13:54:01Z

AntalKrisztian:

== Cerinţa ==
Gigel era foarte plictisit așa că a început să se joace cu piese de lego. El a construit turnuleţe de diverse înalţimi pe care le-a aranjat unul lângă celalalt, în linie. Prietenul său, Gogu, intrând în cameră să vadă ce face, a călcat accidental pe turnuleţe, urlând de durere. Când şi-a dat seama Gigel că şi-a supărat prietenul acesta s-a hotărât să îşi rearanjeze turnurile în aşa fel încât gradul de durere, atunci când cineva va călca pe ele sa fie cat mai mic.
Ca să calculeze acest grad de durere, Gigel, băiat deştept, a aruncat o placă de plastic peste toate turnuleţele, placă ce s-a rupt în locurile în care două turnuri adiacente au inaltimi diferite. Acesta a stabilit ca gradul de durere să fie egal cu numărul părților în care s-a rupt placa iniţială.
Pentru a minimiza gradul de durere, Gigel poate interschimba (de câte ori vrea el) oricare două turnuleţe între ele. (ex: schimbă turnuleţul '''1''' cu turnuleţul '''3''', apoi turnuleţul '''4''' cu turnuleţul '''2''', etc…).
== Date de intrare ==
În fișierul de intrare '''gravitatiein.txt''' se află pe prima linie, '''N''' numărul de turnuleţe. Pe a doua linie se găsesc '''N''' numere naturale, reprezentând înalţimea Hi a fiecărui turnuleţ, în ordinea în care acestea sunt aranjate inițial.
== Date de ieşire ==
În fisierul de iesire '''gravitatieout.txt''' se va scrie un singur numar, '''Nr''', reprezentând gradul minim de durere ce se poate obține prin rearanjarea turnulețelor folosind miscări valide.
== Restricții și precizări ==
* 1 &les; n &les; 100.000
* 0 &les; Hi &les; 4.000.000.000 (patru miliarde)
* Bucata de plastic aruncată are lungimea egală cu lungimea șirului de turnulețe.
* Pentru '''40%''' din punctaj 0 &les; Hi &les; 100.000
== Exemplul 1 ==
; gravitatiein.txt
3
7 3 3
; gravitatieout.txt
Datele de intrare corespund restrictiilor impuse
2
 
== Explicație ==
Gradul minim de durere se poate obține folosind configuratia inițială. Daca de exemplu am schimba primul turnuleț cu al doilea, atunci gradul de durere ar fi 3, placa rupându-se în 3 bucăți diferite.
== Exemplul 2 ==
; gravitatiein.txt
4
4 7 2 7
; gravitatieout.txt
Datele de intrare corespund restrictiilor impuse
3
 
== Explicație ==
Se observă că dacă inversăm ultimul turn cu penultimul se obține configurația: '''4 7 7 2''', configurație ce are gradul de durere '''3''', care este și gradul minim.
== Exemplul 3 ==
; gravitatiein.txt
jfhhdinjd
; gravitatieout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, h_validare):
# Verificăm dacă n este în intervalul 1-10000
if n_validare < 1 or n_validare > 10000:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-10000
for h in h_validare: # Parcurgem lista de înălțimi
# Verificăm dacă înălțimea este în intervalul 0-2^64-1
if h < 0 or h > 2**64-1:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

# Funcția durere_minima calculează gradul minim de durere ce se poate obține prin rearanjarea turnulețelor
def durere_minima(n_minim, h_minim):
# Creăm o listă de perechi (înălțime, poziție inițială)
turnuri = [(h_minim[i], i) for i in range(n_minim)]
# Sortăm lista în funcție de înălțime
turnuri.sort()
# Calculăm numărul de bucăți în care se rupe placa de plastic
calculare = 1
for i in range(1, n_minim):
if turnuri[i-1][1] > turnuri[i][1] or turnuri[i-1][0] != turnuri[i][0]:
calculare += 1
return calculare

if __name__ == '__main__':
file_in = open("gravitatiein.txt", "r")
file_out = open("gravitatieout.txt", "w")

try:
# Citim numărul de turnulețe
n_main = int(file_in.readline())
# Citim înălțimile turnulețelor
H_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(n_main, H_main)
# Calculăm durerea minimă
durere = durere_minima(n_main, H_main)
# Scriem durerea minimă în fișierul de ieșire
file_out.write(str(durere) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

4299 - Gravitatie

2023-11-26T13:52:33Z

AntalKrisztian:

== Cerinţa ==
Gigel era foarte plictisit așa că a început să se joace cu piese de lego. El a construit turnuleţe de diverse înalţimi pe care le-a aranjat unul lângă celalalt, în linie. Prietenul său, Gogu, intrând în cameră să vadă ce face, a călcat accidental pe turnuleţe, urlând de durere. Când şi-a dat seama Gigel că şi-a supărat prietenul acesta s-a hotărât să îşi rearanjeze turnurile în aşa fel încât gradul de durere, atunci când cineva va călca pe ele sa fie cat mai mic.
Ca să calculeze acest grad de durere, Gigel, băiat deştept, a aruncat o placă de plastic peste toate turnuleţele, placă ce s-a rupt în locurile în care două turnuri adiacente au inaltimi diferite. Acesta a stabilit ca gradul de durere să fie egal cu numărul părților în care s-a rupt placa iniţială.
Pentru a minimiza gradul de durere, Gigel poate interschimba (de câte ori vrea el) oricare două turnuleţe între ele. (ex: schimbă turnuleţul '''1''' cu turnuleţul '''3''', apoi turnuleţul '''4''' cu turnuleţul '''2''', etc…).
== Date de intrare ==
În fișierul de intrare '''gravitatiein.txt''' se află pe prima linie, '''N''' numărul de turnuleţe. Pe a doua linie se găsesc '''N''' numere naturale, reprezentând înalţimea <math> Hi </math> a fiecărui turnuleţ, în ordinea în care acestea sunt aranjate inițial.
== Date de ieşire ==
În fisierul de iesire '''gravitatieout.txt''' se va scrie un singur numar, '''Nr''', reprezentând gradul minim de durere ce se poate obține prin rearanjarea turnulețelor folosind miscări valide.
== Restricții și precizări ==
* 1 &les; n &les; 100.000
* 0 &les; Hi &les; 4.000.000.000 (patru miliarde)
* Bucata de plastic aruncată are lungimea egală cu lungimea șirului de turnulețe.
* Pentru '''40%''' din punctaj 0 &les; Hi &les; 100.000
== Exemplul 1 ==
; gravitatiein.txt
3
7 3 3
; gravitatieout.txt
Datele de intrare corespund restrictiilor impuse
2
 
== Explicație ==
Gradul minim de durere se poate obține folosind configuratia inițială. Daca de exemplu am schimba primul turnuleț cu al doilea, atunci gradul de durere ar fi 3, placa rupându-se în 3 bucăți diferite.
== Exemplul 2 ==
; gravitatiein.txt
4
4 7 2 7
; gravitatieout.txt
Datele de intrare corespund restrictiilor impuse
3
 
== Explicație ==
Se observă că dacă inversăm ultimul turn cu penultimul se obține configurația: '''4 7 7 2''', configurație ce are gradul de durere '''3''', care este și gradul minim.
== Exemplul 3 ==
; gravitatiein.txt
jfhhdinjd
; gravitatieout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, h_validare):
# Verificăm dacă n este în intervalul 1-10000
if n_validare < 1 or n_validare > 10000:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-10000
for h in h_validare: # Parcurgem lista de înălțimi
# Verificăm dacă înălțimea este în intervalul 0-2^64-1
if h < 0 or h > 2**64-1:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

# Funcția durere_minima calculează gradul minim de durere ce se poate obține prin rearanjarea turnulețelor
def durere_minima(n_minim, h_minim):
# Creăm o listă de perechi (înălțime, poziție inițială)
turnuri = [(h_minim[i], i) for i in range(n_minim)]
# Sortăm lista în funcție de înălțime
turnuri.sort()
# Calculăm numărul de bucăți în care se rupe placa de plastic
calculare = 1
for i in range(1, n_minim):
if turnuri[i-1][1] > turnuri[i][1] or turnuri[i-1][0] != turnuri[i][0]:
calculare += 1
return calculare

if __name__ == '__main__':
file_in = open("gravitatiein.txt", "r")
file_out = open("gravitatieout.txt", "w")

try:
# Citim numărul de turnulețe
n_main = int(file_in.readline())
# Citim înălțimile turnulețelor
H_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(n_main, H_main)
# Calculăm durerea minimă
durere = durere_minima(n_main, H_main)
# Scriem durerea minimă în fișierul de ieșire
file_out.write(str(durere) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

2274 - Limite

2023-11-26T13:16:04Z

AntalKrisztian:

== Cerinţa ==
Se dau '''n''' numere naturale. Afișați tipul de date C++ minim ca număr de octeți permite memorarea fiecărui număr. Dacă un număr încape și în tipul cu semn și în tipul fără semn, se afișează tipul cu semn.
== Date de intrare ==
Fișierul de intrare '''limitein.txt''' conține numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații.
== Date de ieşire ==
Fișierul de ieșire '''limiteout.txt''' va conține '''n''' șiruri de caractere, pe '''n''' rânduri, reprezentând tipurile de date cerute, dintre '''char, unsigned char, short, unsigned short, int, unsigned int, long long, unsigned long long'''.
== Restricții și precizări ==
* 1 &les; n &les; 10000
* cele n numere citite vor fi mai mici sau egale cu '''18446744073709551615'''
== Exemplul 1 ==
; limitein.txt
5
10 18446744073709551615 32767 127 65535
; limiteout.txt
Datele de intrare corespund restrictiilor impuse
char
unsigned long long
short
char
unsigned short
 
== Exemplul 2 ==
; limitein.txt
gghrguhrkf
; limiteout.txt
Datele de intrare corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcția de validare verifică dacă datele de intrare sunt în intervalul specificat
def validare(n_validare, numere_validare):
# Verificăm dacă n este în intervalul 1-10000
if n_validare < 1 or n_validare > 10000:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-10000
for numar_validare in numere_validare: # Parcurgem lista de numere
# Verificăm dacă numărul este în intervalul 0-2^64-1
if numar_validare < 0 or numar_validare > 2**64-1:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

# Funcția tip_date determină tipul de date C++ minim necesar pentru a stoca un număr
def tip_date(numar_date):
if numar_date <= 127: # Dacă numărul poate fi stocat într-un char
return 'char'
elif numar_date <= 255: # Dacă numărul poate fi stocat într-un unsigned char
return 'unsigned char'
elif numar_date <= 32767: # Dacă numărul poate fi stocat într-un short
return 'short'
elif numar_date <= 65535: # Dacă numărul poate fi stocat într-un unsigned short
return 'unsigned short'
elif numar_date <= 2147483647: # Dacă numărul poate fi stocat într-un int
return 'int'
elif numar_date <= 4294967295: # Dacă numărul poate fi stocat într-un unsigned int
return 'unsigned int'
elif numar_date <= 9223372036854775807: # Dacă numărul poate fi stocat într-un long long
return 'long long'
else: # Dacă numărul este mai mare, atunci trebuie să fie stocat într-un unsigned long long
return 'unsigned long long'

if __name__ == '__main__':
file_in = open("limitein.txt", "r")
file_out = open("limiteout.txt", "w")

try:
# Citim numărul de numere
n_main = int(file_in.readline())
# Citim numerele
numere_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(n_main, numere_main)
# Pentru fiecare număr, determinăm tipul de date minim și îl scriem în fișierul de ieșire
for numar in numere_main:
file_out.write(tip_date(numar) + '\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

2569 - Alo

2023-11-12T15:40:43Z

AntalKrisztian:

De ziua ei, Dora a primit cadou un telefon mobil cu cartelă pentru rețeaua favorită. Suma disponibilă pe cartelă este de '''E''' Eurici dar oferta este grozavă pentru convorbiri. Astfel, pentru fiecare minut de convorbire în care a fost sunată dintr-o altă rețea decât rețeaua ei, cartela se încarcă cu '''1''' Euric dar, dacă sună ea într-o altă rețea, Dora va consuma câte '''2''' Eurici din creditul de pe cartela ei pentru fiecare minut de convorbire. Între membrii rețelei Dorei, toate convorbirile sunt gratuite indiferent de durata convorbirii, fie că sună ea, fie că este sunată.

Toate numerele din rețeaua Dorei au patru cifre și se termină cu cifra '''9''' iar numerele din alte rețele au tot patru cifre și se termină cu cifra '''5'''. Când sună Dora, ea formează întâi cifra '''1''' înaintea numărului pe care îl apelează. Când este sunată, apare cifra '''2''' înaintea numărului de la care primește apelul.
== Cerinţa ==
Scrieți un program care, știind '''E''', valoarea inițială a creditului de pe cartela primită cadou, cele '''N''' numere corespunzătoare convorbirilor pe care le-a avut Dora și duratele acestora exprimate în minute, să determine valoarea creditului rămas pe cartelă la terminarea convorbirilor.
== Date de intrare ==
Din prima linie a fișierului text '''aloin.txt''' se citesc '''E''', valoarea creditului inițial de pe cartelă și '''N''' numărul de convorbiri. Din următoarele '''N''' linii se citesc perechi de forma '''Nr D''' unde '''Nr''' – numărul corespunzător convorbirii și '''D''' – durata acesteia.
== Date de ieşire ==
În fișierul text '''aloout.txt''' se va scrie pe prima linie '''S'''-numărul de Eurici care sunt disponibili pe cartela Dorei după cele '''N''' convorbiri.
== Restricții și precizări ==
* '''5 &les; E &les; 100'''
* '''2 &les; N &les; 500'''
* '''1 &les; D &les; 50'''
* Convorbirile în care sună Dora se încadrează în limita creditului de pe cartelă de la momentul respectiv.
== Exemplul 1 ==
; aloin.txt
: 10 5
: 12345 4
: 12439 15
: 21335 30
: 18375 10
: 22359 20
; aloout.txt
: Datele de intrare corespund restrictiilor impuse.
: 12
 
== Exemplul 2 ==
; aloin.txt
: 4 5
: 12 2
: z 15
: 785 12
: 18 a
: 22 1
; aloout.txt
: Datele de intrare nu corespund restrictiilor impuse.
 
== Explicație ==
* '''12345 4''' – Dora sună la numărul '''2345''' care nu face parte din rețeaua ei și vorbește '''4''' minute. De pe cartelă se consumă '''4*2=8''' Eurici
* '''12439 15''' – Dora sună la numărul '''2439''' din rețeaua ei și vorbește '''15''' minute gratis
* '''21335 30''' – Dora este sunată de la numărul '''1335''' care nu este din rețeaua ei și vorbește '''30''' minute: Cartelase încarcă cu '''30*1=30''' Eurici
* '''18375 10''' – Dora sună la numărul '''8375''' care nu face parte din rețeaua ei și vorbește '''10''' minute. De pe cartelă se consumă '''10*2=20''' Eurici
* '''22359 20''' – Dora este sunată de la '''2359''' din rețeaua ei și vorbește '''20''' minute gratis.

Suma rămasă: '''10-8+30-20=12''' Eurici
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2569 Alo
def validare(e_validare, n_validare, convorbiri_validare):
if e_validare < 5 or e_validare > 100: # Verificăm dacă e este în intervalul 5-100
raise ValueError # Ridicăm o eroare dacă e nu este în intervalul 5-100
if n_validare < 2 or n_validare > 500: # Verificăm dacă n este în intervalul 2-500
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 2-500
for Nr, d in convorbiri_validare: # Parcurgem lista de convorbiri
if d < 1 or d > 50: # Verificăm dacă durata convorbirii este în intervalul 1-50
raise ValueError # Ridicăm o eroare dacă durata convorbirii nu este în intervalul 1-50
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

# Funcția calculeaza_credit calculează creditul rămas pe cartelă după fiecare convorbire
def calculeaza_credit(nr_credit, durata_credit, credit_calc):
# Verificăm dacă Dora sună (numărul începe cu 1)
if str(nr_credit)[0] == '1':
# Verificăm dacă sună în altă rețea (numărul se termină cu 5)
if str(nr_credit)[-1] == '5':
# Dacă sună în altă rețea, se consumă 2 Eurici pe minut
credit_calc -= durata_credit * 2
# Verificăm dacă Dora este sunată (numărul începe cu 2)
elif str(nr_credit)[0] == '2':
# Verificăm dacă este sunată din altă rețea (numărul se termină cu 5)
if str(nr_credit)[-1] == '5':
# Dacă este sunată din altă rețea, cartela se încarcă cu 1 Euric pe minut
credit_calc += durata_credit
return credit_calc # Returnăm creditul rămas pe cartelă

if __name__ == '__main__':
file_in = open('aloin.txt', 'r')
file_out = open('aloout.txt', 'w')

try:
# Citim valoarea inițială a creditului și numărul de convorbiri
E_main, N_main = map(int, file_in.readline().split())
# Citim numerele și duratele convorbirilor
convorbiri_main = [list(map(int, linie.split())) for linie in file_in]
validare(E_main, N_main, convorbiri_main) # Validăm datele de intrare
credit = E_main # Inițializăm creditul cu valoarea inițială
for nr, durata in convorbiri_main: # Parcurgem fiecare convorbire
# Calculăm creditul rămas pe cartelă după fiecare convorbire
credit = calculeaza_credit(nr, durata, credit)
# Scriem creditul rămas pe cartelă în fișierul de ieșire
file_out.write(str(credit))

except ValueError: # Tratăm excepțiile
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

2132 - Min Subsir

2023-11-12T15:16:49Z

AntalKrisztian:

Se consideră un șir de caractere format din litere mici ale alfabetului englez.
== Cerinţa ==
Să se determine '''lungimea minimă''' a unei secvențe care conține toate literele întâlnite în șirul inițial.
== Date de intrare ==
Programul citește de la tastatură șirul de caractere.
== Date de ieşire ==
Programul va afișa pe ecran lungimea secvențele cerute.
== Restricții și precizări ==
* 1 &les; lungime sir &les; 10000
== Exemplul 1 ==
; Intrare
: aadcaabcbacadca
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 5
 
== Exemplul 2 ==
; Intrare
: 54454534
; Ieșire
: Datele introduse nu corespund restricțiilor impuse.
 
== Explicație ==
Sunt folosite literele: '''a,b,c,d'''.

Secvențe de lungime minimă care folosesc toate literele: '''dcaab, bacad'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2132 -Min Subsir
def verificare(verif_car):
# Verificăm dacă lungimea șirului este în intervalul [1, 10000]
if 1 <= len(verif_car) <= 10000:
# Verificăm dacă șirul conține doar litere mici ale alfabetului englez
if not all(c.islower() for c in verif_car if not c.isspace()):
# Dacă șirul conține alte caractere, ridicăm o excepție
raise ValueError
# Dacă șirul este valid, îl returnăm
return verif_car
else:
# Dacă șirul nu este valid, ridicăm o excepție
raise ValueError

# Funcția lungime_minima determină lungimea minim
def lungime_minima(min_lung):
litere_unice = set(min_lung)
lungime_min = len(min_lung)
for i in range(len(min_lung)):
for j in range(i, len(min_lung)):
if set(min_lung[i:j+1]) == litere_unice:
lungime_min = min(lungime_min, j-i+1)
return lungime_min

if __name__ == "__main__":
try:
# Citim șirul de la utilizator
s = input("Introduceti sirul de caractere: ")
# Validăm șirul
s = verificare(s)
print("Datele introduse corespund restricțiilor impuse.")
print(lungime_minima(s))
except ValueError:
# Dacă șirul nu este valid, afișăm un mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2738 - Dist Lung Max

2023-11-12T14:55:50Z

AntalKrisztian:

== Cerinţa ==
Se dă un șir de caractere care conține cuvinte formate din litere mici ale alfabetului englez și separate printr-un singur spațiu. Să se determine cel mai lung cuvânt care are toate literele distincte. Dacă nu există niciun cuvânt cu toate literele distincte se va afișa '''-1'''.
== Date de intrare ==
Programul citește de la tastatură un șir de caractere.
== Date de ieşire ==
Programul va afișa pe ecran cuvântul determinat sau '''-1''', conform cerinței.
== Restricții și precizări ==
* șirul dat conține maximum '''255''' de caractere
* dacă există mai multe cuvinte cu toate literele distincte de lungime maximă se va afișa cel mai din stânga
== Exemplul 1 ==
; Intrare
: abcabcd abcdef ab
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: abcdef
 
== Exemplul 2 ==
; Intrare
: 547545//4/32
; Ieșire
: Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2738 Dist Lung Max
def verificare(verificare_date):
# Verificăm dacă șirul conține cel mult 255 de caractere
if len(verificare_date) <= 255:
# Verificăm dacă șirul conține doar litere mici ale alfabetului englez și spații
if not all(c.islower() or c.isspace() for c in verificare_date):
# Dacă șirul conține alte caractere, ridicăm o excepție
raise ValueError
# Dacă șirul este valid, îl returnăm
return verificare_date
else:
# Dacă șirul nu este valid, ridicăm o excepție
raise ValueError

# Funcția cel_mai_lung_cuvant_cu_litere_distincte determină cel mai lung cuvânt cu litere distincte din șir
def cel_mai_lung_cuvant_cu_litere_distincte(s_lung):
cuvinte = s_lung.split()
lungime_maxima = -1
cuvant_maxim = ""
for cuvant in cuvinte:
if len(cuvant) == len(set(cuvant)):
if len(cuvant) > lungime_maxima:
lungime_maxima = len(cuvant)
cuvant_maxim = cuvant
return cuvant_maxim if cuvant_maxim else -1

if __name__ == "__main__":
try:
# Citim șirul de la utilizator
s = input("Introduceti sirul de caractere: ")
# Validăm șirul
s = verificare(s)
# Dacă șirul este valid, determinăm cel mai lung cuvânt cu litere distincte și afișăm rezultatul
print("Datele introduse corespund restricțiilor impuse.")
print(cel_mai_lung_cuvant_cu_litere_distincte(s))
except ValueError:
# Dacă șirul nu este valid, afișăm un singur mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse..")

</syntaxhighlight>

1270 - B16

2023-11-12T14:41:18Z

AntalKrisztian:

== Cerinţa ==
Se dă un număr natural în baza '''16'''. Să se transforme acest număr în baza '''10'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''' în baza '''16'''.
== Date de ieşire ==
Programul va afișa pe ecran numărul '''n''' transformat în baza '''10'''.
== Restricții și precizări ==
* reprezentarea în baza '''10''' a numărului dat este mai mică decât '''2.000.000.000'''
* Cifrele în baza '''16''' sunt : '''0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F'''.
== Exemplul 1 ==
; Intrare
: 100
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 256
 
== Exemplul 2 ==
; Intrare
: 200000000
; Ieșire
: Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1270 B16
def verificare(n_hex):
try:
# Încercăm să convertim numărul în baza 10
n_dec = int(n_hex, 16)
# Verificăm dacă numărul este în intervalul [0, 2000000000]
if 0 <= n_dec <= 2000000000:
# Dacă numărul este valid, îl returnăm
return n_hex
else:
# Dacă numărul nu este valid, ridicăm o excepție
raise ValueError
except ValueError:
# Dacă conversia a eșuat, ridicăm o excepție
raise ValueError

# Funcția transformare convertește numărul din baza 16 în baza 10
def transformare(numar_hex):
return int(numar_hex, 16)

if __name__ == "__main__":
try:
# Citim numărul de la utilizator
n = input("Introduceti numarul in baza 16: ")
# Validăm numărul
n = verificare(n)
# Dacă numărul este valid, îl convertim în baza 10 și afișăm rezultatul
print("Datele introduse corespund restricțiilor impuse.")
print(transformare(n))
except ValueError:
# Dacă numărul nu este valid, afișăm un mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0807 - Inlocuire 1

2023-11-12T14:29:15Z

AntalKrisztian:

== Cerinţa ==
Se dă un şir de caractere ce conţine cuvinte formate din litere mici ale alfabetului englez, separate prin unul sau mai multe spații. Înaintea primului cuvânt nu există spații, și nici după ultimul. Să se modifice șirul dat, astfel încât să se înlocuiască fiecare cuvânt cu exact trei litere din șir cu simbolul '''*'''.
== Date de intrare ==
Programul va citi de la tastatură şirul dat.
== Date de ieşire ==
Programul va afişa pe ecran şirul transformat corespunzător.
== Restricții și precizări ==
* șirul dat va conține cel mult 255 caractere, litere mici ale alfabetului englez și spații
== Exemplul 1 ==
; Intrare
: bun este izvorul ce are apa rece
; Ieşire
: Datele introduse corespund restricțiilor impuse.
: * este izvorul ce * * rece
 
== Exemplul 2 ==
; Intrare
: 1235//
; Ieşire
: Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0807 Inlocuire 1
def verificare(verificare_n):
# Verificăm dacă șirul conține cel mult 255 de caractere
if len(verificare_n) <= 255:
# Verificăm dacă șirul conține doar litere mici ale alfabetului englez și spații
if not all(c.islower() or c.isspace() for c in verificare_n):
# Dacă șirul conține alte caractere, ridicăm o excepție
raise ValueError
# Dacă șirul este valid, îl returnăm
return verificare_n
else:
# Dacă șirul nu este valid, ridicăm o excepție
raise ValueError

# Funcția inlocuire înlocuiește cuvintele cu trei litere din șir cu '*'
def inlocuire(inlocuire_s):
cuvinte = inlocuire_s.split()
for index in range(len(cuvinte)):
if len(cuvinte[index]) == 3:
cuvinte[index] = '*'
return ' '.join(cuvinte)

if __name__ == "__main__":
try:
# Citim șirul de la utilizator
s = input("Introduceti sirul de caractere: ")
# Validăm șirul
s = verificare(s)
# Dacă șirul este valid, înlocuim cuvintele cu trei litere și afișăm rezultatul
print("Datele introduse corespund restricțiilor impuse.")
print(inlocuire(s))
except ValueError:
# Dacă șirul nu este valid, afișăm un singur mesaj de eroare
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2736 - Baza de Date

2023-11-12T14:04:09Z

AntalKrisztian: Ștergerea conținutului paginii

3481 - Sort Div

2023-11-11T15:28:03Z

AntalKrisztian:

== Cerinţa ==
Se dau '''n''' numere naturale. Să se afișeze acestea în ordinea crescătoare a numărului de divizori ai fiecăruia, la același număr de divizori crescător după cifra de control, la aceeași cifră de control crescător după prima cifră, iar dacă și prima cifră este aceeași atunci numerele se vor afișa în ordinea crescătoare a valorii lor.
== Date de intrare ==
Fișierul de intrare '''sort_divin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie n numere naturale separate prin spații.
== Date de ieşire ==
Fișierul de ieșire '''sort_divout.txt''' va conține pe prima linie cele '''n''' numere separate prin câte un spațiu, ordonate crescător pe baza criteriilor din enunț.
== Restricții și precizări ==
* 1 &les; n &les; 10000
* numerele de pe a doua linie a fișierului de intrare vor fi distincte și mai mici decât '''1.000.000'''
* cifra de control a unui număr se obţine efectuând suma cifrelor sale, apoi suma cifrelor acestei sume etc. până se obţine o sumă formată dintr-o singură cifră. De exemplu, cifra de control a numărului '''645''' este '''6'''. '''(6+4+5=15, 1+5=6)'''
== Exemplul 1 ==
; sort_divin.txt
: 5
: 6 8 3 10 5
; sort_divout.txt
: Datele de intrare corespund restrictiilor impuse.
: 3 5 10 6 8
 
== Exemplul 2 ==
; sort_divin.txt
: 4
: 2 5 6 q x
; sort_divout.txt
: Datele de intrare nu corespund restrictiilor impuse.
 
== Explicaţii ==
'''3''' și '''5''' au ambele '''2''' divizori, deci se afișează în ordine crescătoare după cifra de control. La fel și '''6''', '''8''' și '''10''' care au fiecare câte '''4''' divizori.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 3481 Sort Div
def validare(n_validare, numere_validare):
# Verificăm dacă n este în intervalul 1-10000
if n_validare < 1 or n_validare > 10000:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-10000
for numar in numere_validare: # Parcurgem lista de numere
# Verificăm dacă numărul este în intervalul 1-1000000
if numar < 1 or numar > 1000000:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

# Funcția numar_divizori calculează numărul de divizori ai unui număr.
def numar_divizori(n):
count = 0 # Inițializăm contorul de divizori
# Parcurgem numerele de la 1 la rădăcina pătrată a lui n
for i in range(1, int(n**0.5) + 1):
if n % i == 0: # Verificăm dacă i este un divizor al lui n
# Dacă i și n/i sunt egale, înseamnă că i este un divizor pătrat
if n / i == i:
count += 1 # Adăugăm un divizor
else:
count += 2 # Adăugăm doi divizori (i și n/i)
return count # Returnăm numărul total de divizori

# Funcția cifra_control calculează cifra de control a unui număr.
def cifra_control(numere_control):
# Continuăm să calculăm suma cifrelor până când obținem o singură cifră
while numere_control > 9:
numere_control = sum(int(digit) for digit in str(numere_control)) # Calculăm suma cifrelor
return numere_control # Returnăm cifra de control

# Funcția sortare sortează lista de numere în funcție de criteriile specificate.
def sortare(numere):
# Sortăm numerele în funcție de numărul de divizori, cifra de control, prima cifră și valoarea numărului
numere.sort(key=lambda x: (numar_divizori(x), cifra_control(x), int(str(x)[0]), x))

if __name__ == '__main__':
file_in = open("sort_divin.txt", "r")
file_out = open("sort_divout.txt", "w")

try:
n_main = int(file_in.readline()) # Citim numărul de numere
numere_main = list(map(int, file_in.readline().split())) # Citim numerele
validare(n_main, numere_main) # Validăm datele de intrare
sortare(numere_main) # Sortăm lista de numere în funcție de criteriile specificate
# Scriem numerele sortate în fișierul de ieșire
file_out.write(' '.join(map(str, numere_main)) + '\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

2004 - Ore

2023-11-11T15:15:05Z

AntalKrisztian:

== Cerinţa ==
Se consideră două evenimente a căror durată este exprimată fiecare prin câte trei numere naturale: ore (h), minute (m) şi secunde (s).Să se scrie în fișierul de ieșire:
* a) pe primele două linii, duratele în formatul '''h: m: s'''
* b) pe următoarele două linii, duratele exprimate în secunde, corespunzătoare fiecăruieveniment, pe rânduri separate;
* c) pe următoarea linie suma obţinută din adunarea duratelor celor două evenimente, exprimată în ore, minute, secunde, în formatul '''h: m: s'''.
== Date de intrare ==
Fișierul de intrare '''orein.txt''' conține două linii pe care sunt scrise câte trei numere naturale, separate prin câte un spaţiu, reprezentând duratele a două evenimente exprimate în: '''ore (h), minute (m) şi secunde (s)'''.
== Date de ieşire ==
Fișierul de ieșire '''oreout.txt''' va conține pe primele două linii răspuncul de la cerința '''a)''', apoi pe liniile '''3''' și '''4''' răspunsul la cerința '''b)''', iar pe a '''5'''-a linie răspunsul la cerința '''c)'''.
== Restricții și precizări ==
* 1 &les; h &les; 24
* 0 &les; m &les; 60
* 0 &les; s &les; 60
== Exemplul 1 ==
; orein.txt
: 3 35 55
: 2 40 8
; oreout.txt
: Datele de intrare corespund restrictiilor impuse
: 3: 35: 55
: 2: 40: 8
: 12955
: 9608
: 6: 16: 3
 
== Exemplul 2 ==
; orein.txt
: 9 55 70
: 12 1 99
; oreout.txt
: Datele de intrare nu corespund restrictiilor impuse
 
== Explicaţii ==
În fișierul de intrare sunt detaliile referitoare la duratele cele două evenimente, iar suma lor este '''6: 16: 3'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2004 Ore
def validare(event1_validare, event2_validare):
for event in [event1_validare, event2_validare]: # Parcurgem lista de evenimente
h, m, s = event
# Verificăm dacă orele sunt în intervalul 1-24
if h < 1 or h > 24:
raise ValueError
# Verificăm dacă minutele sunt în intervalul 0-60
if m < 0 or m > 60:
raise ValueError
# Verificăm dacă secundele sunt în intervalul 0-60
if s < 0 or s > 60:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

def calculeaza_durata(event1, event2):
# Calculăm durata în secunde pentru fiecare eveniment
sec1 = event1[0] * 3600 + event1[1] * 60 + event1[2]
sec2 = event2[0] * 3600 + event2[1] * 60 + event2[2]
# Calculăm suma duratelor
total_sec = sec1 + sec2
# Convertim suma duratelor înapoi în ore, minute și secunde
total_o, total_sec = divmod(total_sec, 3600)
total_m, total_s = divmod(total_sec, 60)
return sec1, sec2, total_o, total_m, total_s

if __name__ == '__main__':
file_in = open("orein.txt", "r")
file_out = open("oreout.txt", "w")

try:
# Citim datele pentru fiecare eveniment
event1_main = list(map(int, file_in.readline().split()))
event2_main = list(map(int, file_in.readline().split()))
# Validăm datele de intrare
validare(event1_main, event2_main)
# Calculăm durata în secunde și suma duratelor
sec1_main, sec2_main, total_o_main, total_m_main, total_s_main = calculeaza_durata(event1_main, event2_main)
# Scriem rezultatele în fișierul de ieșire
file_out.write(f'{event1_main[0]}: {event1_main[1]}: {event1_main[2]}\n')
file_out.write(f'{event2_main[0]}: {event2_main[1]}: {event2_main[2]}\n')
file_out.write(f'{sec1_main}\n{sec2_main}\n')
file_out.write(f'{total_o_main}: {total_m_main}: {total_s_main}\n')

# Dacă datele de intrare nu sunt valide, afișăm un mesaj de eroare
except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
# Dacă datele de intrare sunt incomplete, afișăm un mesaj de eroare
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1460 - Serbare

2023-11-11T15:04:24Z

AntalKrisztian:

== Cerinţa ==
La o serbare sunt '''n''' grupe de copii care poartă '''p''' tipuri de uniforme. Scrieţi un program care să afişeze pe ecran tipurile de uniforme în ordinea descrescătoare a numărului total de copii ce poartă fiecare tip de uniformă. Afişarea se va face pe o singură linie, valoriile fiind separate printr-un spaţiu.
== Date de intrare ==
Fișierul de intrare '''serbarein.txt''' conține, pe prima linie, numerele '''n''' şi '''p''', separate printr-un spaţiu, iar pe următoarele '''n''' linii câte două valori separate printr-un spaţiu ce reprezintă numărul de copii dintr-o grupă şi respectiv tipul de uniformă pe care aceştia îl poartă.
== Date de ieşire ==
Fișierul de ieșire '''serbareout.txt''' va conţine tipurile de uniforme în ordinea descrescătoare a numărului total de copii ce poartă fiecare tip de uniformă. Numerele vor fi separate printr-un spaţiu.
== Restricții și precizări ==
* 1 &les; n &les; 1000
* 1 &les; p &les; 11
* Numărul de copii dintr-o grupă este cel mult '''100'''
* Fiecare mărime de uniformă din intervalul '''[1,p]''' este purtată de cel puţin un copil
== Exemplul 1 ==
; serbarein.txt
: 5 3
: 20 2
: 20 3
: 30 2
: 20 1
: 10 1
; serbareout.txt
: Datele de intrare corespund restrictiilor impuse.
: 2 1 3
 
== Exemplul 2 ==
; serbarein.txt
: 3 3
: 20 q
: 20 3
: 30 3000
; serbareout.txt
: Datele de intrare nu corespund restrictiilor impuse.
 
== Explicaţii ==
Tipul '''2''' de uniformă este purtat de '''50''' de copii, tipul '''1''' de '''30''' de copii, iar tipul '''3 '''de '''20''' de copii.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1460 Serbare
def validare(n_validare, p_validare, grupe_validare):
if n_validare < 1 or n_validare > 1000: # Verificăm dacă n este în intervalul 1-1000
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-1000
if p_validare < 1 or p_validare > 11: # Verificăm dacă p este în intervalul 1-11
raise ValueError # Ridicăm o eroare dacă p nu este în intervalul 1-11
for grup in grupe_validare: # Parcurgem lista de grupe
# Verificăm dacă numărul de copii este în intervalul 1-100
if grup[0] < 1 or grup[0] > 100:
raise ValueError
# Verificăm dacă tipul de uniformă este în intervalul 1-p
if grup[1] < 1 or grup[1] > p_validare:
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse.\n")

def uniforme(grupe):
uni = {} # Inițializăm un dicționar gol
for grup in grupe: # Parcurgem lista de grupe
# Dacă tipul de uniformă nu se află încă în dicționar, îl adăugăm cu valoarea 0
if grup[1] not in uni:
uni[grup[1]] = 0
# Adăugăm numărul de copii la totalul pentru tipul respectiv de uniformă
uni[grup[1]] += grup[0]
# Sortăm tipurile de uniforme în ordinea descrescătoare a numărului total de copii
sort_uni = sorted(uni.items(), key=lambda x: x[1], reverse=True)
return [uni[0] for uni in sort_uni] # Returnăm tipurile de uniforme sortate

if __name__ == '__main__':
file_in = open("serbarein.txt", "r")
file_out = open("serbareout.txt", "w")

try:
# Citim numărul de grupe și tipuri de uniforme
n_main, p_main = map(int, file_in.readline().split())
# Citim datele pentru fiecare grup
grupe_main = [list(map(int, file_in.readline().split())) for _ in range(n_main)]
# Validăm datele de intrare
validare(n_main, p_main, grupe_main)
# Calculăm numărul total de copii pentru fiecare tip de uniformă
rezultat_main = uniforme(grupe_main)
# Scriem tipurile de uniforme în fișierul de ieșire, separate printr-un spațiu
file_out.write(' '.join(str(uni) for uni in rezultat_main) + '\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

1013 - Aniversari

2023-11-11T14:44:59Z

AntalKrisztian:

== Cerinţa ==
Se dau datele de naștere a n persoane, numerotate de la '''1''' la '''n''', în forma '''an luna zi'''. Să se determine numărul de ordine al celei mai tinere și al celei mai în vârstă persoană dintre cele date.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' triplete de numere naturale '''a l z''', reprezentând anul, luna și ziua de naștere a fiecărei persoane.
== Date de ieşire ==
Programul va afișa pe ecran două numere '''p q''', reprezentând numărul de ordine al celei mai tinere, respectiv al celei mai în vârstă persoană.
== Restricții și precizări ==
* 1 &les; n &les; 1000
* cele '''n''' date calendaristice sunt corecte
* dacă există două sau mai multe persoane cele mai tinere (în vârstă) se va afișa numărul de ordine mai mic
== Exemplul 1 ==
; Intrare
: 5
: 1998 5 26
: 1987 12 18
: 1987 9 25
: 2015 1 16
: 2015 1 8
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 4 3
 
== Exemplul 2 ==
; Intrare
: 2
: 12 7 1990
: 14 2 2000
; Ieșire
: Datele introduse nu corespund restricțiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1013 Aniversari
def validare(n_val, date_nastere_s):
# Verificăm dacă numărul de persoane este în intervalul [1, 1000]
if 1 <= n_val <= 1000:
# Verificăm dacă data de naștere a fiecărei persoane este validă
for an1, luna1, zi1 in date_nastere_s:
# Data de naștere este validă dacă anul este între 1 și 9999, luna între 1 și 12, și ziua între 1 și 31
if not(1 <= an1 <= 9999 and 1 <= luna1 <= 12 and 1 <= zi1 <= 31):
# Dacă data de naștere nu este validă, ridicăm o excepție
raise ValueError
# Dacă toate datele de naștere sunt valide, returnăm numărul de persoane
return n_val
else:
# Dacă numărul de persoane nu este în intervalul [1, 1000], ridicăm o excepție
raise ValueError

def persoane(numar, data_nastere):
# Inițializăm datele celei mai tinere și celei mai în vârstă persoane
data_tanar = (0, 0, 0)
data_batran = (9999, 12, 31)
numar_tanar = numar_batran = 0

for i in range(numar): # Parcurgem fiecare persoană
anul, luna_nastere, zi_nastere = data_nastere[i] # Extragem data de naștere a persoanei
# Dacă persoana este mai tânără decât cea mai tânără persoană curentă
if (anul, luna_nastere, zi_nastere) > data_tanar:
# Actualizăm data celei mai tinere persoane și numărul său de ordine
data_tanar = (anul, luna_nastere, zi_nastere)
numar_tanar = i + 1
# Dacă persoana este mai în vârstă decât cea mai în vârstă persoană curentă
if (anul, luna_nastere, zi_nastere) < data_batran:
# Actualizăm data celei mai în vârstă persoane și numărul său de ordine
data_batran = (anul, luna_nastere, zi_nastere)
numar_batran = i + 1
return numar_tanar, numar_batran

if __name__ == "__main__":
try:
n = input("Introduceti numarul de persoane: ") # Citim numărul de persoane de la utilizator
date_nastere = [] # Inițializăm lista de date de naștere

# Citim data de naștere a fiecărei persoane de la utilizator
for _ in range(int(n)):
an, luna, zi = map(int, input("Introduceti data de nastere a persoanei (an luna zi): ").split())
date_nastere.append((an, luna, zi))

# Validăm numărul de persoane și datele de naștere
n = validare(int(n), date_nastere)
print("Datele introduse corespund restricțiilor impuse.")
nr_tanar, nr_batran = persoane(n, date_nastere)
print(f"{nr_tanar} {nr_batran}")
except ValueError:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0922 - Puncte

2023-11-11T14:28:13Z

AntalKrisztian:

== Cerinţa ==
Se dau coordonatele carteziene a '''n''' puncte în plan. Să se determine distanța maximă dintre un punct dat și originea sistemului de coordonate și numărul de puncte situate la acea distanță față de origine.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' perechi de puncte '''x y''', reprezentând coordonatele punctelor.
== Date de ieşire ==
Programul va afișa pe ecran două numere '''D C''', reprezentând distanța maximă față de originea sistemului și numărul de puncte situate la acea distanță.
== Restricții și precizări ==
* 1 &les; n &les; 100
* coordonatele punctelor sunt numere întregi din intervalul '''[-1000,1000]'''
* distanța maximă se va afișa cu cel puțin trei zecimale exacte
== Exemplul 1 ==
; Intrare
: 7
: 2 -1
: -2 4
: 2 3
: 3 -1
: -2 -4
: 2 -2
: -4 2
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 4.472 3
 
== Exemplul 2 ==
; Intrare
: 9
: 244a
; Ieșire
: Datele introduse nu corespund restricțiilor impuse.
 
== Explicație ==
Cele trei puncte aflate la distanța '''4.472''' față de origine sunt: '''-2 4''', '''-2 -4''' și '''-4 2.'''
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0922 Puncte
def verificare(n1_val, puncte_val1):
# Verificăm dacă numărul de puncte este în intervalul [1, 100]
if 1 <= n1_val <= 100:
# Verificăm dacă coordonatele fiecărui punct sunt în intervalul [-1000, 1000]
for x1_val, y1_val in puncte_val1:
if not(-1000 <= x1_val <= 1000 and -1000 <= y1_val <= 1000):
# Dacă un punct nu respectă restricțiile, ridicăm o excepție
raise ValueError
# Dacă toate punctele respectă restricțiile, returnăm numărul de puncte
return n1_val
else:
# Dacă numărul de puncte nu este în intervalul [1, 100], ridicăm o excepție
raise ValueError

def distanta_maxima(numar_valoare, puncte_valoare):
# Inițializăm distanța maximă și numărul de puncte
distanta_max = 0
numar_puncte = 0
for i in range(numar_valoare): # Parcurgem fiecare punct
x_valoare, y_valoare = puncte_valoare[i] # Extragem coordonatele punctului

# Calculăm distanța de la origine până la punct
distanta = (x_valoare**2 + y_valoare**2)**0.5

# Dacă distanța este mai mare decât distanța maximă curentă
if distanta > distanta_max:
# Actualizăm distanța maximă și resetăm numărul de puncte
distanta_max = distanta
numar_puncte = 1
# Dacă distanța este egală cu distanța maximă curentă
elif distanta == distanta_max:
numar_puncte += 1 # Incrementăm numărul de puncte
return round(distanta_max, 3), numar_puncte

if __name__ == "__main__":
try:
# Citim numărul de puncte de la utilizator
n_main = input("Introduceti numarul de puncte: ")
puncte_main = [] # Inițializăm lista de puncte
# Citim coordonatele fiecărui punct de la utilizator
for _ in range(int(n_main)):
x_main, y_main = map(int, input("Introduceti coordonatele punctului: ").split())
puncte_main.append((x_main, y_main))

# Validăm numărul de puncte și coordonatele acestora
n_main = verificare(int(n_main), puncte_main)

# Dacă datele introduse sunt valide, calculăm și afișăm distanța maximă și numărul de puncte
print("Datele introduse corespund restricțiilor impuse.")
dist_max, nr_puncte = distanta_maxima(n_main, puncte_main)
print(f"{dist_max} {nr_puncte}")
except ValueError:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0923 - Fractii Max

2023-11-10T19:15:19Z

AntalKrisztian:

== Cerinţa ==
Se dau '''4''' numere naturale '''a b c d''', reprezentând fracţiile '''a/b''' şi '''c/d'''. Determinați și afișați cea mai mare dintre cele două fracții.
== Date de intrare ==
Programul citește de la tastatură numerele '''a b c d'''.
== Date de ieşire ==
Programul afișează pe ecran numerele '''m n''', separate prin exact un spațiu, reprezentând numărătorul şi numitorul fracției maxime, adusă la forma ireductibilă.
== Restricții și precizări ==
* 1 &les; a, b, c, d &les; 10000
== Exemplul 1 ==
; Intrare
: 7
: 14
: 24
: 18
; Ieșire
: Datele de intrare corespund restricțiilor impuse.
: 4 3
 
== Exemplul 2 ==
; Intrare
: 4
: 9
: 15
: 100000
; Ieșire
: Datele introduse nu corespund restricțiilor impuse.
 
== Explicație ==
Fracția maximă este '''24/18'''. Prin simplificare devine '''4/3'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0923 Fractii Max
def verificare(valoare_numar):
# Verificăm dacă numărul este între 1 și 10000
if 1 <= valoare_numar <= 10000:
return valoare_numar # Dacă este, returnăm numărul
else:
raise ValueError # Dacă nu este, ridicăm o excepție

def cmmdc(valoare1, valoare2):
# Folosim algoritmul lui Euclid pentru a găsi cmmdc
while valoare2:
valoare1, valoare2 = valoare2, valoare1 % valoare2
return valoare1 # Returnăm cmmdc

if __name__ == "__main__":
try:
# Citim numerele de la utilizator
a = input("Introduceți numărătorul primei fracții: ")
b = input("Introduceți numitorul primei fracții: ")
c = input("Introduceți numărătorul celei de-a doua fracții: ")
d = input("Introduceți numitorul celei de-a doua fracții: ")

# Validăm numerele folosind funcția de verificare
a = verificare(int(a))
b = verificare(int(b))
c = verificare(int(c))
d = verificare(int(d))
print("Datele de intrare corespund restricțiilor impuse.")

# Calculăm valorile fracțiilor
frac1 = a / b
frac2 = c / d

# Verificăm care fracție este mai mare și o simplificăm
if frac1 > frac2:
cmmdc_val = cmmdc(a, b) # Calculăm cmmdc pentru a și b
print(a // cmmdc_val, b // cmmdc_val) # Afișăm fracția simplificată
else:
cmmdc_val = cmmdc(c, d) # Calculăm cmmdc pentru c și d
print(c // cmmdc_val, d // cmmdc_val) # Afișăm fracția simplificată
except ValueError:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2714 - Frecv Imp

2023-11-10T19:14:37Z

AntalKrisztian:

== Cerinţa ==
Se dă un șir format din '''n''' numere naturale. Toate valorile putere a lui '''2''' din acest șir au frecvență pară, cu o singură excepție. Determinați această valoare – putere a lui '''2''' cu frecvență impară.
== Date de intrare ==
Fișierul de intrare '''frecvimpin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieşire ==
Fișierul de ieșire '''frecvimpout.txt''' va conține pe prima linie numărul '''p''', reprezentând singura valoare din șirul dat care este putere a lui 2 și are frecvență impară.
== Restricții și precizări ==
* 1 &les; n &les; 1.000.000
* numerele de pe a doua linie a fișierului de intrare sunt naturale, nenule și mai mici decât <math> 9223372036854775807 </math>
* <math> 9223372036854775807 </math> = 2 63 - 1
== Exemplul 1 ==
; frecvimpin.txt
: 10
: 41 235 64 41 512 64 1488 512 361 512
; frecvimpout.txt
: Datele de intrare corespund restrictiilor impuse
: 512
 
== Exemplul 2 ==
; frecvimpin.txt
: -1
: 22 77 99 11
; frecvimp.out
: Datele de intrare nu corespund restrictiilor impuse
 
== Explicație ==
În fișierul de intrare sunt '''2''' puteri ale lui 2, '''64''' și '''512''', dintre care '''512''' apare de '''3''' ori.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2714 Frecv Imp
def validare(n_validare, numere_validare):
# Verificăm dacă n este în intervalul 1-1000000
if n_validare < 1 or n_validare > 1000000:
raise ValueError # Ridicăm o eroare dacă n nu este în intervalul 1-1000000
for numar in numere_validare: # Parcurgem lista de numere
if numar < 1 or numar > 9223372036854775807:
# Ridicăm o eroare dacă numărul nu este în intervalul 1-9223372036854775807
raise ValueError
file_out.write("Datele de intrare corespund restrictiilor impuse\n")

def frecvimp(numere):
frec = {} # Inițializăm un dicționar gol
for numar in numere: # Parcurgem lista de numere
# Dacă numărul nu se află încă în dicționar, îl adăugăm cu frecvența 0
if numar not in frec:
frec[numar] = 0
frec[numar] += 1 # Incrementăm frecvența numărului curent

for numar in frec: # Parcurgem dicționarul
# Dacă frecvența numărului curent este impară și dacă numărul este o putere a lui 2
if frec[numar] % 2 == 1 and (numar & (numar - 1) == 0):
return numar # Dacă găsim un astfel de număr îl returnăm

if __name__ == '__main__':
file_in = open("frecvimpin.txt", "r") # Deschidem fișierul de intrare pentru citire
file_out = open("frecvimpout.txt", "w") # Deschidem fișierul de ieșire pentru scriere

try:
# Citim numărul de numere
n_main = int(file_in.readline())
# Citim numerele
numere_main = list(map(int, file_in.readline().split()))
validare(n_main, numere_main) # Validăm datele de intrare
# Calculăm și scriem numărul cu frecvență impară
rezultat_main = frecvimp(numere_main)
file_out.write(str(rezultat_main) + '\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>