Bitnami MediaWiki - User contributions [en]

2182 - 3 Cifre

2024-01-02T15:29:38Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==
Așa cum știm, lui Gigel îi place să se joace cu numerele. A scris pe caiet un număr, apoi a văzut că din acesta se pot extrage mai multe numere cu trei cifre consecutive. De exemplu, a scris pe caiet '''20172017'''; numerele cu trei cifre consecutive care se pot extrage sunt '''201, 172, 720 și 201'''. Gigel începe să-și pună diferite întrebări: care este cel mai mare număr cu trei cifre consecutive obținut? Dar cel mai mic? De câte ori apar ele? Unde apar? Care este cel mai mare număr de apariții a unui număr cu trei cifre?

== Cerinta ==

Fiind numărul un număr natural '''n''' și '''n''' numere naturale '''x (100 ≤ x ≤ 4294967295)''' să se determine:
1. Cel mai mic și cel mai mare număr din trei cifre consecutive care apar în cele '''n''' numere, de câte ori apar ele, în ce număr '''x[1]''' apar prima dată și în ce număr '''x[2]''' apar ultima dată.
2. Numerele din trei cifre consecutive care apar de cele mai multe ori în cele n numere.

== Date de intrare ==

Fișierul de intrare '''3cifrein.txt''' conţine pe prima linie, separate printr-un spațiu, numărul natural n, reprezentând numărul de numere și cerința (1 sau 2). Pe cea de a doua linie sunt scrise cele n numere naturale '''x[1] x[2] ... x[n]''', separate prin câte un spațiu.

== Date de iesire ==

Fișierul de ieșire '''3cifreout.txt''' va conține, pentru cerința 1, pe prima linie patru valori naturale '''nrmin nrapmin x1min x1max''', separate prin câte un spațiu, reprezentând numărul minim de trei cifre care apare, numărul de apariții a acestuia, numărul în care apare prima dată, respectiv numărul în care apare ultima dată, iar pe linia a doua alte patru valori naturale '''nrmax nrapmax x2min x2max''', separate prin câte un spațiu, reprezentând numărul maxim de trei cifre care apare, numărul de apariții a acestuia, numărul în care apare prima dată, respectiv numărul în care apare ultima dată. Pentru cerința 2, fișierul de ieșire va conține pe prima linie numărul maxim de apariții a numerelor din trei cifre consecutive care apar, iar pe linia a doua, separate prin câte un spațiu, numerele respective în ordine crescătoare.

== Restrictii si precizari ==

*1 &les; n &les; 500000
*100 &les; x[i] &les; 4294967295

== Exemplul 1 ==

;3cifrein.txt
:7 1
:415 5213 2017 666 12345678 10000013 13

:Datele introduse corespund restrictiilor impuse.
;3cifreout.txt
:100 1 10000013 10000013
:678 1 12345678 12345678

== Exemplul 2 ==

;3cifreint.txt
:7 1
:25 521013 206678 666 12345678 10101013 13

:Datele introduse nu corespund restrictiilor impuse.

== Rezolvare ==

<syntaxhighlight lang="python3" line="1">

def verifica_restrictii(n, x):
if not (1 <= n <= 500000):
return False

for numar in x:
if not (100 <= numar <= 4294967295):
return False

return True

def trei_cifre_consecutive(n, x, cerinta):
aparitii = {}
min_nr, max_nr = float('inf'), 0

for i in range(n):
numar_str = str(x[i])
for j in range(len(numar_str) - 2):
cifre_consecutive = int(numar_str[j:j+3])

if cifre_consecutive not in aparitii:
aparitii[cifre_consecutive] = [1, i + 1, i + 1]
else:
aparitii[cifre_consecutive][0] += 1
aparitii[cifre_consecutive][2] = i + 1

min_nr = min(min_nr, cifre_consecutive)
max_nr = max(max_nr, cifre_consecutive)

if cerinta == 1:
nr_ap_min, nrap_min, x1min, x1max = min_nr, aparitii[min_nr][0], aparitii[min_nr][1], aparitii[min_nr][2]
nr_ap_max, nrap_max, x2min, x2max = max_nr, aparitii[max_nr][0], aparitii[max_nr][1], aparitii[max_nr][2]
return nr_ap_min, nrap_min, x1min, x1max, nr_ap_max, nrap_max, x2min, x2max

elif cerinta == 2:
max_aparitii = max(aparitii.values(), key=lambda x: x[0])[0]
numere_max_aparitii = [numar for numar, info in aparitii.items() if info[0] == max_aparitii]
numere_max_aparitii.sort()
return max_aparitii, numere_max_aparitii

if __name__ == "__main__":
with open("3cifrein.txt", "r") as file:
n, cerinta = map(int, file.readline().split())
x = list(map(int, file.readline().split()))

if verifica_restrictii(n, x):
rezultat = trei_cifre_consecutive(n, x, cerinta)

with open("3cifreout.txt", "w") as file_out:
if cerinta == 1:
file_out.write(f"{rezultat[0]} {rezultat[1]} {rezultat[2]} {rezultat[3]}\n")
file_out.write(f"{rezultat[4]} {rezultat[5]} {rezultat[6]} {rezultat[7]}\n")
elif cerinta == 2:
file_out.write(f"{rezultat[0]}\n")
file_out.write(" ".join(map(str, rezultat[1])) + "\n")
else:
print("Datele de intrare nu respectă restricțiile specificate.")

</syntaxhighlight>

== Explicatie ==

Se observă că atât 111 cât și 113 apar de câte 3 ori.

1266 - Cauta Nr In Matrice

2024-01-02T15:27:13Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dă o matrice cu '''n''' linii şi '''m''' coloane ce conţine numere naturale astfel încât parcurgând matricea pe prima linie de la stânga la dreapta, pe a doua linie de la dreapta la stânga, pe a treia linie de la stânga la drepta, ş.a.m.d., toate elementele matricei vor forma un şir strict crescător. Fiind date '''p''' numere naturale ordonate strict crescător, să se afişeze pentru fiecare numărul liniei şi coloanei unde acesta se găseşte în matrice, respectiv '''0''' dacă acesta nu se găseşte în matrice.

== Date de intrare ==

Fișierul de intrare '''cautanrinmatricein.txt''' conține pe prima linie numerele '''n''' şi '''m''' reprezentând dimensiunile matricei , pe următoarele n linii câte m numere aranjate conform enunţului reprezentând elementele matricei, pe următoarea linie numărul p, iar pe ultima linie cele '''p''' numere în ordine strict crescătoare ce trebuie căutate în matrice.

== Date de iesire ==

Fișierul de ieșire '''cautanrinmatriceout.txt''' va conține pe primele '''p''' linii numărul liniei şi coloanei pe care se află în matrice fiecare din cele '''p''' numere date, respectiv '''0''' dacă numărul nu se găseşte în matrice.

== Restrictii si precizari ==

*'''1 &les; n , m &les; 1000'''
*elementele matricei sunt numere naturale mai mici decât '''2.000.000.000'''
*'''1 &les; p &les; 1.000.000'''
*cele p numere vor fi mai mici decât '''2.000.000.000'''

== Exemplul 1 ==

;cautanrinmatricein.txt
: 3 4
: 2 5 11 14
: 29 27 23 19
: 32 38 44 59
: 3
: 11 24 38

:Datele introduse corespund restrictiilor impuse.
;cautanrinmatriceout.txt
: 1 3
: 0
: 3 2

== Exemplul 2 ==

;cautanrinmatricein.txt
: 3 2
: 5 8
: 12 19
: 23 21

:Datele introduse nu corespund restrictiilor impuse.

== Rezolvare ==

<syntaxhighlight lang="python3" line="1">

def verifica_restrictiile(n, m, p, matrice, numere_cautate):
if not (1 <= n <= 1000 and 1 <= m <= 1000 and 1 <= p <= 1000000):
return False

for rand in matrice:
if len(rand) != m:
return False

if len(numere_cautate) != p:
return False

if any(not (1 <= num < 2000000000) for rand in matrice for num in rand) or any(not (1 <= num < 2000000000) for num in numere_cautate):
return False

return True

def cautare_numere_in_matrice(n, m, matrice, p, numere_cautate):
rezultat = []

for numar in numere_cautate:
gasit = False
for i in range(n):
if i % 2 == 0:
for j in range(m):
if matrice[i][j] == numar:
rezultat.append((i + 1, j + 1))
gasit = True
break
else:
for j in range(m - 1, -1, -1):
if matrice[i][j] == numar:
rezultat.append((i + 1, j + 1))
gasit = True
break

if not gasit:
rezultat.append(0)

return rezultat

if __name__ == "__main__":
with open("cautanrinmatricein.txt", "r") as fisier:
n, m = map(int, fisier.readline().split())
matrice = [list(map(int, fisier.readline().split())) for _ in range(n)]
p = int(fisier.readline())
numere_cautate = list(map(int, fisier.readline().split()))

if verifica_restrictiile(n, m, p, matrice, numere_cautate):
rezultat = cautare_numere_in_matrice(n, m, matrice, p, numere_cautate)

with open("cautanrinmatriceout.txt", "w") as fisier_out:
for item in rezultat:
if isinstance(item, tuple):
fisier_out.write(f"{item[0]} {item[1]}\n")
else:
fisier_out.write(f"{item}\n")
else:
print("Datele de intrare nu respectă restricțiile specificate.")

</syntaxhighlight>

== Explicatie ==

Numărul 11 se află în matrice pe linia 1 coloana 3, numărul 24 nu se află în matrice, iar numărul 38 se află în matrice pe linia 3, coloana 2.

3672 - Calculeaza pe n

2023-12-29T12:31:39Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se citește de la tastatură număr natural '''n'''. Pornind de la valoarea '''1''', asupra valorii curente '''x''' se pot aplica următoarele trei operații: înmulțire cu '''2''', înmulțire cu '''3''' sau adunare cu '''1'''. De exemplu, dacă '''x=1''' atunci se poate obține '''2''' (prin înmulțirea cu 2 sau prin adunarea cu 1) sau '''3''' (prin înmulțirea cu 3).

Calculați numărul minim de operații necesare pentru a obține numărul '''n''' începând de la numărul '''1'''.

== Date de intrare ==

Programul citește de la tastatură numărul '''n'''.

== Date de iesire ==

Programul va afișa pe ecran numărul '''k''', reprezentând numărul minim de operații pentru obținerea numărului '''n''' pornind de la '''1''' sau valoarea '''0''' dacă nu se poate obține '''n'''.

== Restrictii si precizari ==

*1 &les; n &les; 1.000.000

== Exemplul 1 ==
;Intrare
:1
;Iesire
:Datele introduse corespund restrictiilor impuse
:0

== Exemplul 2 ==
;Intrare
:0
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def numar_minim_operatii(n):
dp = [float('inf')] * (n + 1)
dp[1] = 0

for i in range(1, n + 1):
if i * 2 <= n:
dp[i * 2] = min(dp[i * 2], dp[i] + 1)
if i * 3 <= n:
dp[i * 3] = min(dp[i * 3], dp[i] + 1)
if i + 1 <= n:
dp[i + 1] = min(dp[i + 1], dp[i] + 1)

return dp[n] if dp[n] != float('inf') else 0

def verificare_date_intrare(n):
return 1 <= n <= 1000000

# Citire număr de la tastatură
n = int(input("Introduceți numărul n: "))

# Verificare date de intrare
if not verificare_date_intrare(n):
print("Datele introduse nu corespund restricțiilor impuse")
else:
# Calcul și afișare rezultat
rezultat = numar_minim_operatii(n)
print(f"Numărul minim de operații pentru a obține {n} este: {rezultat}")

</syntaxhighlight>

3244 - tabla

2023-12-29T12:30:37Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==

O tablă de șah de dimensiune '''n x n''' conține pe toate pătrățelele câte o piesă cu una din culorile: alb, negru, roșu, verde sau albastru. Pe tablă nu există 3 piese consecutive pe aceeași linie sau coloană de aceeași culoare. O mutare presupune interschimbarea a două piese alăturate, fie pe o linie, fie pe o coloană. După mutare se acordă punctaj dacă se obțin următoarele situații și nu numai:

*'''3''' piese de aceeași culoare consecutive pe o linie sau o coloană '''= 1''' punct;
*'''3''' piese de aceeași culoare consecutive pe o linie și o coloană '''= 5''' puncte;
La orice situație de mai sus, o piesă în plus de aceeași culoare mai contribuie cu încă 1 la punctaj. De exemplu, 4 piese de aceeași culoare consecutive pe o linie sau o coloană '''= 2''' puncte. Punctajele obținute de piesele interschimbate se adună. Punctajul este 0 dacă nu se obțin măcar 3 piese consecutive de aceeași culoare.

== Cerinta ==

Găsiți cel mai mare punctaj obținut în urma unei singure mutări.

== Date de intrare ==

Fișierul de intrare '''tablain.txt''' conține, pe prima linie, numărul natural '''n''', ce reprezintă dimensiunea tablei. Pe fiecare dintre următoarele '''n''' linii se află câte '''n''' valori separate prin spatii. Valorile posibile pot fi: '''1, 2, 3, 4 și 5'''. Valoarea '''1''' reprezintă piesa de culoare albă, '''2''' piesa de culoare neagră etc.

== Date de iesire ==

Fișierul de ieșire '''tablaout.txt''' va conține cel mai mare punctaj obținut.

== Restrictii si precizari ==

*1 &les; n &les; 20

== Exemplul 1 ==
;tablain.txt
:3
:1 1 2
:2 2 1
:3 4 5

;tablaout.txt
:Datele introduse corespund restrictiilor impuse
:2

== Exemplul 2 ==
;tablain.txt
:3
:0 0 0
:-10 23 3
:1 72 0

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def calculeaza_punctaj(tabla, n, i1, j1, i2, j2):
punctaj = 0

# Verificare pe linii
if i1 < n - 2 and tabla[i1][j1] == tabla[i1 + 1][j1] == tabla[i1 + 2][j1]:
punctaj += 1
if i2 < n - 2 and tabla[i2][j2] == tabla[i2 + 1][j2] == tabla[i2 + 2][j2]:
punctaj += 1

# Verificare pe coloane
if j1 < n - 2 and tabla[i1][j1] == tabla[i1][j1 + 1] == tabla[i1][j1 + 2]:
punctaj += 1
if j2 < n - 2 and tabla[i2][j2] == tabla[i2][j2 + 1] == tabla[i2][j2 + 2]:
punctaj += 1

# Verificare pe diagonale
if i1 < n - 2 and j1 < n - 2 and tabla[i1][j1] == tabla[i1 + 1][j1 + 1] == tabla[i1 + 2][j1 + 2]:
punctaj += 1
if i2 < n - 2 and j2 < n - 2 and tabla[i2][j2] == tabla[i2 + 1][j2 + 1] == tabla[i2 + 2][j2 + 2]:
punctaj += 1

return punctaj

def cel_mai_mare_punctaj(tabla, n):
max_punctaj = 0

for i1 in range(n):
for j1 in range(n):
for i2 in range(i1, n):
for j2 in range(n):
# Pentru fiecare pereche de piese alaturate, calculam punctajul
if (i1 != i2 or abs(j1 - j2) != 1) and (j1 != j2 or abs(i1 - i2) != 1):
tabla[i1][j1], tabla[i2][j2] = tabla[i2][j2], tabla[i1][j1]
punctaj = calculeaza_punctaj(tabla, n, i1, j1, i2, j2)
max_punctaj = max(max_punctaj, punctaj)
tabla[i1][j1], tabla[i2][j2] = tabla[i2][j2], tabla[i1][j1] # revenire la starea initiala

return max_punctaj

def verificare_date_intrare(n, tabla):
if not (1 <= n <= 20):
return False

for i in range(n):
if len(tabla[i]) != n or not all(1 <= tabla[i][j] <= 5 for j in range(n)):
return False

return True

# Citire date de intrare
with open("tablain.txt", "r") as file:
n = int(file.readline())
tabla = [list(map(int, file.readline().split())) for _ in range(n)]

# Verificare date de intrare
if not verificare_date_intrare(n, tabla):
print("Datele introduse nu corespund restricțiilor impuse")
else:
# Calcul si afisare rezultat
rezultat = cel_mai_mare_punctaj(tabla, n)
with open("tablaout.txt", "w") as file:
file.write(str(rezultat) + "\n")

</syntaxhighlight>

== Explicatie ==

Prin interschimbarea elementului (1,3) cu (2,3) se obține:
:1 1 1
:2 2 2
:3 4 5
și am 1 punct din prima linie și 1 punct din a doua linie.

2629 - H3

2023-12-29T12:29:06Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==

Tocmai ai primit cadou de ziua ta un șir de numere naturale '''a[1], a[2], …, a[n]'''. Ca să te simți împlinit, trebuie să determini lungimea maximă a unei secvențe cu proprietatea că oricare două valori din secvență sunt distincte.

== Cerinta ==

Determină lungimea maximă cerută și anul viitor vei mai primi un șir!

== Date de intrare ==

Programul citește de la tastatură numărul '''n''', apoi șirul de '''n''' numere naturale, separate prin spații.

== Date de iesire ==

Programul va afișa pe ecran lungimea maximă a secvenței de valori distincte.

== Restrictii si precizari ==

*1 &les; n &les; 1.000.000
*0 &les; a[i] &les; 1.000.000.000

== Exemplul 1 ==
;Intrare
:9
:1 2 1 2 5 6 7 2 9
;Iesire
:Datele introduse corespund restrictiilor impuse
:5

== Exemplul 2 ==
;Intrare
:5
:-10 0 5.2 8 3
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def lungime_maxima_secventa_distincte(n, vector):
frecvente = dict()
stanga = 0
lungime_maxima = 0

for dreapta in range(n):
numar = vector[dreapta]

while frecvente.get(numar, 0) > 0:
frecvente[vector[stanga]] -= 1
stanga += 1

frecvente[numar] = 1
lungime_maxima = max(lungime_maxima, dreapta - stanga + 1)

return lungime_maxima

def verificare_date_intrare(n, vector):
if not (1 <= n <= 1000000) or len(vector) != n or not all(0 <= numar <= 1000000000 for numar in vector):
return False
return True

# Citire numar de elemente
n = int(input("Introduceți numărul de elemente: "))

# Citire vector
vector = list(map(int, input("Introduceți elementele vectorului, separate prin spațiu: ").split()))

# Verificare date de intrare
if not verificare_date_intrare(n, vector):
print("Datele introduse nu corespund restricțiilor impuse")
else:
# Calcul și afișare rezultat
rezultat = lungime_maxima_secventa_distincte(n, vector)
print(f"Lungimea maximă a secvenței de valori distincte este: {rezultat}")

</syntaxhighlight>

== Explicatie ==

Secvența de lungime maximă 5 este 1 2 5 6 7.

2627 - H1

2023-12-29T12:27:49Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==

Se dau două șiruri de numere naturale '''a[1], a[2], …, a[n]''' și '''b[1], b[2], …, b[m]'''.

== Cerinta ==

Să se determine câte numere distincte au în comun cele două șiruri. De exemplu, șirurile '''a=(2,5,1,4,5,1)''' și '''b=(1,1,1,3,7,5)''' au în comun două numere distincte: 1 și 5.

