Bitnami MediaWiki - User contributions [en]

28354

2023-12-03T15:40:03Z

Alexandra Leș:

'''28354 (Florin Bojor)'''

''Fie <math>O</math> punctul de intersecție a diagonalelor patrulaterului convex <math>ABCD</math> și punctele <math>E</math> ,<math>F</math> ,<math>G</math> și <math>H</math> pe segmentele <math>OA</math>, <math>OB</math>, <math>OC</math>, respectiv <math>OD</math>, astfel încât <math>AE = BF = CG = DH</math>. Notăm cu <math>I</math>,<math>J</math>,<math>K</math> și <math>L</math> mijloacele segmentelor <math>AB</math>, <math>BC</math>, <math>CD</math>, respectiv <math>DA</math> și cu <math>M</math>,<math>N</math>,<math>P</math> și <math>Q</math> mijloacele segmentelor <math>EF</math>, <math>FG</math>,
<math>GH</math>, respectiv <math>HE</math>. Arătați că:
<li> a) punctele <math>I</math>,<math>M</math> și <math>K</math> sunt coliniare dacă și numai dacă <math>AC=BD</math>.
<li> b) <math>AC \not= BD</math>, punctele de intersecție ale dreptelor <math>IM</math>,<math>NJ</math>,<math>PK</math> și <math>LQ</math> sunt vărfurile unui dreptunghi.''</li></ol>

'''Soluție.'''
a)Fie <math>AE = BF = CG = x</math> și versorii <math>\overrightarrow{i}</math> și <math>\overrightarrow{j}</math> a vectorilor <math>\overrightarrow{A C}</math> respectiv <math>\overrightarrow{B D}</math>.

Deoarece <math>I</math> și <math>M</math> sunt mijloacele segmentelor <math>AB</math>, respectiv <math>EF</math>,obținem:

<math>\overrightarrow{I M} = \frac{{1}}{2} \cdot (\overrightarrow{A E}+\overrightarrow{B F}) =\frac{{x}}{2} \cdot
\overrightarrow{i} + \frac{{x}}{2} \cdot \overrightarrow{j} </math>. (1)

Cum <math>K</math> este mijloxul segemntului <math>CD</math>,deducem:

<math>\overrightarrow{I K} = \frac{{1}}{2} \cdot (\overrightarrow{A C}+\overrightarrow{B D}) =\frac{{AC}}{2} \cdot
\overrightarrow{i} + \frac{{BD}}{2} \cdot \overrightarrow{j} </math> (2)

Din (1) și (2) rezultă ca <math>I</math>,<math>M</math> și<math>K</math> sunt coliniare dacă și numai dacă <math>AC = BD</math>.

b)Notăm <math>\overrightarrow{i} +\overrightarrow{j} = \overrightarrow{O R}</math> și <math>\overrightarrow{-i} +\overrightarrow{j} = \overrightarrow{O S}</math>.

Se observă că semidreptele (OR și OS sunt bisectoarele unghiurilor COD,respectiv AOD.Ca în (1),deducem că <math>\overrightarrow{P K} =\overrightarrow{I M} = \frac{{x}}{2} \cdot (\overrightarrow{i}+\overrightarrow{j}) =\frac{{x}}{2} \cdot \overrightarrow{O R}</math>,iar <math>\overrightarrow{J N} =\overrightarrow{Q L} = \frac{{x}}{2} \cdot (\overrightarrow{-i}+\overrightarrow{j}) =\frac{{x}}{2} \cdot \overrightarrow{O S}</math>.

Fiind bisectoarele a două unghiuri adiacente suplementare,semidreptele (OR și OS sunt perpendiculare ,de unde rezultă că <math>IM \perp JN</math>,<math>JN \perp KP</math> , <math>KP \perp LQ</math> și <math>LQ \perp IM</math>.Dar <math>AC \not= BD</math> , deci <math>I</math>,<math>M</math> și <math>K<math>M</math> sunt necoliniare ,așadar <math>IM \parallel KP</math> , și analog <math>JN \parallel LQ</math>.Notând cu <math>X</math>,<math>Y</math>,<math>Z</math>,<math>W</math> intersecțiile perechilor de drepte <math>IM</math> și <math>JN</math>,<math>JN</math> și <math>KP</math>,<math>KP</math> și <math>LQ</math>,<math>LQ</math> și <math>IM</math> ,din cele de mai înaite rezultă că <math>XYZW</math> este dreptunghi.

28354

2023-12-03T15:35:38Z

Alexandra Leș: Pagină nouă: '''28354 (Florin Bojor)''' ''Fie <math>O</math> punctul de intersecție a diagonalelor patrulaterului convex <math>ABCD</math> și punctele <math>E</math> ,<math>F</math> ,<math>G</math> și <math>H</math> pe segmentele <math>OA</math>, <math>OB</math>, <math>OC</math>, respectiv <math>OD</math>, astfel încât <math>AE = BF = CG = DH</math>. Notăm cu <math>I</math>,<math>J</math>,<math>K</math> și <math>L</math> mijloacele segmentelor <math>AB</math>, <math>BC</math>, <ma...

'''28354 (Florin Bojor)'''

''Fie <math>O</math> punctul de intersecție a diagonalelor patrulaterului convex <math>ABCD</math> și punctele <math>E</math> ,<math>F</math> ,<math>G</math> și <math>H</math> pe segmentele <math>OA</math>, <math>OB</math>, <math>OC</math>, respectiv <math>OD</math>, astfel încât <math>AE = BF = CG = DH</math>. Notăm cu <math>I</math>,<math>J</math>,<math>K</math> și <math>L</math> mijloacele segmentelor <math>AB</math>, <math>BC</math>, <math>CD</math>, respectiv <math>DA</math> și cu <math>M</math>,<math>N</math>,<math>P</math> și <math>Q</math> mijloacele segmentelor <math>EF</math>, <math>FG</math>,
<math>GH</math>, respectiv <math>HE</math>. Arătați că:
<li> a) punctele <math>I</math>,<math>M</math> și <math>K</math> sunt coliniare dacă și numai dacă <math>AC=BD</math>.
<li> b) <math>AC \not= BD</math>, punctele de intersecție ale dreptelor <math>IM</math>,<math>NJ</math>,<math>PK</math> și <math>LQ</math> sunt vărfurile unui dreptunghi.''</li></ol>

'''Soluție.'''
a)Fie <math>AE = BF = CG = x</math> și versorii <math>\overrightarrow{i}</math> și <math>\overrightarrow{j}</math> a vectorilor <math>\overrightarrow{A C}</math> respectiv <math>\overrightarrow{B D}</math>.

Deoarece <math>I</math> și <math>M</math> sunt mijloacele segmentelor <math>AB</math>, respectiv <math>EF</math>,obținem:

<math>\overrightarrow{I M} = \frac{{1}}{2} \cdot (\overrightarrow{A E}+\overrightarrow{B F}) =\frac{{x}}{2} \cdot
\overrightarrow{i} + \frac{{x}}{2} \cdot \overrightarrow{j} </math>. (1)

Cum <math>K</math> este mijloxul segemntului <math>CD</math>,deducem:

<math>\overrightarrow{I K} = \frac{{1}}{2} \cdot (\overrightarrow{A C}+\overrightarrow{B D}) =\frac{{AC}}{2} \cdot
\overrightarrow{i} + \frac{{BD}}{2} \cdot \overrightarrow{j} </math> (2)

Din (1) și (2) rezultă ca <math>I<math>M</math>,<math>M</math> și<math>K</math> sunt coliniare dacă și numai dacă <math>AC = BD</math>.

b)Notăm <math>\overrightarrow{i} +\overrightarrow{j} = \overrightarrow{O R}</math> și <math>\overrightarrow{-i} +\overrightarrow{j} = \overrightarrow{O S}</math>.