== Date de intrare ==

Programul citește de la tastatură numere naturale '''A, B, C, D, n, x, m, y'''. Cele două șiruri se generează astfel:

*a[1] = x și, pentru i ≥ 2, a[i] = A + (a[i-1] * C + D) % (B - A + 1)
*b[1] = y și, pentru i ≥ 2, b[i] = A + (b[i-1] * C + D) % (B - A + 1)

== Date de iesire ==

Programul va afișa pe ecran numărul '''C''', reprezentând câte numere distincte au în comun cele două șiruri.

== Restrictii si precizari ==

*2 &les; n, m &les; 2 000 000
*2 &les; A, B, C, D, x, y &les; 10 000 000

== Exemplul 1 ==
;Intrare
:1 30 17 16 50 2 60 14
;Iesire
:Datele introduse corespund restrictiilor impuse
:4

== Exemplul 2 ==
;Intrare
:6.2 8 -11 2.2 0 -2.2 8 10
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def generate_sequence(A, B, C, D, x, n):
sequence = [x]
for i in range(2, n + 1):
next_element = (A + (sequence[i - 1] * C + D)) % (B - A + 1)
sequence.append(next_element)
return sequence

def verificare_date_intrare(A, B, C, D, x, n, m, y):
if not (2 <= n <= 2000000) or not (2 <= m <= 2000000):
return False
if not (2 <= A <= 10000000) or not (2 <= B <= 10000000) or not (2 <= C <= 10000000) or not (2 <= D <= 10000000):
return False
if not (2 <= x <= 10000000) or not (2 <= y <= 10000000):
return False
return True

# Citire date de intrare
A, B, C, D, n, x, m, y = map(int, input().split())

# Verificare date de intrare
if not verificare_date_intrare(A, B, C, D, x, n, m, y):
print("Datele introduse nu corespund restricțiilor impuse")
else:
# Generare șiruri
sequence_a = generate_sequence(A, B, C, D, x, n)
sequence_b = generate_sequence(A, B, C, D, y, m)

# Identificare numere comune
set_a = set(sequence_a)
set_b = set(sequence_b)
common_numbers = set_a.intersection(set_b)

# Afișare rezultat
print(len(common_numbers))

</syntaxhighlight>

3587 - Duplicat

2023-12-29T12:26:49Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dau un număr '''n''' și '''n+1''' numere naturale cuprinse între 1 și n inclusiv.
Cerința 1: Pentru un număr '''k''' citit, să se afișeze al '''k'''-lea termen al șirului citit anterior.
Cerința 2: Știind că dintre cele '''n+1''' numere citite, un singur număr se poate repeta, se cere să se afișeze acest număr.

== Date de intrare ==

Programul citește de la tastatură numărul '''n''' pe prima linie, iar apoi, pe a doua linie '''n+1''' numere naturale, separate prin spații. Pe a treia linie se va afla numărul '''k'''.

== Date de iesire ==

Programul va afișa pe ecran pe prima linie răspunsul pentru cerința 1, iar pe a doua linie răspunsul pentru cerința 2.

== Restrictii si precizari ==

*1 &les; n &les; 470000
*Pentru cerința 2, un singur număr se poate repeta de mai multe ori
*Atenție la limita de timp și de memorie !!!

== Exemplul 1 ==
;Intrare
:5
:1 2 3 3 4 5
:2
;Iesire
:Datele introduse corespund restrictiilor impuse
:2
:3

== Exemplul 2 ==
;Intrare
:-5
:1 5 0 2 2 2.6
:4
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def cerinta_1_si_2(n, numere, k):
aparitii = [0] * (n + 1)

for numar in numere:
aparitii[numar] += 1

frecventa_maxima = max(aparitii)
numar_repetat = aparitii.index(frecventa_maxima)

count = 0
for numar in numere:
if numar == numar_repetat:
count += 1
if count == 2:
break

index_k = numere[k - 1]
return index_k, numar_repetat

def verificare_date_intrare(n, numere, k):
if not (1 <= n <= 470000) or len(numere) != n + 1 or not all(1 <= numar <= n for numar in numere) or not (1 <= k <= n + 1):
return False
return True

# Citire numar de elemente
n = int(input("Introduceți numărul n: "))

# Citire vector de n+1 numere
numere = list(map(int, input("Introduceți n+1 numere, separate prin spațiu: ").split()))

# Citire numar k
k = int(input("Introduceți numărul k: "))

# Verificare date de intrare
if not verificare_date_intrare(n, numere, k):
print("Datele introduse nu corespund restricțiilor impuse")
else:
# Calcul și afișare rezultat
rezultat_cerinta_1, rezultat_cerinta_2 = cerinta_1_si_2(n, numere, k)
print(f"Răspuns pentru cerința 1: {rezultat_cerinta_1}")
print(f"Răspuns pentru cerința 2: {rezultat_cerinta_2}")

</syntaxhighlight>

== Explicatie ==

Al doilea numar din șir este 2, iar numărul 3 se repeta.

3523 - John

2023-12-29T12:25:36Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Un canadian deține o firmă cu '''n''' muncitori. Fiecare din aceștia lucrează la '''m''' case, codificate prin numere naturale. Canadianul dorește să afle:

:1) numărul maxim de muncitori care lucrează la aceeași casă
:2) numărul maxim de case la care lucreaza simultan cel putin doi muncitori

== Date de intrare ==

Programul citește de la tastatură numerele '''n, m''', iar apoi '''n * m''' numere naturale. Primele '''m''' numere reprezintă indicii caselor la care lucrează muncitorul 1, următoarele '''m''' numere reprezintă indicii caselor la care lucrează muncitorul 2, …, ultimele m numere reprezintă indicii caselor la care lucrează muncitorul n.

== Date de iesire ==

Programul va afișa pe ecran raspunsurile la cele două cerințe.

== Restrictii si precizari ==

*'''n, m''', numărul de case la care se lucrează sunt mai mici decât '''1.001'''
*cele '''n * m''' numere citite vor fi mai mici decât '''1.000.000.001'''

== Exemplul 1 ==
;Intrare
:3 3
:1 2 3
:2 3 4
:3 4 5
;Iesire
:Datele introduse corespund restrictiilor impuse
:3
:2

== Exemplul 2 ==
;Intrare
:3 3
:5.2 100 7.9
:0 2 17
:-3 9 10.7
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def max_muncitori_pe_o_casa(numar_muncitori, indici_case):
frecventa_case = {}
for indice_casa in indici_case:
if indice_casa not in frecventa_case:
frecventa_case[indice_casa] = 0
frecventa_case[indice_casa] += 1

return max(frecventa_case.values())

def max_case_cu_muncitori(n, m, indici_case_muncitori):
frecventa_case = {}
for indici_case in indici_case_muncitori:
for indice_casa in indici_case:
if indice_casa not in frecventa_case:
frecventa_case[indice_casa] = 0
frecventa_case[indice_casa] += 1

numar_maxim_case = 0
for frecventa in frecventa_case.values():
if frecventa >= 2:
numar_maxim_case += 1

return numar_maxim_case

def verificare_date_intrare(n, m, indici_case_muncitori):
if not (1 <= n <= 1000) or not (1 <= m <= 1000):
return False
for indici_case in indici_case_muncitori:
if len(indici_case) != m or not all(1 <= indice <= 1000000000 for indice in indici_case):
return False
return True

# Citire date de intrare
n = int(input("Introduceți numărul de muncitori (n): "))
m = int(input("Introduceți numărul de case (m): "))

indici_case_muncitori = []
for i in range(n):
indici_casa_muncitor = list(map(int, input(f"Introduceți indicii caselor pentru muncitorul {i + 1}, separați prin spațiu: ").split()))
indici_case_muncitori.append(indici_casa_muncitor)

# Verificare date de intrare
if not verificare_date_intrare(n, m, indici_case_muncitori):
print("Datele introduse nu corespund restricțiilor impuse")
else:
# Calcul și afișare rezultate
max_muncitori_pe_o_casa_result = max_muncitori_pe_o_casa(n, indici_case_muncitori[0])
max_case_cu_muncitori_result = max_case_cu_muncitori(n, m, indici_case_muncitori)

print(f"Numărul maxim de muncitori care lucrează la aceeași casă este: {max_muncitori_pe_o_casa_result}")
print(f"Numărul maxim de case la care lucrează simultan cel puțin doi muncitori este: {max_case_cu_muncitori_result}")

</syntaxhighlight>

== Explicatie ==

Toți cei 3 muncitori lucrează la casa 3. Intersecția dintre oricare 2 muncitori este mai mică sau egală cu 2.

3795 - Paranteze4

2023-12-29T12:23:30Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Să se scrie un program care citește un șir de paranteze rotunde care se închid corect (corect parantezat) în care parantezele deschise sunt numerotate de la stânga la dreapta, începând de la 1, și determină pentru fiecare paranteză închisă numărul de ordine al parantezei deschise corespunzătoare.

Un șir de paranteze rodunde '''S''' este corect parantezat dacă:

*S este șirul vid, sau
*S = (T) și T este corect parantezat, sau
*S = AB, iar A și B sunt corect parantezate.

== Date de intrare ==

Programul citește de la tastatură șir de paranteze rotunde, corect parantezat.

== Date de iesire ==

Programul va afișa pe ecran, pentru fiecare paranteză închisă, poziția în șir a parantezei deschise corespunzătoare.

== Restrictii si precizari ==

*șirul citit va conține cel mult '''254''' de caractere, numai ( și );
*în șirul dat caracterele sunt numerotate de la 1.

== Exemplul 1 ==
;Intrare
:()((()())())
;Iesire
Datele introduse corespund restrictiilor impuse
:1 4 5 3 6 2

== Exemplul 2 ==
;Intrare
:( ) b a / .
;Iesire
Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def paranteze_corecte(sir):
stiva = []
rezultat = []

for i, paranteza in enumerate(sir):
if paranteza == '(':
stiva.append(i + 1)
elif paranteza == ')':
if stiva:
deschisa = stiva.pop()
rezultat.append((deschisa, i + 1))
else:
print("Parantezele nu sunt corect parantezate.")
return None

if stiva:
print("Parantezele nu sunt corect parantezate.")
return None

return rezultat

def verificare_date_intrare(sir):
return all(caracter in '()' for caracter in sir) and len(sir) <= 254

# Citire șir de paranteze rotunde
sir_paranteze = input("Introduceți șirul de paranteze rotunde: ")

# Verificare date de intrare
if not verificare_date_intrare(sir_paranteze):
print("Datele introduse nu corespund restrictiilor impuse")
else:
# Calcul și afișare rezultate
rezultate = paranteze_corecte(sir_paranteze)
if rezultate:
for deschisa, inchisa in rezultate:
print(f"Paranteza deschisa la pozitia {deschisa} se inchide la pozitia {inchisa}.")

</syntaxhighlight>

== Explicatie ==

1 2 3 4 5 6
( ) ( ( ( ) ( ) ) ( ) )
1 4 5 3 6 2

2880 - Gradinita

2023-12-29T12:20:35Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

La grădinița Prichindel sunt copii cuminți și copii obraznici. Moș Crăciun a adus cadouri doar pentru câțiva copii cuminți. Problema este că nu se știe exact care copil e obraznic și care este cuminte. Ajutați-o pe doamna educatoare să afle care copil primește cadou și care nu. Se cunoaște faptul că la grădiniță sunt exact '''n''' copii și fiecare copil are inscripționat pe uniformă un număr natural nenul, distinct.

În prima etapă, sunt scoși din lista Moșului copiii obraznici care sunt cei ce au inscripționate pe uniformă numere prime. În a două etapă, din copiii rămași, sunt scoși și cei care au suma cifrelor de pe pozițiile impare egală cu un număr prim (cifrele se numerotează de la stânga la dreapta, începând cu poziția 1, corespunzătoare cifrei cea mai semnificative).

În a treia etapă (ultima), se elimină din lista copiilor cuminți rămași după primele două etape, din '''k în k''' până când se ajunge la capătul listei.

Să se determine copiii care au rămas pe lista copiilor cuminți după toate cele trei etape eliminatorii, sau mesajul Toti copiii sunt obraznici!, dacă toți copiii au fost eliminați.

== Date de intrare ==

Pe prima linie a fișierului de intrare '''gradinitain.txt''' se află două numere '''n''' și '''k''' cu semnificația din enunț. Pe a două linie a fișierului de intrare se află n numere naturale, cu semnificația din enunț.

== Date de iesire ==

În fișierul de ieșire '''gradinitaout.txt''' se va afișa lista după a treia etapă eliminatorie conform valorii cerinței.

== Restrictii si precizari ==

*'''1 &les; n &les; 100000'''
*'''1 &les; x &les; 100000''' (unde x reprezintă numărul inscripționat pe uniforma unui copil)

== Exemplul 1 ==
;gradinitain.txt
:9 4
:3 102 31 333 46 1022 10 4848 21

;gradinitaout.txt
:Datele introduse corespund restrictiilor impuse
:333 46 10

== Exemplul 2 ==
;gradinitain.txt
:-5 7
:5 309 -57 982 4

:Datele introduse nu corespund restrictiilor impuse

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

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

def verificare_date_intrare(n, k, copii):
if not (1 <= n <= 100000) or not (1 <= k <= 100000):
return False
for copil in copii:
if not (1 <= copil <= 100000):
return False
return True

# Citire din fișierul de intrare
with open('gradinitain.txt', 'r') as file:
n, k = map(int, file.readline().split())
copii = list(map(int, file.readline().split()))

# Verificare date de intrare
if not verificare_date_intrare(n, k, copii):
print("Datele introduse nu corespund restrictiilor impuse")
else:
# Etapa 1: Eliminare copii obraznici cu numere prime
copii = [copil for copil in copii if not este_prim(copil)]

# Etapa 2: Eliminare copii obraznici cu suma cifrelor de pe poziții impare primă
copii = [copil for copil in copii if not este_prim(suma_cifre(copil))]

# Etapa 3: Eliminare copii cuminți din k în k
if copii:
copii = copii[k-1::k]

# Scriere în fișierul de ieșire
with open('gradinitaout.txt', 'w') as file:
if copii:
file.write(' '.join(map(str, copii)))
else:
file.write('Toti copiii sunt obraznici!')

</syntaxhighlight>

0184 - Interval 1