Se observă că semidreptele (OR și OS sunt bisectoarele unghiurilor COD,respectiv AOD.Ca în (1),deducem că <math>\overrightarrow{P K} =\overrightarrow{I M} = \frac{{x}}{2} \cdot (\overrightarrow{i}+\overrightarrow{j}) =\frac{{x}}{2} \cdot \overrightarrow{O R}</math>,iar <math>\overrightarrow{J N} =\overrightarrow{Q L} = \frac{{x}}{2} \cdot (\overrightarrow{-i}+\overrightarrow{j}) =\frac{{x}}{2} \cdot \overrightarrow{O S}</math>.

Fiind bisectoarele a două unghiuri adiacente suplementare,semidreptele (OR și OS sunt perpendiculare ,de unde rezultă că <math>IM \perp JN</math>,<math>JN \perp KP</math> , <math>KP \perp LQ</math> și <math>LQ \perp IM</math>.Dar <math>AC \not= BD</math> , deci <math>I</math>,<math>M</math> și <math>K<math>M</math> sunt necoliniare ,așadar <math>IM \parallel KP</math> , și analog <math>JN \parallel LQ</math>.Notând cu <math>X</math>,<math>Y</math>,<math>Z</math>,<math>W</math> intersecțiile perechilor de drepte <math>IM</math> și <math>JN</math>,<math>JN</math> și <math>KP</math>,<math>KP</math> și <math>LQ</math>,<math>LQ</math> și <math>IM</math> ,din cele de mai înaite rezultă că <math>XYZW</math> este dreptunghi.

4024 - Matprod

2023-04-28T22:17:01Z

Alexandra Leș: Pagină nouă: == Cerinţa == Se consideră o matrice pătratică '''A=(ai,j)'''de ordin '''n''', elementele sale fiind cifre în baza '''10'''. Pentru fiecare element ai,j al matricei definim drumul de la elementul a1,1 la elementul ai,j ca fiind format din elementele: '''a1,1, a2,1, …, ai,1, ai,2, ai,3, …, ai,j'''. Pentru fiecare element '''ai,j''' al matricei, se cere să se calculeze suma produselor oricăror două elemente situate pe drumul de la elementul '''a1,1''' la elementul '...

== Cerinţa ==
Se consideră o matrice pătratică '''A=(ai,j)'''de ordin '''n''', elementele sale fiind cifre în baza '''10'''. Pentru fiecare element ai,j al matricei definim drumul de la elementul a1,1 la elementul ai,j ca fiind format din elementele: '''a1,1, a2,1, …, ai,1, ai,2, ai,3, …, ai,j'''. Pentru fiecare element '''ai,j''' al matricei, se cere să se calculeze suma produselor oricăror două elemente situate pe drumul de la elementul '''a1,1''' la elementul '''ai,j'''.
== Date de intrare ==
Fișierul de intrare '''matprod.in''' conține pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' cifre separate prin spaţiu, reprezentând elementele matricei '''A'''.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fişierul de ieşire '''matprod.out''' se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând va conţine pe primele '''n''' linii câte '''n''' numere naturale separate prin spaţiu, reprezentând suma cerută pentru fiecare element al matricei.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 2 &les; n &les; 1000
* elementele matricei A sunt cifre
== Exemplu ==
; matprod.in
: 3
: 1 2 3
: 4 5 0
: 9 3 7
; matprod.out
: Datele sunt introduse corect.
: 0 2 11
: 4 29 29
: 49 91 210
== Explicație ==
De exemplu, pentru elementul '''a3,2''', drumul este format din '''1, 4, 9, 3''', iar suma este '''1•4+1•9+1•3+4•9+4•3+9•3=91'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>

def validare_matrice(matrice):
n = len(matrice)
# Verificăm dacă matricea este patratică și dacă fiecare element este un numar întreg pozitiv
for i in range(n):
if len(matrice[i]) != n:
return False
for j in range(n):
if not matrice[i][j].isdigit():
return False
matrice[i][j] = int(matrice[i][j])
return True

def calculeaza_suma_produselor(matrice):
n = len(matrice)
# Inițializăm două matrici pentru a calcula sumele și produsele
s = [[0 for j in range(n)] for i in range(n)]
b = [[0 for j in range(n)] for i in range(n)]

# Calculăm sumele parțiale ale matricei
s[0][0] = matrice[0][0]
for i in range(1, n):
s[i][0] = s[i-1][0] + matrice[i][0]
for j in range(1, n):
s[0][j] = s[0][j-1] + matrice[0][j]
for i in range(1, n):
for j in range(1, n):
s[i][j] = s[i][j-1] + s[i-1][j] - s[i-1][j-1] + matrice[i][j]

# Calculăm suma produselor pentru fiecare element al matricei
b[0][0] = 0
for i in range(1, n):
b[i][0] = b[i-1][0] + s[i-1][0] * matrice[i][0]
for j in range(1, n):
b[0][j] = b[0][j-1] + s[0][j-1] * matrice[0][j]
for i in range(1, n):
for j in range(1, n):
b[i][j] = b[i][j-1] + (s[i][j-1] - s[i-1][j-1] + s[i-1][0]) * matrice[i][j]

return b

if __name__ == '__main__':
# Citim datele de intrare din fișier
with open('matprod.in', 'r') as f:
n = int(f.readline())
matrice = [f.readline().split() for _ in range(n)]

# Validăm matricea
if not validare_matrice(matrice):
# Dacă matricea nu este validă, afișăm o eroare in fișierul de ieșire și ieșim din program
with open('matprod.out', 'w') as f:
f.write("Datele nu corespund restricțiilor impuse.")
else:
# Daca matricea este validă, calculăm suma produselor și o afisam în fișierul de ieșire
rezultat = calculeaza_suma_produselor(matrice)

with open('matprod.out', 'w') as f:
f.write("Datele sunt introduse corect.\n")
for i in range(n):
f.write(' '.join(str(x) for x in rezultat[i]) + '\n')

</syntaxhighlight>

1749 - Zona 4

2023-04-28T21:35:49Z

Alexandra Leș:

== Enunț ==
Considerăm o matrice pătratică cu '''N''' linii și '''N''' coloane. În această matrice sunt definite '''4''' zone: 

'''zona 1''', formată din elementele situate strict deasupra diagonalei principale și strict deasupra diagonalei secundare; 
'''zona 2''', formată din elementele situate strict deasupra diagonalei principale și strict sub diagonala secundară; 
'''zona 3''', formată din elementele situate strict sub diagonala principală și strict sub diagonala secundară; 
'''zona 4''', formată din elementele situate strict sub diagonala principală și strict deasupra diagonalei secundare; 
== Cerinţa ==
Se dă o matrice pătratică și un număr natural '''Z''', reprezentând o zonă din matrice. Să se determine suma elementelor din zona '''Z'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''N Z''', iar apoi '''N*N''' numere naturale, reprezentând elementele matricei.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou numărul '''S''', reprezentând suma elementelor din zona '''Z''' a matricei.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; N &les; 200
* 1 &les; Z &les; 4
*elementele matricei vor fi mai mici decât 1000
== Exemplu ==
; Intrare
: 5 2
: 7 4 8 5 10
: 7 7 10 2 2
: 1 2 8 8 4
: 9 9 5 3 2
: 3 6 7 1 7
; Ieșire
: Datele sunt introduse corect.
: 16
== Explicație ==
Elementele din zona '''2''' sunt '''2 8 4 2''', cu suma '''16'''.

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

def validare_matrice(matrice):
n = len(matrice)
# Verificăm dacă matricea este pătratică
for linie in matrice:
if len(linie) != n:
return False
# Verificăm dacă elementele matricei sunt mai mici decât 1000
for i in range(n):
for j in range(n):
if matrice[i][j] >= 1000:
return False
return True

def suma_zona(matrice, z):
n = len(matrice) # dimensiunea matricei

s = 0 # suma inițială este 0

# pentru fiecare zonă, adăugăm elementele corespunzătoare la suma
if z == 1:
# Zona 1 este triunghiulară și se află sub diagonala principală
for i in range(n):
for j in range(n):
if i < j and i + j < n: # condiția pentru a fi în zona 1
s += matrice[i][j] # adăugăm elementul la sumă

elif z == 2:
# Zona 2 este triunghiulară și se află deasupra diagonalei principale
for i in range(n):
for j in range(n):
if i < j and i + j > n - 1: # condiția pentru a fi în zona 2
s += matrice[i][j] # adăugăm elementul la sumă

elif z == 3:
# Zona 3 este triunghiulară și se află deasupra diagonalei secundare
for i in range(n):
for j in range(n):
if i > j and i + j > n - 1: # condiția pentru a fi în zona 3
s += matrice[i][j] # adăugăm elementul la sumă

elif z == 4:
# Zona 4 este triunghiulară și se află sub diagonala secundară
for i in range(n):
for j in range(n):
if i > j and i + j < n: # condiția pentru a fi în zona 4
s += matrice[i][j] # adăugăm elementul la sumă

return s # returnăm suma calculată

if __name__ == '__main__':
dimensiune, zona = input().split()
z = int(zona)
matrice = []
for i in range(n):
linie = [int(x) for x in input().split()]
matrice.append(linie)

if validare_matrice(matrice):
s = suma_zona(matrice, z)
print(("Datele sunt introduse corect.\n"))
print(s)
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

1451 - Iceberg

2023-04-28T21:34:57Z

Alexandra Leș: Pagină nouă: == Cerinţa == Se dă o matrice reprezentând o zonă dintr-un ocean ce conține un iceberg; valorile egale cu '''1''' fac parte din iceberg, iar cele egale cu '''0''' reprezintă apă. Se știe că icebergul este înconjurat de apa (nu există nici o valoare de '''1''' pe marginea matricei) și că într-un interval de timp se topesc toate zonele icebergului care au cel puțin doua laturi vecine cu apa. Determinați și afișați cate intervale de timp sunt necesare ca ice...

== Cerinţa ==
Se dă o matrice reprezentând o zonă dintr-un ocean ce conține un iceberg; valorile egale cu '''1''' fac parte din iceberg, iar cele egale cu '''0''' reprezintă apă.

Se știe că icebergul este înconjurat de apa (nu există nici o valoare de '''1''' pe marginea matricei) și că într-un interval de timp se topesc toate zonele icebergului care au cel puțin doua laturi vecine cu apa.

Determinați și afișați cate intervale de timp sunt necesare ca icebergul să se topească în întregime. De asemenea, afișați pentru fiecare interval de timp câte poziții de gheață are icebergul la începutul intervalului.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi o matrice de '''n''' linii și '''n''' coloane reprezentând zona icebergului.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou numărul '''t''' reprezentând numărul de intervale de timp și '''t''' numere naturale reprezentând suprafața ghețarului la începutul fiecărui interval.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; N &les; 31
* Elementele de pe marginile matricii sunt tot timpul 0
== Exemplu ==
; Intrare
: 7
: 0 0 0 0 0 0 0
: 0 1 1 1 1 1 0
: 0 0 1 1 1 0 0
: 0 0 1 1 1 0 0
: 0 1 1 1 1 1 0
: 0 0 0 0 0 0 0
: 0 0 0 0 0 0 0
; Ieșire
: Datele sunt introduse corect.
: 4
: 16
: 12
: 8
: 2
== Explicație ==

După primul interval de timp ghețarul arată astfel: 

0 0 0 0 0 0 0 
0 0 1 1 1 0 0 
0 0 1 1 1 0 0 
0 0 1 1 1 0 0 
0 0 1 1 1 0 0 
0 0 0 0 0 0 0 

După cel de-al doilea interval de timp ghețarul arată astfel: 

0 0 0 0 0 0 0 
0 0 0 1 0 0 0 
0 0 1 1 1 0 0 
0 0 1 1 1 0 0 
0 0 0 1 0 0 0 
0 0 0 0 0 0 0 

După cel de-al treilea interval de timp ghețarul arată astfel: 

0 0 0 0 0 0 0 
0 0 0 0 0 0 0 
0 0 0 1 0 0 0 
0 0 0 1 0 0 0 
0 0 0 0 0 0 0 
0 0 0 0 0 0 0 

iar la pasul următor se topește de în întregime. 

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

def validare_matrice(matrice):
n = len(matrice)
# verificăm dacă matricea este pătratică și are dimensiunea între 1 și 31
if not all(len(row) == n for row in matrice) or n < 1 or n > 31:
return False
# verificăm dacă marginile matricei conțin doar valori de 0
if not all(matrice[0][j] == 0 and matrice[n-1][j] == 0 and matrice[i][0] == 0 and matrice[i][n-1] == 0
for i in range(n) for j in range(n)):
return False
# verificăm dacă matricea conține doar valori de 0 și 1
if not all(val in [0, 1] for row in matrice for val in row):
return False
# verificăm dacă icebergul este înconjurat de apă
for i in range(1, n-1):
for j in range(1, n-1):
if matrice[i][j] == 1 and all(matrice[i+di][j+dj] == 0 for di, dj in [(0,1), (1,0), (0,-1), (-1,0)]):
return False
return True

def topire_iceberguri(matrice):
n = len(matrice)
S = sum(row.count(1) for row in matrice) # calculăm inițial numărul de celule din iceberg
v = [S] # adăugăm numărul inițial de celule în lista de soluții
while S > 0: # repetăm până când icebergul a fost complet topit
for i in range(1, n-1):
for j in range(1, n-1):
if matrice[i][j] == 1: # dacă celula este o parte din iceberg
contor = 0
if matrice[i-1][j] == 0: contor += 1 # dacă celula de sus este apă
if matrice[i+1][j] == 0: contor += 1 # dacă celula de jos este apă
if matrice[i][j-1] == 0: contor += 1 # dacă celula din stânga este apă
if matrice[i][j+1] == 0: contor += 1 # dacă celula din dreapta este apă
if contor >= 2: # dacă icebergul are mai mult de o celulă de apă învecinată
S -= 1 # scădem numărul de celule din iceberg
matrice[i][j] = 2 # marcam celula curenta ca fiind topita
v.append(S) # adăugăm numărul de celule din iceberg în lista de soluții
for i in range(1, n-1):
for j in range(1, n-1):
if matrice[i][j] == 2:
matrice[i][j] = 0 # resetăm celulele topite la valoarea de apă
return v

if __name__ == '__main__':
# citim matricea de la tastatură
n = int(input())
matrice = []
for i in range(n):
linie = list(map(int, input().split()))
matrice.append(linie)

# validăm matricea
if not validare_matrice(matrice):
print("Datele nu corespund restricțiilor impuse.")
else:
solutie = topire_iceberguri(matrice)
print("Datele sunt introduse corect.")
print(len(solutie)-1)
for t in solutie[:-1]:
print(t)

</syntaxhighlight>

1749 - Zona 4

2023-04-28T20:54:43Z

Alexandra Leș: Pagină nouă: == Enunț == Considerăm o matrice pătratică cu '''N''' linii și '''N''' coloane. În această matrice sunt definite '''4''' zone: '''zona 1''', formată din elementele situate strict deasupra diagonalei principale și strict deasupra diagonalei secundare; '''zona 2''', formată din elementele situate strict deasupra diagonalei principale și strict sub diagonala secundară; '''zona 3''', formată din elementele situate strict sub diagonala principală și strict sub diag...

== Enunț ==
Considerăm o matrice pătratică cu '''N''' linii și '''N''' coloane. În această matrice sunt definite '''4''' zone:

'''zona 1''', formată din elementele situate strict deasupra diagonalei principale și strict deasupra diagonalei secundare;
'''zona 2''', formată din elementele situate strict deasupra diagonalei principale și strict sub diagonala secundară;
'''zona 3''', formată din elementele situate strict sub diagonala principală și strict sub diagonala secundară;
'''zona 4''', formată din elementele situate strict sub diagonala principală și strict deasupra diagonalei secundare;
== Cerinţa ==
Se dă o matrice pătratică și un număr natural '''Z''', reprezentând o zonă din matrice. Să se determine suma elementelor din zona '''Z'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''N Z''', iar apoi '''N*N''' numere naturale, reprezentând elementele matricei.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou numărul '''S''', reprezentând suma elementelor din zona '''Z''' a matricei.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; N &les; 200
* 1 &les; Z &les; 4
*elementele matricei vor fi mai mici decât 1000
== Exemplu ==
; Intrare
: 5 2
: 7 4 8 5 10
: 7 7 10 2 2
: 1 2 8 8 4
: 9 9 5 3 2
: 3 6 7 1 7
; Ieșire
: Datele sunt introduse corect.
: 16
== Explicație ==
Elementele din zona '''2''' sunt '''2 8 4 2''', cu suma '''16'''.

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

def validare_matrice(matrice):
n = len(matrice)
# Verificăm dacă matricea este pătratică
for linie in matrice:
if len(linie) != n:
return False
# Verificăm dacă elementele matricei sunt mai mici decât 1000
for i in range(n):
for j in range(n):
if matrice[i][j] >= 1000:
return False
return True

def suma_zona(matrice, z):
n = len(matrice) # dimensiunea matricei

s = 0 # suma inițială este 0

# pentru fiecare zonă, adăugăm elementele corespunzătoare la suma
if z == 1:
# Zona 1 este triunghiulară și se află sub diagonala principală
for i in range(n):
for j in range(n):
if i < j and i + j < n: # condiția pentru a fi în zona 1
s += matrice[i][j] # adăugăm elementul la sumă

elif z == 2:
# Zona 2 este triunghiulară și se află deasupra diagonalei principale
for i in range(n):
for j in range(n):
if i < j and i + j > n - 1: # condiția pentru a fi în zona 2
s += matrice[i][j] # adăugăm elementul la sumă

elif z == 3:
# Zona 3 este triunghiulară și se află deasupra diagonalei secundare
for i in range(n):
for j in range(n):
if i > j and i + j > n - 1: # condiția pentru a fi în zona 3
s += matrice[i][j] # adăugăm elementul la sumă

elif z == 4:
# Zona 4 este triunghiulară și se află sub diagonala secundară
for i in range(n):
for j in range(n):
if i > j and i + j < n: # condiția pentru a fi în zona 4
s += matrice[i][j] # adăugăm elementul la sumă

return s # returnăm suma calculată

if __name__ == '__main__':
dimensiune, zona = input().split()
z = int(zona)
matrice = []
for i in range(n):
linie = [int(x) for x in input().split()]
matrice.append(linie)

if validare_matrice(matrice):
s = suma_zona(matrice, z)
print(("Datele sunt introduse corect.\n"))
print(s)
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

0234 - Med Poz

2023-04-28T13:01:50Z

Alexandra Leș:

== Enunț ==
Se consideră un tablou bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere intregi din intervalul '''[-100,100]'''.
== Cerinţa ==
Să se determine media aritmetică a elementelor strict pozitive din matrice, care sunt situate sub diagonala principală.
== Date de intrare ==
Fişierul de intrare '''medpoz.in''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fişierul de ieşire '''medpoz.out''' se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou va conţine un singur număr, reprezentând valoarea cerută.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 2 &les; n &les; 20
* dacă în matrice nu există elemente strict pozitive, situate sub diagonala principală, se va afișa mesajul '''NU EXISTA''';
* media se va afişa cu exact trei zecimale, fără rotunjire;
== Exemplu ==
; medpoz.in
: 4
: -1 2 4 5
: 0 6 3 1
: 2 4 2 0
: 3 -5 1 -3
; medpoz.out
: Datele sunt introduse corect.
: 2.500
== Explicație ==
Valorile strict pozitive situate sub diagonala principală sunt '''2''', '''4''', '''3''' şi '''1''', iar media lor aritmetică este '''2.5'''. Se va afişa cu trei zecimale, adică '''2.500'''
== Rezolvare ==
<syntaxhighlight lang="python" line>

def validare_date(n: int, a: list[list[int]]) -> bool:
# Verificare dimensiunea matricei
if not (2 <= n <= 20):
return False
# Verificare interval valori elemente
for i in range(n):
for j in range(n):
if not (-100 <= a[i][j] <= 100):
return False
return True

def media_aritmetica_pozitive_sub_diagonala(n: int, a: list[list[int]]) -> float:
suma_pozitive_sub_diagonala = 0
numar_elemente_pozitive_sub_diagonala = 0
# Parcurgere elemente sub diagonala principală
for i in range(1, n):
for j in range(i):
# Dacă elementul este strict pozitiv, se adună la suma S
if a[i][j] > 0:
suma_pozitive_sub_diagonala += a[i][j]
numar_elemente_pozitive_sub_diagonala += 1
# Daca nu s-au găsit elemente pozitive sub diagonală, se returnează None
if numar_elemente_pozitive_sub_diagonala == 0:
return None
# Altfel, se calculează și se returnează media aritmetică
else:
return suma_pozitive_sub_diagonala / numar_elemente_pozitive_sub_diagonala

if __name__ == '__main__':
# Citire date de intrare
with open('medpoz.in', 'r') as fin:
n = int(fin.readline())
a = []
for i in range(n):
linie = list(map(int, fin.readline().split()))
a.append(linie)
# Verificare date de intrare
if not validare_date(n, a):
with open('medpoz.out', 'w') as fout:
fout.write("Datele nu corespund restricțiilor impuse.")
else:
# Calcul și afișare rezultat
rezultat = media_aritmetica_pozitive_sub_diagonala(n, a)
if rezultat is None:
print("NU EXISTA")
else:
with open('medpoz.out', 'w') as fout:
fout.write("Datele sunt introduse corect.\n")
fout.write(f"{rezultat:.3f}")

</syntaxhighlight>

3483 - Pct

2023-04-28T12:52:37Z

Alexandra Leș: Pagină nouă: == Cerinţa == Se dau '''n''' puncte distincte în plan, de coordonate întregi. Aflați numărul maxim de puncte aflate în interiorul sau pe laturile unui pătrat de latură '''k''', având vârfurile de coordonate întregi și laturile paralele cu axele de coordonate. == Date de intrare == Fișierul de intrare '''pct.in''' conține pe prima linie numerele '''n''' și '''k''', iar pe a doua linie '''n''' perechi de numere întregi reprezentând coordonatele punctelor, separ...

== Cerinţa ==
Se dau '''n''' puncte distincte în plan, de coordonate întregi. Aflați numărul maxim de puncte aflate în interiorul sau pe laturile unui pătrat de latură '''k''', având vârfurile de coordonate întregi și laturile paralele cu axele de coordonate.
== Date de intrare ==
Fișierul de intrare '''pct.in''' conține pe prima linie numerele '''n''' și '''k''', iar pe a doua linie '''n''' perechi de numere întregi reprezentând coordonatele punctelor, separate prin spații.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fişierul de ieşire '''pct.out''' se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou va conţine numărul maxim de puncte situate în interiorul sau pe laturile unui pătrat de latură k.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 100.000
* 2 &les; k &les; 1000
*coordonatele punctelor sunt cuprinse între 0 și 1000, inclusiv
== Exemplu ==
; pct.in
: 3 2
: 1 1
: 1 0
: 3 4
; pct.out
: Datele sunt introduse corect.
: 2
== Explicație ==
Se poate alege pătratul de latură '''2''', având vârful stânga-jos de coordonate '''(0,0)'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>

#Funcție care verifică dacă datele de intrare sunt valide, conform restricțiilor problemei.
def validare(n, k, puncte):

if not (1 <= n <= 100000): # n trebuie să fie între 1 și 100000
return False
if not (2 <= k <= 1000): # k trebuie să fie între 2 și 1000
return False
for x, y in puncte: # fiecare punct trebuie să aibă coordonate între 0 și 1000
if not (0 <= x <= 1000 and 0 <= y <= 1000):
return False
return True

#Funcție care află numărul maxim de puncte situate în interiorul sau pe laturile unui pătrat de latură k.
def rezolvare(n, k, puncte):

a = [[False] * 1002 for _ in range(1002)] # matricea a reține dacă există puncte la coordonatele (i, j)
sp = [[0] * 1002 for _ in range(1002)] # matricea sp reține suma punctelor dintr-un dreptunghi format de (1, 1) și (i, j)
lin = col = 0 # variabilele lin și col rețin coordonatele maxime ale punctelor

# parcurgerea listei de puncte
for x, y in puncte:
a[x + 1][y + 1] = True # marchează existența punctului la coordonatele (x+1, y+1)

if lin < x:
lin = x # actualizează coordonata maximă pe linii

if col < y:
col = y # actualizează coordonata maximă pe coloane

# parcurgerea matricii sp și calcularea sumelor
for i in range(1, lin+1):
for j in range(1, col+1):
sp[i][j] = sp[i-1][j] + sp[i][j-1] - sp[i-1][j-1] + a[i][j]

maxi = 0 # variabila maxi reține numărul maxim de puncte găsit până acum

# parcurgerea matricii sp și găsirea numărului maxim de puncte
for i in range(1, lin+1):
for j in range(1, col+1):
linie_dr = i + k
coloana_dr = j + k
if linie_dr <= lin and coloana_dr <= col:
puncte = sp[linie_dr][coloana_dr] - sp[linie_dr][j-1] - sp[i-1][coloana_dr] + sp[i-1][j-1]
if maxi < puncte:
maxi = puncte

return maxi

#Funcția principală
if __name__ == '__main__':
with open('pct.in', 'r') as f:

n, k = map(int, f.readline().split())
puncte = [tuple(map(int, linie.split())) for linie in f.readlines()]

if validare(n, k, puncte):
rezultat = rezolvare(n, k, puncte)

with open('pct.out', 'w') as f:
f.write('Datele sunt introduse corect.\n')
f.write(str(rezultat))
else:
with open('pct.out', 'w') as f:
f.write('Datele nu corespund restricțiilor impuse.\n')

</syntaxhighlight>

1008 - Spirala 1

2023-04-26T19:22:51Z

Alexandra Leș:

== Cerinţa ==
Se dau '''n''' numere naturale, un '''n''' este un pătrat perfect. Să se construiască în memorie o matrice pătratică cu toate cele '''n''' numere, în spirală, în sens invers acelor de ceas astfel: pe prima coloană, începând cu linia '''1''', se vor trece primele elemente din şir (de sus în jos), apoi pe ultima linie, începând de la prima coloană până la ultima (de la stânga la dreapta), apoi pe ultima coloană, de la ultima linie la prima (de jos în sus), apoi pe prima linie, de la ultima coloană la prima (de la dreapta la stânga) şamd.
== Date de intrare ==
Fișierul de intrare '''spirala1.in''' conține pe prima linie numărul '''n''', iar pe următoarea linie cele '''n''' numere.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fişierul de ieşire '''spirala1.out''' se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând va conţine matricea construită, câte o linie a matricei pe o linie a fişierului, elementele fiecărei linii fiind separate prin exact un spaţiu.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 10000
* numerele date vor fi mai mici decât 1000
== Exemplu ==
; spirala1.in
: 9
: 2 6 7 3 7 1 7 1 5
; spirala1.out
: Datele sunt introduse corect.
: 2 1 7
: 6 5 1
: 7 3 7

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

def validare(n: int, lst: list[int]) -> bool:

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

if any(num >= 1000 for num in lst):
return False

if int(n ** 0.5) ** 2 != n:
return False

return True

def construieste_matrice_spirala(n: int, lst: list[int]) -> list[list[int]]:

n = int(n ** 0.5)
matrice = [[0] * n for _ in range(n)]

for k in range(1, (n + 1) // 2 + 1):
for i in range(k - 1, n - k + 1):
matrice[i][k - 1] = lst.pop(0)

for j in range(k, n - k + 1):
matrice[n - k][j] = lst.pop(0)

for i in range(n - k - 1, k - 2, -1):
matrice[i][n - k] = lst.pop(0)

for j in range(n - k - 1, k - 1, -1):
matrice[k - 1][j] = lst.pop(0)

return matrice

if __name__ == "__main__":
with open("spirala1.in", "r") as fin:
n = int(fin.readline().strip())
lst = list(map(int, fin.readline().split()))

if validare(n, lst):
matrice = construieste_matrice_spirala(n, lst)
with open("spirala1.out", "w") as fout:
fout.write("Datele sunt introduse corect.\n")
for linie in matrice:
fout.write(" ".join(map(str, linie)) + "\n")

else:
with open("spirala1.out", "w") as fout:
fout.write("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicație rezolvare ==
Acest cod citește datele de intrare din fișierul "spirala1.in" si construiește o matrice pătratică cu toate cele n numere, în spirală, în sens invers acelor de ceas. Mai exact, citim numarul "n" , care reprezintă numarul de elemente din matrice, iar apoi construim o matrice de dimensiune "n x n" cu ajutorul unui for loop care trece de la exteriorul spre interiorul matricei. În interiorul loop-ului for, se citesc elementele matricei în funcție de poziția curentă a loop-ului si pozițiile pe care trebuie sa le aibă fiecare element in matrice. Ulterior, matricea construită este scrisă in fișierul "spirala1.out".

1008 - Spirala 1

2023-04-26T19:18:11Z

Alexandra Leș: Pagină nouă: == Cerinţa == Se dau '''n''' numere naturale, un '''n''' este un pătrat perfect. Să se construiască în memorie o matrice pătratică cu toate cele '''n''' numere, în spirală, în sens invers acelor de ceas astfel: pe prima coloană, începând cu linia '''1''', se vor trece primele elemente din şir (de sus în jos), apoi pe ultima linie, începând de la prima coloană până la ultima (de la stânga la dreapta), apoi pe ultima coloană, de la ultima linie la prima (d...

== Cerinţa ==
Se dau '''n''' numere naturale, un '''n''' este un pătrat perfect. Să se construiască în memorie o matrice pătratică cu toate cele '''n''' numere, în spirală, în sens invers acelor de ceas astfel: pe prima coloană, începând cu linia '''1''', se vor trece primele elemente din şir (de sus în jos), apoi pe ultima linie, începând de la prima coloană până la ultima (de la stânga la dreapta), apoi pe ultima coloană, de la ultima linie la prima (de jos în sus), apoi pe prima linie, de la ultima coloană la prima (de la dreapta la stânga) şamd.
== Date de intrare ==
Fișierul de intrare '''spirala1.in''' conține pe prima linie numărul '''n''', iar pe următoarea linie cele '''n''' numere.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fişierul de ieşire '''spirala1.out''' se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând va conţine matricea construită, câte o linie a matricei pe o linie a fişierului, elementele fiecărei linii fiind separate prin exact un spaţiu.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 10000
* numerele date vor fi mai mici decât 1000
== Exemplu ==
; spirala1.in
: 9
: 2 6 7 3 7 1 7 1 5
; spirala1.out
: Datele sunt introduse corect.
: 2 1 7
: 6 5 1
: 7 3 7

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

def validare(n: int, lst: list[int]) -> bool:

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

if any(num >= 1000 for num in lst):
return False

if int(n ** 0.5) ** 2 != n:
return False

return True

def construieste_matrice_spirala(n: int, lst: list[int]) -> list[list[int]]:

n = int(n ** 0.5)
matrice = [[0] * n for _ in range(n)]

for k in range(1, (n + 1) // 2 + 1):
for i in range(k - 1, n - k + 1):
matrice[i][k - 1] = lst.pop(0)

for j in range(k, n - k + 1):
matrice[n - k][j] = lst.pop(0)

for i in range(n - k - 1, k - 2, -1):
matrice[i][n - k] = lst.pop(0)

for j in range(n - k - 1, k - 1, -1):
matrice[k - 1][j] = lst.pop(0)

return matrice

if __name__ == "__main__":
with open("spirala1.in", "r") as fin:
n = int(fin.readline().strip())
lst = list(map(int, fin.readline().split()))

if validare(n, lst):
matrice = construieste_matrice_spirala(n, lst)
with open("spirala1.out", "w") as fout:
fout.write("Datele sunt introduse corect.\n")
for linie in matrice:
fout.write(" ".join(map(str, linie)) + "\n")

else:
with open("spirala1.out", "w") as fout:
fout.write("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
== Explicații rezolvare ==
Acest cod citeste datele de intrare din fisierul "spirala1.in" si construieste o matrice pătratică cu toate cele n numere, în spirală, în sens invers acelor de ceas astfel: pe prima coloană, începând cu linia 1, se vor trece primele elemente din şir (de sus în jos), apoi pe ultima linie, începând de la prima coloană până la ultima (de la stânga la dreapta), apoi pe ultima coloană, de la ultima linie la prima (de jos în sus), apoi pe prima linie, de la ultima coloană la prima (de la dreapta la stânga) şamd. Mai exact, citim numarul "n" de la intrare, care reprezinta numarul de elemente din matrice, iar apoi construim o matrice de dimensiune "n x n" cu ajutorul unui for loop care trece de la exteriorul spre interiorul matricei. In interiorul loop-ului for, se citesc elementele matricei in functie de pozitia curenta a loop-ului si pozitiile pe care trebuie sa le aiba fiecare element in matrice. Ulterior, matricea construita este scrisa in fisierul "spirala1.out".

0961 - Criptare

2023-04-26T18:50:23Z

Alexandra Leș: Pagină nouă: == Cerinţa == După dezastrul cauzat de hackerul Gigel ( #Suprasolicitare ), administratorul rețelei s-a decis să ia măsuri. Acesta este responsabil de o rețea cu '''n*n''' calculatoare dispuse sub forma unei matrice cu '''n''' linii și '''n''' coloane, în care fiecare calculator este conectat la calculatoarele adiacente(sus, dreapta, stânga, jos), fiecare calculator de pe rândul '''n''' este conectat la calculatorul de pe rândul '''1''' și aceeași coloană, și...

== Cerinţa ==
După dezastrul cauzat de hackerul Gigel ( #Suprasolicitare ), administratorul rețelei s-a decis să ia măsuri.

Acesta este responsabil de o rețea cu '''n*n''' calculatoare dispuse sub forma unei matrice cu '''n''' linii și '''n''' coloane, în care fiecare calculator este conectat la calculatoarele adiacente(sus, dreapta, stânga, jos), fiecare calculator de pe rândul '''n''' este conectat la calculatorul de pe rândul '''1''' și aceeași coloană, și fiecare calculator de pe de pe coloana '''n''' este conectat la cel de pe coloana '''1''' și aceeași linie.

În această rețea, există calculatoare criptate, care nu pot primi pachete de date corupte. Calculatoarele necriptate pot primi pachete corupte dar nu le pot prelucra. Comportamentul lor este unul aparte: când un calculator necriptat primește un pachet de date, îl transmite mai departe la următorul calculator pe aceeași direcție până întâlnesc un calculator criptat. Calculatorul care conține pachetul de date corupt poate primi apoi o comandă prin care să îl transmită mai departe în altă direcție.

Rețeaua devine suprasolicitată dacă pachetul corupt ajunge pe o linie sau coloană care conține numai calculatoare necriptate, putându-se astfel să se transmită la infinit.

Hackerul Gigel a profitat de această slăbiciune a rețelei și a reușit dea comenzi prin terminalele calculatoarelor astfel încât pachetul de date să se transmită la infinit între ele, suprasolicitând rețeaua, (vezi problema #Suprasolicitare ).

Administratorul rețelei a decis să cripteze suficiente calculatoare pentru a evita orice posibilitate de suprasolicitare a rețelei. Deoarece criptarea unui singur calculator ia mult timp, administratorul dorește să afle numărul minim de calculatoare care trebuie criptate astfel încât hackerul Gigel să nu se mai poată distra cu rețeaua.
== Date de intrare ==
Fișierul de intrare '''criptare.in''' conține pe prima linie numărul n, urmat de n rânduri cu n numere. Valoarea 1 reprezentă un calculator deja criptat, iar valoarea 0 un calculator necriptat.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fişierul de ieşire '''criptare.out''' se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând va conţine numărul Sol, reprezentând numărul minim de calculatoare ce necesită a fi criptate, iar pe următoarele Sol rânduri o pereche de numere x și y reprezentând că pe linia x și coloana y calculatorul trebuie criptat.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 1000
* Orice soluție cu număr minim de calculatoare criptate este corectă.
* Pentru afișarea doar a lui Sol, se acordă 20% din punctaj
* Pentru teste în valoare de 40 de puncte, n ≤ 10.
== Exemplu ==
; criptare.in
: 5
: 0 0 0 0 0
: 1 1 1 1 1
: 1 0 1 1 0
: 0 1 0 1 0
: 0 0 0 0 0
; criptare.out
: Datele sunt introduse corect.
: 2
: 1 1
: 5 3
== Explicație ==
După criptarea calculatoarelor '''(1,1)''' și '''(5,3)''', hackerul Gigel nu mai poate trimite pachetul la infinit pe linia '''1''', respectiv linia '''5'''
== Rezolvare ==
<syntaxhighlight lang="python" line>

# Funcție care verifică dacă datele de intrare sunt valide
def validare_date(n: int, a: list[list[int]]) -> bool:

if n < 1 or n > 1000:
return False
for i in range(n):
if len(a[i]) != n:
return False
for j in range(n):
if a[i][j] not in [0, 1]:
return False
return True

# Funcție care calculează numărul minim de calculatoare care trebuie criptate astfel încât hackerul Gigel să nu se mai
# se poată distra cu rețeaua.
def criptare(n: int, a: list[list[int]]) -> tuple[int, list[tuple[int, int]]]:
L, C = [], []
for i in range(n):
linie_criptata = any(a[i][j] for j in range(n)) # verifică dacă există cel puțin un element 1 în linia i
coloana_criptata = any(a[j][i] for j in range(n)) # verifică dacă există cel puțin un element 1 în coloana i
if not linie_criptata:
L.append(i + 1) # adaugă linia i+1 la lista L dacă aceasta nu are niciun element 1
if not coloana_criptata:
C.append(i + 1) # adaugă coloana i+1 la lista C dacă aceasta nu are niciun element 1
numar_calculatoare_criptate = max(len(L), len(C)) # determină numărul minim de calculatoare care trebuie criptate
puncte_criptare = [(L[i], C[i]) for i in range(min(len(L), len(C)))] # perechile (linie, coloană) pentru primele L sau C elemente
if len(L) > len(C):
for i in range(len(C), len(L)):
puncte_criptare.append((L[i], 1)) # adaugă perechi (linie, 1) pentru fiecare element L care nu are corespondent în C
elif len(C) > len(L):
for i in range(len(L), len(C)):
puncte_criptare.append((1, C[i])) # adaugă perechi (1, coloană) pentru fiecare element C care nu are corespondent în L
return numar_calculatoare_criptate, puncte_criptare

#Programul principal
if __name__ == '__main__':
with open('criptare.in', 'r') as fin:
n = int(fin.readline().strip())
a = [list(map(int, fin.readline().split())) for _ in range(n)]
if validare_date(n, a):
numar_calculatoare_criptate, puncte_criptare = criptare(n, a)
with open('criptare.out', 'w') as fout:
fout.write("Datele sunt introduse corect.\n")
fout.write(str(numar_calculatoare_criptate) + '\n')
for Sol in puncte_criptare:
fout.write(str(Sol[0]) + ' ' + str(Sol[1]) + '\n')
else:
with open('criptare.out', 'w') as fout:
fout.write("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

0210 - Chenar

2023-04-26T18:27:34Z

Alexandra Leș: Pagină nouă: == Enunț == Se consideră tabloul bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere naturale cu cel mult patru cifre fiecare. == Cerinţa == Scrieţi un program care citeşte numărul natural '''n''' şi cele '''n*n''' elemente ale tabloului şi apoi afişează elementele chenarului exterior al tabloului, separate prin câte un spaţiu. Chenarul este parcurs în sensul acelor de ceasornic începând din colţul său stânga-sus. Chenarul este format din p...

== Enunț ==
Se consideră tabloul bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere naturale cu cel mult patru cifre fiecare.
== Cerinţa ==
Scrieţi un program care citeşte numărul natural '''n''' şi cele '''n*n''' elemente ale tabloului şi apoi afişează elementele chenarului exterior al tabloului, separate prin câte un spaţiu. Chenarul este parcurs în sensul acelor de ceasornic începând din colţul său stânga-sus. Chenarul este format din prima şi ultima linie, prima şi ultima coloană a tabloului.
== Date de intrare ==
Fişierul de intrare '''chenar.in''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele tabloului
== Date de ieşire ==
Dacă datele sunt introduse corect,în fişierul de ieşire ''' chenar.out''' se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând va conţine elementele cerute, separate prin câte un spaţiu.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 2 &les; n &les; 23
* elementele tabloului sunt mai mici decât 1000
== Exemplu ==
; chenar.in
: 5
: 1 2 3 4 5
: 6 7 8 9 1
: 2 3 4 5 6
: 7 8 9 1 2
: 3 4 5 6 7
; chenar.out
: Datele sunt introduse corect.
: 1 2 3 4 5 1 6 2 7 6 5 4 3 7 2 6
== Rezolvare ==
<syntaxhighlight lang="python" line>

# Funție care verifică dacă datele de intrare sunt valide conform cerinței.
def validare(n: int, a: list[list[int]]) -> bool:
# Verifică dacă n este între 2 și 23, inclusiv
if n < 2 or n > 23:
return False
# Verifică dacă fiecare element din matricea a este între 0 și 9999, inclusiv
for i in range(n):
for j in range(n):
if a[i][j] < 0 or a[i][j] >= 10000:
return False
return True

# Funcție care returnează elementele chenarului exterior al tabloului, în sensul acelor
# de ceasornic începând din colțul stânga-sus.
def chenar(n: int, a: list[list[int]]) -> list[int]:
# Inițializăm lista rezultat cu elementele din prima linie a matricei a
result = []
for j in range(n):
result.append(a[0][j])
# Adăugăm elementele de pe ultima coloană a matricei a, cu excepția colțului din dreapta sus
for i in range(1, n):
result.append(a[i][n-1])
# Adăugăm elementele de pe ultima linie a matricei a, în ordine inversă
for j in range(n-2, -1, -1):
result.append(a[n-1][j])
# Adăugăm elementele de pe prima coloană a matricei a, cu excepția colțului din stânga sus, în ordine inversă
for i in range(n-2, 0, -1):
result.append(a[i][0])
# Returnăm lista cu elementele chenarului
return result

# Programul principal
if __name__ == '__main__':
# Deschidem fișierele de intrare și de ieșire
with open('chenar.in', 'r') as fin, open('chenar.out', 'w') as fout:
# Citim dimensiunea matricei
n = int(fin.readline().strip())
# Inițializăm matricea a cu datele citite din fișierul de intrare
a = []
for i in range(n):
row = list(map(int, fin.readline().strip().split()))
a.append(row)

# Verificăm dacă datele de intrare sunt valide
if validare(n, a):
# Calculăm elementele chenarului și le scriem în fișierul de ieșire, separate prin spațiu
result = chenar(n, a)
fout.write("Datele sunt introduse corect.\n")
fout.write(' '.join(map(str, result)))
else:
# Scriem mesajul de eroare în fișierul de ieșire
fout.write('Datele nu corespund restricțiilor impuse.')

</syntaxhighlight>

0234 - Med Poz

2023-04-26T18:13:34Z

Alexandra Leș: Pagină nouă: == Enunț == Se consideră un tablou bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere intregi din intervalul '''[-100,100]'''. == Cerinţa == Să se determine media aritmetică a elementelor strict pozitive din matrice, care sunt situate sub diagonala principală. == Date de intrare == Fişierul de intrare '''medpoz.in''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere naturale separate prin spaţii, reprez...

== Enunț ==
Se consideră un tablou bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere intregi din intervalul '''[-100,100]'''.
== Cerinţa ==
Să se determine media aritmetică a elementelor strict pozitive din matrice, care sunt situate sub diagonala principală.
== Date de intrare ==
Fişierul de intrare '''medpoz.in''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fişierul de ieşire '''medpoz.out''' se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând va conţine un singur număr, reprezentând valoarea cerută.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 2 &les; n &les; 20
* dacă în matrice nu există elemente strict pozitive, situate sub diagonala principală, se va afișa mesajul '''NU EXISTA''';
* media se va afişa cu exact trei zecimale, fără rotunjire;
== Exemplu ==
; medpoz.in
: 4
: -1 2 4 5
: 0 6 3 1
: 2 4 2 0
: 3 -5 1 -3
; medpoz.out
: Datele sunt introduse corect.
: 2.500
== Explicație ==
Valorile strict pozitive situate sub diagonala principală sunt '''2''', '''4''', '''3''' şi '''1''', iar media lor aritmetică este '''2.5'''. Se va afişa cu trei zecimale, adică '''2.500'''
== Rezolvare ==
<syntaxhighlight lang="python" line>

def validare_date(n: int, a: list[list[int]]) -> bool:
# Verificare dimensiunea matricei
if not (2 <= n <= 20):
return False
# Verificare interval valori elemente
for i in range(n):
for j in range(n):
if not (-100 <= a[i][j] <= 100):
return False
return True

def media_aritmetica_pozitive_sub_diagonala(n: int, a: list[list[int]]) -> float:
suma_pozitive_sub_diagonala = 0
numar_elemente_pozitive_sub_diagonala = 0
# Parcurgere elemente sub diagonala principală
for i in range(1, n):
for j in range(i):
# Dacă elementul este strict pozitiv, se adună la suma S
if a[i][j] > 0:
suma_pozitive_sub_diagonala += a[i][j]
numar_elemente_pozitive_sub_diagonala += 1
# Daca nu s-au găsit elemente pozitive sub diagonală, se returnează None
if numar_elemente_pozitive_sub_diagonala == 0:
return None
# Altfel, se calculează și se returnează media aritmetică
else:
return suma_pozitive_sub_diagonala / numar_elemente_pozitive_sub_diagonala

if __name__ == '__main__':
# Citire date de intrare
with open('medpoz.in', 'r') as fin:
n = int(fin.readline())
a = []
for i in range(n):
linie = list(map(int, fin.readline().split()))
a.append(linie)
# Verificare date de intrare
if not validare_date(n, a):
with open('medpoz.out', 'w') as fout:
fout.write("Datele nu corespund restricțiilor impuse.")
else:
# Calcul și afișare rezultat
rezultat = media_aritmetica_pozitive_sub_diagonala(n, a)
if rezultat is None:
print("NU EXISTA")
else:
with open('medpoz.out', 'w') as fout:
fout.write("Datele sunt introduse corect.\n")
fout.write(f"{rezultat:.3f}")

</syntaxhighlight>

0223 - Min Cols 1

2023-04-26T17:28:54Z

Alexandra Leș: Pagină nouă: == Enunț == Se consideră un tablou bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere naturale cu cel mult două cifre fiecare. == Cerinţa == Să se determine ultima cifră a produsului elementelor de pe diagonala secundară cu proprietatea că sunt minime pe coloanele lor. == Date de intrare == Fişierul de intrare '''mincols1.in''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere naturale separate prin sp...

== Enunț ==
Se consideră un tablou bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere naturale cu cel mult două cifre fiecare.
== Cerinţa ==
Să se determine ultima cifră a produsului elementelor de pe diagonala secundară cu proprietatea că sunt minime pe coloanele lor.
== Date de intrare ==
Fişierul de intrare '''mincols1.in''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fişierul de ieşire '''mincols1.out''' se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou va conţine un singur număr, reprezentând valoarea cerută.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 2 &les; n &les; 30
* dacă în matrice nu există asemenea elemente, se va afișa mesajul '''NU EXISTA'''
== Exemplu ==
; mincols1.in
: 4
: 3 4 90 10
: 25 2 7 9
: 18 3 10 4
: 3 7 20 3
; mincols1.out
: Datele sunt introduse corect.
: 1
== Explicație ==
Dintre valorile de pe diagonala secundară, sunt minime pe coloanele lor '''7''' şi '''3'''. Produsul lor este '''21''', iar ultima cifră este '''1'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>

# Funcție care verifică dacă datele de intrare respectă condițiile problemei.
def validare(n, a):

if n < 2 or n > 30:
return False
for i in range(n):
for j in range(n):
if a[i][j] < 0 or a[i][j] > 99:
return False
return True

# Funție care determină ultima cifră a produsului elementelor de pe diagonala secundară cu proprietatea că sunt minime pe coloanele lor.
def ultima_cifra_produsului_diag_sec_min_pe_coloane(n, a):

p = 1
exista_minim_pe_coloane = False
for i in range(n):
j = n - i - 1 # indicii elementelor de pe diagonala secundară
minim_pe_coloana = min(a[k][j] for k in range(n))
if a[i][j] == minim_pe_coloana:
exista_minim_pe_coloane = True
p = (p * a[i][j]) % 10
if exista_minim_pe_coloane:
return p
else:
print("NU EXISTA")

if __name__ == "__main__":
# Citim datele de intrare din fișierul "mincols1.in".
with open("mincols1.in") as f:
n = int(f.readline())
a = [list(map(int, f.readline().split())) for _ in range(n)]
# Verificăm dacă datele de intrare sunt valide.
if validare(n, a):
# Apelăm funcția care calculează rezultatul cerut.
rezultat = ultima_cifra_produsului_diag_sec_min_pe_coloane(n, a)
if rezultat is not None:
# Scriem rezultatul în fișierul de ieșire "mincols1.out".
with open("mincols1.out", "w") as g:
g.write("Datele sunt introduse corect.\n")
g.write(str(rezultat))
else:
# Scriem un mesaj de eroare în fișierul de ieșire "mincols1.out".
with open("mincols1.out", "w") as g:
g.write("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

0211 - Spirala

2023-04-26T17:08:54Z

Alexandra Leș: Pagină nouă: == Enunț == Se consideră tabloul bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere naturale cu cel mult patru cifre fiecare. == Cerinţa == Scrieţi un program care citeşte numărul natural '''n''' şi cele '''n*n''' elemente ale tabloului şi apoi afişează pe ecran elementele tabloului, separate prin câte un spaţiu, obţinute prin parcurgerea în spirală în sensul acelor de ceasornic. == Date de intrare == Fişierul de intrare '''spirala.in''' co...

== Enunț ==
Se consideră tabloul bidimensional cu '''n''' linii şi '''n''' coloane ce conţine numere naturale cu cel mult patru cifre fiecare.
== Cerinţa ==
Scrieţi un program care citeşte numărul natural '''n''' şi cele '''n*n''' elemente ale tabloului şi apoi afişează pe ecran elementele tabloului, separate prin câte un spaţiu, obţinute prin parcurgerea în spirală în sensul acelor de ceasornic.
== Date de intrare ==
Fişierul de intrare '''spirala.in''' conţine pe prima linie numărul n, iar pe următoarele n linii câte n numere naturale separate prin spaţii, reprezentând elementele tabloului.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou fişierul de ieşire '''spirala.out''' va conţine pe prima linie elementele cerute, separate prin câte un spaţiu.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 2 &les; n &les; 23
* elementele tabloului sunt mai mici decât 1000
== Exemplu ==
; spirala.in
: 4
: 1 2 3 4
: 5 6 7 8
: 9 10 11 12
: 13 14 15 16
; spirala.out
: Datele sunt introduse corect.
: 1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10
== Rezolvare ==
<syntaxhighlight lang="python" line>

from typing import List

def validare_date(n: int, a: List[List[int]]) -> bool:
# Verificăm dacă n este între 2 și 23
if n < 2 or n > 23:
return False

# Verificăm dacă matricea are n linii și n coloane
if len(a) != n:
return False
for row in a:
if len(row) != n:
return False

# Verificăm dacă toate elementele matricei au cel mult 4 cifre
for row in a:
for elem in row:
if elem >= 10000:
return False

# Toate verificările au trecut, deci matricea este validă
return True

def rezolvare_spirala(n: int, a: List[List[int]]) -> List[int]:
# Inițializăm poziția curentă la colțul din stânga sus
poz_i, poz_j = 0, 0

# Inițializăm direcția de mers
directii = [(0, 1), (1, 0), (0, -1), (-1, 0)]
dir_index = 0

# Inițializăm lista rezultat
rezultat = []

# Parcurgem matricea în spirală
for _ in range(n * n):
# Adăugăm elementul curent în rezultat
rezultat.append(a[poz_i][poz_j])

# Marcam elementul curent ca fiind deja vizitat
a[poz_i][poz_j] = None

# Calculăm următoarea poziție în funcție de direcție
urm_i = poz_i + directii[dir_index][0]
urm_j = poz_j + directii[dir_index][1]

# Dacă următoarea poziție este invalidă sau deja vizitată,
# schimbăm direcția de mers
if (not 0 <= urm_i < n) or (not 0 <= urm_j < n) or (a[urm_i][urm_j] is None):
dir_index = (dir_index + 1) % 4
urm_i = poz_i + directii[dir_index][0]
urm_j = poz_j + directii[dir_index][1]

# Actualizăm poziția curentă
poz_i, poz_j = urm_i, urm_j

# Returnăm lista rezultat
return rezultat

# Funcția principală
if __name__ == "__main__":
# Citim datele de intrare
with open("spirala.in", "r") as fin:
n = int(fin.readline())
a = []
for _ in range(n):
row = list(map(int, fin.readline().split()))
a.append(row)

# Verificăm dacă datele de intrare sunt valide
if not validare_date(n, a):
with open("spirala.out", "w") as fout:
fout.write("Datele nu corespund restricțiilor impuse.")
else :

# Rezolvăm problema
rezultat = rezolvare_spirala(n, a)

# Afișăm rezultatul
with open("spirala.out", "w") as fout:
fout.write("Datele sunt introduse corect.\n")
fout.write(" ".join(str(elem) for elem in rezultat))
fout.write("\n")

</syntaxhighlight>

0782 - Zona 1

2023-04-26T16:51:29Z

Alexandra Leș: Pagină nouă: == Cerinţa == Se dă o matrice pătratică cu '''n''' linii și '''n''' coloane și elemente numere naturale mai mici decât '''1000'''. Să se afișeze în ordine strict crescătoare valorile care apar sub diagonala principală și sub diagonala secundară de cel puţin '''2''' ori. Fiecare valoare se va afişa o singură dată. == Date de intrare == Programul citește de la tastatură numărul '''n''', apoi elementele matricei, linie cu linie. == Date de ieşire == Dacă d...

== Cerinţa ==
Se dă o matrice pătratică cu '''n''' linii și '''n''' coloane și elemente numere naturale mai mici decât '''1000'''. Să se afișeze în ordine strict crescătoare valorile care apar sub diagonala principală și sub diagonala secundară de cel puţin '''2''' ori. Fiecare valoare se va afişa o singură dată.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', apoi elementele matricei, linie cu linie.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou numărul, în ordine strict crescătoare, valorile cerute, separate printr-un spaţiu.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 200
== Exemplu ==
; Intrare
: 6
: 10 8 5 8 4 2
: 6 5 3 1 3 8
: 8 1 4 7 8 8
: 5 1 9 6 6 1
: 8 9 3 2 3 6
: 8 9 3 3 9 6
; Ieșire
: Datele sunt introduse corect.
: 3 9
== Rezolvare ==
<syntaxhighlight lang="python" line>

def validare_date(n, a):
# Verificăm dacă matricea respectă restricția impusă
# și anume să conțină elemente mai mici decât 200.
for i in range(n):
for j in range(n):
if a[i][j] >= 200:
return False
return True

def valorile_sub_diagonala(n, a):
# Parcurgem matricea și adaugăm elementele sub diagonala secundară
# și peste diagonala principală în lista v.
v = []
for i in range(n):
for j in range(n):
if i > j and i + j > n - 1:
v.append(a[i][j])
# Sortăm lista v în ordine crescătoare și căutăm elementele care se repetă și apar de cel puțin 2 ori.
v.sort()
rezultat = []
for i in range(1, len(v)):
if v[i] == v[i-1] and v[i] not in rezultat:
rezultat.append(v[i])
return rezultat

if __name__ == "__main__":
# Citim dimensiunea matricei și elementele acesteia.
n = int(input())
a = []
for i in range(n):
linie = input()
a.append([int(x) for x in linie.split()])
# Verificăm dacă matricea este validă și afișăm valorile care respectă condițiile problemei, în ordine crescătoare.
if not validare_date(n, a):
print("Datele nu corespund restrictiilor impuse.")
else:
rezultat = valorile_sub_diagonala(n, a)
print("Datele sunt introduse corect.")
for x in rezultat:
print(x, end=" ")
print()

</syntaxhighlight>

0729 - Zona

2023-04-26T12:32:29Z

Alexandra Leș: Pagină nouă: == Cerinţa == Se dă o matrice pătratică cu '''n''' linii și '''n''' coloane și elemente numere naturale mai mici decât '''1000'''. Să se afișeze în ordine strict crescătoare valorile situate sub diagonala principală și deasupra diagonalei secundare. Dacă o valoare apare în zona respectivă de mai multe ori, se va afișa o singură dată. == Date de intrare == Programul citește de la tastatură numărul '''n''', apoi elementele matricei, linie cu linie. == Date...

== Cerinţa ==
Se dă o matrice pătratică cu '''n''' linii și '''n''' coloane și elemente numere naturale mai mici decât '''1000'''. Să se afișeze în ordine strict crescătoare valorile situate sub diagonala principală și deasupra diagonalei secundare. Dacă o valoare apare în zona respectivă de mai multe ori, se va afișa o singură dată.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', apoi elementele matricei, linie cu linie.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou,în ordine strict crescătoare, valorile cerute, separate prin spații.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 200
== Exemplu ==
; Intrare
: 6
: 10 8 5 8 4 2
: 6 5 3 1 3 8
: 8 1 4 7 8 8
: 5 1 9 6 6 1
: 8 9 10 1 3 6
: 8 2 3 3 9 6
; Ieșire
: Datele sunt introduse corect.
: 1 5 6 8
== Rezolvare ==
<syntaxhighlight lang="python" line>

# Functia de validare pentru matricea de intrare.
def validare(n: int, a: list[list[int]]) -> bool:

# Verificăm dacă n se află în intervalul specificat
if n < 1 or n > 200:
return False
# Verificăm dacă fiecare element al matricei se află în intervalul [0, 1000)
for i in range(n):
for j in range(n):
if a[i][j] < 0 or a[i][j] >= 1000:
return False
return True

# Funcția care rezolvă problema și returnează valorile cerute.
def rezolva_matrice(n: int, a: list[list[int]]) -> list[int]:
# Inițializăm un vector v de dimensiune 1000, initial cu valori 0
v = [0] * 1000
# Parcurgem matricea și setăm elementele corespunzătoare din v pe 1 dacă se află sub diagonala principală și
# deasupra diagonalei secundare
for i in range(n):
for j in range(n):
if i > j and i + j < n - 1:
v[a[i][j]] = 1
# Inițializam o lista rezultat cu valorile de 0 și apoi adaugăm valorile de 1 din v in ordine crescătoare
rezultat = []
for i in range(1000):
if v[i] == 1:
rezultat.append(i)
return rezultat

# Programul principal
if __name__ == '__main__':
# Citim n și matricea de la tastatură
n = int(input())
a = []
for i in range(n):
a.append(list(map(int, input().split())))

# Verificăm dacă matricea îndeplineste cerințele problemei
if validare(n, a):
# Dacă matricea este validă, rezolvăm problema și afișăm rezultatul
rezultat = rezolva_matrice(n, a)
print("Datele sunt introduse corect.")
print("Valorile cerute sunt:", " ".join(map(str, rezultat)))
else:
# Dacă matricea nu este valida, afișăm un mesaj corespunzator
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

0998 - Matrice 6

2023-04-26T12:12:26Z

Alexandra Leș: Pagină nouă: == Cerinţa == Se consideră o matrice pătratică cu '''n''' linii şi '''n''' coloane şi elemente numere naturale. Să se modifice matricea în felul următor: toate elementele de pe liniile care conţin valoare maximă din matrice vor fi mărite cu valoarea minimă din matrice. == Date de intrare == Fișierul de intrare '''matrice6.in''' conține pe prima linie numărul '''n''', iar următoarele '''n''' linii câte '''n''' numere naturale, reprezentând elementele matrice...

== Cerinţa ==
Se consideră o matrice pătratică cu '''n''' linii şi '''n''' coloane şi elemente numere naturale. Să se modifice matricea în felul următor: toate elementele de pe liniile care conţin valoare maximă din matrice vor fi mărite cu valoarea minimă din matrice.
== Date de intrare ==
Fișierul de intrare '''matrice6.in''' conține pe prima linie numărul '''n''', iar următoarele '''n''' linii câte '''n''' numere naturale, reprezentând elementele matricei.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou matricea modificată, câte o linie a matricei pe o linie a fişierului, elementele fiecărei linii fiind separate prin exact un spaţiu.În cazul contrar,se va afișa în fișier '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 100
* elementele matricei vor fi mai mici decât 1 000 000 000
== Exemplu ==
; matrice6.in
: 4
: 2 5 3 2
: 2 2 4 4
: 3 2 2 2
: 5 3 5 2
; matrice6.out
: Datele sunt introduse corect.
: 4 7 5 4
: 2 2 4 4
: 3 2 2 2
: 7 5 7 4
== Rezolvare ==
<syntaxhighlight lang="python" line>

def validare(n: int, matrice: list[list[int]]) -> bool:
# Verificăm dacă numărul de linii și coloane ale matricei este cel puțin 1 și cel mult 100
if n < 1 or n > 100:
return False

# Verificăm dacă matricea are n linii și n coloane
if len(matrice) != n:
return False
for linie in matrice:
if len(linie) != n:
return False

# Verificăm dacă toate elementele matricei sunt numere naturale mai mici decât 1 000 000 000
for linie in matrice:
for element in linie:
if not isinstance(element, int) or element < 0 or element >= 1000000000:
return False

return True

def rezolvare(n: int, matrice: list[list[int]]) -> list[list[int]]:
# Găsim valoarea maximă și valoarea minimă din matrice
Max = matrice[0][0]
Min = matrice[0][0]
for linie in matrice:
for element in linie:
if element > Max:
Max = element
if element < Min:
Min = element

# Identificăm liniile care conțin valoarea maximă
liniile_maximului = []
for i, linie in enumerate(matrice):
if Max in linie:
liniile_maximului.append(i)

# Adăugăm valoarea minimă la fiecare element de pe liniile identificate anterior
for i in liniile_maximului:
for j in range(n):
matrice[i][j] += Min

return matrice

if __name__ == '__main__':
with open('matrice6.in', 'r') as fin:
n = int(fin.readline())
matrice = [list(map(int, fin.readline().split())) for _ in range(n)]

if validare(n, matrice):
matrice_modificata = rezolvare(n, matrice)
with open('matrice6.out', 'w') as fout:
fout.write("Datele sunt introduse corect.\n")
for linie in matrice_modificata:
fout.write(' '.join(str(element) for element in linie) + '\n')
else:
with open("matrice6.out", "w") as f_out:
fout.write("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

1437 - Fractii 4

2023-04-25T20:38:19Z

Alexandra Leș: Ștergerea conținutului paginii

1590 - Arma 1

2023-04-25T20:30:29Z

Alexandra Leș: Ștergerea conținutului paginii

0081 - Matrice

2023-04-25T16:01:49Z

Alexandra Leș: Pagină nouă: == Cerinţa == Scrieţi un program care citeşte de la tastatură un număr natural '''n''' ( '''1 ≤ n ≤ 20''' ) şi apoi elementele unui tablou bidimensional cu '''n''' linii şi '''n''' coloane, care memorează numere naturale. Programul afişează pe ecran numărul de elemente din tablou care sunt strict mai mari decât toate elementele cu care se învecinează direct (aflate pe aceeaşi linie dar pe o coloană alăturată sau pe aceeaşi coloană dar pe o linie alătu...

== Cerinţa ==
Scrieţi un program care citeşte de la tastatură un număr natural '''n''' ( '''1 ≤ n ≤ 20''' ) şi apoi elementele unui tablou bidimensional cu '''n''' linii şi '''n''' coloane, care memorează numere naturale.
Programul afişează pe ecran numărul de elemente din tablou care sunt strict mai mari decât toate elementele cu care se învecinează direct (aflate pe aceeaşi linie dar pe o coloană alăturată sau pe aceeaşi coloană dar pe o linie alăturată).
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n*n''' numere naturale, separate prin spaţii.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou numărul de elemente din tablou care respectă regula.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 20
* elementele matricei vor fi mai mici decât 1.000.000
== Exemplu ==
; Intrare
: 4
: 1 5 1 1
: 2 1 2 3
: 1 3 4 2
: 2 1 2 1
; Date de ieșire
: Datele sunt introduse corect.
: 5
== Explicație ==
Elementele din matrice care respectă regula sunt: '''5 2 3 4 2'''
== Rezolvare ==
<syntaxhighlight lang="python" line>

def validare_date(n, matrice):
# Verifică dimensiunea matricei
if n < 1 or n > 20:
return False

# Verifică dacă elementele matricei sunt numere naturale
for linie in matrice:
for element in linie:
if not isinstance(element, int) or element < 0:
return False

# Datele sunt valide
return True

def rezolva_problema(n, matrice):
numar_elemente= 0

# Verifică fiecare element din matrice
for i in range(n):
for j in range(n):
este_maxim = True

# Verifică dacă există un element vecin mai mare
if i > 0 and matrice[i-1][j] > matrice[i][j]:
este_maxim = False
if i < n-1 and matrice[i+1][j] > matrice[i][j]:
este_maxim = False
if j > 0 and matrice[i][j-1] > matrice[i][j]:
este_maxim = False
if j < n-1 and matrice[i][j+1] > matrice[i][j]:
este_maxim = False

# Dacă este maxim, crește numărul de elemente găsite
if este_maxim:
numar_elemente+= 1

# Returnează numărul de elemente găsite
return numar_elemente

if __name__ == '__main__':
# Citirea datelor de intrare
n = int(input())
matrice = []
for i in range(n):
linie = [int(x) for x in input().split()]
matrice.append(linie)

# Verificarea datelor de intrare
if not validare_date(n, matrice):
print("Datele nu corespund restricțiilor impuse.")
else :
# Rezolvarea problemei și afișarea rezultatului
rezultat = rezolva_problema(n, matrice)
print("Datele sunt introduse corect.")
print(rezultat)

</syntaxhighlight>

2877 - Sort Matrix Lin Col

2023-04-25T12:49:33Z

Alexandra Leș: Pagină nouă: == Cerinţa == Se dă o matrice pătratică de dimensiune '''n'''. Să se ordoneze crescător fiecare linie a matricei, apoi să se ordoneze crescător fiecare coloană a acesteia. == Date de intrare == Programul citește de la tastatură numărul '''n''', iar apoi elementele matricei. Fiecare linie se află pe câte un rând, elementele fiecărei linii fiind separate prin câte un spațiu. == Date de ieşire == Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Da...

== Cerinţa ==
Se dă o matrice pătratică de dimensiune '''n'''. Să se ordoneze crescător fiecare linie a matricei, apoi să se ordoneze crescător fiecare coloană a acesteia.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi elementele matricei. Fiecare linie se află pe câte un rând, elementele fiecărei linii fiind separate prin câte un spațiu.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou matricea modificată, câte o linie a matricei pe o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spațiu.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 100
* elementele matricei vor fi mai mici decât 1.000.000
== Exemplul 1 ==
; Intrare
: 3
: 4 1 3
: 9 6 8
: 5 2 7
; Ieșire
: Datele sunt introduse corect.
: 1 3 4
: 2 5 7
: 6 8 9
== Exemplul 2 ==
; Intrare
: 4
: 12 7 1 8
: 20 9 11 2
: 15 4 5 13
: 3 18 10 6
; Ieșire
: Datele sunt introduse corect.
: 1 5 8 12
: 2 6 10 15
: 3 7 11 18
: 4 9 13 20
== Rezolvare ==
<syntaxhighlight lang="python" line>

# Funcție de validare a datelor de intrare conform cerințelor problemei.
def validare_date_intrare(n, a):
if not 1 <= n <= 100:
return False
for linie in a:
for elem in linie:
if elem > 999:
return False
return True

# Funcția principală care primește matricea și returnează matricea ordonată crescător pe fiecare linie și coloană.
def ordonare_matrice(n, a):
for i in range(n):
a[i].sort() # ordonare crescătoare pe linii
a_transpusa = [list(x) for x in zip(*a)] # transpunerea matricei
for i in range(n):
a_transpusa[i].sort() # ordonare crescătoare pe coloane
a_ordonata = [list(x) for x in zip(*a_transpusa)] # transpunerea inversă a matricei
return a_ordonata

if __name__ == '__main__':
n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
if not validare_date_intrare(n, a):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
a_ordonata = ordonare_matrice(n, a)
for linie in a_ordonata:
print(*linie)

</syntaxhighlight>

0784 - Lin Col Egale

2023-04-25T12:23:10Z

Alexandra Leș: Pagină nouă: == Cerinţa == Se dă o matrice cu '''n''' linii şi '''n''' coloane şi elemente numere naturale. Să se determine câte elemente ale matricei se află pe linii și coloane de sumă egală. Elementul '''a[i,j]''' va fi numărat dacă suma elementelor de pe linia '''i''' este egală cu cea de pe coloana '''j'''. == Date de intrare == Programul citește de la tastatură numărul '''n''', iar apoi '''n*n''' numere naturale, separate prin spaţii, reprezentând elementele matric...

== Cerinţa ==
Se dă o matrice cu '''n''' linii şi '''n''' coloane şi elemente numere naturale. Să se determine câte elemente ale matricei se află pe linii și coloane de sumă egală. Elementul '''a[i,j]''' va fi numărat dacă suma elementelor de pe linia '''i''' este egală cu cea de pe coloana '''j'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n*n''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou numărul '''C''', reprezentând valoarea calculată.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 100
* elementele matricei vor fi mai mici decât 1.000.000
== Exemplu ==
; Date de intrare
: 5
: 3 1 8 5 4
: 7 8 5 1 2
: 2 2 6 7 3
: 9 8 1 3 6
: 7 5 3 1 7
; Date de ieșire
: Datele sunt introduse corect.
: 2
== Explicație ==
Cele două elemente se află pe linia '''2''', coloana '''3''', respectiv linia '''5''', coloana '''3'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>

from typing import List
def validare_date(n: int, matrice: List[List[int]]) -> bool:
# Verifică dacă n are valoarea potrivită
if n < 1 or n > 100:
return False

# Verifică dacă matricea are dimensiunea potrivită
if len(matrice) != n:
return False
for linie in matrice:
if len(linie) != n:
return False

# Verifică dacă toate elementele matricei sunt numere naturale mai mici decât 1000
for linie in matrice:
for elem in linie:
if not (isinstance(elem, int) and 0 <= elem < 1000):
return False

return True

def determina_nr_elemente(n: int, matrice: List[List[int]]) -> int:
# Inițializăm două liste goale, V si H, pentru a calcula sumele elementelor de pe fiecare linie și coloană
V = [0] * (n + 1)
H = [0] * (n + 1)

# Parcurgem matricea și adunăm elementele de pe fiecare linie și coloana în listele V si H
for i in range(1, n + 1):
for j in range(1, n + 1):
V[i] += matrice[i - 1][j - 1]
H[j] += matrice[i - 1][j - 1]

# Initializam numar_elemente_egale cu 0, pentru a numara elementele care se află pe o linie și o coloană al caror sume sunt egale
numar_elemente_egale = 0

# Parcurgem din nou matricea ăi numărăm elementele care se află pe o linie și o coloană al caror sume sunt egale
for i in range(1, n + 1):
for j in range(1, n + 1):
if V[i] == H[j]:
numar_elemente_egale += 1

# Returnăm numarul de elemente care se află pe o linie și o coloană al căror sume sunt egale
return numar_elemente_egale

if __name__ == "__main__":
# Citire date de intrare
n = int(input())
matrice = []
for i in range(n):
linie = [int(elem) for elem in input().split()]
matrice.append(linie)

# Validare date de intrare
if validare_date(n, matrice):
# Calculare și afișare rezultat
C = determina_nr_elemente(n, matrice)
print("\nDatele sunt introduse corect.\n")
print(C)
else:
print("Datele nu corespund restrictiilor impuse.")

</syntaxhighlight>

0781 - Zone 1

2023-04-25T12:04:38Z

Alexandra Leș: Pagină nouă: == Cerinţa == Se dă o matrice cu '''n''' linii şi '''n''' coloane şi elemente numere naturale. Cele două diagonale delimitează în matrice '''4''' zone: '''NORD''' – elementele situate deasupra diagonalei principale şi deasupra celei secundare '''EST''' – elementele situate deasupra diagonalei principale şi sub cea secundară '''SUD''' – elementele situate sub diagonala principală şi sub cea secundară '''VEST''' – elementele situate sub diagonala principal...

== Cerinţa ==
Se dă o matrice cu '''n''' linii şi '''n''' coloane şi elemente numere naturale. Cele două diagonale delimitează în matrice '''4''' zone:
'''NORD''' – elementele situate deasupra diagonalei principale şi deasupra celei secundare
'''EST''' – elementele situate deasupra diagonalei principale şi sub cea secundară
'''SUD''' – elementele situate sub diagonala principală şi sub cea secundară
'''VEST''' – elementele situate sub diagonala principală şi deasupra celei secundare
Să se afişeze, în ordine crescătoare, sumele elementelor din cele patru zone.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n*n''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou numerele '''S1 S2 S3 S4''', separate printr-un spaţiu, în ordine crescătoare.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 100
* elementele matricei vor fi mai mici decât 1.000.000
== Exemplu ==
; Date de intrare
: 5
: 3 1 8 5 4
: 7 8 5 1 2
: 2 2 6 7 3
: 9 8 1 3 6
: 7 5 3 1 7
; Date de ieșire
: Datele sunt introduse corect.
: 10 18 19 20
== Rezolvare ==
<syntaxhighlight lang="python" line>

#Functia verifică dacă datele introduse respectă restricțiile impuse.
def validare_date(n, matrice):

for i in range(n):
for j in range(n):
if matrice[i][j] >= 1000:
return False
return True

#Funcție care calculează cele patru sume cerute în problemă
def rezolvare(n, matrice):
S1, S2, S3, S4 = 0, 0, 0, 0

for i in range(n):
for j in range(n):
if i < j and i + j < n:
S1 += matrice[i][j]
elif i < j and i + j > n - 1:
if i + j == n - 1:
continue
S2 += matrice[i][j]
elif i > j and i + j > n - 1 and j != n - 1 - i:
S3 += matrice[i][j]
elif i > j and i + j < n and j != n - 1 - i:
S4 += matrice[i][j]

return sorted([S1, S2, S3, S4])

if __name__ == '__main__':
# citirea datelor de intrare
n = int(input())
matrice = []
for i in range(n):
linie = input().split()
linie = [int(x) for x in linie]
matrice.append(linie)

# validarea datelor de intrare
if validare_date(n, matrice):
print("\nDatele sunt introduse corect.\n")
# rezolvarea problemei
rezultat = rezolvare(n, matrice)

# afisarea rezultatului
for s in rezultat:
print(s, end=' ')
else:
print('Datele nu corespund restrictiilor impuse.')

</syntaxhighlight>

3678 - Pal Pow

2023-04-25T11:07:18Z

Alexandra Leș: /* Rezolvare */

== Cerinţa ==
Un număr natural se numește palPow dacă oglinditul său are strict mai mulți divizori pozitivi decât are numărul. De exemplu '''23''' este un număr palPow deoarece 23 are doi divizori pozitivi '''(1 23)''' iar oglinditul său, 32, are șase divizori pozitivi ('''1 2 4 8 16 32'''). Oglinditul unui număr este valoarea obținută considerând cifrele numărului de la dreapta la stânga(de exemplu, oglinditul lui '''675''' este '''576''' iar oglinditullui '''20310''' este '''1302'''). Pentru un șir de n numere naturale date să se determine câte numere palPow sunt în șir precum și care este cel mai mic și cel mai mare număr palPow din șir
== Date de intrare ==
Fișierul de intrare conține pe prima linie numărul '''n''' și pe a doua linie '''n''' numere naturale separate prin spațiu
== Date de ieşire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi fișierul de ieșire va conține pe prima linie trei valori separate prin câte un spațiu, reprezentând în ordine, numărul de numere palPow, cel mai mic număr palPow, cel mai mare număr palPow din șirul dat. În cazul în care datele nu respectă restricțiile, pe ecran se va afișa: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; n &les; 1000.
* numerele din șir sunt naturale cel mult egale cu 1.000.000
* șirul conține cel puțin un număr palPow

== Exemplu ==
; palpow.in
: 6
: 13 23 231 408 48 36
; palpow.out
: Datele sunt introduse corect.
: 23 231 48

== Rezolvare ==
<syntaxhighlight lang="python" line>
#Funcția verifică dacă datele de intrare sunt valide
def validare_date_intrare(n, numere):
#Numărul de elemente din șir trebuie să fie între 1 și 1000 inclusiv
if not (1 <= n <= 1000):
return False,
for numar in numere:
#Toate numerele din șir trebuie să fie naturale și să nu depășească 1.000.000
if not (1 <= numar <= 100_000_000):
return False,
return True, ""

#Returnează oglinditul unui număr dat.
def oglindit(numar):
ogl = 0
while numar > 0:
ogl = ogl * 10 + numar % 10
numar //= 10
return ogl

#Calculează numărul de divizori ai unui număr dat.
def nr_divizori(numar):
nr_div = 0
for d in range(1, int(numar ** 0.5) + 1):
if numar % d == 0:
nr_div += 2
if int(numar ** 0.5) ** 2 == numar:
nr_div -= 1
return nr_div

#Verifică dacă un număr dat este palPow.
def este_palPow(numar):
ogl = oglindit(numar)
return nr_divizori(numar) < nr_divizori(ogl)

if __name__ == "__main__":
with open("palpow.in") as f:
n = int(f.readline())
numere = list(map(int, f.readline().split()))

with open("palpow.out", "w") as f:
# Validarea datelor de intrare
if validare_date_intrare(n, numere):
print("\nDatele sunt introduse corect.")
rezultat = [str(numar) for numar in numere if este_palPow(numar)]
f.write(" ".join(rezultat))
else:
print("\nDatele nu corespund restricțiilor impuse.")

</syntaxhighlight>

3678 - Pal Pow

2023-04-25T11:06:51Z

Alexandra Leș: /* Rezolvare */

== Cerinţa ==
Un număr natural se numește palPow dacă oglinditul său are strict mai mulți divizori pozitivi decât are numărul. De exemplu '''23''' este un număr palPow deoarece 23 are doi divizori pozitivi '''(1 23)''' iar oglinditul său, 32, are șase divizori pozitivi ('''1 2 4 8 16 32'''). Oglinditul unui număr este valoarea obținută considerând cifrele numărului de la dreapta la stânga(de exemplu, oglinditul lui '''675''' este '''576''' iar oglinditullui '''20310''' este '''1302'''). Pentru un șir de n numere naturale date să se determine câte numere palPow sunt în șir precum și care este cel mai mic și cel mai mare număr palPow din șir
== Date de intrare ==
Fișierul de intrare conține pe prima linie numărul '''n''' și pe a doua linie '''n''' numere naturale separate prin spațiu
== Date de ieşire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi fișierul de ieșire va conține pe prima linie trei valori separate prin câte un spațiu, reprezentând în ordine, numărul de numere palPow, cel mai mic număr palPow, cel mai mare număr palPow din șirul dat. În cazul în care datele nu respectă restricțiile, pe ecran se va afișa: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; n &les; 1000.
* numerele din șir sunt naturale cel mult egale cu 1.000.000
* șirul conține cel puțin un număr palPow

== Exemplu ==
; palpow.in
: 6
: 13 23 231 408 48 36
; palpow.out
: Datele sunt introduse corect.
: 23 231 48

== Rezolvare ==
<syntaxhighlight lang="python" line>
#Funcția verifică dacă datele de intrare sunt valide
def validare_date_intrare(n, numere):
#Numărul de elemente din șir trebuie să fie între 1 și 1000 inclusiv
if not (1 <= n <= 1000):
return False,
for numar in numere:
#Toate numerele din șir trebuie să fie naturale și să nu depășească 1.000.000
if not (1 <= numar <= 100_000_000):
return False,
return True, ""

#Returnează oglinditul unui număr dat.
def oglindit(numar):
ogl = 0
while numar > 0:
ogl = ogl * 10 + numar % 10
numar //= 10
return ogl

#Calculează numărul de divizori ai unui număr dat.
def nr_divizori(numar):
nr_div = 0
for d in range(1, int(numar ** 0.5) + 1):
if numar % d == 0:
nr_div += 2
if int(numar ** 0.5) ** 2 == numar:
nr_div -= 1
return nr_div

#Verifică dacă un număr dat este palPow.
def este_palPow(numar):
ogl = oglindit(numar)
return nr_divizori(numar) < nr_divizori(ogl)

if __name__ == "__main__":
with open("palpow.in") as f:
n = int(f.readline())
numere = list(map(int, f.readline().split()))

with open("palpow.out", "w") as f:
# Validarea datelor de intrare
if validare_date_intrare(n, numere):
print("\nDatele sunt introduse corect.")
rezultat = [str(numar) for numar in numere if este_palPow(numar)]
f.write(" ".join(rezultat))
else:
print("\nDatele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3678 - Pal Pow

2023-04-25T11:06:16Z

Alexandra Leș: /* Exemplu */

== Cerinţa ==
Un număr natural se numește palPow dacă oglinditul său are strict mai mulți divizori pozitivi decât are numărul. De exemplu '''23''' este un număr palPow deoarece 23 are doi divizori pozitivi '''(1 23)''' iar oglinditul său, 32, are șase divizori pozitivi ('''1 2 4 8 16 32'''). Oglinditul unui număr este valoarea obținută considerând cifrele numărului de la dreapta la stânga(de exemplu, oglinditul lui '''675''' este '''576''' iar oglinditullui '''20310''' este '''1302'''). Pentru un șir de n numere naturale date să se determine câte numere palPow sunt în șir precum și care este cel mai mic și cel mai mare număr palPow din șir
== Date de intrare ==
Fișierul de intrare conține pe prima linie numărul '''n''' și pe a doua linie '''n''' numere naturale separate prin spațiu
== Date de ieşire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi fișierul de ieșire va conține pe prima linie trei valori separate prin câte un spațiu, reprezentând în ordine, numărul de numere palPow, cel mai mic număr palPow, cel mai mare număr palPow din șirul dat. În cazul în care datele nu respectă restricțiile, pe ecran se va afișa: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; n &les; 1000.
* numerele din șir sunt naturale cel mult egale cu 1.000.000
* șirul conține cel puțin un număr palPow

== Exemplu ==
; palpow.in
: 6
: 13 23 231 408 48 36
; palpow.out
: Datele sunt introduse corect.
: 23 231 48

== Rezolvare ==
<syntaxhighlight lang="python" line>
#Funcția verifică dacă datele de intrare sunt valide
def validare_date_intrare(n, numere):
#Numărul de elemente din șir trebuie să fie între 1 și 1000 inclusiv
if not (1 <= n <= 1000):
return False,
for numar in numere:
#Toate numerele din șir trebuie să fie naturale și să nu depășească 1.000.000
if not (1 <= numar <= 100_000_000):
return False,
return True, ""

#Returnează oglinditul unui număr dat.
def oglindit(numar):
ogl = 0
while numar > 0:
ogl = ogl * 10 + numar % 10
numar //= 10
return ogl

#Calculează numărul de divizori ai unui număr dat.
def nr_divizori(numar):
nr_div = 0
for d in range(1, int(numar ** 0.5) + 1):
if numar % d == 0:
nr_div += 2
if int(numar ** 0.5) ** 2 == numar:
nr_div -= 1
return nr_div

#Verifică dacă un număr dat este palPow.
def este_palPow(numar):
ogl = oglindit(numar)
return nr_divizori(numar) < nr_divizori(ogl)

if __name__ == "__main__":
with open("palpow.in") as f:
n = int(f.readline())
numere = list(map(int, f.readline().split()))

with open("palpow.out", "w") as f:
# Validarea datelor de intrare
if validare_date_intrare(n, numere):
print("\nDatele de intrare corespund restricțiilor impuse.")
rezultat = [str(numar) for numar in numere if este_palPow(numar)]
f.write(" ".join(rezultat))
else:
print("\nDatele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3678 - Pal Pow

2023-04-25T11:05:26Z

Alexandra Leș: /* Exemplu */

== Cerinţa ==
Un număr natural se numește palPow dacă oglinditul său are strict mai mulți divizori pozitivi decât are numărul. De exemplu '''23''' este un număr palPow deoarece 23 are doi divizori pozitivi '''(1 23)''' iar oglinditul său, 32, are șase divizori pozitivi ('''1 2 4 8 16 32'''). Oglinditul unui număr este valoarea obținută considerând cifrele numărului de la dreapta la stânga(de exemplu, oglinditul lui '''675''' este '''576''' iar oglinditullui '''20310''' este '''1302'''). Pentru un șir de n numere naturale date să se determine câte numere palPow sunt în șir precum și care este cel mai mic și cel mai mare număr palPow din șir
== Date de intrare ==
Fișierul de intrare conține pe prima linie numărul '''n''' și pe a doua linie '''n''' numere naturale separate prin spațiu
== Date de ieşire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi fișierul de ieșire va conține pe prima linie trei valori separate prin câte un spațiu, reprezentând în ordine, numărul de numere palPow, cel mai mic număr palPow, cel mai mare număr palPow din șirul dat. În cazul în care datele nu respectă restricțiile, pe ecran se va afișa: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; n &les; 1000.
* numerele din șir sunt naturale cel mult egale cu 1.000.000
* șirul conține cel puțin un număr palPow

== Exemplu ==
; palpow.in
: 6
: 13 23 231 408 48 36
; Ieșire
: Datele sunt introduse corect.
; palpow.out
: 23 231 48

== Rezolvare ==
<syntaxhighlight lang="python" line>
#Funcția verifică dacă datele de intrare sunt valide
def validare_date_intrare(n, numere):
#Numărul de elemente din șir trebuie să fie între 1 și 1000 inclusiv
if not (1 <= n <= 1000):
return False,
for numar in numere:
#Toate numerele din șir trebuie să fie naturale și să nu depășească 1.000.000
if not (1 <= numar <= 100_000_000):
return False,
return True, ""

#Returnează oglinditul unui număr dat.
def oglindit(numar):
ogl = 0
while numar > 0:
ogl = ogl * 10 + numar % 10
numar //= 10
return ogl

#Calculează numărul de divizori ai unui număr dat.
def nr_divizori(numar):
nr_div = 0
for d in range(1, int(numar ** 0.5) + 1):
if numar % d == 0:
nr_div += 2
if int(numar ** 0.5) ** 2 == numar:
nr_div -= 1
return nr_div

#Verifică dacă un număr dat este palPow.
def este_palPow(numar):
ogl = oglindit(numar)
return nr_divizori(numar) < nr_divizori(ogl)

if __name__ == "__main__":
with open("palpow.in") as f:
n = int(f.readline())
numere = list(map(int, f.readline().split()))

with open("palpow.out", "w") as f:
# Validarea datelor de intrare
if validare_date_intrare(n, numere):
print("\nDatele de intrare corespund restricțiilor impuse.")
rezultat = [str(numar) for numar in numere if este_palPow(numar)]
f.write(" ".join(rezultat))
else:
print("\nDatele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3064 - Copii 1

2023-04-25T11:04:44Z

Alexandra Leș: /* Exemplul 2 */

== Enunț ==
Iliuță și Pandele au învățat la școală operații aritmetice cu numere naturale. Astfel cei doi frați exersează operațiile folosindu-se de o tablă. Iliuță spune un număr natural '''X''', iar Pandele scrie pe tablă rezultatul înmulțirii tuturor numerelor naturale de la '''1''' la '''X'''. Glumeț, Iliuță șterge cifrele egale cu '''0''' de la finalul numărului scris de Pandele.
Ca să îl ierte, Pandele spune și el un număr natural '''Y''' și îi cere lui Iliuță să determine un număr natural '''Z''' care este cel mai mare divizor al lui '''Y''' având un număr impar de divizori.

== Cerinţa ==
Cunoscându-se numerele spuse de copii, scrieți un program care rezolvă următoarele cerințe:
1) afișează ultimele '''K''' cifre ale produsului calculat de Pandele, după ștergerea cifrelor egale cu '''0''' de la finalul acestuia;
2) afișează numărul '''Z''' cu semnificația de mai sus și numărul de divizori ai acestuia.
== Date de intrare ==
Fișierul de intrare '''copii.in''' conține pe prima linie numărul '''C''', care reprezintă numărul cerinței și poate avea doar valorile '''1''' sau '''2'''. Pentru prima cerință fișierul conține pe a doua linie numărul '''X''', iar pe cea de a treia linie numărul '''K'''. Pentru a doua cerință fișierul conține pe a doua linie numărul '''Y'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi Pentru cerința 1), pe prima linie a fișierului '''copii.out''' se vor afișa cele '''K''' cifre cerute, fără spații, în ordine de la stânga la dreapta.
Pentru cerința 2), pe prima linie se vor afișa, în această ordine, numărul '''Z''' determinat și numărul de divizori ai acestuia. Numerele vor fi separate printr-un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; X &les; 1.000.000
* 1 &les; Y &les; 1.000.000.000.000
* 1 &les; K &les; 9
* Numărul rămas după ștergerea zerourilor de la finalul produsului are cel puțin K cifre
* Pentru rezolvarea primei cerințe se acordă 40 de puncte
* Pentru rezolvarea primei cerințe se acordă 40 de puncte

== Exemple ==
===Exemplul 1===
; copii.in
: 1
: 12
: 3
; copii.out
: Datele sunt introduse corect.
: 016
== Explicație ==
Produsul '''1*2*3*4*5*6*7*8*9*10*11*12 = 479001600'''. După ștergerea zerourilor de la finalul produsului, ultimele '''3''' cifre sunt '''016'''.

Exemplul 2:
===Exemplul 2===
; copii.in
: 2
: 14641
; copii.out
: Datele sunt introduse corect.
: 14641 5

== Explicație ==
Cel mai mare divizor al lui '''14641''' care are un număr impar de divizori este chiar '''14641'''.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(c, x=None, y=None, k=None):
if c not in [1, 2]:
print("Datele nu corespund restricțiilor impuse.")
return False

if c == 1:
if not (1 <= x <= 10**6 and 1 <= y <= 10**12 and 1 <= k <= 9):
print("Datele nu corespund restricțiilor impuse.")
return False
elif c == 2:
if not (1 <= y <= 10**12):
print("Datele nu corespund restricțiilor impuse.")
return False

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

def produs_ultimele_k_cifre(x, k):
product = 1
for i in range(1, x+1):
product *= i
while product % 10 == 0:
product //= 10
product %= 10**k
return product

def numar_divizori(n):
count = 0
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
count += 1 if i % 2 == 1 else 0
if i != n // i and (n // i) % 2 == 1:
count += 1
return count

if __name__ == '__main__':
with open('copii.in', 'r') as fin:
c = int(fin.readline().strip())
if c == 1:
x = int(fin.readline().strip())
k = int(fin.readline().strip())
if not validare_date(c, x, k=k):
exit()
print(f"Produsul ultimelor {k} cifre ale lui {x}! este {produs_ultimele_k_cifre(x, k)}")
elif c == 2:
y = int(fin.readline().strip())
if not validare_date(c, y=y):
exit()
divizori_count = produs_ultimele_k_cifre(y)
max_divizor = 1
for i in range(3, int(y**0.5) + 1, 2):
while y % i == 0:
max_divizor *= i
y //= i
if y > 2:
max_divizor *= y
print(f"Cel mai mare divizor al lui {y} cu un numar impar de divizori este {max_divizor} cu {divizori_count} divizori impari")
with open('copii.out', 'w') as fout:
if c == 1:
fout.write(str(produs_ultimele_k_cifre(x, k)))
elif c == 2:
fout.write(f"{max_divizor} {divizori_count}")

</syntaxhighlight>

2881 - Cartonase 1

2023-04-25T11:04:01Z

Alexandra Leș: /* Exemplu */

== Cerinţa ==
Într-o zi, câțiva copii plictisiți de “Popa Prostul”, au inventat jocul “Popa Prostul 2”. Acest joc se joacă cu mai multe cartonașe identice. La început, fiecare jucător primește un număr de cartonașe. Primul jucător pune pe masă un număr de cartonașe egal cu cel mai mare divizor al numărului de cartonașe pe care îl avea în mână. Următorul pune un număr maxim de cartonașe, divizor al numărului de cartonașe pe care le are în mână, dar și divizor al numărului de cartonașe pus de jucătorul dinainte. Jocul continuă până când unul dintre copii pune jos un singur cartonaș. Jucătorul care va fi nevoit să pună un singur cartonaș va fi pierzătorul.

Dându-se numărul n de copii și numărul de cartonașe pe care îl primește fiecare, să se determine numărul de ordine al copilului care va pierde jocul.
== Date de intrare ==
Pe prima linie a fișierului de intrare '''cartonase1.in''' se va găsi numărul '''n''' de copii. Pe a doua linie vor fi '''n''' numere: '''x1,x2…xn''' reprezentând numărul de cartonașe pe care îl primește fiecare jucător.
== Date de ieşire ==
Dacă datele sunt introduse corect, în fișier se va afișa:
'''"Datele sunt introduse corect."''', apoi pe prima linie a fișierului '''cartonase1.out''' se va scrie numărul de ordine al pierzătorului sau valoarea '''-1''' dacă nu există pierzător.În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 2 &les; n &les; 100.000
* 1 &les; xi &les; 100.000.000
* Primul jucător va avea numărul de ordine 1.
== Exemplu ==
; cartonase1.in
: 8
: 30 15 6 18 303 45 44 25
; cartonase1.out
: Datele sunt introduse corect.
: 7

== Explicație ==
Primul jucător va pune '''30 de cartonaşe'''.
Al doilea jucător va pune '''15 cartonaşe'''.
Al treilea jucător va pune '''3''' cartonaşe.
Jucătorii '''4, 5 şi 6''' vor pune '''3''' cartonaşe fiecare.
Jucătorul cu numărul '''7''' va fi obligat să pună '''1''' cartonaş şi va pierde jocul.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def cmmdc(a, b):
while b:
r = a % b
a = b
b = r
return a

def validare_date(n, xi):
if not (2 <= n <= 100_000):
return False
for num in xi:
if not (1 <= num <= 100_000_000):
return False
return True

if __name__ == '__main__':
with open('cartonase1.in', 'r') as fin, open('cartonase1.out', 'w', encoding='utf-8') as fout:
n = int(fin.readline())
xi = list(map(int, fin.readline().split()))
if not validare_date(n, xi):
fout.write("Datele nu corespund restricțiilor impuse.")
else:
fout.write("Datele sunt introduse corect\n")
x = xi[0]
ok = True
for i in range(2, n + 1):
y = xi[i - 1]
x = cmmdc(x, y)
if x == 1:
fout.write(str(i))
ok = False
break
if ok:
fout.write("-1")

</syntaxhighlight>

== Explicație rezolvare ==
Funcția cmmdc calculează cel mai mare divizor comun între două numere folosind algoritmul lui Euclid(algoritmul împarte deîmpărțitul la rest până când împărțitorul este 0, apoi returnează deîmpărțitul). Funcția validate_date primește numărul de elemente n și o listă de numere xi și verifică dacă acestea respectă condițiile din enunț. Mai precis, n trebuie să fie între 2 și 100.000, iar fiecare element din xi trebuie să fie între 1 și 100.000.000. În funcția principală, se deschide fișierul de intrare cartonase1.in în modul citire și fișierul de ieșire cartonase1.out în modul scriere, cu codificarea utf-8. Se citește n și lista xi din fișierul de intrare. Se validează datele citite din fișierul de intrare folosind funcția validate_date. Dacă acestea nu respectă condițiile din enunț, se afișează un mesaj de eroare în fișierul de ieșire și programul se termină. Altfel, se afișează un mesaj de confirmare în fișierul de ieșire. Se inițializează variabila x cu primul element din xi. Se parcurge lista xi de la al doilea element până la ultimul folosind o buclă for. Pentru fiecare element y, se calculează CMMDC-ul dintre x și y folosind funcția cmmdc și se actualizează valoarea lui x. Dacă x devine egal cu 1, se afișează poziția i în fișierul de ieșire și se setează variabila ok pe False. Se folosește variabila ok pentru a verifica dacă s-a găsit sau nu o pereche de numere cu CMMDC-ul egal cu 1. Dacă ok este True la finalul buclei, se afișează -1 în fișierul de ieșire.

2446 - Numere 24

2023-04-25T11:03:27Z

Alexandra Leș: /* Exemplul 3 */

== Enunț ==
Se consideră răsturnatul unui număr natural valoarea obținută prin parcurgerea cifrelor acestuia de la dreapta la stânga. De exemplu, răsturnatul numărului '''245''' este '''542'''. Un număr este palindrom dacă este egal cu răsturnatul său. De exemplu '''121''' este palindrom, iar numărul '''21''' nu este palindrom.
Se consideră inițial șirul numerelor naturale '''0, 1, 2, 3, 4,''' …
Din acest șir se elimină numerele divizibile cu 10 și, după fiecare număr care NU este palindrom, se inserează răsturnatul său. Noul șir astfel obținut va fi '''1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 21, 13, 31''', …
== Cerinţa ==
Scrieți un program care să citească:
1. un număr natural '''n''' și să afișeze al '''n'''-lea număr eliminat din șirul inițial;
2. un număr natural '''x''' și să afișeze următoarele trei numere: '''n1''' – numărul de apariții în noul șir ale numărului obținut din '''x''' prin eliminarea ultimei sale cifre; '''n2''' – numărul de apariții în noul șir ale numărului obținut din '''x''' prin eliminarea ultimelor sale două cifre; '''n3''' – numărul de apariții în noul șir ale numărului obținut din '''x''' prin eliminarea ultimelor sale trei cifre.
3. un număr natural '''k''' și să afișeze numărul valorilor de '''k''' cifre din noul șir.
== Date de intrare ==
Fișierul de intrare '''numere24.in''' conține pe prima linie un număr natural '''C''', care poate fi '''1''', '''2''' sau '''3'''.
Pe linia a doua se găsește numărul natural '''n''', dacă '''C=1''', sau numărul natural '''x''', dacă '''C=2''' sau numărul natural '''k''', dacă '''C=3''', numerele având semnificația din enunț
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou dacă valoarea lui '''C''' este '''1''', se va rezolva numai cerința '''1'''. În acest caz, în fişierul de ieşire '''numere24.out''' se va scrie al '''n'''-lea număr eliminat.
Dacă valoarea lui '''C''' este '''2''', se va rezolva numai cerința '''2'''. În acest caz, în fişierul de ieşire numere24.out se vor scrie trei numere, '''n1, n2, n3''', cu semnificația din enunț, în această ordine, separate prin câte spațiu.
Dacă valoarea lui '''C''' este '''3''', se va rezolva numai cerința '''3'''. În acest caz, fişierul de ieşire numere24.out va conține numărul valorilor de '''k''' cifre din noul șir . În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; n &les; 2.000.000.000
* 1000 &les; x &les; 2.000.000.000
* 1 &les; k &les; 50 (1 &les; k &les; 18, pentru teste în valoare de 20 de puncte)
* Pentru rezolvarea corectă a primei cerințe se acordă 10 puncte, pentru rezolvarea corectă a celei de a doua cerințe se acordă 25 de puncte, iar pentru rezolvarea corectă a celei de a treia cerințe se acordă 55 de puncte.
* În concurs s-au acordat 10 puncte din oficiu. Aici se acordă 10 puncte pentru exemplele din enunț.
== Exemple ==
===Exemplul 1===
; numere24.in
: 1
: 2
; numere24.out
: Datele sunt introduse corect.
: 10
== Explicație ==
'''n=2''' și al doilea număr eliminat este '''10'''. ('''C''' fiind '''1''' se rezolvă numai cerința 1)
===Exemplul 2===
; numere24.in
: 2
: 1205
; numere24.out
: Datele sunt introduse corect.
: 0 2 1

== Explicație ==
'''x=1205''', numărul '''120''' nu apare în șir, deci '''n1=0''', '''12''' apare de două ori, deci '''n2=2''', iar '''1''' apare o singură dată, deci '''n3=1''' ('''C''' fiind '''2''' se rezolvă numai cerința 2)

===Exemplul 3===
; numere24.in
: 3
: 2
; numere24.out
: Datele sunt introduse corect.
: 153

== Explicație ==
'''k=2''' și în noul șir sunt '''153''' de numere de câte '''2''' cifre. ('''C''' fiind '''3''' se rezolvă numai cerința '''3''')
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_numar(numar, limit):
if not numar.isdigit():
return False
if int(numar) < 0 or int(numar) > limit:
return False
return True

def validare_numere(n, x, k, c):
if c == 1:
return validare_numar(n, 2000000000)
elif c == 2:
return all(validare_numar(numar, 2000000000) for numar in [x])
elif c == 3:
return validare_numar(k, 50)
return False

def constr_sir():
sir = [str(i) for i in range(10)]
for i in range(1, 10):
sir.append(str(i * 10 + i))
for i in range(1, 100):
for j in range(10):
s = str(i) + str(j) + str(i)[::-1]
sir.append(s)
return sir

def cerinta_1(n):
sir = constr_sir()
numere_eliminate = []
i = 0
while len(numere_eliminate) < n:
if sir[i] not in numere_eliminate and sir[i] != sir[i][::-1]:
numere_eliminate.append(sir[i])
sir[i] = sir[i][:-1]
else:
i += 1
return numere_eliminate[-1]

def cerinta_2(x):
sir = constr_sir()
counts = [0, 0, 0]
for i in range(len(sir)):
if sir[i][-1] == x:
counts[0] += 1
if len(sir[i]) >= 2 and sir[i][-2] == x // 10:
counts[1] += 1
if len(sir[i]) >= 3 and sir[i][-3] == x // 100:
counts[2] += 1
return counts

def cerinta_3(k):
sir = constr_sir()
count = 0
for num in sir:
if len(num) == k:
count += 1
elif len(num) > k:
break
return count

if __name__ == '__main__':
with open('numere24.in', 'r') as f:
c = int(f.readline().strip())
n, x, k = map(int, f.readline().split())

if validare_numere(n, x, k, c):
print("Datele sunt introduse corect.")
if c == 1:
result = cerinta_1(n)
with open('numere24.out', 'w') as f:
f.write(str(result) + '\n')
elif c == 2:
counts = cerinta_2(x)
with open('numere24.out', 'w') as f:
f.write(' '.join(map(str, counts)) + '\n')
elif c == 3:
count = cerinta_3(k)
with open('numere24.out', 'w') as f:
f.write(str(count) + '\n')
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

2446 - Numere 24

2023-04-25T11:03:17Z

Alexandra Leș: /* Exemplul 2 */

== Enunț ==
Se consideră răsturnatul unui număr natural valoarea obținută prin parcurgerea cifrelor acestuia de la dreapta la stânga. De exemplu, răsturnatul numărului '''245''' este '''542'''. Un număr este palindrom dacă este egal cu răsturnatul său. De exemplu '''121''' este palindrom, iar numărul '''21''' nu este palindrom.
Se consideră inițial șirul numerelor naturale '''0, 1, 2, 3, 4,''' …
Din acest șir se elimină numerele divizibile cu 10 și, după fiecare număr care NU este palindrom, se inserează răsturnatul său. Noul șir astfel obținut va fi '''1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 21, 13, 31''', …
== Cerinţa ==
Scrieți un program care să citească:
1. un număr natural '''n''' și să afișeze al '''n'''-lea număr eliminat din șirul inițial;
2. un număr natural '''x''' și să afișeze următoarele trei numere: '''n1''' – numărul de apariții în noul șir ale numărului obținut din '''x''' prin eliminarea ultimei sale cifre; '''n2''' – numărul de apariții în noul șir ale numărului obținut din '''x''' prin eliminarea ultimelor sale două cifre; '''n3''' – numărul de apariții în noul șir ale numărului obținut din '''x''' prin eliminarea ultimelor sale trei cifre.
3. un număr natural '''k''' și să afișeze numărul valorilor de '''k''' cifre din noul șir.
== Date de intrare ==
Fișierul de intrare '''numere24.in''' conține pe prima linie un număr natural '''C''', care poate fi '''1''', '''2''' sau '''3'''.
Pe linia a doua se găsește numărul natural '''n''', dacă '''C=1''', sau numărul natural '''x''', dacă '''C=2''' sau numărul natural '''k''', dacă '''C=3''', numerele având semnificația din enunț
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
'''"Datele sunt introduse corect."''', apoi pe un rând nou dacă valoarea lui '''C''' este '''1''', se va rezolva numai cerința '''1'''. În acest caz, în fişierul de ieşire '''numere24.out''' se va scrie al '''n'''-lea număr eliminat.
Dacă valoarea lui '''C''' este '''2''', se va rezolva numai cerința '''2'''. În acest caz, în fişierul de ieşire numere24.out se vor scrie trei numere, '''n1, n2, n3''', cu semnificația din enunț, în această ordine, separate prin câte spațiu.
Dacă valoarea lui '''C''' este '''3''', se va rezolva numai cerința '''3'''. În acest caz, fişierul de ieşire numere24.out va conține numărul valorilor de '''k''' cifre din noul șir . În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricţii şi precizări ==
* 1 &les; n &les; 2.000.000.000
* 1000 &les; x &les; 2.000.000.000
* 1 &les; k &les; 50 (1 &les; k &les; 18, pentru teste în valoare de 20 de puncte)
* Pentru rezolvarea corectă a primei cerințe se acordă 10 puncte, pentru rezolvarea corectă a celei de a doua cerințe se acordă 25 de puncte, iar pentru rezolvarea corectă a celei de a treia cerințe se acordă 55 de puncte.
* În concurs s-au acordat 10 puncte din oficiu. Aici se acordă 10 puncte pentru exemplele din enunț.
== Exemple ==
===Exemplul 1===
; numere24.in
: 1
: 2
; numere24.out
: Datele sunt introduse corect.
: 10
== Explicație ==
'''n=2''' și al doilea număr eliminat este '''10'''. ('''C''' fiind '''1''' se rezolvă numai cerința 1)
===Exemplul 2===
; numere24.in
: 2
: 1205
; numere24.out
: Datele sunt introduse corect.
: 0 2 1

== Explicație ==
'''x=1205''', numărul '''120''' nu apare în șir, deci '''n1=0''', '''12''' apare de două ori, deci '''n2=2''', iar '''1''' apare o singură dată, deci '''n3=1''' ('''C''' fiind '''2''' se rezolvă numai cerința 2)

===Exemplul 3===
; numere24.in
: 3
: 2
; numere24.out
: 153

== Explicație ==
'''k=2''' și în noul șir sunt '''153''' de numere de câte '''2''' cifre. ('''C''' fiind '''3''' se rezolvă numai cerința '''3''')
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_numar(numar, limit):
if not numar.isdigit():
return False
if int(numar) < 0 or int(numar) > limit:
return False
return True

def validare_numere(n, x, k, c):
if c == 1:
return validare_numar(n, 2000000000)
elif c == 2:
return all(validare_numar(numar, 2000000000) for numar in [x])
elif c == 3:
return validare_numar(k, 50)
return False

def constr_sir():
sir = [str(i) for i in range(10)]
for i in range(1, 10):
sir.append(str(i * 10 + i))
for i in range(1, 100):
for j in range(10):
s = str(i) + str(j) + str(i)[::-1]
sir.append(s)
return sir

def cerinta_1(n):
sir = constr_sir()
numere_eliminate = []
i = 0
while len(numere_eliminate) < n:
if sir[i] not in numere_eliminate and sir[i] != sir[i][::-1]:
numere_eliminate.append(sir[i])
sir[i] = sir[i][:-1]
else:
i += 1
return numere_eliminate[-1]

def cerinta_2(x):
sir = constr_sir()
counts = [0, 0, 0]
for i in range(len(sir)):
if sir[i][-1] == x:
counts[0] += 1
if len(sir[i]) >= 2 and sir[i][-2] == x // 10:
counts[1] += 1
if len(sir[i]) >= 3 and sir[i][-3] == x // 100:
counts[2] += 1
return counts

def cerinta_3(k):
sir = constr_sir()
count = 0
for num in sir:
if len(num) == k:
count += 1
elif len(num) > k:
break
return count

if __name__ == '__main__':
with open('numere24.in', 'r') as f:
c = int(f.readline().strip())
n, x, k = map(int, f.readline().split())

if validare_numere(n, x, k, c):
print("Datele sunt introduse corect.")
if c == 1:
result = cerinta_1(n)
with open('numere24.out', 'w') as f:
f.write(str(result) + '\n')
elif c == 2:
counts = cerinta_2(x)
with open('numere24.out', 'w') as f:
f.write(' '.join(map(str, counts)) + '\n')
elif c == 3:
count = cerinta_3(k)
with open('numere24.out', 'w') as f:
f.write(str(count) + '\n')
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

1595 - Bomboane 1

2023-04-25T11:01:36Z

Alexandra Leș: /* Exemplul 1 */

== Cerinţa ==
Lui Cristian, ca oricărui alt copil, îi plac bomboanele. A primit cadou de la prietenii lui cutii cu bomboane. Fiind multe cutii le-a numerotat: '''1''', '''2''', '''3''', … Desfăcând câteva, a văzut că există o legătură între numărul de pe etichetă și numărul de bomboane din cutie. Astfel în fiecare cutie sunt atâtea bomboane câți divizori pari are numărul de pe cutie. De exemplu cutia cu numărul '''10''' conține '''2''' bomboane, cutia cu numărul '''8''' conține '''3''' bomboane ș.a.m.d.

Cristian a ales la întâmplare două etichete x și y dorind să desfacă toate cutiile cu etichete cuprinse între x și y. Ajutați-l să determine prima cutie, etichetată cu a, și utima cutie, etichetată cu b, cu număr maxim de bomboane (x≤a≤b≤y), câte cutii n sunt cu acest număr de bomboane și care este acest număr d de bomboane.
== Date de intrare ==
Fișierul de intrare '''bomboane1.in''' conține pe prima linie numerele naturale nenule '''x''' și '''y''' separate prin câte un spațiu.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou fișierul de ieșire '''bomboane1.out''' va conține o singură linie pe care vor fi scrise cele patru valori determinate, în ordinea din cerință ('''a b n d'''), separate prin câte un spațiu.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; x &les; a &les; b &les; y&les; 1.000.000.000
* y - x &les; 1000
== Exemplul 1 ==
; bomboane1.in
: 10 20
; bomboane1.out
: Datele sunt introduse corect.
: 12 20 3 4

== Explicație ==
Dacă parcurgem toate numerele de la '''10''' la '''20''' constatăm că numărul maxim de divizori pari este '''4''' obținut la numerele '''12''', '''16''' şi '''20''' (3 numere).

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(x, a, b, y):
if not (1 <= x <= a <= b <= y <= 1_000_000_000 and y - x <= 1000):
return False
return True

def nr_bomboane(n):
cnt = 0
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
if i % 2 == 0:
cnt += 1
if (n/i) % 2 == 0 and i != n // i:
cnt += 1
if i*i == n and i % 2 == 0:
cnt -= 1
if n % 2 == 0:
cnt += 1
return cnt

if __name__ == '__main__':
with open("bomboane1.in", "r") as f_in:
x, y = map(int, f_in.readline().split())

a = x
while a % 2 != 0:
a += 1
if a % 4 != 0:
a += 2
b = y
while b % 2 != 0:
b -= 1
if b % 4 != 0:
b -= 2

max_numar_divizori = 0
for i in range(a, b+1, 4):
numar_divizori = nr_bomboane(i)
if numar_divizori > max_numar_divizori:
max_numar_divizori = numar_divizori

cnt = 0
for i in range(a, b+1, 4):
numar_divizori = nr_bomboane(i)
if numar_divizori == max_numar_divizori:
cnt += 1
if cnt == 1:
min_div_box = i
max_div_box = i

with open("bomboane1.out", "w") as f_out:

if validare_date(x, a, b, y):
f_out.write("Datele sunt introduse corect.\n")
else:
f_out.write("Datele nu corespund restricțiilor impuse.")

f_out.write(f"{min_div_box} {max_div_box} {cnt} {max_numar_divizori}\n")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția validare_date(x, a, b, y) verifică dacă datele de intrare respectă restricțiile și returnează True dacă sunt, altfel False. Funcția nr_bomboane(n) calculează numărul de divizori pari ai unui număr n. În funcția if __name__ == '__main__': se deschide fișierul de intrare și se citesc valorile x și y. Se calculează apoi valorile a și b ca fiind cele mai apropiate numere pare de x și y, respectiv. Se parcurge apoi intervalul de la a la b, cu pași de 4, și se calculează numărul de divizori pari ai fiecărui număr, iar din aceștia se găsește maximul. În a doua parcurgere a intervalului, se numără câte cutii au numărul maxim de divizori pari și se găsesc primele și ultimele cutii care îndeplinesc această condiție. Rezultatul final este afișat în fișierul de ieșire în formatul cerut de problemă.

1595 - Bomboane 1

2023-04-25T11:01:19Z

Alexandra Leș: /* Date de ieşire */

== Cerinţa ==
Lui Cristian, ca oricărui alt copil, îi plac bomboanele. A primit cadou de la prietenii lui cutii cu bomboane. Fiind multe cutii le-a numerotat: '''1''', '''2''', '''3''', … Desfăcând câteva, a văzut că există o legătură între numărul de pe etichetă și numărul de bomboane din cutie. Astfel în fiecare cutie sunt atâtea bomboane câți divizori pari are numărul de pe cutie. De exemplu cutia cu numărul '''10''' conține '''2''' bomboane, cutia cu numărul '''8''' conține '''3''' bomboane ș.a.m.d.

Cristian a ales la întâmplare două etichete x și y dorind să desfacă toate cutiile cu etichete cuprinse între x și y. Ajutați-l să determine prima cutie, etichetată cu a, și utima cutie, etichetată cu b, cu număr maxim de bomboane (x≤a≤b≤y), câte cutii n sunt cu acest număr de bomboane și care este acest număr d de bomboane.
== Date de intrare ==
Fișierul de intrare '''bomboane1.in''' conține pe prima linie numerele naturale nenule '''x''' și '''y''' separate prin câte un spațiu.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou fișierul de ieșire '''bomboane1.out''' va conține o singură linie pe care vor fi scrise cele patru valori determinate, în ordinea din cerință ('''a b n d'''), separate prin câte un spațiu.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; x &les; a &les; b &les; y&les; 1.000.000.000
* y - x &les; 1000
== Exemplul 1 ==
; bomboane1.in
: 10 20
; bomboane1.out
: Datele introduse corespund restricțiilor impuse.
: 12 20 3 4
== Explicație ==
Dacă parcurgem toate numerele de la '''10''' la '''20''' constatăm că numărul maxim de divizori pari este '''4''' obținut la numerele '''12''', '''16''' şi '''20''' (3 numere).

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(x, a, b, y):
if not (1 <= x <= a <= b <= y <= 1_000_000_000 and y - x <= 1000):
return False
return True

def nr_bomboane(n):
cnt = 0
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
if i % 2 == 0:
cnt += 1
if (n/i) % 2 == 0 and i != n // i:
cnt += 1
if i*i == n and i % 2 == 0:
cnt -= 1
if n % 2 == 0:
cnt += 1
return cnt

if __name__ == '__main__':
with open("bomboane1.in", "r") as f_in:
x, y = map(int, f_in.readline().split())

a = x
while a % 2 != 0:
a += 1
if a % 4 != 0:
a += 2
b = y
while b % 2 != 0:
b -= 1
if b % 4 != 0:
b -= 2

max_numar_divizori = 0
for i in range(a, b+1, 4):
numar_divizori = nr_bomboane(i)
if numar_divizori > max_numar_divizori:
max_numar_divizori = numar_divizori

cnt = 0
for i in range(a, b+1, 4):
numar_divizori = nr_bomboane(i)
if numar_divizori == max_numar_divizori:
cnt += 1
if cnt == 1:
min_div_box = i
max_div_box = i

with open("bomboane1.out", "w") as f_out:

if validare_date(x, a, b, y):
f_out.write("Datele sunt introduse corect.\n")
else:
f_out.write("Datele nu corespund restricțiilor impuse.")

f_out.write(f"{min_div_box} {max_div_box} {cnt} {max_numar_divizori}\n")

</syntaxhighlight>
== Explicație rezolvare ==
Funcția validare_date(x, a, b, y) verifică dacă datele de intrare respectă restricțiile și returnează True dacă sunt, altfel False. Funcția nr_bomboane(n) calculează numărul de divizori pari ai unui număr n. În funcția if __name__ == '__main__': se deschide fișierul de intrare și se citesc valorile x și y. Se calculează apoi valorile a și b ca fiind cele mai apropiate numere pare de x și y, respectiv. Se parcurge apoi intervalul de la a la b, cu pași de 4, și se calculează numărul de divizori pari ai fiecărui număr, iar din aceștia se găsește maximul. În a doua parcurgere a intervalului, se numără câte cutii au numărul maxim de divizori pari și se găsesc primele și ultimele cutii care îndeplinesc această condiție. Rezultatul final este afișat în fișierul de ieșire în formatul cerut de problemă.

1481 - Gradina Piticului

2023-04-25T10:58:14Z

Alexandra Leș:

== Enunț ==
Un pitic pasionat de numere trebuie să-și pună flori în grădină. El are de plantat m rânduri cu flori, aceeași floare pe tot rândul. Rândurile sunt numerotate de la 1 la m. Având la dispoziție suficiente specii de flori, piticul nostru s-a gândit să le planteze folosind următorul algoritm matematic: pe rândurile care sunt numere prime, va planta exact floarea numerotată cu numărul prim respectiv, iar pe celelalte rânduri va planta floarea numerotată cu suma divizorilor primi ai numărului neprim.
== Cerinţa ==
Să se realizeze un program care să afişeze ordinea de așezare a florilor pe cele '''m''' rânduri.
== Date de intrare ==
Fișierul de intrare '''pitic.in''' conține pe prima linie numărul '''m'''.
== Date de ieşire ==
Dacă datele sunt introduse corect, în fișier se va afișa: '''"Datele sunt introduse corect."''', apoi fişierul de ieşire '''pitic.out''' va conține pe prima linie un șir de '''m''' numere, separate prin câte un spațiu, fiecare număr reprezentând specia de floare ce urmează să fie plantată pe rândul respectiv. În cazul în care datele nu respectă restricțiile, se va afișa în fișier :'''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; m &les; 1000
== Exemplu ==
; pitic.in
: 6
; pitic.out
: Datele sunt introduse corect.
: 0 2 3 2 5 5

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

def validare_date(m):
return 1 <= m <= 1000

def prim(n):
d = 2
cnt = 1
while n > 1:
p = 0
while n % d == 0:
p += 1
n //= d
if p > 0:
cnt *= (p + 1)
d += 1
if d * d > n:
d = n
if cnt == 2:
return 1
else:
return 0

def sumprim(n):
s = 0
d = 2
while n > 1:
p = 0
while n % d == 0:
p += 1
n //= d
if p > 0:
s += d
d += 1
if d * d > n:
d = n
return s

if __name__ == "__main__":
with open("pitic.in") as fin, open("pitic.out", "w") as fout:
m = int(fin.readline().strip())
if validare_date(m):
fout.write("Datele de intrare corespund restrictiilor impuse.\n")
for i in range(1, m + 1):
if prim(i):
fout.write(str(i) + " ")
else:
fout.write(str(sumprim(i)) + " ")
else:
fout.write("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație rezolvare ==
Funcția validare_date(m) verifică dacă numărul m este între 1 și 1000, returnând True dacă este și False altfel. Funcția prim(n) verifică dacă numărul n este prim. Mai exact, aceasta determină factorii primi ai lui n și verifică dacă n are exact doi factori primi distincți. Dacă da, atunci n este prim și funcția returnează 1, altfel funcția returnează 0. Funcția sumprim(n) calculează suma divizorilor primi ai lui n, cu excepția lui n . Pentru aceasta, se determină factorii primi ai lui n și se adună doar aceia care sunt prima putere a unui număr prim. În funcția principală, se citește numărul m din fișierul de intrare și se verifică dacă este valid. Dacă da, se scrie mesajul "Datele de intrare corespund restrictiilor impuse." în fișierul de ieșire și se parcurg toate rândurile de la 1 la m. Pentru fiecare rând, se determină dacă este prim și, dacă da, se scrie numărul prim respectiv în fișierul de ieșire. În caz contrar, se calculează suma divizorilor primi ai rândului respectiv și se scrie acea sumă în fișierul de ieșire. Dacă m nu este valid, se scrie în fișierul de ieșire mesajul "Datele de intrare nu corespund restrictiilor impuse."

1438 - Razboi

2023-04-25T10:56:16Z

Alexandra Leș:

== Enunţ ==
În Regatul Numerelor, a început războiul civil. Se dau '''n''' soldați, reprezentați prin '''n''' numere naturale, nu neapărat distincte. Cei '''n''' soldați sunt recrutați în două batalioane adverse, după o lege de recrutare. Această lege are un număr asociat, care este egal cu '''1''' sau '''2'''. Dacă legea este '''1''', atunci soldații care au ultima cifră egală cu 0, 2, 4, 6 și 8 sunt recrutați de primul batalion, iar ceilalți de cel de-al doilea. Dacă legea e '''2''', atunci soldații care au suma divizorilor număr par sunt recrutați de primul batalion, iar restul de cel de-al doilea.
== Cerinţa ==
Dându-se '''n''', numărul de soldați, '''L''', legea de recrutare, și identificatorii celor '''n''' soldați, să se afișeze numărul soldaților din primul, respectiv al doilea batalion.
== Date de intrare ==
Fișierul de intrare '''razboi.in''' conține pe prima linie numerele '''n''' şi '''L''', cu semnificaţiile din enunţ, iar pe a doua linie se găsesc '''n''' numere reprezentând identificatorii celor '''n''' soldați.
== Date de iesire ==
Dacă datele sunt introduse corect, în fișier se va afișa: '''"Datele sunt introduse corect."''', apoi fișierul de ieșire '''razboi.out''' va conține pe prima linie cele două numere cerute, separate printr-un spațiu. În cazul în care datele nu respectă restricțiile, se va afișa în fișier: '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 0 &les; n &les; 60 000
*Numerele din şir < 100 000
== Exemplul 1 ==
; razboi.in
: 3 2
: 6 17 2
; razboi.out
: Datele sunt introduse corect.
: 2 1
== Explicație ==
Suma divizorilor lui '''6''' este '''12'''.
Suma divizorilor lui '''17''' este '''18'''.
Suma divizorilor lui '''2''' este '''3'''.

Așadar, primul batalion are doi soldați, iar al doilea batalion are unul singur.
== Exemplu2 ==
; razboi.in
: 10 1
: 15 150 12 36 45 78 85 95 93 141
; razboi.out
: Datele sunt introduse corect.
: 4 6
== Explicație ==
Suma divizorilor lui '''6''' este '''12'''.
Suma divizorilor lui '''17''' este '''18'''.
Suma divizorilor lui '''2''' este '''3'''.

Așadar, primul batalion are doi soldați, iar al doilea batalion are unul singur.
== Exemplu3 ==
; razboi.in
: 10 2
: 15 150 12 36 45 78 85 95 93 14
; razboi.out
: Datele sunt introduse corect.
: 9 1
== Rezolvare ==
<syntaxhighlight lang="python" line>
def sd(n):
s = 0
for i in range(1, int(n**0.5)+1): # se iterează prin toate numerele de la 1 la rădăcina pătrată a lui n
if n % i == 0: # dacă i divide n
s += i + n // i # se adaugă i și n/i la sumă
if i * i == n: # dacă i este rădăcina pătrată a lui n
s -= i # se scade i din sumă, deoarece a fost adăugat de două ori (de la i și de la n/i)
return s

def validare_date(numar1, numar2):
flag = False
if numar1.isdigit() and numar2.isdigit(): # se verifică dacă cele două numere sunt formate din cifre
if 0 < int(numar1) <= 60000 and 0 < int(numar2) <= 100000: # se verifică dacă cele două numere sunt în intervalele cerute
flag = True
return flag

if __name__ == '__main__':
with open('razboi.in', 'r') as f:
n, L = f.readline().split() # se citesc primele două numere din fișierul 'razboi.in'
soldati = list(map(int, f.readline().split())) # se citesc soldații din fișierul 'razboi.in' și se transformă din string-uri în numere întregi

if validare_date(n, L): # se validează cele două numere citite din fișier
n = int(n) # se transformă n din string în număr întreg
L = int(L) # se transformă L din string în număr întreg

cnt = 0
for x in soldati:
if sd(x) % 2 == 0: # se verifică dacă suma divizorilor lui x este pară
cnt += 1 # se incrementează cnt dacă suma divizorilor este pară
with open('razboi.out', 'w') as f:
f.write("Datele sunt introduse corect.\n")
f.write(str(cnt) + ' ' + str(n - cnt) + '\n') # se scriu în fișierul 'razboi.out' numărul de soldați cu suma divizorilor pară și numărul de soldați cu suma divizorilor impară
else:
f.write("Datele nu corespund restricțiilor impuse.") # scrierea mesajului de eroare în fișierul de ieșire

</syntaxhighlight>

1422 - Ograda

2023-04-25T10:54:33Z

Alexandra Leș: /* Exemplu2 */

== Enunţ ==
În ograda lui Gigel se găsesc găini și văcuțe. Se dau două numere naturale: '''C''' – numărul de capete și '''P''' – numărul de picioare din curte.
== Cerinţa ==
1. Să se afișeze câte găini și câte văcuțe sunt în ograda lui Gigel.
2. Maria, colega lui Gigel, îl provoacă pe acesta să calculeze numărul de divizori impari pentru numărul C și numărul de divizori pari pentru numărul P. Deoarece Gigel nu este bun la matematică, vă cere ajutorul. Să se afișeze cele două numere calculate
== Date de intrare ==
Fișierul de intrare '''ograda.in''' conține pe prima linie un număr natural '''X''' ('''1''' sau '''2''') reprezentând numărul cerinței ce trebuie rezolvată.

A doua linie conține două numere '''C''' și '''P''', separate printr-un spațiu, cu semnificațiile din cerință.
== Date de ieşire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:'''"Datele sunt introduse corect."''', apoi pe urmatorul rand fișierul de ieșire ograda.out va conține:
Pentru cerința 1: pe prima linie se vor afișa două numere, separate printr-un spațiu, '''G''' și '''V''' reprezentând numărul de găini, respectiv numărul de văcuțe din ogradă.
Pentru cerința 2: pe prima linie se vor afişa două numere, separate printr-un spațiu, reprezentând numărul de divizori impari pentru numărul '''C''' și numărul de divizori pari pentru numărul '''P'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran:''' "Datele nu corespund restricțiilor impuse."'''

== Restricții și precizări ==
* C și P ∈ Ν , 2*C &les; P &les; 4*C, iar P este un număr par.
* Pentru cerința 1:C,P &les; 200000000000
* Pentru cerința 2: C, P &les;50000000
* 0 &les; numar1 &les; numar2 &les; 1.000.000.000
* Se consideră că toate găinile au 2 picioare și 1 cap, iar toate văcuțele au 4 picioare și 1 cap. Gigel nu se
* află în ogradă în momentul numărării capetelor și picioarelor.
* Pentru X = 1 se va rezolva doar cerința 1. Pentru X = 2 se va rezolva doar cerința 2.
* d este divizorul lui a dacă restul împărţirii lui a la d este 0.
== Exemplul 1 ==
; ograda.in
: 1
: 5 16
; ograda.out
: Datele sunt introduse corect.
: 2 3

== Explicație ==
Cerința este '''1'''. În ogradă sunt '''2''' găini și '''3''' văcuțe.
== Exemplul 2 ==
; ograda.in
: 2
: 5 16
; ograda.out
: Datele sunt introduse corect.
: 2 5

== Explicație ==
Cerința este '''2'''. Numărul '''5''' are '''2''' divizori impari ('''1''' și '''5'''), iar numărul '''16''' are '''4''' divizori pari ('''2''', '''4''', '''8''', '''16''').
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Verificăm dacă toate valorile de intrare respectă restricțiile
def validare_date(C, P, X):
if not (isinstance(C, int) and isinstance(P, int) and isinstance(X, int)):
return False

if not (0 < C <= 200000000000 and 0 < P <= 200000000000):
if X == 1:
return False
elif not (0 < C <= 50000000 and 0 < P <= 50000000):
return False

if not (2 * C <= P <= 4 * C and P % 2 == 0):
return False

return True

if __name__ == "__main__":
# Citire date de intrare
with open("ograda.in", "r") as f:
X = int(f.readline())
C, P = map(int, f.readline().split())

# Verificare validare date
if validare_date(C, P, X):
with open("ograda.out", "w") as f_out:
f_out.write("Datele sunt introduse corect.\n")

# Rezolvare cerinta 1
if X == 1:
# Numarul total de capete
t = C
# Numarul total de picioare
l = P
# Numarul de gaini (cu 2 picioare si 1 cap)
g = (4*t - l) // 2
# Numarul de vacute (cu 4 picioare si 1 cap)
v = t - g
# Afisare rezultat
with open("ograda.out", "a") as f_out:
f_out.write(str(g) + " " + str(v))

# Rezolvare cerinta 2
elif X == 2:
# Numarul de divizori impari pentru numarul C
d1 = 1
for i in range(3, C+1, 2):
if C % i == 0:
d1 += 1
# Numarul de divizori pari pentru numarul P
d2 = 1
for i in range(2, P+1, 2):
if P % i == 0:
d2 += 1
# Afisare rezultat
with open("ograda.out", "a") as f_out:
f_out.write(str(d1) + " " + str(d2))
else:
with open("ograda.out", "w") as f_out:
f_out.write("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

1422 - Ograda

2023-04-25T10:54:15Z

Alexandra Leș: /* Exemplu2 */

== Enunţ ==
În ograda lui Gigel se găsesc găini și văcuțe. Se dau două numere naturale: '''C''' – numărul de capete și '''P''' – numărul de picioare din curte.
== Cerinţa ==
1. Să se afișeze câte găini și câte văcuțe sunt în ograda lui Gigel.
2. Maria, colega lui Gigel, îl provoacă pe acesta să calculeze numărul de divizori impari pentru numărul C și numărul de divizori pari pentru numărul P. Deoarece Gigel nu este bun la matematică, vă cere ajutorul. Să se afișeze cele două numere calculate
== Date de intrare ==
Fișierul de intrare '''ograda.in''' conține pe prima linie un număr natural '''X''' ('''1''' sau '''2''') reprezentând numărul cerinței ce trebuie rezolvată.

A doua linie conține două numere '''C''' și '''P''', separate printr-un spațiu, cu semnificațiile din cerință.
== Date de ieşire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:'''"Datele sunt introduse corect."''', apoi pe urmatorul rand fișierul de ieșire ograda.out va conține:
Pentru cerința 1: pe prima linie se vor afișa două numere, separate printr-un spațiu, '''G''' și '''V''' reprezentând numărul de găini, respectiv numărul de văcuțe din ogradă.
Pentru cerința 2: pe prima linie se vor afişa două numere, separate printr-un spațiu, reprezentând numărul de divizori impari pentru numărul '''C''' și numărul de divizori pari pentru numărul '''P'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran:''' "Datele nu corespund restricțiilor impuse."'''

== Restricții și precizări ==
* C și P ∈ Ν , 2*C &les; P &les; 4*C, iar P este un număr par.
* Pentru cerința 1:C,P &les; 200000000000
* Pentru cerința 2: C, P &les;50000000
* 0 &les; numar1 &les; numar2 &les; 1.000.000.000
* Se consideră că toate găinile au 2 picioare și 1 cap, iar toate văcuțele au 4 picioare și 1 cap. Gigel nu se
* află în ogradă în momentul numărării capetelor și picioarelor.
* Pentru X = 1 se va rezolva doar cerința 1. Pentru X = 2 se va rezolva doar cerința 2.
* d este divizorul lui a dacă restul împărţirii lui a la d este 0.
== Exemplul 1 ==
; ograda.in
: 1
: 5 16
; ograda.out
: Datele sunt introduse corect.
: 2 3

== Explicație ==
Cerința este '''1'''. În ogradă sunt '''2''' găini și '''3''' văcuțe.
== Exemplu2 ==
; ograda.in
: 2
: 5 16
; ograda.out
: Datele sunt introduse corect.
: 2 5

== Explicație ==
Cerința este '''2'''. Numărul '''5''' are '''2''' divizori impari ('''1''' și '''5'''), iar numărul '''16''' are '''4''' divizori pari ('''2''', '''4''', '''8''', '''16''').
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Verificăm dacă toate valorile de intrare respectă restricțiile
def validare_date(C, P, X):
if not (isinstance(C, int) and isinstance(P, int) and isinstance(X, int)):
return False

if not (0 < C <= 200000000000 and 0 < P <= 200000000000):
if X == 1:
return False
elif not (0 < C <= 50000000 and 0 < P <= 50000000):
return False

if not (2 * C <= P <= 4 * C and P % 2 == 0):
return False

return True

if __name__ == "__main__":
# Citire date de intrare
with open("ograda.in", "r") as f:
X = int(f.readline())
C, P = map(int, f.readline().split())

# Verificare validare date
if validare_date(C, P, X):
with open("ograda.out", "w") as f_out:
f_out.write("Datele sunt introduse corect.\n")

# Rezolvare cerinta 1
if X == 1:
# Numarul total de capete
t = C
# Numarul total de picioare
l = P
# Numarul de gaini (cu 2 picioare si 1 cap)
g = (4*t - l) // 2
# Numarul de vacute (cu 4 picioare si 1 cap)
v = t - g
# Afisare rezultat
with open("ograda.out", "a") as f_out:
f_out.write(str(g) + " " + str(v))

# Rezolvare cerinta 2
elif X == 2:
# Numarul de divizori impari pentru numarul C
d1 = 1
for i in range(3, C+1, 2):
if C % i == 0:
d1 += 1
# Numarul de divizori pari pentru numarul P
d2 = 1
for i in range(2, P+1, 2):
if P % i == 0:
d2 += 1
# Afisare rezultat
with open("ograda.out", "a") as f_out:
f_out.write(str(d1) + " " + str(d2))
else:
with open("ograda.out", "w") as f_out:
f_out.write("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

1422 - Ograda

2023-04-25T10:54:01Z

Alexandra Leș: /* Exemplul 1 */

== Enunţ ==
În ograda lui Gigel se găsesc găini și văcuțe. Se dau două numere naturale: '''C''' – numărul de capete și '''P''' – numărul de picioare din curte.
== Cerinţa ==
1. Să se afișeze câte găini și câte văcuțe sunt în ograda lui Gigel.
2. Maria, colega lui Gigel, îl provoacă pe acesta să calculeze numărul de divizori impari pentru numărul C și numărul de divizori pari pentru numărul P. Deoarece Gigel nu este bun la matematică, vă cere ajutorul. Să se afișeze cele două numere calculate
== Date de intrare ==
Fișierul de intrare '''ograda.in''' conține pe prima linie un număr natural '''X''' ('''1''' sau '''2''') reprezentând numărul cerinței ce trebuie rezolvată.

A doua linie conține două numere '''C''' și '''P''', separate printr-un spațiu, cu semnificațiile din cerință.
== Date de ieşire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:'''"Datele sunt introduse corect."''', apoi pe urmatorul rand fișierul de ieșire ograda.out va conține:
Pentru cerința 1: pe prima linie se vor afișa două numere, separate printr-un spațiu, '''G''' și '''V''' reprezentând numărul de găini, respectiv numărul de văcuțe din ogradă.
Pentru cerința 2: pe prima linie se vor afişa două numere, separate printr-un spațiu, reprezentând numărul de divizori impari pentru numărul '''C''' și numărul de divizori pari pentru numărul '''P'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran:''' "Datele nu corespund restricțiilor impuse."'''

== Restricții și precizări ==
* C și P ∈ Ν , 2*C &les; P &les; 4*C, iar P este un număr par.
* Pentru cerința 1:C,P &les; 200000000000
* Pentru cerința 2: C, P &les;50000000
* 0 &les; numar1 &les; numar2 &les; 1.000.000.000
* Se consideră că toate găinile au 2 picioare și 1 cap, iar toate văcuțele au 4 picioare și 1 cap. Gigel nu se
* află în ogradă în momentul numărării capetelor și picioarelor.
* Pentru X = 1 se va rezolva doar cerința 1. Pentru X = 2 se va rezolva doar cerința 2.
* d este divizorul lui a dacă restul împărţirii lui a la d este 0.
== Exemplul 1 ==
; ograda.in
: 1
: 5 16
; ograda.out
: Datele sunt introduse corect.
: 2 3

== Explicație ==
Cerința este '''1'''. În ogradă sunt '''2''' găini și '''3''' văcuțe.
== Exemplu2 ==
; ograda.in
: 2
: 5 16
; ograda.out
: Datele introduse corespund restricțiilor impuse.
: 2 5

== Explicație ==
Cerința este '''2'''. Numărul '''5''' are '''2''' divizori impari ('''1''' și '''5'''), iar numărul '''16''' are '''4''' divizori pari ('''2''', '''4''', '''8''', '''16''').
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Verificăm dacă toate valorile de intrare respectă restricțiile
def validare_date(C, P, X):
if not (isinstance(C, int) and isinstance(P, int) and isinstance(X, int)):
return False

if not (0 < C <= 200000000000 and 0 < P <= 200000000000):
if X == 1:
return False
elif not (0 < C <= 50000000 and 0 < P <= 50000000):
return False

if not (2 * C <= P <= 4 * C and P % 2 == 0):
return False

return True

if __name__ == "__main__":
# Citire date de intrare
with open("ograda.in", "r") as f:
X = int(f.readline())
C, P = map(int, f.readline().split())

# Verificare validare date
if validare_date(C, P, X):
with open("ograda.out", "w") as f_out:
f_out.write("Datele sunt introduse corect.\n")

# Rezolvare cerinta 1
if X == 1:
# Numarul total de capete
t = C
# Numarul total de picioare
l = P
# Numarul de gaini (cu 2 picioare si 1 cap)
g = (4*t - l) // 2
# Numarul de vacute (cu 4 picioare si 1 cap)
v = t - g
# Afisare rezultat
with open("ograda.out", "a") as f_out:
f_out.write(str(g) + " " + str(v))

# Rezolvare cerinta 2
elif X == 2:
# Numarul de divizori impari pentru numarul C
d1 = 1
for i in range(3, C+1, 2):
if C % i == 0:
d1 += 1
# Numarul de divizori pari pentru numarul P
d2 = 1
for i in range(2, P+1, 2):
if P % i == 0:
d2 += 1
# Afisare rezultat
with open("ograda.out", "a") as f_out:
f_out.write(str(d1) + " " + str(d2))
else:
with open("ograda.out", "w") as f_out:
f_out.write("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

1590 - Arma 1

2023-04-25T10:52:43Z

Alexandra Leș: /* Exemplul 1 */

== Enunț ==
În anul 2214 a izbucnit primul război interstelar. Pământul a fost atacat de către '''n''' civilizaţii extraterestre, pe care le vom numerota pentru simplicitate de la '''1''' la '''n'''.
Pentru a se apăra, pământenii au inventat o armă specială ce poate fi încărcată cu proiectile de diferite greutăţi, fabricate dintr-un material special denumit narun. Dacă arma este programată la nivelul '''p''', atunci un proiectil de greutate '''k''' va ajunge exact la distanţa '''k**p''' km (k la puterea p) faţă de Pământ şi dacă în acel punct se află cartierul general al unui atacator, acesta va fi distrus. De exemplu, dacă arma este programată la nivelul '''2''', un proiectil de greutate '''10''' va distruge cartierul general al extratereştrilor situat la distanţa '''102 = 100''' km de Pământ.

Arma poate fi încărcată cu proiectile de diferite greutăţi, dar cum narunul este un material foarte rar şi foarte scump, pământenii vor să folosească proiectile cât mai uşoare pentru a distruge cartierele generale inamice
== Cerinţa ==
Cunoscându-se '''n''', numărul atacatorilor, precum şi cele n distanţe până la cartierele generale ale acestora, să se scrie un program care determină:

cantitatea minimă de narun necesară pentru a distruge toate cartierele generale inamice;
nivelurile la care trebuie programată arma, pentru a distruge fiecare cartier general inamic cu o cantitate minimă de narun.
== Date de intrare ==
Fișierul de intrare '''arma1.in''' conține pe prima linie un număr natural '''c''' reprezentând cerinţa care trebuie să fie rezolvată ('''1''' sau '''2'''). Pe cea de a doua linie se află numărul natural '''n''', reprezentând numărul atacatorilor. Pe următoarele n linii se află n numere naturale, câte un număr pe o linie; pe cea de a '''i'''-a linie dintre cele n ('''1≤i≤n''') se află distanţa faţă de Pământ a cartierului general al celei de a '''i'''-a civilizaţii extraterestre.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi dacă cerinţa '''c=1''', atunci pe prima linie a fişierului '''arma1.out''' va fi scris un număr natural reprezentând cantitatea minimă de narun necesară distrugerii tuturor cartierelor generale inamice.
Dacă cerinţa este '''c=2''', atunci fişierul de ieşire arma1.out va conţine '''n''' linii. Pe a '''i'''-a linie ('''1≤i≤n''') se va scrie nivelul la care trebuie programată arma pentru a distruge cartierul general al celei de a '''i'''-a civilizaţii extraterestre.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; n &les; 10.000
* Distanţele până la cartierele generale inamice sunt numere naturale nenule ≤ 2.000.000.000.
* Pentru 50% dintre teste cerinţa este 1.
== Exemplul 1 ==
; arma1.in
: 1
: 5
: 100
: 97
: 625
: 40353607
: 81
; arma1.out
: Datele sunt introduse corect.
: 122
 
; arma1.in
: 2
: 5
: 100
: 97
: 625
: 40353607
: 81
; arma1.out
: Datele sunt introduse corect.
: 2
: 1
: 4
: 9
: 4

== Explicație ==
Primul cartier general se poate distruge cu un proiectil de greutate '''10''', programat la nivelul '''2''', al doilea obiectiv cu un proiectil de greutate '''97''' programat la nivelul '''1''', al treilea cu un proiectil de greutate '''5''' programat la nivelul '''4''', al patrulea cu un proiectil de greutate '''7''' programat la nivelul '''9''', iar ultimul cu un proiectil de greutate '''3''' programat la nivelul '''4'''.

Cantitatea minimă de narun necesară este '''10+97+5+7+3=122'''.

Nivelurile sunt în ordine: '''2 1 4 9 4'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = False
if n.isdigit():
if 0 <= int(n) <= 2_000_000_000:
flag = True
return flag

if __name__ == '__main__':
with open('arma1.in', 'r') as f:
cerinta = int(f.readline().strip())
n = int(f.readline().strip())
distante = []
for i in range(n):
numar = f.readline().strip()
if validare_date(numar):
distante.append(int(numar))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
exit()

if validare_date(str(cerinta)) and len(distante) == n:
if cerinta == 1:
cantitate_narun = 0
for distanta in distante:
cantitate_narun += pow(distanta, 3)
print(cantitate_narun)
elif cerinta == 2:
for distanta in distante:
for p in range(3):
if pow(distanta, p) >= distanta:
print(p)
break
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

1590 - Arma 1

2023-04-25T10:52:01Z

Alexandra Leș: /* Exemplul 1 */

== Enunț ==
În anul 2214 a izbucnit primul război interstelar. Pământul a fost atacat de către '''n''' civilizaţii extraterestre, pe care le vom numerota pentru simplicitate de la '''1''' la '''n'''.
Pentru a se apăra, pământenii au inventat o armă specială ce poate fi încărcată cu proiectile de diferite greutăţi, fabricate dintr-un material special denumit narun. Dacă arma este programată la nivelul '''p''', atunci un proiectil de greutate '''k''' va ajunge exact la distanţa '''k**p''' km (k la puterea p) faţă de Pământ şi dacă în acel punct se află cartierul general al unui atacator, acesta va fi distrus. De exemplu, dacă arma este programată la nivelul '''2''', un proiectil de greutate '''10''' va distruge cartierul general al extratereştrilor situat la distanţa '''102 = 100''' km de Pământ.

Arma poate fi încărcată cu proiectile de diferite greutăţi, dar cum narunul este un material foarte rar şi foarte scump, pământenii vor să folosească proiectile cât mai uşoare pentru a distruge cartierele generale inamice
== Cerinţa ==
Cunoscându-se '''n''', numărul atacatorilor, precum şi cele n distanţe până la cartierele generale ale acestora, să se scrie un program care determină:

cantitatea minimă de narun necesară pentru a distruge toate cartierele generale inamice;
nivelurile la care trebuie programată arma, pentru a distruge fiecare cartier general inamic cu o cantitate minimă de narun.
== Date de intrare ==
Fișierul de intrare '''arma1.in''' conține pe prima linie un număr natural '''c''' reprezentând cerinţa care trebuie să fie rezolvată ('''1''' sau '''2'''). Pe cea de a doua linie se află numărul natural '''n''', reprezentând numărul atacatorilor. Pe următoarele n linii se află n numere naturale, câte un număr pe o linie; pe cea de a '''i'''-a linie dintre cele n ('''1≤i≤n''') se află distanţa faţă de Pământ a cartierului general al celei de a '''i'''-a civilizaţii extraterestre.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi dacă cerinţa '''c=1''', atunci pe prima linie a fişierului '''arma1.out''' va fi scris un număr natural reprezentând cantitatea minimă de narun necesară distrugerii tuturor cartierelor generale inamice.
Dacă cerinţa este '''c=2''', atunci fişierul de ieşire arma1.out va conţine '''n''' linii. Pe a '''i'''-a linie ('''1≤i≤n''') se va scrie nivelul la care trebuie programată arma pentru a distruge cartierul general al celei de a '''i'''-a civilizaţii extraterestre.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; n &les; 10.000
* Distanţele până la cartierele generale inamice sunt numere naturale nenule ≤ 2.000.000.000.
* Pentru 50% dintre teste cerinţa este 1.
== Exemplul 1 ==
; arma1.in
: 1
: 5
: 100
: 97
: 625
: 40353607
: 81
; arma1.out
: Datele sunt introduse corect.
: 122
 
; arma1.in
: 2
: 5
: 100
: 97
: 625
: 40353607
: 81
; arma1.out
: 2
: 1
: 4
: 9
: 4

== Explicație ==
Primul cartier general se poate distruge cu un proiectil de greutate '''10''', programat la nivelul '''2''', al doilea obiectiv cu un proiectil de greutate '''97''' programat la nivelul '''1''', al treilea cu un proiectil de greutate '''5''' programat la nivelul '''4''', al patrulea cu un proiectil de greutate '''7''' programat la nivelul '''9''', iar ultimul cu un proiectil de greutate '''3''' programat la nivelul '''4'''.

Cantitatea minimă de narun necesară este '''10+97+5+7+3=122'''.

Nivelurile sunt în ordine: '''2 1 4 9 4'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = False
if n.isdigit():
if 0 <= int(n) <= 2_000_000_000:
flag = True
return flag

if __name__ == '__main__':
with open('arma1.in', 'r') as f:
cerinta = int(f.readline().strip())
n = int(f.readline().strip())
distante = []
for i in range(n):
numar = f.readline().strip()
if validare_date(numar):
distante.append(int(numar))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
exit()

if validare_date(str(cerinta)) and len(distante) == n:
if cerinta == 1:
cantitate_narun = 0
for distanta in distante:
cantitate_narun += pow(distanta, 3)
print(cantitate_narun)
elif cerinta == 2:
for distanta in distante:
for p in range(3):
if pow(distanta, p) >= distanta:
print(p)
break
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

1590 - Arma 1

2023-04-25T10:51:45Z

Alexandra Leș: /* Date de ieşire */

== Enunț ==
În anul 2214 a izbucnit primul război interstelar. Pământul a fost atacat de către '''n''' civilizaţii extraterestre, pe care le vom numerota pentru simplicitate de la '''1''' la '''n'''.
Pentru a se apăra, pământenii au inventat o armă specială ce poate fi încărcată cu proiectile de diferite greutăţi, fabricate dintr-un material special denumit narun. Dacă arma este programată la nivelul '''p''', atunci un proiectil de greutate '''k''' va ajunge exact la distanţa '''k**p''' km (k la puterea p) faţă de Pământ şi dacă în acel punct se află cartierul general al unui atacator, acesta va fi distrus. De exemplu, dacă arma este programată la nivelul '''2''', un proiectil de greutate '''10''' va distruge cartierul general al extratereştrilor situat la distanţa '''102 = 100''' km de Pământ.

Arma poate fi încărcată cu proiectile de diferite greutăţi, dar cum narunul este un material foarte rar şi foarte scump, pământenii vor să folosească proiectile cât mai uşoare pentru a distruge cartierele generale inamice
== Cerinţa ==
Cunoscându-se '''n''', numărul atacatorilor, precum şi cele n distanţe până la cartierele generale ale acestora, să se scrie un program care determină:

cantitatea minimă de narun necesară pentru a distruge toate cartierele generale inamice;
nivelurile la care trebuie programată arma, pentru a distruge fiecare cartier general inamic cu o cantitate minimă de narun.
== Date de intrare ==
Fișierul de intrare '''arma1.in''' conține pe prima linie un număr natural '''c''' reprezentând cerinţa care trebuie să fie rezolvată ('''1''' sau '''2'''). Pe cea de a doua linie se află numărul natural '''n''', reprezentând numărul atacatorilor. Pe următoarele n linii se află n numere naturale, câte un număr pe o linie; pe cea de a '''i'''-a linie dintre cele n ('''1≤i≤n''') se află distanţa faţă de Pământ a cartierului general al celei de a '''i'''-a civilizaţii extraterestre.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi dacă cerinţa '''c=1''', atunci pe prima linie a fişierului '''arma1.out''' va fi scris un număr natural reprezentând cantitatea minimă de narun necesară distrugerii tuturor cartierelor generale inamice.
Dacă cerinţa este '''c=2''', atunci fişierul de ieşire arma1.out va conţine '''n''' linii. Pe a '''i'''-a linie ('''1≤i≤n''') se va scrie nivelul la care trebuie programată arma pentru a distruge cartierul general al celei de a '''i'''-a civilizaţii extraterestre.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; n &les; 10.000
* Distanţele până la cartierele generale inamice sunt numere naturale nenule ≤ 2.000.000.000.
* Pentru 50% dintre teste cerinţa este 1.
== Exemplul 1 ==
; arma1.in
: 1
: 5
: 100
: 97
: 625
: 40353607
: 81
; arma1.out
: Datele introduse corespund restricțiilor impuse.
: 122
 
; arma1.in
: 2
: 5
: 100
: 97
: 625
: 40353607
: 81
; arma1.out
: 2
: 1
: 4
: 9
: 4
== Explicație ==
Primul cartier general se poate distruge cu un proiectil de greutate '''10''', programat la nivelul '''2''', al doilea obiectiv cu un proiectil de greutate '''97''' programat la nivelul '''1''', al treilea cu un proiectil de greutate '''5''' programat la nivelul '''4''', al patrulea cu un proiectil de greutate '''7''' programat la nivelul '''9''', iar ultimul cu un proiectil de greutate '''3''' programat la nivelul '''4'''.

Cantitatea minimă de narun necesară este '''10+97+5+7+3=122'''.

Nivelurile sunt în ordine: '''2 1 4 9 4'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = False
if n.isdigit():
if 0 <= int(n) <= 2_000_000_000:
flag = True
return flag

if __name__ == '__main__':
with open('arma1.in', 'r') as f:
cerinta = int(f.readline().strip())
n = int(f.readline().strip())
distante = []
for i in range(n):
numar = f.readline().strip()
if validare_date(numar):
distante.append(int(numar))
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
exit()

if validare_date(str(cerinta)) and len(distante) == n:
if cerinta == 1:
cantitate_narun = 0
for distanta in distante:
cantitate_narun += pow(distanta, 3)
print(cantitate_narun)
elif cerinta == 2:
for distanta in distante:
for p in range(3):
if pow(distanta, p) >= distanta:
print(p)
break
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

1377 - Max D

2023-04-25T10:46:40Z

Alexandra Leș: /* Exemplu */

== Enunț ==
Fiind elev în clasa '''a IX-a''', George, îşi propune să studieze capitolul divizibilitate cât mai bine. Ajungând la numărul de divizori asociat unui număr natural, constată că sunt numere într-un interval dat, cu acelaşi număr de divizori.
De exemplu, în intervalul '''[1, 10]''', '''6''', '''8''' şi '''10''' au acelaşi număr de divizori, egal cu '''4'''. De asemenea, '''4''' şi '''9''' au acelaşi număr de divizori, egal cu '''3''' etc.

== Cerinţa ==
Scrieţi un program care pentru un interval dat determină care este cel mai mic număr din interval ce are număr maxim de divizori. Dacă sunt mai multe numere cu această proprietate se cere să se numere câte sunt.
== Date de intrare ==
Fişierul de intrare '''maxd.in''' conţine pe prima linie două numere '''a''' şi '''b''' separate prin spaţiu '''(a≤b)''' reprezentând extremităţile intervalului.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou Fişierul de ieşire '''maxd.out''' va conţine pe prima linie trei numere separate prin câte un spaţiu '''min nrdiv contor''' cu semnificaţia:
'''min''' – cea mai mică valoare din interval care are număr maxim de divizori
'''nrdiv''' – numărul de divizori ai lui min
'''contor''' – câte numere din intervalul citit mai au acelaşi număr de divizori egal cu nrdiv.
În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 <= a, b <= 1.000.000.000
* 0 <= b - a <= 10.000
== Exemplu ==
; maxd.in
: 2 10
; maxd.out
: Datele sunt introduse corect.
: 6 4 3

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

def validare_date(a, b):
if str(a).isdigit() and str(b).isdigit():
if 0 < int(a) < int(b) <= 1_000_000_000:
return True
return False
#Funcție pentru găsirea numărului din intervalul [a, b] care are cel mai mare număr de divizori și determinarea numărului de numere din interval care au același număr de divizori.
def gaseste_numar_cu_max_divizori(a, b):
nrmax = 0
cnt = 0
imax = 0
for i in range(a, b+1):
divizori = 0
for j in range(1, i+1):
if i % j == 0:
divizori += 1
if divizori > nrmax:
nrmax = divizori
imax = i
cnt = 1
elif divizori == nrmax:
cnt += 1
return (imax, nrmax, cnt)

if __name__ == "__main__":
with open("maxd.in", "r") as fin:
a, b = map(int, fin.readline().split())

if validare_date(a, b):
rezultat = gaseste_numar_cu_max_divizori(a, b)
with open("maxd.out", "w") as fout:
print("Datele de intrare corespund restricțiilor impuse.")
fout.write(f"{rezultat[0]} {rezultat[1]} {rezultat[2]}")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

1377 - Max D

2023-04-25T10:46:28Z

Alexandra Leș: /* Date de ieşire */

== Enunț ==
Fiind elev în clasa '''a IX-a''', George, îşi propune să studieze capitolul divizibilitate cât mai bine. Ajungând la numărul de divizori asociat unui număr natural, constată că sunt numere într-un interval dat, cu acelaşi număr de divizori.
De exemplu, în intervalul '''[1, 10]''', '''6''', '''8''' şi '''10''' au acelaşi număr de divizori, egal cu '''4'''. De asemenea, '''4''' şi '''9''' au acelaşi număr de divizori, egal cu '''3''' etc.

== Cerinţa ==
Scrieţi un program care pentru un interval dat determină care este cel mai mic număr din interval ce are număr maxim de divizori. Dacă sunt mai multe numere cu această proprietate se cere să se numere câte sunt.
== Date de intrare ==
Fişierul de intrare '''maxd.in''' conţine pe prima linie două numere '''a''' şi '''b''' separate prin spaţiu '''(a≤b)''' reprezentând extremităţile intervalului.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou Fişierul de ieşire '''maxd.out''' va conţine pe prima linie trei numere separate prin câte un spaţiu '''min nrdiv contor''' cu semnificaţia:
'''min''' – cea mai mică valoare din interval care are număr maxim de divizori
'''nrdiv''' – numărul de divizori ai lui min
'''contor''' – câte numere din intervalul citit mai au acelaşi număr de divizori egal cu nrdiv.
În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 <= a, b <= 1.000.000.000
* 0 <= b - a <= 10.000
== Exemplu ==
; maxd.in
: 2 10
; maxd.out
: Datele introduse corespund restricțiilor impuse.
: 6 4 3
== Rezolvare ==
<syntaxhighlight lang="python" line>

def validare_date(a, b):
if str(a).isdigit() and str(b).isdigit():
if 0 < int(a) < int(b) <= 1_000_000_000:
return True
return False
#Funcție pentru găsirea numărului din intervalul [a, b] care are cel mai mare număr de divizori și determinarea numărului de numere din interval care au același număr de divizori.
def gaseste_numar_cu_max_divizori(a, b):
nrmax = 0
cnt = 0
imax = 0
for i in range(a, b+1):
divizori = 0
for j in range(1, i+1):
if i % j == 0:
divizori += 1
if divizori > nrmax:
nrmax = divizori
imax = i
cnt = 1
elif divizori == nrmax:
cnt += 1
return (imax, nrmax, cnt)

if __name__ == "__main__":
with open("maxd.in", "r") as fin:
a, b = map(int, fin.readline().split())

if validare_date(a, b):
rezultat = gaseste_numar_cu_max_divizori(a, b)
with open("maxd.out", "w") as fout:
print("Datele de intrare corespund restricțiilor impuse.")
fout.write(f"{rezultat[0]} {rezultat[1]} {rezultat[2]}")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3118 - Tort O

2023-04-25T10:42:16Z

Alexandra Leș: /* Exemplu */

== Cerinţa ==
Un tort dreptunghiular de dimensiuni '''MxN''' trebuie împărţit în porţii pătrate de aceeaşi mărime. Găsiţi numărul minim de porţii care se pot obţine şi dimensiunea '''L''' a acestora. Atât dimensiunile dreptunghiului cât şi ale pătratelor în care se împarte sunt numere întregi.
== Date de intrare ==
Fişierul de intrare '''tort.in''' va conţine pe prima linie numerele '''M''' şi '''N''' separate printr-un spaţiu.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou fişierul de ieşire '''tort.out''' va conţine pe o singură linie, două numere naturale separate printr-un spaţiu, primul fiind numărul minim de porţii, iar celălalt dimensiunea '''L'''.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; M &les; N &les; 10000
== Exemplu ==
; tort.in
: 20 24
; tort.out
: Datele sunt introduse corect.
: 30 4

== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = False
if isinstance(n, int):
if 0 <= n <= 10_000:
flag = True
return flag

def cmmdc(M, N):
# Funcție care calculează CMMD folosind algoritmul Euclid
while N:
M, N = N, M % N
return M

def numar_minim_patrate(M, N):
# Funcție care calculează numărul minim de pătrate și dimensiunea lor
divizor_comun = cmmdc(M, N)
nr_patrate = (M * N) // (divizor_comun ** 2)
dimensiune_patrat = divizor_comun
return nr_patrate, dimensiune_patrat

if __name__ == "__main__":
with open("tort.in") as f:
M, N = map(int, f.readline().split())

if validare_date(M) and validare_date(N):
nr_patrate, dimensiune_patrat = numar_minim_patrate(M, N)

with open("tort.out", "w") as f:
f.write(f"{nr_patrate} {dimensiune_patrat}\n")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3118 - Tort O

2023-04-25T10:42:03Z

Alexandra Leș: /* Date de ieşire */

== Cerinţa ==
Un tort dreptunghiular de dimensiuni '''MxN''' trebuie împărţit în porţii pătrate de aceeaşi mărime. Găsiţi numărul minim de porţii care se pot obţine şi dimensiunea '''L''' a acestora. Atât dimensiunile dreptunghiului cât şi ale pătratelor în care se împarte sunt numere întregi.
== Date de intrare ==
Fişierul de intrare '''tort.in''' va conţine pe prima linie numerele '''M''' şi '''N''' separate printr-un spaţiu.
== Date de ieşire ==
Dacă datele sunt introduse corect,în fișier se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou fişierul de ieşire '''tort.out''' va conţine pe o singură linie, două numere naturale separate printr-un spaţiu, primul fiind numărul minim de porţii, iar celălalt dimensiunea '''L'''.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.

== Restricții și precizări ==
* 1 &les; M &les; N &les; 10000
== Exemplu ==
; tort.in
: 20 24
; tort.out
: Datele introduse corespund restricțiilor impuse.
: 30 4
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare_date(n):
flag = False
if isinstance(n, int):
if 0 <= n <= 10_000:
flag = True
return flag

def cmmdc(M, N):
# Funcție care calculează CMMD folosind algoritmul Euclid
while N:
M, N = N, M % N
return M

def numar_minim_patrate(M, N):
# Funcție care calculează numărul minim de pătrate și dimensiunea lor
divizor_comun = cmmdc(M, N)
nr_patrate = (M * N) // (divizor_comun ** 2)
dimensiune_patrat = divizor_comun
return nr_patrate, dimensiune_patrat

if __name__ == "__main__":
with open("tort.in") as f:
M, N = map(int, f.readline().split())

if validare_date(M) and validare_date(N):
nr_patrate, dimensiune_patrat = numar_minim_patrate(M, N)

with open("tort.out", "w") as f:
f.write(f"{nr_patrate} {dimensiune_patrat}\n")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3459 - Count Prime

2023-04-25T10:40:10Z

Alexandra Leș: /* Exemplu */

== Cerinţa ==
Să se calculeze cate numere prime sunt în intervalul '''[stanga, dreapta]'''.
== Date de intrare ==
Fișierul de intrare '''countprime.in''' conține pe prima linie două numere '''stanga''' și '''dreapta'''.
== Date de ieşire ==
Dacă datele sunt introduse corect, în fișier se va afișa:'''"Datele sunt introduse corect."''', apoi pe un rând nou fișierul de ieșire '''countprime.out''' va conține pe prima linie numărul '''cnt''', reprezentând numărul de numere prime din intervalul dat. În cazul în care datele nu respectă restricțiile, se va afișa în fișier:'''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; stanga &les; dreapta &les; 2 ** 32
* dreapta - stanga &les; 1.000.000
== Exemplu ==
; countprime.in
: 2 10
; countprime.out
: Datele sunt introduse corect.

== Explicație ==
Sunt '''4''' numere prime în intervalul '''[2, 10]'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>

def validare_date(stanga, dreapta):
flag = False
if stanga.isdigit() and dreapta.isdigit(): #verificam daca ambele string-uri pot fi convertite in numere intregi
if 0 < int(stanga) < int(dreapta) <= 2 ** 32 and int(dreapta) - int(stanga) <= 1_000_000: #verificam daca cele doua numere se afla in intervalul si au o diferenta mai mica sau egala cu 1.000.000
flag = True
return flag

def prim(n):
#Funcția verifică dacă un număr este prim
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True

def câte_prime(stanga, dreapta):
#Funcția calculează numărul de numere prime din intervalul [stanga, dreapta]
nr = 0
for n in range(stanga, dreapta + 1):
if prim(n):
nr += 1
return nr

if __name__ == '__main__':
with open('countprime.in', 'r') as fin, open('countprime.out', 'w') as fout:
stanga, dreapta = fin.readline().split() #citim cele doua numere din fișierul de intrare

if validare_date(stanga, dreapta): #verificăm dacă cele două numere respectă condițiile impuse
cnt = câte_prime(int(stanga), int(dreapta)) #calculăm numărul de numere prime din intervalul [stanga, dreapta]

fout.write("Datele sunt introduse corect.\n") #scriem mesajul in fișierul de ieșire
fout.write(str(cnt)) #scriem in fisierul de ieșire numărul de numere prime

else:
fout.write("Datele introduse nu corespund restrictiilor impuse.")#în cazul în care nu sunt respectate condițiile impuse afișăm mesajul corespunzător

</syntaxhighlight>

0268 - Div K

2023-04-25T10:39:04Z

Alexandra Leș: /* Exemplu */

== Cerinţa ==
Se dau '''n''' numere naturale şi un număr natural '''k'''. Afişaţi acele numere date care au cel puţin '''k''' divizori.
== Date de intrare ==
Fişierul de intrare '''divk.in''' conţine pe prima linie numerele '''n''' şi '''k''', iar pe a doua linie '''n''' numere naturale separate prin spaţii.
== Date de ieşire ==
Dacă datele sunt introduse corect, în fișier se va afișa:'''"Datele sunt introduse corect."''', apoi pe un rând nou fişierul de ieşire '''divk.out''' va conţine pe prima linie numerele care au cel puţin '''k''' divizori, separate printr-un spaţiu, în ordinea în care au fost citite. În cazul în care datele nu respectă restricțiile, se va afișa în fișier:'''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 100
* numerele de pe a doua linie a fişierului de intrare, precum şi k vor avea cel mult 9 cifre
== Exemplu ==
; divk.in
: 6 5
: 100 9 400 56 7 10
; divk.out
: Datele sunt introduse corect.
: 100 400 56

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

# Funcție care verifică dacă sunt respectate restricțiile impuse
def validare_date_numar(numar):
flag = False
if numar.isdigit(): # Verificăm dacă toate caracterele sunt cifre
if 0 <= int(numar) <= 1_000_000_000: # Verificăm dacă numărul este în intervalul permis
flag = True
return flag

# Funcție care verifică dacă sunt respectate restricțiile impuse
def validare_date_numere(n):
flag = False
if 0 <= int(n) <= 1000: # Verificăm dacă numărul este în intervalul permis
flag = True
return flag

# Funcție care găsește toate numerele dintr-o listă cu cel puțin k divizori
def numere_cu_k_divizori(n, k, numere):
rezultat = []

for nr in numere:
divizori = 0
rad_nr = int(math.sqrt(nr)) # Calculează radicalul numărului

# Numărăm divizorii până la radicalul numărului
for i in range(1, rad_nr + 1):
if nr % i == 0:
divizori += 2 # Adăugăm doi divizori la numărul total (i și nr // i)
if i == nr // i:
divizori -= 1 # Dacă divizorii sunt egali, eliminăm unul din total

if divizori >= k:
rezultat.append(nr)

return rezultat

if __name__ == '__main__':
with open('divk.in', 'r') as f_in:
n, k = map(int, f_in.readline().split()) # Citim n și k din fișierul de intrare
if not validare_date_numere(n):
with open('div.out', 'w') as f_out:
f_out.write("\nDatele nu corespund restricțiilor impuse.\n")
exit()

else:
with open('divk.in', 'r') as f:
n, k = map(int, f.readline().split()) # Citim din nou n și k din fișierul de intrare
numere = list(map(int, f.readline().split())) # Citim lista de numere

rezultat = numere_cu_k_divizori(n, k, numere) # Calculăm rezultatul

with open('divk.out', 'w') as f:
f.write("Datele sunt introduse corect.\n")
f.write(' '.join(map(str, rezultat))) # Scriem rezultatul în fișierul de ieșire

</syntaxhighlight>

0306 - Zerouri

2023-04-25T10:38:10Z

Alexandra Leș: /* Exemplu */

== Cerinţa ==
Se dau '''n''' numere naturale nenule. Calculaţi numărul de zerouri de la sfârşitul scrierii zecimale a produsului celor '''n''' numere.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spaţii.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou numărul '''NRZ''', reprezentând valoarea calculată.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 0 &les; n &les; 100
* 0 &les; n &les; 1.000.000.000
== Exemplu ==
; Intrare
: 5
: 10 24 37 46 75
; Ieșire
: Datele sunt introduse corect.
: 3

== Explicație ==
Produsul celor 5 numere este '''30636000''', şi se termină cu '''3''' zerouri.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Funcție pentru validarea numărului de intrare
def validare_date_numar(numar):
flag = False
if numar.isdigit(): # verifică dacă numărul este un întreg pozitiv
if 0 < int(numar) <= 100: # verifică dacă numărul se află în intervalul specificat
flag = True # dacă toate condițiile sunt îndeplinite, returnează 'True'
return flag

# Funcție pentru validarea listei de numere de intrare
def validare_date_numere(n, numere):
flag = False
if len(numere) == n and all(num.isdigit() and int(num) > 0 for num in numere):
# verifică dacă lista conține exact n numere întregi pozitive
flag = True
return flag

# Funcție pentru calculul numărului de zerouri dintr-un număr dat
def nr_zerouri(numar):
NRZ = 0
while numar % 10 == 0:
NRZ += 1
numar //= 10
return NRZ

if __name__ == "__main__":
n = input() # primește numărul de intrare 'n' de la utilizator
if validare_date_numar(n): # verifică dacă 'n' este valid
n = int(n)
numere = input().split() # primește lista de 'n' numere de la utilizator
if validare_date_numere(n, numere): # verifică dacă lista de numere este validă
print("\nDatele sunt introduse corect.\n")
produs = 1
for num in numere:
produs *= int(num) # calculează produsul numerelor din listă
NRZ = nr_zerouri(produs) # calculează numărul de zerouri din produs
print(NRZ) # afișează numărul de zerouri
else:
print("Datele nu corespund restrictiilor impuse.")
else:
print("Datele nu corespund restrictiilor impuse.")

</syntaxhighlight>

0794 - Serpuire

2023-04-25T10:08:00Z

Alexandra Leș: /* Rezolvare */

== Cerinţa ==
Se dă o matrice cu '''n''' linii şi '''n''' coloane şi elemente numere naturale. Să se afișeze elementele prin parcurgerea șerpuită a matricei, începând din elementul de pe prima linie și prima coloană, ca în exemplu.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n*n''' numere naturale, separate prin spaţii, reprezentând elementele matricei, linie cu linie.
== Date de ieşire ==
Dacă datele sunt introduse corect,pe ecran se va afișa :'''"Datele sunt introduse corect."''',apoi pe un rând nou elementele din matrice în ordinea cerută, separate prin câte un spațiu.În cazul contrar,se va afișa pe ecran '''"Datele nu corespund restricțiilor impuse."'''.
== Restricții și precizări ==
* 1 &les; n &les; 25
* elementele matricei vor fi mai mici decât 1.000.000
== Exemplu ==
; Date de intrare
: 4
: 1 3 4 10
: 2 5 9 11
: 6 8 12 15
: 7 13 14 16
; Date de ieșire
: Datele sunt introduse corect.
: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
== Rezolvare ==
<syntaxhighlight lang="python" line>

def validare_date(n, a):
# Verificăm dacă n se află în intervalul dat
if n < 1 or n > 25:
return False

# Verificăm dacă toate elementele matricei sunt mai mici decât 1.000.000
for i in range(1, n + 1):
for j in range(1, n + 1):
if a[i][j] >= 1000000:
return False

# Dacă n și elementele matricei sunt valide, returnăm True
return True

def șerpuire(n, a):
rezultat = []

# Parcurgem matricea în modul cerut
for i in range(1, n + 1):
if i % 2 == 0: # in jos
for j in range(i, 0, -1):
rezultat.append(str(a[j][i - j + 1]))
else: # în sus
for j in range(i, 0, -1):
rezultat.append(str(a[i - j + 1][j]))

for j in range(2, n + 1):
if j % 2 != n % 2: # in jos
for i in range(n, j - 1, -1):
rezultat.append(str(a[n - i + j - 1][i]))
else: # în sus
for i in range(n, j - 1, -1):
rezultat.append(str(a[i][n - i + j - 1]))

# Returnăm rezultatul sub forma de șir de caractere cu elementele separate prin spații
return " ".join(rezultat)

if __name__ == '__main__':
# Citim datele de intrare
n = int(input())
a = [[0 for j in range(n + 1)] for i in range(n + 1)]
for i in range(1, n + 1):
rând = input().split()
for j in range(1, n + 1):
a[i][j] = int(rând[j - 1])

# Verificăm dacă datele sunt valide și afișăm un mesaj corespunzător
if validare_date(n, a):
print("\nDatele sunt introduse corect.\n")
# Rezolvăm problema și afișăm rezultatul
print(șerpuire(n, a))
else:
print("Datele nu corespund restrictiilor impuse.")

</syntaxhighlight>