2023-12-29T12:19:13Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dă un şir de '''n'''' numere întregi şi un număr '''k'''. Să se determine intervalul '''[a,b]''' de lungime minimă care conţine cel puţin '''k''' elemente din sir.

== Date de intrare ==

Fişierul de intrare '''interval1i.txt''' conţine pe prima linie numerele '''n''' şi '''k''', iar pe următoarele linii '''n''' numere întregi separate prin spaţii, reprezentând elementele şirului.

== Date de iesire ==

Fişierul de ieşire '''interval1out.txt''' va conţine pe prima linie două numere '''a''' şi '''b''', separate printr-un spaţiu, cu semnificaţia de mai sus.

== Restrictii si precizari ==

*'''1 &les; k &les; n &les; 1000'''
*elementele şirului aparţin intervalului [-1000,1000] şi pot fi dispuse în fişierul de intrare pe mai multe linii
*dacă există mai multe intervale [a,b] de lungime minimă care conţin cel puţin k elemente din sir se va alege acela pentru care a este minim
*'''a ≤ b'''

== Exemplul 1 ==
;interval1in.txt
:10 3
:11 9 3 2 8 11 9 10 15 13
;interval1out.txt
:Datele introduse corespund restrictiilor impuse
:8 9

== Exemplul 2 ==
;interval1in.txt
:4 2
:20,5,100,75.2

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def gaseste_interval(n, k, sir):
index_start = 0
index_end = k - 1
sir.sort()

lungime_minima = sir[index_end] - sir[index_start]
interval_minim = (sir[index_start], sir[index_end])

for i in range(1, n - k + 1):
lungime_curenta = sir[i + k - 1] - sir[i]
if lungime_curenta < lungime_minima:
lungime_minima = lungime_curenta
index_start = i
index_end = i + k - 1
interval_minim = (sir[index_start], sir[index_end])

return interval_minim

# Citire din fișierul de intrare
with open('interval1i.txt', 'r') as file:
n, k = map(int, file.readline().split())
sir = []
for _ in range(n):
sir.extend(map(int, file.readline().split()))

# Apelare funcție
rezultat = gaseste_interval(n, k, sir)

# Scriere în fișierul de ieșire
with open('interval1out.txt', 'w') as file:
file.write(f"{rezultat[0]} {rezultat[1]}")

# Verificare restrictii
assert 1 <= k <= n <= 1000
assert all(-1000 <= x <= 1000 for x in sir)

</syntaxhighlight>

== Explicatie ==

Intervalul [8,9] conţine 3 elemente ale şirului – 8 9 9 şi are lungimea minimă. Există încă un interval cu aceeaşi lungime care conţine 3 elemente din şir – [9,10] elemente dar 8<9.

0263 - Intervale 2

2023-12-29T12:18:08Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dau '''n''' intervale '''[a,b]''', unde a şi b sunt numere întregi. Să se determine intervalul rezultat prin intersectarea intervalelor date.

== Date de intrare ==

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

== Date de iesire ==

Fişierul de ieşire '''intervale2out.txt''' va conţine pe prima linie cele două numere care reprezintă intervalul intersecție, separate printr-un spațiu, sau valoarea 0, dacă intersecția celor n intervale este mulțimea vidă.

== Restrictii si precizari ==

*1 &les; n &les; 100
*pentru fiecare interval dat [a,b], -100 &les; a , b &les; 100

== Exemplul 1 ==
;intervale2in.txt
:5
:-7 10
:3 20
:-5 5
:0 12
:-8 30
;intervale2out.txt
:Datele introduse corespund restrictiilor impuse
:3 5

== Exemplul 2 ==
;intervale2in.txt
:3
:-2.5 1
:100 0
:6.3 17,2

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def intersectare_intervale(intervale):
# Sortează intervalele după capătul stâng
intervale.sort(key=lambda x: x[0])

# Inițializare intersecție cu primul interval
intersecție = intervale[0]

# Verificare intersecție cu celelalte intervale
for interval in intervale[1:]:
if interval[0] <= intersecție[1]:
# Există intersecție între intervale
intersecție = [max(interval[0], intersecție[0]), min(interval[1], intersecție[1])]
else:
# Nu există intersecție
return [0, 0]

return intersecție

# Citirea datelor din fișierul de intrare
with open("intervale2in.txt", "r") as f:
n = int(f.readline())
intervale = [list(map(int, f.readline().split())) for _ in range(n)]

# Calculul intervalului de intersecție
rezultat = intersectare_intervale(intervale)

# Scrierea rezultatului în fișierul de ieșire
with open("intervale2out.txt", "w") as g:
g.write(" ".join(map(str, rezultat)))

# Verificare restrictii
assert 1 <= n <= 100
for i in range(n):
a, b = intervale[i]
assert -100 <= a <= 100
assert -100 <= b <= 100

</syntaxhighlight>

0262 - Intervale 1

2023-12-29T12:16:56Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dă un șir de '''n''' numere reale, în ordine strict crescătoare. Să se determine un număr natural '''x''', cu proprietatea că în orice interval deschis având drept capete oricare două valori din șir se află cel puțin '''x''' numere întregi.

== Date de intrare ==

Fişierul de intrare '''intervale1in.txt''' conţine pe prima linie numărul '''n'''; urmează n numere reale, în ordine strict crescătoare, separate prin spaţii, reprezentând elementele şirului, ce pot fi dispuse pe mai multe linii.

== Date de iesire ==

Fişierul de ieşire '''intervale1out.txt''' va conţine pe prima linie numărul '''x'''.

== Restrictii si precizari ==

*1 &les; n &les; 100.000
*numerele reale din fișierul de intrare au valoarea absolută mai mică decât '''100.000.000'''

== Exemplul 1 ==
;intervale1in.txt
:6
:3.5 5.1 9.2 16 20.33 100
;intervale1out.txt
:Datele introduse corespund restrictiilor impuse
:2

== Exemplul 2 ==
;intervale1in.out
:6
:100 20.33 16 9.2 5.1 3.5

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def gaseste_x(șir):
# Inițializare x cu o valoare mare
x = float("inf")

# Parcurgere șir și actualizare x
for i in range(1, len(șir)):
distanța = int(șir[i] - șir[i-1])
x = min(x, distanța)

return x + 1 # x este minimul număr natural care îndeplinește condiția

# Citirea datelor din fișierul de intrare
with open("intervale1in.txt", "r") as f:
n = int(f.readline())
șir = [float(f.readline()) for _ in range(n)]

# Calculul valorii x
rezultat = gaseste_x(șir)

# Scrierea rezultatului în fișierul de ieșire
with open("intervale1out.txt", "w") as g:
g.write(str(rezultat))

# Verificare restrictii
assert 1 <= n <= 100000
for i in range(n):
assert abs(șir[i]) < 100000000

</syntaxhighlight>

0949 - Calendar 3

2023-12-29T12:14:55Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Dându-se o dată calendaristică și un număr nr de zile, să se determine care este data aflată la o diferență de nr de zile.

== Date de intrare ==

Programul citește de la tastatură 3 numere naturale '''Z, L și A''', reprezentând ziua, luna si anul curent, iar pe al doilea rând numărul nr de zile.

== Date de iesire ==

Programul va afișa pe ecran 3 numere naturale '''ZI, LUNA, AN''' reprezentând data cerută.

== Restrictii si precizari ==

*-100.000 &les; nr &les; 100000
*Datele calendaristice din fișierul de intrare sunt între 1 ianuarie 1900 și 31 decembrie 2100
*Nu se vor fi date calendaristice invalide precum 29 februarie 2015 sau 31 noiembrie 1980
*Dacă nr este negativ, data cerută se afla înaintea cele curente.

== Exemplul 1 ==
;Intrare
:6 1 2015
:15
;Iesire
:Datele introduse corespund restrictiilor impuse
:21 1 2015

== Exemplul 2 ==
;Intrare
:29 2 2015
:25
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def adauga_zile(Z, L, A, nr_zile):
# Functie pentru a adauga un numar de zile la o data calendaristica
zile_luna = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

while nr_zile > 0:
zile_luna[2] = 29 if (A % 4 == 0 and A % 100 != 0) or (A % 400 == 0) else 28
Z += 1

if Z > zile_luna[L]:
Z = 1
L += 1

if L > 12:
L = 1
A += 1

nr_zile -= 1

return Z, L, A

def verifica_restrictii(Z, L, A, nr_zile):
if (
1 <= Z <= 31
and 1 <= L <= 12
and 1900 <= A <= 2100
and -100000 <= nr_zile <= 100000
):
return True
else:
return False

# Citire date de intrare
Z, L, A = map(int, input().split())
nr_zile = int(input())

# Verificare restricții
if verifica_restrictii(Z, L, A, nr_zile):
# Rezolvare și afișare rezultat
zi_noua, luna_noua, an_nou = adauga_zile(Z, L, A, nr_zile)
print("Datele introduse corespund restrictiilor impuse")
print(f"{zi_noua} {luna_noua} {an_nou}")
else:
print("Date de intrare nevalide!")

</syntaxhighlight>

0948 - Calendar 2

2023-12-29T12:12:46Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Fermierului Ion îi place să-și organizeze activitățile din timp. Chiar prea mult. Acesta ajunge să-și facă planuri și pentru câțiva ani. Singura dilemă pe care o are acesta este în ce zi a săptămânii va cădea data pe care își propune să efectueze respectiva activitate.

Preocuparea sa este atât de mare încât se întreabă și de evenimente care au avut loc în trecut.

== Date de intrare ==

Programul citește de la tastatură numărul o dată calendaristică, formată din 3 numere naturale '''Z, L și A''' reprezentând ziua, luna și anul.

== Date de iesire ==

Programul va afișa pe ecran una din zilele săptămânii (Luni, Marti, Miercuri, Joi, Vineri, Sambata, Duminica) semnificând ziua săptămânii corespunzătoare datei cerute.

== Restrictii si precizari ==

*1 &les; Z &les; 31
*1 &les; L &les; 12
*1900 &les; A &les; 2100
*Nu se vor cere zile invalide precum 29 februarie 2015 sau 31 noiembrie 1980

== Exemplul 1 ==
;Intrare
:6 1 2015
;Iesire
:Datele introduse corespund restrictiilor impuse
:Marti

== Exemplul 2 ==
;Intrare
:31 2 3100
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def ziua_saptamanii(Z, L, A):
if L < 3:
L += 12
A -= 1

K = A % 100
J = A // 100

numar_zi = (Z + 13 * (L + 1) // 5 + K + K // 4 + J // 4 - 2 * J) % 7

zile_saptamana = ["Duminica", "Luni", "Marti", "Miercuri", "Joi", "Vineri", "Sambata"]
return zile_saptamana[numar_zi]

def verifica_restrictii(Z, L, A):
if 1 <= Z <= 31 and 1 <= L <= 12 and 1900 <= A <= 2100:
return True
else:
return False

# Citire date de intrare
Z, L, A = map(int, input().split())

# Verificare restricții
if verifica_restrictii(Z, L, A):
# Rezolvare și afișare rezultat
rezultat = ziua_saptamanii(Z, L, A)
print("Datele introduse corespund restrictiilor impuse")
print(rezultat)
else:
print("Date de intrare nevalide!")

</syntaxhighlight>

2024 - Divizor 112

2023-12-29T12:11:45Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dă un şir format din '''n''' numere naturale nenule. Aflaţi cel mai mic număr natural, diferit de 1, care divide un număr maxim de numere din şir.

== Date de intrare ==

Fișierul de intrare '''divizor112in.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale nenule separate prin spații.

== Date de iesire ==

Fișierul de ieșire '''divizor112out.txt''' va conține pe prima linie cel mai mic număr natural, diferit de 1, care divide un număr maxim de numere din şir.

== Restrictii si precizari ==

*1 &les; n &les; 100.000
*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât 1.000.000

== Exemplul 1 ==
;divizor112in.txt
:5
:1 2 3 4 5

;divizor112out.txt
:Datele introduse corespund restrictiilor impuse
:2

== Exemplul 2 ==
;divizor112in.txt
:-4
:1000001 64 -89 43580
;divizor112out.txt
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def get_prime_factors(num):
factors = {}
divisor = 2
while num > 1:
while num % divisor == 0:
num //= divisor
factors[divisor] = factors.get(divisor, 0) + 1
divisor += 1
return factors

def find_max_divisor(nums):
prime_factors_count = {}
max_divisor = None
max_count = 0

for num in nums:
factors = get_prime_factors(num)
for factor, count in factors.items():
prime_factors_count[factor] = max(prime_factors_count.get(factor, 0), count)

for factor, count in prime_factors_count.items():
if count > max_count:
max_count = count
max_divisor = factor

return max_divisor

def verifica_restrictii(input_file, output_file):
# Citire date de intrare
with open(input_file, "r") as f:
n = int(f.readline())
numbers = list(map(int, f.readline().split()))

# Apelare funcție de rezolvare
result = find_max_divisor(numbers)

# Verificare restricții
if 1 <= n <= 100000 and all(1 <= num < 1000000 for num in numbers):
# Citire rezultat așteptat
with open(output_file, "r") as g:
result_asteptat = int(g.readline().strip())

# Verificare rezultat
if result == result_asteptat:
print("Rezultat corect!")
else:
print("Rezultat incorect!")
print("Rezultat așteptat:", result_asteptat)
print("Rezultat obținut:", result)
else:
print("Date de intrare nevalide!")

# Citire date de intrare
with open("divizor112in.txt", "r") as f:
n = int(f.readline())
numbers = list(map(int, f.readline().split()))

# Apelare funcție de rezolvare
result = find_max_divisor(numbers)

# Scriere date de ieșire
with open("divizor112out.txt", "w") as g:
g.write(str(result) + "\n")

# Apelare funcție de verificare
verifica_restrictii("divizor112in.txt", "divizor112out.txt")

</syntaxhighlight>

== Explicatie ==

2 divide două numere din şir.

3513 - Covoare1

2023-12-29T12:10:27Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se consideră o încăpere de lungime '''n''' și lățime '''m''' împărțită în '''n*m''' zone pătrate, sub forma unei matrici cu n linii și m coloane. Încăperea este acoperită în totalitate cu p covoare dreptunghice de diferite dimensiuni astfel încât acestea nu se suprapun, fiecare zonă pătrată a încăperii fiind acoperită de exact un covor.

Miguel, administratorul clădirii, este responsabil cu spălarea covoarelor. Astfel, el a notat dimensiunile fiecărui covor, în ordine, de sus în jos și de la stânga la dreapta. Covoarele au fost scoase și spălate, iar acum Miguel vrea să le pună la loc.
Cunoscând dimensiunile încăperii, numărul de covoare precum și dimensiunile fiecărui covor în ordinea in care Miguel le-a notat, să se afișeze coordonatele colțului din stânga sus ale fiecărui covor, în ordinea notată de Miguel, adică in ordine lexicografică.

== Date de intrare ==

Fișierul de intrare '''covoare1in.txt''' conține pe prima linie numerele '''n, m, p''', iar pe următoarele '''p''' linii câte două numere a și b reprezentând lungimea (numărul de linii) și lățimea (numărul de coloane) fiecărui covor în ordinea notată de Miguel.

== Date de iesire ==

Fișierul de ieșire '''covoare1out.txt''' va conține '''p''' linii cu câte două numere ce reprezintă coordonatele colțului din stânga sus ale fiecărui covor, în ordinea notată de Miguel.

== Restrictii si precizari ==

*1 &les; n, m &les; 1.000.000
*p &les; 200.000

== Exemplul 1 ==
;covoare1in.txt
:7 8 9
:4 2
:2 4
:5 2
:1 4
:3 3
:2 1
:3 2
:2 3
:1 3

;covoare1out.txt
:Datele introduse corespund restrictiilor impuse
:1 1
:1 3
:1 7
:3 3
:4 3
:4 6
:5 1
:6 6
:7 3

== Exemplul 2 ==
;covoare1in.txt
:-3 -2 2
:6 2
:0 -10

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
import heapq

def rezolva(n, m, p, covoare):
# Initializare heap cu covoare
heapq.heapify(covoare)

# Afișare coordonate în ordinea notată de Miguel
rezultat = []
for _ in range(p):
top_covoare = heapq.heappop(covoare)
rezultat.append((top_covoare[0], top_covoare[1]))

return rezultat

def verifica_rezultat(input_file, output_file):
# Citire date de intrare
with open(input_file, "r") as f:
n, m, p = map(int, f.readline().split())
covoare = [tuple(map(int, f.readline().split())) for _ in range(p)]

# Apelare funcție de rezolvare
rezultat_obtinut = rezolva(n, m, p, covoare)

# Citire rezultat așteptat
with open(output_file, "r") as g:
rezultat_asteptat = [tuple(map(int, linie.split())) for linie in g.readlines()]

# Verificare rezultat
if rezultat_obtinut == rezultat_asteptat:
print("Rezultat corect!")
else:
print("Rezultat incorect!")
print("Rezultat așteptat:")
print(rezultat_asteptat)
print("Rezultat obținut:")
print(rezultat_obtinut)

# Citire date de intrare
with open("covoare1in.txt", "r") as f:
n, m, p = map(int, f.readline().split())
covoare = [tuple(map(int, f.readline().split())) for _ in range(p)]

# Apelare funcție de rezolvare
rezultat = rezolva(n, m, p, covoare)

# Scriere date de ieșire
with open("covoare1out.txt", "w") as g:
for coord in rezultat:
g.write(f"{coord[0]} {coord[1]}\n")

# Apelare funcție de verificare
verifica_rezultat("covoare1in.txt", "covoare1out.txt")

</syntaxhighlight>

1820 - Binar

2023-12-29T12:08:36Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Ionel a învăţat recent la Informatică reprezentarea numerelor în baza 2. Pentru a-și aprofunda cunoştinţele, profesorul său a inventat următoarea problemă: Dintr-un fişier text se citeşte un şir de '''N''' valori de '''1, 0''' şi '''-1'''. Valoarea -1 are semnificaţia de terminare a unui număr, iar valorile de 0 şi 1 reprezintă cifrele în baza 2 a câte unui număr natural. Să se determine primele '''NR''' valori codificate, cu numerele de apariţii cât mai mari.

== Date de intrare ==

Fişierul '''binarin.txt''' cu următoarea structura:
*pe prima linie numerele '''N''' şi '''NR''' cu semnificaţia din enunţ.
*pe a doua linie '''N''' valori de 1, 0 sau -1.

== Date de iesire ==

Fişierul '''binarout.txt''' va conţine perechi distincte de numere '''X''', '''AP''' cu semnificaţia '''X''' – valoarea codificata în baza 10, '''AP '''– numărul de apariţii ale valorii '''X''', pe fiecare linie câte o pereche despărţită printr-un spaţiu. Perechile vor fi afişate în ordinea descrescătoare a valorii '''AP''', iar la valori egale, în ordinea descrescătoare a valorii lui '''X'''.

== Restrictii si precizari ==

*10 &les; N &les; 100.000.
*1 &les; NR &les; 3.
*Înaintea fiecărei valori de -1 se găseşte cel putin o valoare de 0 sau 1.
*Numerele codificate astfel sunt mai mici decat 10000 în baza 10.
*Se poate ca la stânga unui număr codificat să fie doar valori de 0.
*În şir sunt codificate cel puţin 3 valori distincte.
*Şirul de valori se incheie cu o valoare de -1.

== Exemplul 1 ==
;binarin.txt
:19 3
:1 0 -1 1 -1 1 0 -1 1 1 -1 1 0 1 -1 1 0 1 -1
;binarout.txt
:Datele introduse corespund restrictiilor impuse
:5 2
:2 2
:3 1

== Exemplul 2 ==
;binarin.txt
:10 5
:-1 1 1 0 0 8 3 -10 0 8
;binarout.txt
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def binar_to_decimal(binar):
# Convertirea unui număr binar în decimal
decimal = 0
for bit in binar:
decimal = decimal * 2 + int(bit)
return decimal

def verifica_rezultat(input_file, output_file):
# Citire date de intrare
with open(input_file, "r") as f:
N, NR = map(int, f.readline().split())
sir_binar = list(map(int, f.readline().split()))

# Initializare dicționar pentru frecvențe
frecvente = {}

# Parcurgere șir binar
i = 0
while i < N:
numar_binar = []
while i < N and sir_binar[i] != -1:
numar_binar.append(str(sir_binar[i]))
i += 1

numar_decimal = binar_to_decimal(numar_binar)
if numar_decimal in frecvente:
frecvente[numar_decimal] += 1
else:
frecvente[numar_decimal] = 1

i += 1

# Sortare și scriere rezultat în fișierul de ieșire
rezultate_sortate = sorted(frecvente.items(), key=lambda x: (-x[1], -x[0]))

# Citire rezultat așteptat
with open(output_file, "r") as g:
rezultat_asteptat = [tuple(map(int, linie.split())) for linie in g.readlines()]

# Verificare rezultat
if rezultate_sortate[:NR] == rezultat_asteptat:
print("Rezultat corect!")
else:
print("Rezultat incorect!")
print("Rezultat așteptat:")
print(rezultat_asteptat)
print("Rezultat obținut:")
print(rezultate_sortate[:NR])

# Citire date de intrare
with open("binarin.txt", "r") as f:
N, NR = map(int, f.readline().split())
sir_binar = list(map(int, f.readline().split()))

# Initializare dicționar pentru frecvențe
frecvente = {}

# Parcurgere șir binar
i = 0
while i < N:
numar_binar = []
while i < N and sir_binar[i] != -1:
numar_binar.append(str(sir_binar[i]))
i += 1

numar_decimal = binar_to_decimal(numar_binar)
if numar_decimal in frecvente:
frecvente[numar_decimal] += 1
else:
frecvente[numar_decimal] = 1

i += 1

# Sortare și scriere rezultat în fișierul de ieșire
rezultate_sortate = sorted(frecvente.items(), key=lambda x: (-x[1], -x[0]))

with open("binarout.txt", "w") as g:
for valoare, aparitii in rezultate_sortate[:NR]:
g.write(f"{valoare} {aparitii}\n")

# Apelare funcție de verificare
verifica_rezultat("binarin.txt", "binarout.txt")

</syntaxhighlight>

== Explicatie ==

Numerele codificate sunt: 1 apare odată, 2 apare de 2 ori, 3 apare odată
şi 5 apare de 2 ori. Sunt afişate primele 3 în ordinea descrescătoare a numărului de apariţii. Numerele 2 şi 5 care au acelaşi număr de apariţii se afișează în ordinea descrescătoare a valorii lor.

3374 - Caroiaj

2023-12-29T12:06:31Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==

Se consideră un caroiaj format din '''n''' linii și '''n''' coloane, fiecare element din caroiaj fiind o literă mică din alfabetul englez. Să se constuiască șirul de caractere obținut prin parcurgerea caroiajului pe chenare dinspre exteriorul spre interiorul caroiajului, fiecare chenar fiind parcurs în sensul arcelor de ceas, pornind din colțul stânga sus al fiecărui chenar. Determinați cea mai lungă secvență de caractere situate pe poziții alăturate în șirul construit, care este simetrică. Dacă există mai multe astfel de secvențe de lungime maximă, se va determina ultima dintre ele.

== Cerinta ==

Cunoscând numărul natural '''n''' și un caroiaj format din '''n''' linii și '''n''' coloane de litere mici ale alfabetului englez, să se determine cea mai lungă secvență de caractere situate pe poziții alăturate în șirul construit, care este simetrică. Dacă există mai multe secvențe simetrice de lungime maximă, se va determina ultima dintre ele.

== Date de intrare ==

Fișierul de intrare '''caroiajin.txt''' conţine pe prima linie, numărul natural ''''''n,iar pe următoarele '''n''' linii se află câte '''n''' caractere, litere mici ale alfabetului englez.

== Date de iesire ==

Pe prima linie a fişierului '''caroiajout.txt''' va fi scrisă ultima secvență simetrică de caractere, de lungime maximă din șirul format prin parcurgerea caroiajului de caractere pe chenare, dinspre exteriorul spre interiorul caroiajului, fiecare chenar fiind parcurs în sensul arcelor de ceas, pornind de la colțul din stânga sus al fiecărui chenar.

== Restrictii si precizari ==

*1 &les; n &les; 500
*literele mici din caroiaj aparțin alfabetului englez

== Exemplul 1 ==
;caroiajin.txt
:5
:abcde
:bceaf
:abade
:abbad
:ffabc
;caroiajout.txt
:Datele introduse corespund restrictiilor impuse
:abcdefedcba

== Exemplul 2 ==
;caroiajin.txt
:4
:ABCDEF
:BceaF
:ABBad
:FFabC

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def parcurgere_caroiaj(n, caroiaj):
rezultat = ""

for i in range((n + 1) // 2):
# Parcurgere pe chenarul exterior al caroiajului
for j in range(i, n - i):
rezultat += caroiaj[i][j]

# Parcurgere pe chenarul din dreapta
for j in range(i + 1, n - i):
rezultat += caroiaj[j][n - i - 1]

# Parcurgere pe chenarul din jos
for j in range(n - i - 2, i - 1, -1):
rezultat += caroiaj[n - i - 1][j]

# Parcurgere pe chenarul din stanga
for j in range(n - i - 2, i, -1):
rezultat += caroiaj[j][i]

return rezultat

def cea_mai_lunga_secventa_simetrica(șir):
max_len = 0
start = 0

for i in range(1, len(șir)):
# Căutăm palindrom la fiecare caracter
j = 0
while i - j >= 0 and i + j < len(șir) and șir[i - j] == șir[i + j]:
j += 1

current_len = 2 * j - 1
if current_len > max_len:
max_len = current_len
start = i - j + 1

return șir[start:start + max_len]

def verifica_rezultat(input_file, output_file):
with open(input_file, "r") as f:
n = int(f.readline())
caroiaj = [list(f.readline().strip()) for _ in range(n)]

with open(output_file, "r") as g:
rezultat_asteptat = g.readline().strip()

sir_construit = parcurgere_caroiaj(n, caroiaj)
rezultat_program = cea_mai_lunga_secventa_simetrica(sir_construit)

if rezultat_program == rezultat_asteptat:
print("Rezultat corect!")
else:
print("Rezultat incorect!")
print("Rezultat așteptat:")
print(rezultat_asteptat)
print("Rezultat obținut:")
print(rezultat_program)

# Citire date de intrare
with open("caroiajin.txt", "r") as f:
n = int(f.readline())
caroiaj = [list(f.readline().strip()) for _ in range(n)]

# Construire șir parcurgând caroiajul
sir_construit = parcurgere_caroiaj(n, caroiaj)

# Determinare cea mai lungă secvență simetrică
rezultat = cea_mai_lunga_secventa_simetrica(sir_construit)

# Scriere rezultat în fișierul de ieșire
with open("caroiajout.txt", "w") as g:
g.write(rezultat)

# Verificare rezultat pentru exemplul dat
verifica_rezultat("caroiajin.txt", "caroiajout.txt")

</syntaxhighlight>

== Explicatie ==

Șirul de caractere format la parcurgerea caroiajului pe chenare în maniera indicată în text, este: abcdefedcbaffaabceadabbba. Ultima secvență simetrică de lungime maximă este abcdefedcba.

2739 - Sir Platou

2023-12-29T12:05:04Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dă un șir de caractere care conține cuvinte. Cuvintele sunt formate din litere mici ale alfabetului englez și sunt separate prin unul sau mai multe spații.

Determinați secvențele de cuvinte de lungime maximă cu proprietatea că fiecare cuvânt din secvență, cu excepția ultimului, se termină cu litera de început a cuvântului următor. Secvențele au minim '''2''' cuvinte și se afișează în ordinea în care apar în șir.

Fiecare secvență determinată va fi afișată pe câte o linie a ecranului, cuvintele dintr-o secvență fiind separate prin atâtea spații cât sunt între ele în șir. Dacă nu există nicio astfel de secvență se va afișa '''-'''1.

== Date de intrare ==

Programul citește de la tastatură un șir de caractere.

== Date de iesire ==

Programul va afișa pe ecran secvențele de lungime maximă care îndeplinesc cerința, fiecare pe câte o linie, sau '''-1''' dacă nu există nicio astfel de cerință.

== Restrictii si precizari ==

*șirul dat conține maximum '''255''' de caractere

== Exemplul 1 ==
;Intrare
:ab bc cd ef fg gh
;Iesire
:Datele introduse corespund restrictiilor impuse
:ab bc cd
:ef fg gh

== Exemplul 2 ==
;Intrare
:12 AB cD 0 75
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def detecteaza_secvente(sir):
cuvinte = sir.split()
secvente_maxime = []

for i in range(len(cuvinte) - 1):
secventa_curenta = [cuvinte[i]]
for j in range(i + 1, len(cuvinte)):
if cuvinte[j][0] == cuvinte[i][-1]:
secventa_curenta.append(cuvinte[j])
else:
break

if len(secventa_curenta) > 1:
secvente_maxime.append(secventa_curenta)

return secvente_maxime if secvente_maxime else -1

def verifica_rezultat(input_file, output_file):
with open(input_file, "r") as f:
sir_intrare = f.readline().strip()

with open(output_file, "r") as g:
rezultat_asteptat = g.readline().strip()

rezultat_program = detecteaza_secvente(sir_intrare)

if rezultat_program == -1:
rezultat_program_str = "-1"
else:
rezultat_program_str = "\n".join([" ".join(secventa) for secventa in rezultat_program])

if rezultat_program_str == rezultat_asteptat:
print("Rezultat corect!")
else:
print("Rezultat incorect!")
print("Rezultat așteptat:")
print(rezultat_asteptat)
print("Rezultat obținut:")
print(rezultat_program_str)

# Verificare rezultat pentru exemplele date
verifica_rezultat("exemplu1in.txt", "exemplu1out.txt")
verifica_rezultat("exemplu2in.txt", "exemplu2out.txt")

</syntaxhighlight>

1156 - InaltimiQ

2023-12-29T12:03:56Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dau înălțimile a '''n''' copii, numerotați de la 1 la n, exprimate prin numere naturale. Afișați numerele de ordine ale copiilor în ordinea crescătoare a înălțimii lor.

Pentru sortare se va folosit metoda QuickSort sau MergeSort.

== Date de intrare ==

Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații, reprezentând, în ordine, înălțimile copiilor.

== Date de iesire ==

Programul va afișa pe ecran n numere naturale distincte cuprinse între 1 și n, separate prin exact un spațiu, reprezentând numerele de ordine ale copiilor în ordinea crescătoare a înălțimii.

== Restrictii si precizari ==

*1 &les; n &les; 1000
*înălțimile copiilor vor fi numere naturale distincte din intervalul '''[1 , 10000]'''

== Exemplul 1 ==
;Intrare
:7
:8 20 16 14 10 4 12
;Iesire
:Datele introduse corespund restrictiilor impuse
:6 1 5 7 4 3 2

== Exemplul 2 ==
;Intrare
:4
:-6 0 -10 25
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_date_intrare(n, inaltimi):
if not (1 <= n <= 1000):
return False

if len(inaltimi) != n or any(h < 1 or h > 10000 for h in inaltimi):
return False

return True

def merge_sort(arr):
if len(arr) <= 1:
return arr

mid = len(arr) // 2
left = arr[:mid]
right = arr[mid:]

left = merge_sort(left)
right = merge_sort(right)

return merge(left, right)

def merge(left, right):
result = []
i = j = 0

while i < len(left) and j < len(right):
if left[i][1] < right[j][1]:
result.append(left[i])
i += 1
elif left[i][1] == right[j][1]:
if left[i][0] < right[j][0]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
else:
result.append(right[j])
j += 1

result.extend(left[i:])
result.extend(right[j:])

return result

# Citire date de intrare
try:
n = int(input())
inaltimi = list(map(int, input().split()))

# Verificare date de intrare
if not verifica_date_intrare(n, inaltimi):
raise ValueError("Datele introduse nu corespund restricțiilor impuse.")

# Adaugare numere de ordine și înălțimi într-o listă de tupluri
copii = list(enumerate(inaltimi, start=1))

# Sortare folosind MergeSort
copii_sortati = merge_sort(copii)

# Afișare rezultat
for copil in copii_sortati:
print(copil[0], end=" ")

except ValueError as ve:
print(ve)

</syntaxhighlight>

0092 - Proiecte

2023-12-29T12:02:55Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==

La un birou care se ocupă cu analiza proiectelor de investiţii, '''n''' investitori au depus până la termenul legal, câte un proiect.

== Cerinta ==

Cunoscând timpul necesar pentru analizarea fiecărui proiect, scrieţi un program care determină ordinea în care vor fi analizate proiectele, astfel încât timpul mediu de aşteptare pentru investitori să fie minim.

== Date de intrare ==

Pe prima linie a fişierului '''proiectein.txt''' se găseşte un număr natural '''n''' reprezentând numărul de proiecte depuse.

Pe linia a doua, separate prin câte un spaţiu, se găsesc '''n''' numere naturale '''t1, t2, …, tn''', reprezentând timpii necesari pentru analizarea fiecărui proiect.

== Date de iesire ==

Pe prima linie a fişierului '''proiecteout.txt''' se vor găsi n numere naturale cuprinse între 1 şi n, reprezentând ordinea în care vor fi analizate proiectele.

== Restrictii si precizari ==

*1 &les; n &les; 1000
*numerele de pe a doua linie a fişierului de intrare vor fi mai mici sau egale cu '''100'''

== Exemplul 1 ==
;proiectein.txt
:5
:60 50 30 10 40
;proiecteout.txt
:Datele introduse corespund restrictiilor impuse
:4 3 5 2 1

== Exemplul 2 ==
;proiectein.txt
:4
:238 -100 8
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_date_intrare(n, timp_analiza):
if not (1 <= n <= 1000):
return False

if len(timp_analiza) != n or any(ti < 1 or ti > 100 for ti in timp_analiza):
return False

return True

def ordine_analiza_proiecte(n, timp_analiza):
proiecte = list(enumerate(timp_analiza, 1))
proiecte.sort(key=lambda x: x[1])
ordine_proiecte = [proiect[0] for proiect in proiecte]
return ordine_proiecte

# Citire date de intrare
try:
with open("proiectein.txt", "r") as f:
n = int(f.readline())
timp_analiza = list(map(int, f.readline().split()))

# Verificare date de intrare
if not verifica_date_intrare(n, timp_analiza):
raise ValueError("Datele introduse nu corespund restricțiilor impuse.")

# Calculare și afișare rezultat
rezultat = ordine_analiza_proiecte(n, timp_analiza)
with open("proiecteout.txt", "w") as g:
for proiect in rezultat:
g.write(f"{proiect} ")

except ValueError as ve:
print(ve)

</syntaxhighlight>

== Explicatie ==

4 3 5 2 1 este ordinea de analizare a proiectelor. Numerele de ordine ale proiectelor sunt date de ordinea numerelor de pe linia a doua din fişierul de intrare.

2087 - K Min Sum

2023-12-29T12:01:28Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se consideră un număr natural '''k''' și două tablouri unidimensionale '''A și B''', cu '''n''' respectiv '''m''' elemente, numere întregi, sortate crescător. Să se afișeze primele '''k''' perechi de numere de sumă minimă. Fiecare pereche conține un număr din '''A''', un număr din '''B'''.

== Date de intrare ==

Fișierul de intrare '''kminsumin.txt''' conține pe prima linie trei numere naturale '''n, m și k''' având semnificația din enunț.
Pe a doua linie se găsesc '''n''' numere naturale separate prin spații ce reprezintă elementele tabloului '''A'''.
Pe a treia linie se găsesc '''m''' numere naturale separate prin spații ce reprezintă elementele tabloului '''B'''.

== Date de iesire ==

Fișierul de ieșire '''kminsumout.txt''' va conține '''k'' linii. Fiecare linie conține două numere întregi separate prin spațiu ce reprezintă descrierea unei perechi (un număr din A, un număr din B).

== Restrictii si precizari ==

*1 &les; n, m &les; 1000
*1 &les; k &les; 20000
*valorile elementelor celor două tablouri vor aparține intervalului '''[-1.000.000,1.000.000]'''
*ordinea de afișare a celor k perechi nu contează

== Exemplul 1 ==
;kminsumin.txt
:5 3 4
:1 2 3 4 5
:2 3 6
;kminsumout.txt
:Datele introduse corespund restrictiilor impuse
:1 2
:1 3
:2 2
:2 3

== Exemplul 2 ==
;kminsumin.txt
:5 3 4
:1 4 2 9 5
:2 3 6

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_date_intrare(n, m, k, A, B):
if not (1 <= n <= 1000 and 1 <= m <= 1000 and 1 <= k <= 20000):
return False

if not (-1000000 <= min(A + B) <= max(A + B) <= 1000000):
return False

return True

def k_min_sum_pairs(n, m, k, A, B):
pairs = []

i, j = 0, 0
while i < n and j < m and len(pairs) < k:
pairs.append((A[i], B[j]))
if i + 1 < n and (j + 1 >= m or A[i + 1] + B[j] < A[i] + B[j + 1]):
i += 1
else:
j += 1

return pairs

# Citire date de intrare
try:
with open("kminsumin.txt", "r") as f:
n, m, k = map(int, f.readline().split())
A = list(map(int, f.readline().split()))
B = list(map(int, f.readline().split()))

# Verificare date de intrare
if not verifica_date_intrare(n, m, k, A, B):
raise ValueError("Datele introduse nu corespund restricțiilor impuse.")

# Calculare și afișare rezultat
rezultat = k_min_sum_pairs(n, m, k, A, B)
with open("kminsumout.txt", "w") as g:
for pair in rezultat:
g.write(f"{pair[0]} {pair[1]}\n")

except ValueError as ve:
print(ve)

</syntaxhighlight>

== Explicatie ==

Tablou A conține 5 numere sortate crescător, tablou B conține 3 numere sortate crescător. Se pot forma 5•3 perechi. Primele 4 perechi corect formate de sumă minimă sunt: 1 2, 1 3, 2 2, 2 3.

4266 - MITM

2023-12-29T12:00:24Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Fie un număr natural '''s''' și un șir de '''n''' numere naturale nenule. Să se determine suma maximă posibilă, mai mică sau egală cu s ce se poate obține dintr-un subșir al șirului.

== Date de intrare ==

Programul citește de la tastatură numărul '''n''' și '''s''', apoi n numere naturale, separate prin spații, reprezentând elementele șirului.

== Date de iesire ==

Programul va afișa pe ecran numărul '''M''', reprezentând suma maximă posibilă, mai mică sau egală cu '''s''' ce se poate obține dintr-un subșir al șirului.

== Restrictii si precizari ==

*'''3 &les; n &les; 40'''
*'''1 &les; s &les; 2.000.000.000'''
*Șirul va conține numere naturale nenule mai mici decât 50.000.001.
*Toate elementele șirului vor fi mici sau egale decât s.

== Exemplul 1 ==
;Intrare
:5 20
:5 10 6 8 3

;Iesire
:Datele introduse corespund restrictiilor impuse
:19

== Exemplul 2 ==
;Intrare
:1 1
:4 29 2 0
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare_date_intrare(n, s, sir):
if not (3 <= n <= 40 and 1 <= s <= 2000000000):
return False

if not all(1 <= x < 50000001 for x in sir):
return False

return True

def suma_maxima_subsir(arr, s):
n = len(arr)
suma_maxima = 0
suma_curenta = 0
stanga = 0

for dreapta in range(n):
suma_curenta += arr[dreapta]

while suma_curenta > s:
suma_curenta -= arr[stanga]
stanga += 1

suma_maxima = max(suma_maxima, suma_curenta)

return suma_maxima

# Citire date de intrare
try:
n = int(input("Introduceți numărul de elemente: "))
s = int(input("Introduceți suma dorită: "))
sir = list(map(int, input("Introduceți șirul de numere separate prin spațiu: ").split()))

# Verificare date de intrare
if not verificare_date_intrare(n, s, sir):
raise ValueError("Datele introduse nu corespund restricțiilor impuse.")

# Calculare și afișare rezultat
rezultat = suma_maxima_subsir(sir, s)
print(f"Suma maximă posibilă mai mică sau egală cu {s} este: {rezultat}")

except ValueError as ve:
print(ve)

</syntaxhighlight>

== Explicatie ==

Suma maximă mai mică sau egală decât 20 este 17 și se formează doar din numărul 17.

3310 - Afin

2023-12-29T11:59:24Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==
Cifrul Afin este un cifru unde fiecare literă este înlocuită cu o altă literă printr-o operație matematica. Fiecărei litere '''i''' se asociază un cod: '''a-0, b-1, c-2, … z-25'''. De asemenea, mai avem două numere '''a''' și '''b''', numite chei. Fiecare literă se înlocuiește cu litera care are codul egal cu '''(a*x+b)mod. 26''' , unde x este codul literei.

== Cerinta ==

Dându-se valoarea celor două chei și un mesaj să se afișeze mesajul criptat.

== Date de intrare ==

Fișierul de intrare '''afinin.txt''' conține pe prima linie numerele '''a b''' iar pe a doua linie un mesaj.

== Date de iesire ==

Fișierul de ieșire '''afinout.txt''' va conține pe prima linie mesajul criptat.

== Restrictii si precizari ==

*1 &les; a , b &les; 26
*1 &les; lungimea șirului &les;10000
*mesajul va conține doar litere mici ale alfabetului englez

== Exemplul 1 ==
;afinin.txt
:17 20
:twentyfifteen
;afinout.txt
:Datele introduse corespund restrictiilor impuse
:fekhfmbabfkkh

== Exemplul 2 ==
;afinin.txt
:17 20
:TWEntyfiftEEN

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare_rezultat_corect(a, b, mesaj, mesaj_criptat):
if not (1 <= a <= 26 and 1 <= b <= 26):
return False

if not (1 <= len(mesaj) <= 10000):
return False

if not mesaj.isalpha() or not mesaj.islower():
return False

if not mesaj_criptat.isalpha() or not mesaj_criptat.islower():
return False

return True

# Citire date de intrare
with open("afinin.txt", "r") as f:
a, b = map(int, f.readline().split())
mesaj = f.readline().strip()

# Calculare mesaj criptat
mesaj_criptat = cripteaza_afin(a, b, mesaj)

# Scriere rezultat în fișier de ieșire
with open("afinout.txt", "w") as f_out:
if verificare_rezultat_corect(a, b, mesaj, mesaj_criptat):
f_out.write(f"{mesaj_criptat}\n")
else:
f_out.write("Datele introduse nu corespund restrictiilor impuse.\n")

</syntaxhighlight>

2665 - Dreptunghi1

2023-12-29T11:57:45Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Dată fiind o matrice dreptunghiulară cu elemente '''0 şi 1''', care este aria maximă a unui dreptunghi format numai din elemente egale cu 1?

== Date de intrare ==

Pe prima linie a fişierului '''dreptunghi1in.txt''' se vor găsi trei numere: numărul de linii, '''m''', al matricei, numărul de coloane, '''n''', precum şi numărul '''z''' al elementelor '''0''' din matrice. Pe următoarele z linii vom avea cate o pereche de numere lin şi col, separate printr-un spaţiu, cu semnificaţia că elementul de la linia lin şi coloana col este 0. Restul elementelor matricei sunt considerate 1. Este posibil ca anumite perechi lin şi col să se repete.

== Date de iesire ==

Fişierul '''dreptunghi1out.txt''' va conţine un singur număr, aria celui mai mare dreptunghi plin numai cu 1.

== Restrictii si precizari ==

*'''1 &les; m, n, z &les; 10.000''';
*Perechile lin şi col sunt coordonate corecte în matrice, nu neapărat unice.

== Punctaje partiale ==

*Pentru 20% din teste: 1 ≤ m, n ≤ 30;
*Pentru 40% din teste: 1 ≤ m, n ≤ 100.

== Exemplul 1 ==
;dreptunghi1in.txt
:6 6 3
:4 1
:4 5
:3 3
;dreptunghi1out.txt
:Datele introduse corespund restrictiilor impuse
:12

== Exemplul 2 ==
;dreptunghi1in.txt
:1 2
:0 0
:-1 -2 -3

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare_rezultat_corect(m, n, z, pozitii_0, aria_maxima):
if not (1 <= m <= 10000 and 1 <= n <= 10000 and 1 <= z <= 10000):
return False

for lin, col in pozitii_0:
if not (0 <= lin < m and 0 <= col < n):
return False

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

return True

# Citire date de intrare
with open("dreptunghi1in.txt", "r") as f:
m, n, z = map(int, f.readline().split())
pozitii_0 = [tuple(map(int, f.readline().split())) for _ in range(z)]

# Calculare aria maxima
aria_maxima = calculeaza_aria_maxima(m, n, z, pozitii_0)

# Scriere rezultat în fișier de ieșire
with open("dreptunghi1out.txt", "w") as f_out:
if verificare_rezultat_corect(m, n, z, pozitii_0, aria_maxima):
f_out.write(f"{aria_maxima}\n")
else:
f_out.write("Datele introduse nu corespund restrictiilor impuse.\n")

</syntaxhighlight>

== Explicatie ==

Matricea este:
;111111
;111111
:110111
:011101
:111111
:111111
Cel mai mare dreptunghi are arie 12.

3670 - Afin1

2023-12-29T11:56:01Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==

Cifrul Afin este un cifru unde fiecare literă este înlocuită cu o altă literă printr-o operație matematica. Fiecărei litere i se asociază un cod:''' a-0 , b-1 , c-2 , … z-25''' . De asemenea, mai avem două numere '''a''' și '''b''', numite chei. Fiecare literă se înlocuiește cu litera care are codul egal cu '''(a*x+b) mod 26''' , unde x este codul literei. Pentru anumite perechi de numere a și b rezultatul expresiei '''(a*x+b) mod 26''' poate fi același pentru valori diferite ale lui x; p pereche a b cu această proprietate se consideră ineficientă.

== Cerinta ==

Dându-se valoarea celor două chei și un mesaj criptat să se afișeze mesajul decriptat. Dacă '''a''' și '''b''' formează o pereche ineficientă atunci se afișează mesajul -1.

== Date de intrare ==

Fișierul de intrare '''afin1in.txt''' conține pe prima linie numerele '''a b''' iar pe a doua linie mesajul criptat.

== Date de iesire ==

Fișierul de ieșire '''afin1out.txt''' va conține pe prima linie mesajul decriptat sau numarul -1 daca a si b formeaza o pereche ineficienta.

== Restrictii si precizari ==

*1 &les; lungimea mesajului &les; 10000

== Exemplul 1 ==
;afin1in.txt
:17 20
:fekhfmbabfkkh
;afin1out.txt
:Datele introduse corespund restrictiilor impuse
:twentyfifteen

== Exemplul 2 ==
;afin1in.txt
:17 20
:FEKhfmbabfkkh

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def este_ineficienta(a, b):
for x in range(26):
if (a * x + b) % 26 == x:
return True
return False

def decripteaza_mesaj(a, b, mesaj_criptat):
mesaj_decriptat = ""
a_invers = -1
for i in range(26):
if (a * i) % 26 == 1:
a_invers = i
break

if a_invers == -1:
return -1 # Perechea de chei este ineficientă

for litera in mesaj_criptat:
if litera.isalpha():
cod_litera = ord(litera) - ord('a')
x_decriptat = (a_invers * (cod_litera - b)) % 26
litera_decriptata = chr(x_decriptat + ord('a'))
mesaj_decriptat += litera_decriptata
else:
mesaj_decriptat += litera

return mesaj_decriptat

def verificare_rezultat_corect(a, b, mesaj_criptat, rezultat_decriptare):
if rezultat_decriptare == -1:
return True # Perechea de chei este considerată ineficientă

if not (1 <= len(mesaj_criptat) <= 10000):
return False

return True

# Citire date de intrare
with open("afin1in.txt", "r") as f:
a, b = map(int, f.readline().split())
mesaj_criptat = f.readline().strip()

# Decriptare mesaj
rezultat_decriptare = decripteaza_mesaj(a, b, mesaj_criptat)

# Scriere rezultat în fișier de ieșire
with open("afin1out.txt", "w") as f_out:
if verificare_rezultat_corect(a, b, mesaj_criptat, rezultat_decriptare):
if rezultat_decriptare == -1:
f_out.write("-1\n")
else:
f_out.write(f"{rezultat_decriptare}\n")
else:
f_out.write("Datele introduse nu corespund restrictiilor impuse.\n")

</syntaxhighlight>

3508 - Bal

2023-12-29T11:54:01Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

La balul din acest an participă '''n''' băieți și '''n''' fete, numerotați de la 1 la n. Compatibilitățile dintre aceștia pot fi reprezentate sub forma unui graf bipartit. Fie mat matricea de adiacentă. Atunci, băiatul '''i''' se poate cupla cu fata '''j''' doar dacă sunt compatibili, adică '''mat[i][j] = 1'''. Aflați numărul de moduri de a forma cele '''n''' cupluri.

== Date de intrare ==

Programul citește de la tastatură numărul '''n''', iar apoi matricea de adiacență.

== Date de iesire ==

Programul va afișa pe ecran numărul de moduri de a forma cuplurile, modulo '''1.000.000.007'''.

== Restrictii si precizari ==

*1 < n < 25

== Exemplul 1 ==
;Intrare
:3
:0 1 1
:1 0 1
:1 1 1
;Iesire
:Datele introduse corespund restrictiilor impuse
:3

== Exemplul 2 ==
;Intrare
:3
:-5 34 0
:3 87 0
:0 0 -1
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
MOD = 1000000007

def numar_moduri_cuplare(n, matrice):
dp = [[0] * (1 << n) for _ in range(n + 1)]
dp[0][0] = 1

for i in range(1, n + 1):
for mask in range(1 << n):
num_bits = bin(mask).count('1')

for j in range(n):
if matrice[i-1][j] == 1 and (mask & (1 << j)) == 0:
dp[i][mask | (1 << j)] = (dp[i][mask | (1 << j)] + dp[i-1][mask]) % MOD

rezultat = sum(dp[n])
return rezultat % MOD

def verificare(n, matrice, rezultat):
if not (1 < n < 25):
return False

if rezultat < 0 or rezultat >= MOD:
return False

for i in range(n):
for j in range(n):
if matrice[i][j] not in {0, 1}:
return False

return True

# Citire date de intrare
n = int(input("Introduceți numărul n: "))
matrice_adiacenta = [list(map(int, input().split())) for _ in range(n)]

# Calcul și afișare rezultat
rezultat = numar_moduri_cuplare(n, matrice_adiacenta)

# Verificare și afișare rezultat
if verificare(n, matrice_adiacenta, rezultat):
print(rezultat)
else:
print("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

== Explicatie ==

Cele 3 modalități sunt:
:(1, 2), (2, 1), (3, 3)
:(1, 2), (2, 3), (3, 1)
:(1, 3), (2, 1), (3, 2)

4050 - amongus

2023-12-29T11:48:36Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==

În jocul Among Us un echipaj încearcă să piloteze o navetă spațială. O parte din ei încearcă să saboteze misiunea. Acești „impostori” sunt de obicei periculoși și astfel astronauții (sau „crewmates”) trebuie să se ferească pe cât posibil de aceștia. Astronauții au studiat planul interiorului navetei și au constatat că este compartimentat în nxm cabine, dispuse pe n rânduri, câte m pe fiecare rând, iar din fiecare cabină se poate trece în oricare altă cabină alăturată situată într-una din cele '''8 direcții''' '''(N, E, S, V, N-V, N-E, S-V, S-E)'''. Astronautii au creat o matrice a codurilor asociind fiecărei cabine un număr din mulțimea '''{0,1,2}''' cu semnificația:
*cod 0 dacă este o cabină sigură (adică în cabină nu se află niciun impostor)
*cod 1 dacă în ea se află un impostor
*cod 2 dacă este un portal („vent”).

== Cerinta ==

Cunoscând matricea codurilor, pentru a ajuta astronauții, vi se cere:
*1) să determinați numărul total de cabine sigure, nu sunt neapărat accesibile, ce nu conțin portale
*2) să marcați în matricea codurilor cu codul 3 fiecare cabină sigură (și accesibilă)
*3) să determinați numărul portalelor situate în cabine accesibile.

== Date de intrare ==

Fișierul de intrare '''amongusin.txt''' conține:
*pe prima linie numărul '''p''' reprezentând cerința care se rezolvă (1, 2 sau 3)
*pe a doua linie, două numere naturale '''n''' și '''m''' cu semnificația din enunț
*pe fiecare din următoarele '''n''' linii, câte '''m''' numere naturale din mulțimea {0,1,2}, separate prin câte un spațiu, reprezentând matricea de codificare a interiorului navetei spațiale.

== Date de iesire ==

Fișierul de ieșire '''amongusout.txt''' va conține:
*dacă p=1, pe prima linie, un număr natural reprezentând răspunsul la cerința 1
*dacă p=2, n linii cu câte m numere naturale, separate prin câte un spațiu,reprezentând matricea codurilor modificată conform cerinței 2
*dacă p=3, pe prima linie, un număr natural reprezentând răspunsul la cerința 3.

== Restrictii si precizari ==

*1 &les; n, m &les; 100
*astronauții pot intra în naveta doar prin cabina de coordonate '''(1,1)''' ceea ce înseamnă că accesul în unele cabine nu se poate realiza deși sunt sigure
*în cazul în care în prima cabină se află un impostor, pentru oricare dintre cerințe, se va scrie în fișier mesajul misiune esuata
*pentru cerința 1, se va modifica în 3 codul fiecărei cabine sigure
*un portal poate fi situat doar într-o cabină sigură
*există și cabine sigure care nu conțin portale
*impostorii nu se deplasează în afara cabinei în care se află inițial

== Exemplul 1 ==
;amongusin.txt
:1
:3 4
:0 2 1 0
:2 0 1 0
:0 0 1 2
;amongusout.txt
:Datele introduse corespund restrictiilor impuse
:6

== Exemplul 2 ==
;amongusin.txt
:8
:-1 7
:0 0 2 5
:-8 6 1 0
:0 0 0 -3

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def numar_cabine_sigure(matrice, n, m):
numar_sigure = 0
for i in range(n):
for j in range(m):
if matrice[i][j] == 0:
numar_sigure += 1
return numar_sigure

def marcaza_cabine_sigure(matrice, n, m):
for i in range(n):
for j in range(m):
if matrice[i][j] == 0:
matrice[i][j] = 3

def numar_portale_accesibile(matrice, n, m):
numar_portale = 0
for i in range(n):
for j in range(m):
if matrice[i][j] == 2 and not are_impstor_in_jur(matrice, n, m, i, j):
numar_portale += 1
return numar_portale

def are_impstor_in_jur(matrice, n, m, i, j):
for x in range(max(0, i-1), min(n, i+2)):
for y in range(max(0, j-1), min(m, j+2)):
if matrice[x][y] == 1:
return True
return False

def verificare(rezultat, p, n, m, matrice_initiala):
if p == 1:
return isinstance(rezultat, int) and 0 <= rezultat <= n * m
elif p == 2:
if not all(isinstance(row, list) and len(row) == m for row in rezultat):
return False
if not all(isinstance(elem, int) and 0 <= elem <= 3 for row in rezultat for elem in row):
return False
for i in range(n):
for j in range(m):
if matrice_initiala[i][j] == 0 and rezultat[i][j] != 3:
return False
return True
elif p == 3:
return isinstance(rezultat, int) and 0 <= rezultat <= n * m

# Citire date de intrare
with open("amongusin.txt", "r") as file:
p = int(file.readline().strip())
n, m = map(int, file.readline().split())
matrice_initiala = [list(map(int, file.readline().split())) for _ in range(n)]

# Rezolvare cerinte
if p == 1:
rezultat = numar_cabine_sigure(matrice_initiala, n, m)
elif p == 2:
rezultat = matrice_initiala.copy()
marcaza_cabine_sigure(rezultat, n, m)
elif p == 3:
rezultat = numar_portale_accesibile(matrice_initiala, n, m)

# Scriere rezultat în fișierul de ieșire
with open("amongusout.txt", "w") as file:
if p == 1 or p == 3:
file.write(str(rezultat) + "\n")
elif p == 2:
for linie in rezultat:
file.write(" ".join(map(str, linie)) + "\n")

# Verificare rezultat
rezultat_corect = verificare(rezultat, p, n, m, matrice_initiala)
print("Rezultat corect:", rezultat_corect)

</syntaxhighlight>

== Explicatie ==

Se rezolva cerința 1. Matricea codurilor conține 6 camere sigure, codificate cu 0.

4327 - Chimie

2023-12-29T11:46:31Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Eroul nostru Mateo, studiind Tabelul periodic al elementelor constată că toate elementele chimice sunt aranjate în funcție de numărul lor atomic, sunt grupate în tabel pe '''7 rânduri(perioade)''', iar aceste rânduri au pe ultima coloană(grupa 18) elementele numite și gaze nobile iar cele 7 numere atomice ale acestora sunt: '''2(He), 10(Ne), 18(Ar), 36(Kr), 54(Xe), 86(Rn) și 118(Og)'''. Mateo primește un set de elemente chimice și dorește să afle care este diferența maximă dintre numărul atomic al gazului nobil aflat pe același rând și numărul atomic al fiecărui element din setul primit și de câte ori apare acel element. Dacă există mai multe elemente distincte cu diferența maximă se va afișa cel cu numărul atomic mai mare, urmat de numărul de apariții al acestuia.

== Date de intrare ==

Fișierul de intrare '''chimiein.txt''' conține numere naturale între 1 si 118, reprezentând numerele atomice ale elementelor chimice din setul primit.

== Date de iesire ==

Fișierul de ieșire '''chimieout.txt''' va conține numărul '''E''', reprezentând numărul atomic al elementului selectat conform enunțului și separat printr-un spațiu, numărul de apariții ap ale acestui număr.

== Restrictii si precizari ==

*în fișierul de intrare pot fi până la '''1.000.000''' de numere.
*se garantează că în fiecare test va exista cel puțin un element cu număr atomic diferit de cel al gazelor nobile.

== Exemplul 1 ==
;chimiein.txt
:79 42 82 24 82 24 42 9 18
;chimieout.txt
:Datele introduse corespund restrictiilor impuse
:42 2

== Exemplul 2 ==
;chimiein.txt
:6 25 78 120 281 300
;chimieout.txt
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def gaz_nobil_perioada(numar_atomic):
gaze_nobile = {2: "He", 10: "Ne", 18: "Ar", 36: "Kr", 54: "Xe", 86: "Rn", 118: "Og"}

for perioada in range(1, 8):
nobil_perioada = 18 * (perioada - 1)
if numar_atomic <= nobil_perioada + 2:
return nobil_perioada + 2, gaze_nobile[nobil_perioada + 2]

return 118, "Og"

def verificare(numere_atomice, rezultat):
max_numar_atomic, numar_aparitii_max = rezultat

for numar_atomic in numere_atomice:
nobil, _ = gaz_nobil_perioada(numar_atomic)
diferenta = numar_atomic - nobil
if diferenta == max_numar_atomic:
numar_aparitii_max -= 1

return numar_aparitii_max == 0

# Citire date de intrare
with open("chimiein.txt", "r") as file:
numere_atomice = list(map(int, file.readline().split()))

# Calcul și afișare rezultat
max_numar_atomic = 0
numar_aparitii_max = 0

for numar_atomic in numere_atomice:
nobil, _ = gaz_nobil_perioada(numar_atomic)
diferenta = numar_atomic - nobil
if diferenta > max_numar_atomic:
max_numar_atomic = diferenta
numar_aparitii_max = 1
elif diferenta == max_numar_atomic:
numar_aparitii_max += 1

rezultat = (max_numar_atomic, numar_aparitii_max)

# Scriere rezultat în fișierul de ieșire
with open("chimieout.txt", "w") as file:
file.write(f"{max_numar_atomic} {numar_aparitii_max}\n")

# Verificare rezultat
rezultat_corect = verificare(numere_atomice, rezultat)
print("Rezultat corect:", rezultat_corect)

</syntaxhighlight>

== Explicatie ==

Din fișierul de intrare se citesc 9 numere dintre care 24 și 42 sunt la diferența maximă de 12 față de numărul atomic al gazului nobil de pe același rând, 36 pentru 24 și 54 pentru 42. Numărul 42 este mai mare și apare în fișierul de intrare de două ori.

2637 - ZOO

2023-12-29T11:42:47Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Într-o grădină zoologică reprezentată printr-o matrice '''A''' cu '''n''' linii și '''m''' coloane, fiecare cușcă se află într-o poziție din matrice și conține '''x''' animale. De exemplu, dacă '''A[2][6] = 5''' înseamnă că în cușcă de pe linia 2 și coloana 6 se află '''5 animale'''. Să se răspundă la '''Q''' întrebări de forma '''i1, j1, i2, j2''' unde răspunsul va fi numărul de animale din dreptunghiul din matrice cu cordonatele colțului din stânga sus i1 și j1 și cordonatele colțului din dreapta jos i2 și j2, unde i reprezintă linia și j coloana.

== Date de intrare ==

Fișierul de intrare '''zooin.txt''' conține pe prima linie numerele '''n''' si '''m''', separate printr-un spațiu, iar pe urmatoarele '''n''' linii, câte '''m''' numere, reprezentând matricea. Pe linia '''n + 2''' se află numărul '''Q''', iar pe următoarele '''Q''' linii, câte 4 numere '''(i1 j1 i2 j2)''' cu semnificația din enunț.

== Date de iesire ==

Fișierul de ieșire '''zooout.txt''' pe fiecare linie i răspunsul la întrebarea i.

== Restrictii si precizari ==

*1 &les; n, m &les; 100
*1 &les; Q &les; 100.000
*numărul maxim de animale dintr-o cușcă este de '''1.000.000.000'''
*numerotarea liniilor și a coloanelor din matrice începe de la 1

== Exemplul 1 ==
;zooin.txt
:4 4
:1 2 4 1
:8 1 3 2
:3 1 2 2
:8 1 3 1
:2
:2 2 4 4
:3 1 4 3
;zooout.txt
:Datele introduse corespund restrictiilor impuse
:16
:18

== Exemplul 2 ==
;zooin.txt
:4 3
:-2 5 6
:0 -1 7
:0 0 1
:-8 2 10
:1
:1 1 0 0

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def precalculeaza_sume(matrice, n, m):
sume = [[0] * (m + 1) for _ in range(n + 1)]

for i in range(1, n + 1):
for j in range(1, m + 1):
sume[i][j] = matrice[i - 1][j - 1] + sume[i - 1][j] + sume[i][j - 1] - sume[i - 1][j - 1]

return sume

def calculeaza_numar_animale(sume, i1, j1, i2, j2):
return sume[i2][j2] - sume[i1 - 1][j2] - sume[i2][j1 - 1] + sume[i1 - 1][j1 - 1]

def verifica_rezultate(rezultate_asteptate, rezultate_calculate):
return all(r1 == r2 for r1, r2 in zip(rezultate_asteptate, rezultate_calculate))

# Citire date de intrare
with open("zooin.txt", "r") as file:
n, m = map(int, file.readline().split())
matrice = [list(map(int, file.readline().split())) for _ in range(n)]
Q = int(file.readline())
intrebari = [list(map(int, file.readline().split())) for _ in range(Q)]
rezultate_asteptate = [int(file.readline()) for _ in range(Q)]

# Precalculează sumele parțiale
sume = precalculeaza_sume(matrice, n, m)

# Calcul și afișare rezultate
rezultate_calculate = []
for intrebare in intrebari:
i1, j1, i2, j2 = intrebare
rezultate_calculate.append(calculeaza_numar_animale(sume, i1, j1, i2, j2))

# Verificare rezultate
if verifica_rezultate(rezultate_asteptate, rezultate_calculate):
print("Rezultatele sunt corecte. Scriere în fișierul de ieșire.")

# Scrie rezultatele în fișierul de ieșire
with open("zooout.txt", "w") as file:
for rezultat in rezultate_calculate:
file.write(str(rezultat) + "\n")
else:
print("Rezultatele nu corespund așteptărilor.")

</syntaxhighlight>

== Explicatie ==

16=1+3+2+1+2+2+1+3+1 si 18=3+1+2+8+1+3

3311 - Nr Reg

2023-12-29T11:40:28Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==

'''Numerele regulate''' sunt numerele ce au ca factori primi doar numerele '''2, 3 și 5'''. Primele 20 de numere regulate sunt: '''1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24, 25, 27, 30, 32, 36'''.

== Cerinta ==

Fișierul de intrare '''nrregin.txt''' conține pe prima linie numărul natural '''n (n<=10000)'''. Scrieți un program care determină:

*cel de-al '''n'''-lea număr regulat, '''x''';
*cel mai mic divizor '''d''' al lui '''x''' cu proprietatea că '''p = x / d''' este pătrat perfect;
*valoarea p.
Programul va scrie în fișierul '''nrregout.txt''' valorile '''x d p''', separate prin câte spațiu.

Exemplu: dacă n=10, al zecelea număr regulat este x=12; d=3, iar p=4.

== Date de intrare ==

Fișierul de intrare '''nrregin.txt conține pe prima linie numărul natural '''n'''.

== Date de iesire ==

Fișierul de ieșire '''nrregout.txt''' va conține pe prima linie numărul '''x d p''', separate prin câte un spațiu.

== Restrictii si precizari ==

*1 &les; n &les; 10000
*prin convenție s-a stabilit că numărul 1 face parte din șirul numerelor regulate.

== Exemplul 1 ==
;nrregin.txt
:10
;nrregout.txt
:Datele introduse corespund restrictiilor impuse
:12 3 4

== Exemplul 2 ==
;nrrgin.txt
:17
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def cel_mai_mic_divizor_patratic(n):
numere_regulate = [1]
while len(numere_regulate) < n:
for x in numere_regulate:
for d in [2, 3, 5]:
if x * d not in numere_regulate:
numere_regulate.append(x * d)
numere_regulate.sort()

x = numere_regulate[n - 1]

# Determinăm cel mai mic divizor pătratic
d = 2
while x % (d ** 2) != 0:
d += 1

p = x // (d ** 2)
return x, d, p

def verificare_rezultat(x, d, p):
# Adăugăm condițiile de verificare
return x % (d ** 2) == 0 and all(x % (f ** 2) == 0 for f in [2, 3, 5])

# Citire date de intrare
with open("nrregin.txt", "r") as file:
n = int(file.readline())

# Calcul și afișare rezultat
rezultat = cel_mai_mic_divizor_patratic(n)

# Verificare rezultat
if verificare_rezultat(*rezultat):
with open("nrregout.txt", "w") as file:
file.write(" ".join(map(str, rezultat)) + "\n")
else:
print("Rezultat invalid. Verificați condițiile.")

</syntaxhighlight>

== Explicatie ==

Al zecelea număr regulat este 12; numărul minim care îl divide pe 12 pentru a obține un pătrat perfect este 3 iar pătratul perfect este 4.

4021 - Tablou 1

2023-12-29T11:36:05Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Generaţi un tablou bidimensional cu proprietăţile:

*conţine '''N''' linii şi '''N''' coloane;
*elementele sale sunt numere naturale nenule;
*suma elementelor este egală cu numărul natural nenul S;
*pe nici o linie şi pe nici o coloană nu există două elemente identice;
*diferenţa dintre cel mai mare şi cel mai mic element ale tabloului este minimă.

== Date de intrare ==

Fișierul de intrare '''tablouin.txt''' conţine pe prima linie două numere naturale nenule '''N S''', separate printr-un spaţiu, reprezentând numărul de linii şi de coloane ale tabloului, respectiv valoarea sumei tuturor elementelor din tablou.

== Date de iesire ==

Fișierul de ieșire '''tablouout.txt''' va conţine N linii pe care se vor scrie elementele tabloului, câte o linie din tablou pe o linie din fişier; elementele de pe aceeaşi linie se vor separa prin câte un spaţiu.

== Restrictii si precizari ==

*'''1 < N &les; 100'''
*''''0 < S < 2^31'''
*Dacă problema nu are soluţie, în fişierul de ieşire se va scrie cifra 0.
*Dacă problema are mai multe soluţii, în fişier se va scrie una singură.

== Exemplul 1 ==
;tablouin.txt
:3 51

;tablouout.txt
:Datele introduse corespund restrictiilor impuse
:4 6 7
:7 4 6
:6 7 4

== Exemplul 2 ==
;tablouin.txt
:0 -10
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def is_valid(tablou):
# Verificare pe linii
for linie in tablou:
if len(set(linie)) != len(linie):
return False

# Verificare pe coloane
for coloana in zip(*tablou):
if len(set(coloana)) != len(coloana):
return False

return True

def generate_tablou(N, S):
if N == 1:
if S == 1:
return [[1]]
else:
return [[0]]

# Initializare tablou
tablou = [[0] * N for _ in range(N)]

# Alegem coltul din stanga sus si coltul din dreapta jos
tablou[0][0] = 1
tablou[N - 1][N - 1] = S - (N - 1)

# Alegem coltul din stanga jos si coltul din dreapta sus
tablou[N - 1][0] = 1
tablou[0][N - 1] = S - (N - 1)

return tablou if is_valid(tablou) else None

# Citire date de intrare
with open("tablouin.txt", "r") as file:
N, S = map(int, file.readline().split())

# Generare tablou
tablou = generate_tablou(N, S)

# Scriere rezultat în fișierul de ieșire
with open("tablouout.txt", "w") as file:
if tablou:
for linie in tablou:
file.write(' '.join(map(str, linie)) + '\n')
else:
file.write("0\n")

</syntaxhighlight>

1313 - Produs Matrice

2023-12-29T11:33:04Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dau dimensiunile a două matrice, '''A''' și '''B''' și valorile acestora. Calculați produsul lor .

== Date de intrare ==

Fișierul de intrare '''produs_matricein.txt''' conține pe prima linie numerele '''m n''', apoi începând cu următoarea linie matricea '''A''' de dimensiuni '''(m,n)''' . Pe linia '''m+2''' numărul '''p''', apoi matricea '''B''' de dimensiuni '''(n,p)''' .

== Date de iesire ==

Fișierul de ieșire '''produs_matriceout.txt''' va conține matricea '''C''' , construită pe baza cerinței .

== Restrictii si precizari ==

*1 &les; n , m , p &les; 100
*-10.000 &les; A[i][j] , B[i][j] &les; 10.000

== Exemplul 1 ==
;produs_matricein.txt
:2 3
:1 -2 3
:0 1 -1
:2
:3 1
:-1 -1
:0 1
;produs_matriceout.txt
:Datele introduse corespund restrictiilor impuse
:5 6
:-1 -2

== Exemplul 2 ==
;produs_matricein.txt
:2 3
:-100 2000 0
:5982 0 0
:1
:4683
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def citeste_matrice(file):
dimensiuni = list(map(int, file.readline().split()))
matrice = [list(map(int, file.readline().split())) for _ in range(dimensiuni[0])]
return dimensiuni, matrice

def scrie_matrice(file, matrice):
for linie in matrice:
file.write(' '.join(map(str, linie)) + '\n')

def produs_matrice(matrice_a, matrice_b):
m, n = len(matrice_a), len(matrice_a[0])
n1, p = len(matrice_b), len(matrice_b[0])

if n != n1:
return None # Nu se poate realiza produsul matriceal

matrice_c = [[0 for _ in range(p)] for _ in range(m)]

for i in range(m):
for j in range(p):
for k in range(n):
matrice_c[i][j] += matrice_a[i][k] * matrice_b[k][j]

return matrice_c

# Citire date de intrare
with open("produs_matricein.txt", "r") as file:
dimensiuni_a, matrice_a = citeste_matrice(file)
_ = file.readline() # Ignorăm linia cu numărul p
dimensiuni_b, matrice_b = citeste_matrice(file)

# Calcul produs matriceal
rezultat = produs_matrice(matrice_a, matrice_b)

# Scriere rezultat în fișierul de ieșire
if rezultat:
with open("produs_matriceout.txt", "w") as file:
scrie_matrice(file, rezultat)
else:
print("Produsul matriceal nu este posibil din cauza dimensiunilor incorecte.")

</syntaxhighlight>

== Explicatie ==

Dacă se înmulțeste A cu B și rezultatul se află în C , atunci elementul C[i][j] reprezintă suma de produse dintre elementele de pe linia i a matricei A cu elementele de pe coloana j a matricei B. Având exemplul nostru , luăm C[1][2] = A[1][1] * B[1][2] + A[1][2] * B[2][2] + A[1][3] * B[3][2].

3237 - GCDnot1

2023-12-29T11:31:39Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dau '''m''' şi '''n''' numere naturale nenule. Să se determine două numere naturale '''a''' şi '''b''' astfel încât '''c.m.m.d.c.(a + i , b + j) > 1''' pentru orice i = 0 , m-1 şi orice j = 0 , n-1.

== Date de intrare ==

Programul citește de la tastatură numerele '''m''' şi '''n'''.

== Date de iesire ==

Programul va afișa pe ecran numerele '''a''' şi '''b'''.

== Restrictii si precizari ==

*1 &les; m , n &les; 5
*numerele a şi b vor avea cel mult 18 cifre fiecare

== Exemplul 1 ==
;Intrare
:1 2
;Iesire
:Datele introduse corespund restrictiilor impuse
:6 14

== Exemplul 2 ==
;Intrare
:0 100
;Iesire
:Datele introduse nu corespund restrictiilor impuse

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

def gaseste_numere_prime(m, n):
for a in range(2, 1000):
for b in range(a + 1, a + 1000):
if all(este_prim(a) and este_prim(b) and este_prim(a + n) and este_prim(b + m) and este_prim(a + i) and este_prim(b + j) for i in range(m) for j in range(n)):
return a, b

# Citire date de intrare
m = int(input("Introduceți m: "))
n = int(input("Introduceți n: "))

# Găsire numere a și b
a, b = gaseste_numere_prime(m, n)

# Afișare rezultat
print(f"Numerele a și b sunt: {a}, {b}")

</syntaxhighlight>

== Explicatie ==

Avem (6 , 14) = 2 > 1 şi (6 , 15) = 3 > 1.

2278 - MMultiplication

2023-12-29T11:30:20Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dau două matrice cu elemente numere întregi. Determinați produsul lor, dacă este posibil.

== Date de intrare ==

Fișierul de intrare '''mmultiplicationin.txt''' conține pe prima linie numerele '''n''' și '''m''' reprezentând numărul de linii, respectiv de coloane, al matricii '''A'''. Pe următoarele '''n''' linii sunt câte '''m''' numere întregi separate printr-un spațiu, reprezentând elementele matricii A. Pe linia '''n+2''' a fișierului se află două numere '''p''' și '''q''' reprezentând numărul de linii, respectiv de coloane, al matricii '''B'''. Pe următoarele '''p''' linii sunt câte '''q''' numere întregi separate printr-un spațiu, reprezentând elementele matricii B.

== Date de iesire ==

Fișierul de ieșire '''mmultiplicationout.txt''' va conține pe prima linie numărul '''-1''', în cazul în care matricele nu pot fi înmulțite. Dacă matricele pot fi înmulțite, se va afișa matricea rezultată după înmulțirea celor două, câte o linie a matricei pe o linie din fișier, elementele fiecărei linii fiind separate prin câte un spațiu.

== Restrictii si precizari ==

*1 &;les; n, m, p, q &les; 1000
*elementele matricelor vor fi numere întregi cu valoarea absolută mai mică decât '''2000'''

== Exemplul 1 ==
;Intrare
;mmultiplicationin.txt
:4 3
:1 2 3
:4 5 6
:7 8 9
:10 11 12
:3 5
:1 2 3 4 5
:6 7 8 9 10
:11 12 13 14 0

;Iesire
:Datele introduse corespund restrictiilor impuse
;mmultiplicationout.txt
:46 52 58 64 25
:100 115 130 145 70
:154 178 202 226 115
:208 241 274 307 160

== Exemplul 2 ==
;Intrare
;mmultiplicationin.txt
:2 3
:3600 0 -10
:54 2479 1
:3 2
:0 0
:1 1
:0 1

;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def citeste_matrice(fisier):
# Citeste dimensiunile matricei
n, m = map(int, fisier.readline().split())
matrice = []

# Citeste elementele matricei
for _ in range(n):
linie = list(map(int, fisier.readline().split()))
matrice.append(linie)

return matrice, n, m

def este_input_valid(n_A, m_A, n_B, m_B):
return 1 <= n_A <= 1000 and 1 <= m_A <= 1000 and 1 <= n_B <= 1000 and 1 <= m_B <= 1000 and m_A == n_B

def inmulteste_matrici(matrice_A, n_A, m_A, matrice_B, n_B, m_B):
if m_A != n_B:
raise ValueError("Numărul de coloane al primei matrici nu coincide cu numărul de linii al celei de-a doua matrici")

matrice_produs = [[0] * m_B for _ in range(n_A)]

for i in range(n_A):
for j in range(m_B):
for k in range(m_A):
matrice_produs[i][j] += matrice_A[i][k] * matrice_B[k][j]

return matrice_produs, n_A, m_B

def scrie_matrice(fisier, matrice, n, m):
fisier.write(f"{n} {m}\n")
for linie in matrice:
fisier.write(" ".join(map(str, linie)) + "\n")

def main():
# Citirea datelor de intrare din fisier
with open("mmultiplicationin.txt", "r") as f:
n_A, m_A = map(int, f.readline().split())
matrice_A, _, _ = citeste_matrice(f)
n_B, m_B = map(int, f.readline().split())
matrice_B, _, _ = citeste_matrice(f)

# Verificare validitate date de intrare
if not este_input_valid(n_A, m_A, n_B, m_B):
print("Datele introduse nu corespund restrictiilor impuse.")
return

# Calcularea produsului matricelor
try:
matrice_produs, n_produs, m_produs = inmulteste_matrici(matrice_A, n_A, m_A, matrice_B, n_B, m_B)

# Scrierea rezultatului în fisierul de ieșire
with open("mmultiplicationout.txt", "w") as g:
scrie_matrice(g, matrice_produs, n_produs, m_produs)

except ValueError as e:
# Nu se poate efectua înmulțirea
with open("mmultiplicationout.txt", "w") as g:
g.write("-1")

if __name__ == "__main__":
main()

</syntaxhighlight>

1396 - MDiferenta

2023-12-29T11:29:01Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dau două matrice cu elemente numere întregi. Calculați diferența dintre prima și a doua matrice.

== Date de intrare ==

Fișierul de intrare '''mdiferentain.txt''' conține pe prima linie numerele '''n m''', reprezentând dimensiunile primei matrice. Urmează '''n''' linii cu câte '''m''' valori, elementele primei matrice.

Linia '''n+2''' conține numerele '''p q''', reprezentând dimensiunile celei de-a doua matrice. Urmează '''p''' linii cu câte '''q'''' valori, elementele celei de-a doua matrice.

== Date de iesire ==

Fișierul de ieșire '''mdiferentaout.txt''' va conține pe prima linie numerele '''S T''', reprezentând dimensiunile matricei diferență. Următoarele '''S''' linii vor conține câte '''T''' valori separate prin exact un spațiu, reprezentând valorile din matricea diferență.

== Restrictii si precizari ==

*1 &les; n , m , p , q &les; 100;
*valoarea absolută a elementelor fiecărei matrice vor fi mai mici decât 1.000.000.000;
*scăderea matricelor se poate efectua pentru fiecare test.

== Exemplul 1 ==
;Intrare
;mdiferentain.txt
:3 4
:2 1 4 6
:5 -8 5 5
:2 5 -2 4
:3 4
:3 7 -5 0
:1 -4 1 5
:-4 2 8 7
;Iesire
:Datele introduse corespund restrictiilor impuse
;mdiferentaout.txt
:3 4
:-1 -6 9 6
:4 -4 4 0
:6 3 -10 -3

== Exemplul 2 ==
;Intrare
;mdiferentain.txt
:2 3
:5 0 -10
:4 300 2
:3 4
:5 10 8 -3
:6 100 34 -8
:0 15 -10 0
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def citeste_matrice(fisier):
# Citeste dimensiunile matricei
n, m = map(int, fisier.readline().split())
matrice = []

# Citeste elementele matricei
for _ in range(n):
linie = list(map(int, fisier.readline().split()))
matrice.append(linie)

return matrice, n, m

def este_input_valid(n1, m1, n2, m2):
return 1 <= n1 <= 100 and 1 <= m1 <= 100 and 1 <= n2 <= 100 and 1 <= m2 <= 100

def diferenta_matricelor(matrice1, n1, m1, matrice2, n2, m2):
if n1 != n2 or m1 != m2:
raise ValueError("Dimensiunile matricelor nu corespund")

matrice_diferenta = [[0] * m1 for _ in range(n1)]

for i in range(n1):
for j in range(m1):
matrice_diferenta[i][j] = matrice1[i][j] - matrice2[i][j]

return matrice_diferenta, n1, m1

def scrie_matrice(fisier, matrice, n, m):
fisier.write(f"{n} {m}\n")
for linie in matrice:
fisier.write(" ".join(map(str, linie)) + "\n")

def main():
# Citirea datelor de intrare din fisier
with open("mdiferentain.txt", "r") as f:
n1, m1 = map(int, f.readline().split())
matrice1, _, _ = citeste_matrice(f)
n2, m2 = map(int, f.readline().split())
matrice2, _, _ = citeste_matrice(f)

# Verificare validitate date de intrare
if not este_input_valid(n1, m1, n2, m2):
print("Datele introduse nu corespund restrictiilor impuse.")
return

# Calcularea diferenței matricelor
try:
matrice_diferenta, n_diferenta, m_diferenta = diferenta_matricelor(matrice1, n1, m1, matrice2, n2, m2)

# Scrierea rezultatului în fisierul de iesire
with open("mdiferentaout.txt", "w") as g:
scrie_matrice(g, matrice_diferenta, n_diferenta, m_diferenta)

except ValueError as e:
print(f"EROARE: {e}")

if __name__ == "__main__":
main()

</syntaxhighlight>

1395 - MSuma

2023-12-29T11:27:36Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dau două matrice cu elemente numere întregi. Calculați suma lor.

== Date de intrare ==

Fișierul de intrare '''msumain.txt''' conține pe prima linie numerele '''n m''', reprezentând dimensiunile primei matrice. Urmează '''n''' linii cu câte '''m''' valori, elementele primei matrice.

Linia '''n+2''' conține numerele '''p q''', reprezentând dimensiunile celei de-a doua matrice. Urmează '''p''' linii cu câte '''q valori''', elementele celei de-a doua matrice.

== Date de iesire ==

Fișierul de ieșire '''msumaout.txt''' va conține pe prima linie numerele '''S T''', reprezentând dimensiunile matricei sumă. Următoarele '''S''' linii vor conține câte '''T''' valori separate prin exact un spațiu, reprezentând valorile din matricea sumă.

== Restrictii si precizari ==

*1 &les; n , m , p , q &les; 100;
*valoarea absolută a elementelor fiecărei matrice vor fi mai mici decât 1.000.000.000;
*adunarea matricelor se poate efectua pentru fiecare test.

== Exemplul 1 ==
;Intrare
;msumain.txt
:3 4
:2 1 4 6
:5 -8 5 5
:2 5 -2 4
:3 4
:3 7 -5 0
:1 -4 1 5
:-4 2 8 7

;Iesire
:Datele introduse corespund restrictiilor impuse
;msumaout.txt
:3 4
:5 8 -1 6
:6 -12 6 10
:-2 7 6 11

== Exemplul 2 ==
;Intrare
;msumain.txt
:2 3
:-3 7 0
:8000 1 -2
:3 2
:7 0
:5438 870
:0 0

;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def citeste_matrice(fisier):
# Citeste dimensiunile matricei
n, m = map(int, fisier.readline().split())
matrice = []

# Citeste elementele matricei
for _ in range(n):
linie = list(map(int, fisier.readline().split()))
matrice.append(linie)

return matrice, n, m

def este_input_valid(n1, m1, n2, m2):
return 1 <= n1 <= 100 and 1 <= m1 <= 100 and 1 <= n2 <= 100 and 1 <= m2 <= 100

def suma_matricelor(matrice1, n1, m1, matrice2, n2, m2):
if n1 != n2 or m1 != m2:
raise ValueError("Dimensiunile matricelor nu corespund")

matrice_suma = [[0] * m1 for _ in range(n1)]

for i in range(n1):
for j in range(m1):
matrice_suma[i][j] = matrice1[i][j] + matrice2[i][j]

return matrice_suma, n1, m1

def scrie_matrice(fisier, matrice, n, m):
fisier.write(f"{n} {m}\n")
for linie in matrice:
fisier.write(" ".join(map(str, linie)) + "\n")

def main():
# Citirea datelor de intrare din fisier
with open("msumain.txt", "r") as f:
n1, m1 = map(int, f.readline().split())
matrice1, _, _ = citeste_matrice(f)
n2, m2 = map(int, f.readline().split())
matrice2, _, _ = citeste_matrice(f)

# Verificare validitate date de intrare
if not este_input_valid(n1, m1, n2, m2):
print("Datele introduse nu corespund restrictiilor impuse.")
return

# Calcularea sumei matricelor
try:
matrice_suma, n_suma, m_suma = suma_matricelor(matrice1, n1, m1, matrice2, n2, m2)

# Scrierea rezultatului în fisierul de iesire
with open("msumaout.txt", "w") as g:
scrie_matrice(g, matrice_suma, n_suma, m_suma)

except ValueError as e:
print(f"EROARE: {e}")

if __name__ == "__main__":
main()

</syntaxhighlight>

1888 - Cartonase

2023-12-29T11:26:32Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Vlad este pasionat de jocuri și vrea să vă propună unul. Pe o tablă cu '''n''' linii și '''m''' coloane, inițial goală, se așază la fiecare mutare un cartonaș în căsuța de coordonate '''x''' și '''y''' cu un număr pe el reprezentând numărul de vecini (Nord, Sud, Est, Vest) deja completați. Primul cartonaș pus este '''0''' deoarece nu este nimic completat încă. Întrebarea este care este suma tuturor numerelor de pe cartonașele așezate pe tabla după ce aceasta este completată?

== Date de intrare ==

Fișierul de intrare '''cartonasein.txt''' conține pe prima linie numerele '''n''' și '''m''', și pe următoarele '''n*m''' linii câte o pereche de numere x și y cu semnificația că se pune un cartonaș în căsuța cu aceste coordonate.

== Date de iesire ==

Fișierul de ieșire '''cartonaseout.txt''' va conține pe prima linie numărul '''S''', reprezentând suma numerelor de pe cartonașe.

== Restrictii si precizari ==

*1 &les; n, m &les; 10.000

== Exemplul 1 ==

;cartonasein.txt
:2 5
:2 4
:2 5
:1 1
:1 3
:1 5
:2 2
:1 4
:1 2
:2 3
:2 1

:Datele introduse corespund restrictiilor impuse
;cartonaseout.txt
:13

== Exemplul 2 ==

;cartonasein.txt
:3 4
:-5 6
:1 1
:0 5
:9 -3
:-10 -6

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def este_input_valid(n, m, cartonase):
if not (1 <= n <= 10000 and 1 <= m <= 10000):
return False

for x, y in cartonase:
if not (1 <= x <= n and 1 <= y <= m):
return False

return True

# Citire date de intrare
with open("cartonasein.txt", "r") as f:
n, m = map(int, f.readline().split())
cartonase = [tuple(map(int, f.readline().split())) for _ in range(n * m)]

# Verificare validitate date de intrare
if not este_input_valid(n, m, cartonase):
print("Datele introduse nu corespund restricțiilor impuse.")
else:
# Inițializare matrice
tabla = [[0] * m for _ in range(n)]

# Parcurgere și actualizare valori pentru fiecare cartonaș
for x, y in cartonase:
tabla[x - 1][y - 1] = 1 # Se pune cartonașul pe tabla

# Se actualizează vecinii
if x > 1:
tabla[x - 2][y - 1] += 1 # Vecinul din Nord
if x < n:
tabla[x][y - 1] += 1 # Vecinul din Sud
if y > 1:
tabla[x - 1][y - 2] += 1 # Vecinul din Vest
if y < m:
tabla[x - 1][y] += 1 # Vecinul din Est

# Calcul suma numerelor de pe cartonașe
suma = sum(tabla[i][j] for i in range(n) for j in range(m))

# Scriere rezultat în fișierul de ieșire
with open("cartonaseout.txt", "w") as f:
f.write(str(suma) + "\n")

</syntaxhighlight>

== Explicatie ==

Suma cartonașelor este 13.

3203 - SimonaH

2023-12-29T11:25:33Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Din perfecţiunea Simonei H. a apărut şi noţiunea de '''p'''-număr, un număr natural cu cifre nenule, ale cărui cifre le putem permuta. Să se afle suma resturilor împărţirii tuturor numerelor obţinute prin permutarea cifrelor lui '''n''' la un număr dat '''p'''.

== Date de intrare ==

Fișierul de intrare '''simonahin.txt''' conține pe prima linie numerele '''n''' şi '''p'''.

== Date de iesire ==

Fișierul de ieșire '''simonahout.txt''' va conține pe prima linie suma resturilor împărţirii tuturor numerelor obţinute prin permutarea cifrelor lui '''n''' la numărul dat '''p'''.

== Restrictii si precizari ==

*1 &les; n &les; 10^18
*2 &les; p &les; 5

== Exemplul 1 ==
;simonahin.txt
:325 5
;simonahout.txt
:Datele introduse corespund restrictiilor impuse
:10

== Exemplul 2 ==
;simonahin.txt
:652 1

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def este_input_valid(n, p):
return 1 <= n <= 10**18 and 2 <= p <= 5

def putere_modulo(x, y, p):
result = 1
x = x % p

while y > 0:
if y % 2 == 1:
result = (result * x) % p
y = y // 2
x = (x * x) % p

return result

def suma_resturi_permutari(n):
suma_totala = 0

for p in [2, 3, 4, 5]:
cifre = [int(digit) for digit in str(n)]
factorial_inv = 1
cifre_freq = [0] * 10

for cifra in cifre:
cifre_freq[cifra] += 1

for i in range(1, 10):
factorial_inv = (factorial_inv * putere_modulo(i, cifre_freq[i], p)) % p

invers_mod_p = putere_modulo(factorial_inv, p-2, p)
suma_totala = (suma_totala + invers_mod_p) % p

return suma_totala

if __name__ == "__main__":
# Citire date de intrare
n, p = map(int, input("Introduceți numerele n și p, separate prin spațiu: ").split())

# Verificare validitate date de intrare
if not este_input_valid(n, p):
print("Datele introduse nu corespund restricțiilor impuse.")
else:
# Calcul și afișare rezultat în fișierul de ieșire
rezultat = suma_resturi_permutari(n)
with open("simonahout.txt", "w") as f:
f.write(str(rezultat) + "\n")

</syntaxhighlight>

== Explicatie ==

Numerele 325, 235, 532, 352, 253, 523 împărţite la 5 dau resturile 0,0,2,2,3,3, suma acestora fiind 10.

4194 - EchipaFB

2023-12-29T11:24:26Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Într-o şcoală sunt '''F''' fete şi '''B''' băieţi. Pentru fiecare valoare a lui '''K''' de la '''1''' la '''F+B''', aflaţi în câte moduri se poate alcătui o echipă formată din '''K''' elevi, care să conţină un număr impar de fete.

== Date de intrare ==

Programul citește de la tastatură numerele '''F''' şi '''B'''.

== Date de iesire ==

Programul va afișa pe ecran, pentru fiecare '''K''' de la '''1''' la '''F+B''', numărul de moduri în care putem forma echipa, modulo '''998244353'''.

== Restrictii si precizari ==

*1 &les; F,B &les; 100.000

== Exemplul 1 ==
;Intrare
:3 2
;Iesire
;Datele introduse corespund restrictiilor impuse
:3 6 4 2 1

== Exemplul 2 ==
;Intrare
:-10 7
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==

<syntaxhighlight lang="python3" line="1">
MODULO = 998244353

def este_input_valid(F, B):
return 1 <= F <= 100000 and 1 <= B <= 100000

def calculeaza_moduri(F, B):
rezultate = []
total_elevi = F + B

for K in range(1, total_elevi + 1):
moduri = 0
for numar_fete in range(1, min(K, F) + 1, 2):
numar_baieti = K - numar_fete
if numar_baieti <= B:
moduri += 1

rezultate.append(moduri % MODULO)

return rezultate

if __name__ == "__main__":
# Citire date de intrare
F = int(input("Introduceți numărul de fete (F): "))
B = int(input("Introduceți numărul de băieți (B): "))

# Verificare validitate date de intrare
if not este_input_valid(F, B):
print("Datele introduse nu corespund restricțiilor impuse.")
else:
# Calcul și afișare rezultate
rezultate = calculeaza_moduri(F, B)
for K, moduri in enumerate(rezultate, start=1):
print(f"Pentru K = {K}, numărul de moduri este: {moduri}")

</syntaxhighlight>

== Explicatie ==

Să notăm cu A,B,C fetele şi cu X,Y băieţii. Pentru K=1 echipele pot fi A, B, respectiv C. Pentru K=2: AX, AY, BX, BY, CX, CY. Pentru K=3: AXY, BXY, CXY, ABC. Pentru K=4: ABCX, ABCY. Pentru K=5: ABCXY.

3206 - Nr Inversiuni

2023-12-29T11:23:17Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==
Se dă șirul '''a1, a2, …, an''' care este o permutare a mulțimii '''{1, 2, ..., n}'''. O '''inversiune''' în permutare este o pereche '''(i, j)''' cu proprietatea că '''i < j''' și '''a[i] > a[j]'''.

== Cerinta ==

Să se determine numărul inversiunilor permutării.

== Date de intrare ==

Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații, reprezentând permutarea.

== Date de iesire ==

Programul va afișa pe ecran numărul '''S''', reprezentând numărul inversiunilor permutării.

== Restrictii si precizari ==

*1 &les; n &les; 100.000

== Exemplul 1 ==
;Intrare
:5
:4 2 5 1 3
;Iesire
:Datele introduse corespund restrictiilor impuse
:6

== Exemplul 2 ==
;Intrare
:5
:-2 8 0 3
;Iesire
:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def este_permutare_valida(n, permutare):
if n != len(permutare):
return False

elemente_unice = set(permutare)
return len(elemente_unice) == n and all(1 <= elem <= n for elem in elemente_unice)

def numara_inversiuni(arr):
if len(arr) <= 1:
return arr, 0

mijloc = len(arr) // 2
stanga, inversiuni_stanga = numara_inversiuni(arr[:mijloc])
dreapta, inversiuni_dreapta = numara_inversiuni(arr[mijloc:])

concatenat, inversiuni_split = combina_si_numara(stanga, dreapta)

inversiuni_totale = inversiuni_stanga + inversiuni_dreapta + inversiuni_split

return concatenat, inversiuni_totale

def combina_si_numara(stanga, dreapta):
concatenat = []
inversiuni_split = 0
i = j = 0

while i < len(stanga) and j < len(dreapta):
if stanga[i] <= dreapta[j]:
concatenat.append(stanga[i])
i += 1
else:
concatenat.append(dreapta[j])
inversiuni_split += len(stanga) - i
j += 1

concatenat.extend(stanga[i:])
concatenat.extend(dreapta[j:])

return concatenat, inversiuni_split

if __name__ == "__main__":
n = int(input("Introduceți numărul n: "))
permutare = list(map(int, input("Introduceți permutarea: ").split()))

if este_permutare_valida(n, permutare):
_, inversiuni = numara_inversiuni(permutare)
print("Numărul inversiunilor permutării:", inversiuni)
else:
print("Permutarea introdusă nu este validă.")

</syntaxhighlight>

== Explicatie ==
Cele 6 inversiuni sunt date de perechile de indici (1,2), (1,4), (1,5), (2,4), (3,4), (3,5).

2182 - 3 Cifre

2023-12-29T11:21:21Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==
Așa cum știm, lui Gigel îi place să se joace cu numerele. A scris pe caiet un număr, apoi a văzut că din acesta se pot extrage mai multe numere cu trei cifre consecutive. De exemplu, a scris pe caiet '''20172017'''; numerele cu trei cifre consecutive care se pot extrage sunt '''201, 172, 720 și 201'''. Gigel începe să-și pună diferite întrebări: care este cel mai mare număr cu trei cifre consecutive obținut? Dar cel mai mic? De câte ori apar ele? Unde apar? Care este cel mai mare număr de apariții a unui număr cu trei cifre?

== Cerinta ==

Fiind numărul un număr natural '''n''' și '''n''' numere naturale '''x (100 ≤ x ≤ 4294967295)''' să se determine:
1. Cel mai mic și cel mai mare număr din trei cifre consecutive care apar în cele '''n''' numere, de câte ori apar ele, în ce număr '''x[1]''' apar prima dată și în ce număr '''x[2]''' apar ultima dată.
2. Numerele din trei cifre consecutive care apar de cele mai multe ori în cele n numere.

== Date de intrare ==

Fișierul de intrare '''3cifrein.txt''' conţine pe prima linie, separate printr-un spațiu, numărul natural n, reprezentând numărul de numere și cerința (1 sau 2). Pe cea de a doua linie sunt scrise cele n numere naturale '''x[1] x[2] ... x[n]''', separate prin câte un spațiu.

== Date de iesire ==

Fișierul de ieșire '''3cifreout.txt''' va conține, pentru cerința 1, pe prima linie patru valori naturale '''nrmin nrapmin x1min x1max''', separate prin câte un spațiu, reprezentând numărul minim de trei cifre care apare, numărul de apariții a acestuia, numărul în care apare prima dată, respectiv numărul în care apare ultima dată, iar pe linia a doua alte patru valori naturale '''nrmax nrapmax x2min x2max''', separate prin câte un spațiu, reprezentând numărul maxim de trei cifre care apare, numărul de apariții a acestuia, numărul în care apare prima dată, respectiv numărul în care apare ultima dată. Pentru cerința 2, fișierul de ieșire va conține pe prima linie numărul maxim de apariții a numerelor din trei cifre consecutive care apar, iar pe linia a doua, separate prin câte un spațiu, numerele respective în ordine crescătoare.

== Restrictii si precizari ==

*1 &les; n &les; 500000
*100 &les; x[i] &les; 4294967295

== Exemplul 1 ==

;3cifrein.txt
:7 1
:415 5213 2017 666 12345678 10000013 13

:Datele introduse corespund restrictiilor impuse.
;3cifreout.txt
:100 1 10000013 10000013
:678 1 12345678 12345678

== Exemplul 2 ==

;3cifreint.txt
:7 1
:25 521013 206678 666 12345678 10101013 13

:Datele introduse nu corespund restrictiilor impuse.

== Rezolvare ==

<syntaxhighlight lang="python3" line="1">
def este_valid(x):
for num in x:
if not (100 <= num <= 4294967295):
return False
return True

def main():
# Citim datele de intrare din fișier
with open("3cifre.in", "r") as f:
n, cerinta = map(int, f.readline().split())
numere = list(map(int, f.readline().split()))

# Verificăm dacă datele de intrare sunt valide
if not (1 <= n <= 500000) or not este_valid(numere):
print("Date de intrare nevalide.")
return

if cerinta == 1:
aparitii, max_aparitii, max_aparitii_numere = cautare_3_cifre(numere)

# Găsim cel mai mic triplet
min_triplet = min(aparitii, key=lambda x: x if aparitii[x]['count'] > 0 else float('inf'))
nrmin = min_triplet
nrapmin = aparitii[min_triplet]['count']
x1min = aparitii[min_triplet]['first_index']
x1max = aparitii[min_triplet]['last_index']

# Găsim cel mai mare triplet
max_triplet = max(aparitii, key=lambda x: aparitii[x]['count'])
nrmax = max_triplet
nrapmax = aparitii[max_triplet]['count']
x2min = aparitii[max_triplet]['first_index']
x2max = aparitii[max_triplet]['last_index']

# Scriem rezultatele în fișierul de ieșire
with open("3cifreout.txt", "w") as fout:
fout.write(f"{nrmin} {nrapmin} {x1min} {x1max}\n")
fout.write(f"{nrmax} {nrapmax} {x2min} {x2max}\n")

elif cerinta == 2:
aparitii, max_aparitii, max_aparitii_numere = cautare_3_cifre(numere)

# Găsim numerele cu cele mai multe apariții
max_aparitii_numere.sort()
with open("3cifreout.txt", "w") as fout:
fout.write(f"{max_aparitii}\n")
fout.write(" ".join(map(str, max_aparitii_numere)) + "\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

== Explicatie ==

Se observă că atât 111 cât și 113 apar de câte 3 ori.

1266 - Cauta Nr In Matrice

2023-12-29T11:20:18Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se dă o matrice cu '''n''' linii şi '''m''' coloane ce conţine numere naturale astfel încât parcurgând matricea pe prima linie de la stânga la dreapta, pe a doua linie de la dreapta la stânga, pe a treia linie de la stânga la drepta, ş.a.m.d., toate elementele matricei vor forma un şir strict crescător. Fiind date '''p''' numere naturale ordonate strict crescător, să se afişeze pentru fiecare numărul liniei şi coloanei unde acesta se găseşte în matrice, respectiv '''0''' dacă acesta nu se găseşte în matrice.

== Date de intrare ==

Fișierul de intrare '''cautanrinmatricein.txt''' conține pe prima linie numerele '''n''' şi '''m''' reprezentând dimensiunile matricei , pe următoarele n linii câte m numere aranjate conform enunţului reprezentând elementele matricei, pe următoarea linie numărul p, iar pe ultima linie cele '''p''' numere în ordine strict crescătoare ce trebuie căutate în matrice.

== Date de iesire ==

Fișierul de ieșire '''cautanrinmatriceout.txt''' va conține pe primele '''p''' linii numărul liniei şi coloanei pe care se află în matrice fiecare din cele '''p''' numere date, respectiv '''0''' dacă numărul nu se găseşte în matrice.

== Restrictii si precizari ==

*'''1 &les; n , m &les; 1000'''
*elementele matricei sunt numere naturale mai mici decât '''2.000.000.000'''
*'''1 &les; p &les; 1.000.000'''
*cele p numere vor fi mai mici decât '''2.000.000.000'''

== Exemplul 1 ==

;cautanrinmatricein.txt
: 3 4
: 2 5 11 14
: 29 27 23 19
: 32 38 44 59
: 3
: 11 24 38

:Datele introduse corespund restrictiilor impuse.
;cautanrinmatriceout.txt
: 1 3
: 0
: 3 2

== Exemplul 2 ==

;cautanrinmatricein.txt
: 3 2
: 5 8
: 12 19
: 23 21

:Datele introduse nu corespund restrictiilor impuse.

== Rezolvare ==

<syntaxhighlight lang="python3" line="1">
def este_matrice_valida(matrice):
# Verificăm dacă matricea este ordonată strict crescător pe fiecare linie
for linie in matrice:
if linie != sorted(linie):
return False
return True

def cautare_in_matrice(matrice, p, numere_cautate):
rezultate = []

for numar in numere_cautate:
gasit = False
i, j = 0, 0

while i < len(matrice) and j < len(matrice[0]):
if matrice[i][j] == numar:
gasit = True
rezultate.append((i + 1, j + 1)) # Linia și coloana în matrice (indexare de la 1)
break
elif matrice[i][j] < numar:
i += 1
else:
j += 1

if not gasit:
rezultate.append((0, 0))

return rezultate

def main():
# Citim datele de intrare din fișier
with open("cautanrinmatricein.txt", "r") as f:
n, m = map(int, f.readline().split())
matrice = [list(map(int, f.readline().split())) for _ in range(n)]
p = int(f.readline())
numere_cautate = list(map(int, f.readline().split()))

# Verificăm dacă matricea este validă
if not este_matrice_valida(matrice):
print("Matricea nu este ordonată strict crescător pe fiecare linie.")
return

# Căutăm fiecare număr în matrice
rezultate = cautare_in_matrice(matrice, p, numere_cautate)

# Scriem rezultatele în fișierul de ieșire
with open("cautanrinmatriceout.txt", "w") as f:
for rezultat in rezultate:
f.write(f"{rezultat[0]} {rezultat[1]}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

== Explicatie ==

Numărul 11 se află în matrice pe linia 1 coloana 3, numărul 24 nu se află în matrice, iar numărul 38 se află în matrice pe linia 3, coloana 2.

3935 - determinanta

2023-12-29T11:18:38Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se consideră o matrice cu '''n''' linii şi '''n''' coloane şi elemente egale cu '''0''' sau '''1'''. Să se calculeze determinantul matricei.

== Date de intrare ==

Fișierul de intrare '''determinantain.txt''' conține pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte o pereche de numere naturale '''l, c''', reprezentând faptul că elementul matricei de pe linia '''l''' şi coloana '''c''' are valoarea '''1'''.

== Date de iesire ==

Fișierul de ieșire '''determinantaout.txt''' va conține pe prima linie valoarea determinantului matricei.

== Restrictii si precizari ==

*2 &les; '''n''' &les; 100.000
*1 &les; '''l,c''' &les; n
*Exceptând elementele din poziţiile '''(l,c)''', care sunt egale cu '''1''', celelalte elemente ale matricei au valoarea '''0'''.

== Exemplul 1 ==
;determinantain.txt
: 3
: 1 1
: 2 2
: 3 3
: Datele introduse corespund restrictiilor impuse.
; determinantaout.txt
: 1

== Exemplul 2 ==
;determinantain.txt
: 3
: 2 2
: 3 3
: 2 2

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==

<syntaxhighlight lang="python3" line="1">

def este_intrare_valida(n, pozitii):
# Verificăm dacă toate pozițiile sunt în limitele matricei
for linie, coloana in pozitii:
if not (1 <= linie <= n and 1 <= coloana <= n):
return False
return True

def citeste_intrare(numefisier):
with open(numefisier, 'r') as fisier:
n = int(fisier.readline())
pozitii = [tuple(map(int, fisier.readline().split())) for _ in range(n)]

if este_intrare_valida(n, pozitii):
matrice = [[0] * n for _ in range(n)]
for linie, coloana in pozitii:
matrice[linie - 1][coloana - 1] = 1
return matrice, n
else:
raise ValueError("Date de intrare nevalide")

def scrie_iesire(numefisier, rezultat):
with open(numefisier, 'w') as fisier:
fisier.write(str(rezultat) + '\n')

def calculeaza_determinant(matrice, dimensiune):
# Cazul de bază: matrice de dimensiune 2x2
if dimensiune == 2:
return matrice[0][0] * matrice[1][1] - matrice[0][1] * matrice[1][0]

determinant = 0
for i in range(dimensiune):
# Eliminăm linia și coloana corespunzătoare elementului selectat
submatrice = [linie[:i] + linie[i+1:] for linie in matrice[1:]]
semn = (-1) ** i
determinant += semn * matrice[0][i] * calculeaza_determinant(submatrice, dimensiune - 1)

return determinant

if __name__ == "__main__":
fisier_intrare = "determinantain.txt"
fisier_iesire = "determinantaout.txt"

try:
# Citim matricea și dimensiunea din fișierul de intrare
matrice, dimensiune = citeste_intrare(fisier_intrare)

# Calculăm determinantul
rezultat_determinant = calculeaza_determinant(matrice, dimensiune)

# Scriem rezultatul în fișierul de ieșire
scrie_iesire(fisier_iesire, rezultat_determinant)
except ValueError as e:
print(f"Eroare: {e}")

</syntaxhighlight>

3935 - determinanta

2023-12-29T11:17:53Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se consideră o matrice cu '''n''' linii şi '''n''' coloane şi elemente egale cu '''0''' sau '''1'''. Să se calculeze determinantul matricei.

== Date de intrare ==

Fișierul de intrare '''determinantain.txt''' conține pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte o pereche de numere naturale '''l, c''', reprezentând faptul că elementul matricei de pe linia '''l''' şi coloana '''c''' are valoarea '''1'''.

== Date de iesire ==

Fișierul de ieșire '''determinantaout.txt''' va conține pe prima linie valoarea determinantului matricei.

== Restrictii si precizari ==

*2 &les; '''n''' &les; 100.000
*1 &les; '''l,c''' &les; n
*Exceptând elementele din poziţiile '''(l,c)''', care sunt egale cu '''1''', celelalte elemente ale matricei au valoarea '''0'''.

== Exemplul 1 ==
;determinantain.txt
: 3
: 1 1
: 2 2
: 3 3
: Datele introduse corespund restrictiilor impuse.
; determinantaout.txt
: 1

== Exemplul 2 ==
;determinantain.txt
: 3
: 2 2
: 3 3
: 2 2

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==

<syntaxhighlight lang="python3" line="1">

def is_valid_input(n, positions):
# Verificăm dacă toate pozițiile sunt în limitele matricei
for l, c in positions:
if not (1 <= l <= n and 1 <= c <= n):
return False
return True

def read_input(file_name):
with open(file_name, 'r') as file:
n = int(file.readline())
positions = [tuple(map(int, file.readline().split())) for _ in range(n)]

if is_valid_input(n, positions):
matrix = [[0] * n for _ in range(n)]
for l, c in positions:
matrix[l-1][c-1] = 1
return matrix, n
else:
raise ValueError("Invalid input data")

def write_output(file_name, result):
with open(file_name, 'w') as file:
file.write(str(result) + '\n')

if __name__ == "__main__":
input_file = "determinantain.txt"
output_file = "determinantaout.txt"

try:
# Citim matricea și dimensiunea din fișierul de intrare
matrix, size = read_input(input_file)

# Calculăm determinantul
determinant_result = calc_determinant(matrix, size)

# Scriem rezultatul în fișierul de ieșire
write_output(output_file, determinant_result)
except ValueError as e:
print(f"Error: {e}")

</syntaxhighlight>

0139 - n311 - Obtinere numar prin aplicare repetata de operatii

2023-12-27T13:30:47Z

Mesarosdenisa: /* Rezolvare */

== Enunt ==

Pornind de la numărul '''1''',orice număr natural se poate obţine aplicând repetat în mod convenabil operaţii din cele de mai jos:

*înmulţire cu '''3'''
*adunare cu '''1'''
*scădere cu '''1'''
De exemplu numărul '''24''' se poate obţine astfel:

Adunăm '''1: 1 + 1 = 2'''
Adunăm '''1: 2 + 1 = 3'''
Înmultim cu '''3: 3 * 3 = 9'''
Scădem '''1: 9 - 1 = 8'''
Înmulțim cu '''3: 8 * 3 = 24'''

Urmărind operaţiile de la stânga la dreapta pentru exemplul de mai sus, şirul de operaţii se codifică cu 1, 1, 3, -1, 3.

== Cerinta ==

Cunoscând numărul natural '''n''',să se tipărească şirul de operaţii prin care se poate ajunge de la numărul iniţial 1 la numărul final n.

== Date de intrare ==

Fişierul de intrare '''n311in.txt''' conţine pe prima linie valoarea numărului natural '''n'''.

== Date de iesire ==

Fişierul de ieşire '''n311out.txt''' va conţine pe prima linie şirul de operaţii format din numere întregi separate prin câte un spaţiu, cu semnificaţia de mai sus.

== Restrictii si precizari ==

*1 &les; n %les; 2 000 000000;
*Pot exista mai multe soluţii, se acceptă oricare, dacă se încadrează în timpul de execuţie;
*Nu este obligatorie folosirea tuturor tipurilor de operaţii.

== Exemplul 1 ==
;n311in.txt
:24
;n311out.txt
:Datele introduse corespund restrictiilor impuse
:1 1 3 -1 3

== Exemplul 2 ==
;n311in.txt
:-121

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n):
return 1 <= n <= 2000000000

def generare_sir_operatii(n):
operatii = []

def backtracking(current, target):
if current == target:
return True
if current > target:
return False

# Încercăm să adunăm 1
if backtracking(current + 1, target):
operatii.append(1)
return True

# Încercăm să scădem 1
if backtracking(current - 1, target):
operatii.append(-1)
return True

# Încercăm să înmulțim cu 3
if backtracking(current * 3, target):
operatii.append(3)
return True

return False

# Apelăm funcția de backtracking
backtracking(1, n)

return operatii

# Citire din fișierul de intrare
with open('n311in.txt', 'r') as file:
n = int(file.readline())

# Verificare restricții
if verifica_restrictii(n):
# Generare și afișare șir de operații
operatii = generare_sir_operatii(n)

# Scriere în fișierul de ieșire
with open('n311out.txt', 'w') as file_out:
file_out.write(" ".join(map(str, operatii)))
else:
print("Date de intrare nevalide.")

</syntaxhighlight>

0139 - n311 - Obtinere numar prin aplicare repetata de operatii

2023-12-27T13:29:32Z

Mesarosdenisa:

== Enunt ==

Pornind de la numărul '''1''',orice număr natural se poate obţine aplicând repetat în mod convenabil operaţii din cele de mai jos:

*înmulţire cu '''3'''
*adunare cu '''1'''
*scădere cu '''1'''
De exemplu numărul '''24''' se poate obţine astfel:

Adunăm '''1: 1 + 1 = 2'''
Adunăm '''1: 2 + 1 = 3'''
Înmultim cu '''3: 3 * 3 = 9'''
Scădem '''1: 9 - 1 = 8'''
Înmulțim cu '''3: 8 * 3 = 24'''

Urmărind operaţiile de la stânga la dreapta pentru exemplul de mai sus, şirul de operaţii se codifică cu 1, 1, 3, -1, 3.

== Cerinta ==

Cunoscând numărul natural '''n''',să se tipărească şirul de operaţii prin care se poate ajunge de la numărul iniţial 1 la numărul final n.

== Date de intrare ==

Fişierul de intrare '''n311in.txt''' conţine pe prima linie valoarea numărului natural '''n'''.

== Date de iesire ==

Fişierul de ieşire '''n311out.txt''' va conţine pe prima linie şirul de operaţii format din numere întregi separate prin câte un spaţiu, cu semnificaţia de mai sus.

== Restrictii si precizari ==

*1 &les; n %les; 2 000 000000;
*Pot exista mai multe soluţii, se acceptă oricare, dacă se încadrează în timpul de execuţie;
*Nu este obligatorie folosirea tuturor tipurilor de operaţii.

== Exemplul 1 ==
;n311in.txt
:24
;n311out.txt
:Datele introduse corespund restrictiilor impuse
:1 1 3 -1 3

== Exemplul 2 ==
;n311in.txt
:-121

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def sir_operatii(n):
operatii = []

while n != 1:
operatii.append(n)
if n % 3 == 0:
n = n // 3
elif (n - 1) % 3 == 0:
n = n - 1
elif (n + 1) % 3 == 0:
n = n + 1

operatii.append(1)
return operatii[::-1] # Inversăm șirul pentru a obține operațiile de la 1 la n

# Citire date de intrare
with open("n311.txt", "r") as file:
n = int(file.readline())

# Rezolvare problema
rezultat = sir_operatii(n)

# Scriere rezultat în fișierul de ieșire
with open("n311.txt", "w") as file_out:
file_out.write(" ".join(map(str, rezultat)))

</syntaxhighlight>

0198 - Submultimi

2023-12-27T13:25:54Z

Mesarosdenisa: /* Rezolvare */

== Cerinta ==

Se citește un număr natural nenul '''n'''. Să se afişeze, în ordine lexicografică, toate submulțimile nevide ale mulţimii '''{1,2,..,n}'''.

== Date de intrare ==

Fişierul de intrare '''submultimiin.txt''' conţine pe prima linie numărul '''n'''.

== Date de iesire ==

Fişierul de ieşire '''submultimiout.txt''' va conţine pe fiecare linie câte o submulțime, elementele unei submulțimi fiind separate printr-un spațiu.

== Restrictii si precizari ==

*1 &les; n &les; 10

== Exemplul 1 ==
;submultimiin.txt
:4
;submultimiout.txt
:Datele introduse corespund restrictiilor impuse
:1
:1 2
:1 2 3
:1 2 3 4
:1 2 4
:1 3
:1 3 4
:1 4
:2
:2 3
:2 3 4
:2 4
:3
:3 4
:4

== Exemplul 2 ==
;submultimiin.txt
:19736

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n):
return 1 <= n <= 10

def genereaza_submultimi(n):
submultimi = []

def backtrack(start, current):
submultimi.append(current[:])

for i in range(start, n + 1):
current.append(i)
backtrack(i + 1, current)
current.pop()

backtrack(1, [])
return submultimi[1:] # Excludem mulțimea vidă

# Citire din fișierul de intrare
with open('submultimiin.txt', 'r') as file:
n = int(file.readline())

# Verificare restricții
if verifica_restrictii(n):
# Generare submulțimi
rezultat = genereaza_submultimi(n)

# Scriere în fișierul de ieșire
with open('submultimiout.txt', 'w') as file_out:
for subset in rezultat:
file_out.write(" ".join(map(str, subset)) + "\n")
else:
print("Date de intrare nevalide.")

</syntaxhighlight>

0198 - Submultimi

2023-12-27T13:24:40Z

Mesarosdenisa:

== Cerinta ==

Se citește un număr natural nenul '''n'''. Să se afişeze, în ordine lexicografică, toate submulțimile nevide ale mulţimii '''{1,2,..,n}'''.

== Date de intrare ==

Fişierul de intrare '''submultimiin.txt''' conţine pe prima linie numărul '''n'''.

== Date de iesire ==

Fişierul de ieşire '''submultimiout.txt''' va conţine pe fiecare linie câte o submulțime, elementele unei submulțimi fiind separate printr-un spațiu.

== Restrictii si precizari ==

*1 &les; n &les; 10

== Exemplul 1 ==
;submultimiin.txt
:4
;submultimiout.txt
:Datele introduse corespund restrictiilor impuse
:1
:1 2
:1 2 3
:1 2 3 4
:1 2 4
:1 3
:1 3 4
:1 4
:2
:2 3
:2 3 4
:2 4
:3
:3 4
:4

== Exemplul 2 ==
;submultimiin.txt
:19736

:Datele introduse nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def generare_submultimi(n, subset, index):
if index == n + 1:
if len(subset) > 0:
print(" ".join(map(str, subset)))
return

# Includem elementul la index în submulțime
generare_submultimi(n, subset + [index], index + 1)

# Nu includem elementul la index în submulțime
generare_submultimi(n, subset, index + 1)

# Citire date de intrare
with open("submultimi.txt", "r") as file:
n = int(file.readline().strip())

# Rezolvare problema
generare_submultimi(n, [], 1)

</syntaxhighlight>