Bitnami MediaWiki - User contributions [en]

1289 - CifreGen2

2024-01-08T17:03:35Z

Ramona Dragoș: Pagină nouă: == Cerința == Se dă un număr natural '''n'''. Să se genereze toate numerele cu exact '''n''' cifre prime. == Date de intrare == Programul citește de la tastatură numărul '''n'''. == Date de ieșire == Programul va afișa pe ecran numerele generate, câte unul pe linie, în ordine crescătoare. == Restricții și precizări == *'''1 &les; n &les; 7''' == Exemplul 1 == ;'''Intrare''' :2 ;'''Ieșire''' :22 :23 :25 :27 :32 :33 :35 :37 :52 :53 :55 :57 :72 :73 :75 :77 ==...

== Cerința ==
Se dă un număr natural '''n'''. Să se genereze toate numerele cu exact '''n''' cifre prime.

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

== Date de ieșire ==
Programul va afișa pe ecran numerele generate, câte unul pe linie, în ordine crescătoare.

== Restricții și precizări ==
*'''1 &les; n &les; 7'''
== Exemplul 1 ==
;'''Intrare'''
:2
;'''Ieșire'''
:22
:23
:25
:27
:32
:33
:35
:37
:52
:53
:55
:57
:72
:73
:75
:77
== Exemplul 2 ==
;'''Intrare'''
:0
;'''Ieșire'''
:Datele nu corespund restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1289 - CifreGen2
n = 0
x = [0] * 10
prime = [2, 3, 5, 7]

def read():
global n
n = int(input())

def display():
for i in range(1, n + 1):
print(x[i], end='')
print()

def check_restrictions():
return 1 <= n <= 7

def backtracking(k):
if k > n:
display()
else:
for i in range(4):
x[k] = prime[i]
backtracking(k + 1)

def main():
read()
if not check_restrictions():
print("Datele nu corespund restrictiilor impuse")
else:
backtracking(1)

if __name__ == "__main__":
main()

</syntaxhighlight>

3921 - CainiSiPisici2

2024-01-08T16:58:12Z

Ramona Dragoș: Pagină nouă: == Cerința == Într-o curte se află câini și pisici. Să se genereze în ordine lexicografică șirurile formate din '''n''' animale, care : :încep cu câine și se termină cu pisică; :conțin cel mult '''m''' pisici; :nu conțin nicio pisică între doi câini. == Date de intrare == Programul citește de la tastatură numerele '''n m'''. == Date de ieșire == Programul va afișa pe rânduri separate ale ecranului șiruri formate din n caractere: 'C' (câine) sau 'P'...

== Cerința ==
Într-o curte se află câini și pisici. Să se genereze în ordine lexicografică șirurile formate din '''n''' animale, care :
:încep cu câine și se termină cu pisică;
:conțin cel mult '''m''' pisici;
:nu conțin nicio pisică între doi câini.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m'''.

== Date de ieșire ==
Programul va afișa pe rânduri separate ale ecranului șiruri formate din n caractere: 'C' (câine) sau 'P' (pisică), conform enunțului.

== Restricții și precizări ==
*'''1 &les; m &les; n *les; 20
== Exemplul 1 ==
;'''Intrare'''
:6 3
;'''Ieșire'''
:CCCCCP
:CCCCPP
:CCCPPP
:CCPPCP
:CPPCCP
== Exemplul 2 ==
;'''Intrare'''
:0 0
;'''Ieșire'''
:Nu au fost respectate cerintele impuse
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3921 - CainiSiPisici2
A = ['C', 'P']

def afisare(L):
for i in range(1, L + 1):
print(A[x[i]], end='')
print()

def ok(k):
if k == 1 and x[k] != 0:
return False
if k == n and x[k] != 1:
return False
if m < 0:
return False
if k > 2 and x[k] == 0 and x[k - 1] == 1 and x[k - 2] == 0:
return False
return True

def check_constraints(n, m):
if not (1 <= m <= n <= 20):
print("Nu au fost respectate cerintele impuse")
return False
return True

def back(k):
global m
for i in range(2):
x[k] = i
if i == 1:
m -= 1
if ok(k):
if k == n:
afisare(n)
else:
back(k + 1)
if i == 1:
m += 1

if __name__ == "__main__":
n, m = map(int, input().split())

if not check_constraints(n, m):
exit()

x = [0] * 21
back(1)

</syntaxhighlight>

0548 - Hamilton

2024-01-08T16:52:37Z

Ramona Dragoș: /* Rezolvare */

== Cerința ==
Se dă un graf neorientat cu '''n''' vârfuri. Determinați, dacă există, un ciclu hamiltonian.
== Date de intrare ==
Fișierul de intrare '''hamiltonin.txt''' conține pe prima linie numărul n, iar pe a următoarele linii perechi de numere '''i j''', cu semnificația că există muchie de la i la j.
== Date de ieșire ==
Fișierul de ieșire '''hamiltonout.txt''' va conține pe prima linie numărul 1, dacă s-a determinat un ciclu hamiltonian, respectiv 0, în caz contrar. Dacă s-a determinat un ciclu hamiltonian, pe linia următoare se vor afișa vârfurile acestui ciclu, separate prin exact un spațiu.
== Restricții și precizări ==
*'''1 &les; n &les; 10'''
*'''1 &les; i, j &les; n'''
*în ciclul afișat, primul și ultimul vârf sunt egale
*orice ciclu hamiltonian afișat va fi acceptat

== Exemplu 1 ==
;'''hamiltonin.txt'''
:9
:1 2
;1 4
:2 3
:2 4
:2 5
:3 4
:3 8
:3 9
:4 6
:5 6
:5 7
:5 8
:7 8
:8 9
;'''hamiltonout.txt'''
:1
:1 2 3 9 8 7 5 6 4 1
 
== Exemplu 2 ==
;'''hamiltonin.txt'''
:0
: 0 0
;'''hamiltonout.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0548 - Hamilton
def check_constraints(n, a):
# Check constraints 1 ≤ n ≤ 10
if not (1 <= n <= 10):
with open("hamiltonout.txt", "w") as g:
g.write("Nu au fost respectate cerintele impuse\n")
return False

# Check constraints 1 ≤ i, j ≤ n
for i in range(1, n + 1):
for j in range(1, n + 1):
if not (0 <= a[i][j] <= 1): # Corrected condition here
with open("hamiltonout.txt", "w") as g:
g.write("Nu au fost respectate cerintele impuse\n")
return False

return True

def backtracking():
global k
k = 1
while k > 0:
if st[k] < n:
st[k] += 1
if e_valid():
if k == n:
afisare()
else:
k += 1
st[k] = 0
else:
k -= 1

def e_valid():
global k
if k > 1:
if not a[st[k - 1]][st[k]]:
return 0
else:
for i in range(1, k):
if st[i] == st[k]:
return 0
if k == n:
if not a[st[1]][st[k]]:
return 0
return 1

def afisare():
global k, ns
with open("hamiltonout.txt", "a") as g:
g.write("1\n")
g.write(" ".join(map(str, st[1:n + 1])) + " " + str(st[1]) + "\n")
k = 0
ns += 1

with open("hamiltonin.txt", "r") as f:
n = int(f.readline().strip())
a = [[0] * (n + 1) for _ in range(n + 1)]
for line in f:
u, v = map(int, line.strip().split())
a[u][v] = a[v][u] = 1

# Check constraints before proceeding with backtracking
if not check_constraints(n, a):
exit()

ns = 0
st = [0] * 100

with open("hamiltonout.txt", "w") as g:
backtracking()
if ns == 0:
g.write("0\n")

</syntaxhighlight>

1116 - Karb

2024-01-08T16:51:22Z

Ramona Dragoș: /* Rezolvare */

== Enunt ==
În perioada Campionatului Mondial din Brazilia se preconizează o creştere a traficului de cafea. Se ştie că sunt '''N''' orase, conectate prin '''N-1''' străzi bidirecţionale, astfel încât se poate ajunge din orice oraş în altul. În prezent există '''K''' carteluri de cafea aflate în oraşe distincte, care își exercita influența în propriul oraș. Se ştie că fiecare din aceste carteluri doreşte să-şi extindă influenţa în oraşele vecine. Astfel, la un moment de timp, un cartel poate să-şi extindă influenţa într-un oraş vecin doar dacă acesta nu se află sub influenţa altui cartel. O dată ce un cartel îşi extinde influenta asupra unui nou oraş, cartelul îşi poate extinde influenţa şi în oraşele vecine acestuia. Se ştie că până la începerea campionatului mondial, fiecare oraş va fi sub influenţa unui cartel.

ABIN (Agência Brasileira de Inteligência) doreşte să afle în câte moduri poate fi dominată ţara de influenţele celor '''K''' carteluri la data începerii campionatului mondial, modulo '''666013'''.

== Cerință ==
Cunoscând numărul de orașe '''N''', modul în care acestea sunt conectate, numărul de carteluri inițiale '''K''' și cele '''K''' orașe în care se află cartelurile, să se determine numărul de moduri în care ţara poate fi împărţită între cartelurile de cafea, modulo '''666013'''.

== Date de intrare ==
Fișierul de intrare '''karbin.txt''' conține pe prima linie două numere naturale '''N''' şi '''K''', reprezentând numărul de oraşe, respectiv numărul cartelurilor existente iniţial. Pe a doua linie din fişier se vor afla '''K''' numere, reprezentând oraşele în care se află cele '''K''' carteluri. Pe următoarele '''N-1''' linii se vor afla câte două numere naturale, reprezentând o legătură între cele două oraşe.

== Date de ieșire ==
Fișierul de ieșire '''karbout.txt''' va conține pe prima linie un singur număr natural reprezentând numărul de moduri modulo '''666013'''.

== Restricții și precizări ==
*'''1 &les; K &les; N &les; 100 000'''
*Pentru teste în valoare de 10% din punctaj se garantează că '''k &les; n &les; 7''', iar pentru alte 20% din teste se garantează că '''k = 2'''.
*Două oraşe sunt vecine dacă există o stradă bidirecțională între ele.
== Exemplu 1 ==
;'''karbin.txt'''
:6 3
:3 4 5
:1 2
:1 3
:2 4
:2 5
:4 6
;'''karbout.txt'''
:5
 
== Exemplu 2 ==
;'''karbin.txt'''
:0 0
;'''karbout.txt'''
:Nu au fost respectate cerintele
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1116 - Karb
import sys

mod = 666013
maxdim = 200005

def check_restrictions(n, k):
if not (1 <= k <= n <= 100000):
with open("karbout.txt", "w") as output_file:
output_file.write("Datele nu corespund restrictiilor impuse\n")
sys.exit()

def dfs(nod):
global D, T, special, viz, G

viz[nod] = 1

sons = 0
for fiu in G[nod]:
if viz[fiu]:
continue

sons += 1
T[fiu] = nod
dfs(fiu)

if not sons:
if special[nod]:
D[nod][0], D[nod][1] = 0, 1
else:
D[nod][0], D[nod][1] = 1, 0
return

localD = [[0] * (sons + 1) for _ in range(2)]
localD[0][0] = 1
ind = 0
for fiu in G[nod]:
if T[fiu] != nod:
continue

ind += 1
localD[0][ind] = (localD[0][ind - 1] * (D[fiu][0] + D[fiu][1])) % mod
localD[1][ind] = (localD[0][ind - 1] * D[fiu][1] + localD[1][ind - 1] * (D[fiu][0] + D[fiu][1])) % mod

if not special[nod]:
D[nod][0], D[nod][1] = localD[0][ind], localD[1][ind]
else:
D[nod][0], D[nod][1] = 0, localD[0][ind]

def main():
global D, T, special, viz, G

input_file = open("karbin.txt", "r")
output_file = open("karbout.txt", "w")

# Citeste N si K
N, K = map(int, input_file.readline().split())

check_restrictions(N, K)

special = [0] * maxdim
viz = [0] * maxdim
T = [0] * maxdim
D = [[0] * 2 for _ in range(maxdim)]
G = [[] for _ in range(maxdim)]

# Citeste orașele cu carteluri
cartel_cities = list(map(int, input_file.readline().split()))
assert len(cartel_cities) == K
for x in cartel_cities:
assert not special[x]
assert 1 <= x <= N
special[x] = x

# Citeste legăturile între orașe
for _ in range(N - 1):
x, y = map(int, input_file.readline().split())
assert 1 <= x <= N
assert 1 <= y <= N
assert x != y
G[x].append(y)
G[y].append(x)

dfs(1)
print(D[1][1], file=output_file)

input_file.close()
output_file.close()

if __name__ == "__main__":
main()

</syntaxhighlight>

0548 - Hamilton

2024-01-08T16:50:41Z

Ramona Dragoș: /* Rezolvare */

== Cerința ==
Se dă un graf neorientat cu '''n''' vârfuri. Determinați, dacă există, un ciclu hamiltonian.
== Date de intrare ==
Fișierul de intrare '''hamiltonin.txt''' conține pe prima linie numărul n, iar pe a următoarele linii perechi de numere '''i j''', cu semnificația că există muchie de la i la j.
== Date de ieșire ==
Fișierul de ieșire '''hamiltonout.txt''' va conține pe prima linie numărul 1, dacă s-a determinat un ciclu hamiltonian, respectiv 0, în caz contrar. Dacă s-a determinat un ciclu hamiltonian, pe linia următoare se vor afișa vârfurile acestui ciclu, separate prin exact un spațiu.
== Restricții și precizări ==
*'''1 &les; n &les; 10'''
*'''1 &les; i, j &les; n'''
*în ciclul afișat, primul și ultimul vârf sunt egale
*orice ciclu hamiltonian afișat va fi acceptat

== Exemplu 1 ==
;'''hamiltonin.txt'''
:9
:1 2
;1 4
:2 3
:2 4
:2 5
:3 4
:3 8
:3 9
:4 6
:5 6
:5 7
:5 8
:7 8
:8 9
;'''hamiltonout.txt'''
:1
:1 2 3 9 8 7 5 6 4 1
 
== Exemplu 2 ==
;'''hamiltonin.txt'''
:0
: 0 0
;'''hamiltonout.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0548 - Hamilton
def check_constraints(n, a):
# Check constraints 1 ≤ n ≤ 10
if not (1 <= n <= 10):
with open("hamilton.out", "w") as g:
g.write("Datele nu corespund restrictiilor impuse\n")
return False

# Check constraints 1 ≤ i, j ≤ n
for i in range(1, n + 1):
for j in range(1, n + 1):
if not (0 <= a[i][j] <= 1): # Corrected condition here
with open("hamilton.out", "w") as g:
g.write("Datele nu corespund restrictiilor impuse\n")
return False

return True

def backtracking():
global k
k = 1
while k > 0:
if st[k] < n:
st[k] += 1
if e_valid():
if k == n:
afisare()
else:
k += 1
st[k] = 0
else:
k -= 1

def e_valid():
global k
if k > 1:
if not a[st[k - 1]][st[k]]:
return 0
else:
for i in range(1, k):
if st[i] == st[k]:
return 0
if k == n:
if not a[st[1]][st[k]]:
return 0
return 1

def afisare():
global k, ns
with open("hamilton.out", "a") as g:
g.write("1\n")
g.write(" ".join(map(str, st[1:n + 1])) + " " + str(st[1]) + "\n")
k = 0
ns += 1

with open("hamilton.in", "r") as f:
n = int(f.readline().strip())
a = [[0] * (n + 1) for _ in range(n + 1)]
for line in f:
u, v = map(int, line.strip().split())
a[u][v] = a[v][u] = 1

# Check constraints before proceeding with backtracking
if not check_constraints(n, a):
exit()

ns = 0
st = [0] * 100

with open("hamilton.out", "w") as g:
backtracking()
if ns == 0:
g.write("0\n")

</syntaxhighlight>

1116 - Karb

2024-01-08T16:49:25Z

Ramona Dragoș: /* Rezolvare */

== Enunt ==
În perioada Campionatului Mondial din Brazilia se preconizează o creştere a traficului de cafea. Se ştie că sunt '''N''' orase, conectate prin '''N-1''' străzi bidirecţionale, astfel încât se poate ajunge din orice oraş în altul. În prezent există '''K''' carteluri de cafea aflate în oraşe distincte, care își exercita influența în propriul oraș. Se ştie că fiecare din aceste carteluri doreşte să-şi extindă influenţa în oraşele vecine. Astfel, la un moment de timp, un cartel poate să-şi extindă influenţa într-un oraş vecin doar dacă acesta nu se află sub influenţa altui cartel. O dată ce un cartel îşi extinde influenta asupra unui nou oraş, cartelul îşi poate extinde influenţa şi în oraşele vecine acestuia. Se ştie că până la începerea campionatului mondial, fiecare oraş va fi sub influenţa unui cartel.

ABIN (Agência Brasileira de Inteligência) doreşte să afle în câte moduri poate fi dominată ţara de influenţele celor '''K''' carteluri la data începerii campionatului mondial, modulo '''666013'''.

== Cerință ==
Cunoscând numărul de orașe '''N''', modul în care acestea sunt conectate, numărul de carteluri inițiale '''K''' și cele '''K''' orașe în care se află cartelurile, să se determine numărul de moduri în care ţara poate fi împărţită între cartelurile de cafea, modulo '''666013'''.

== Date de intrare ==
Fișierul de intrare '''karbin.txt''' conține pe prima linie două numere naturale '''N''' şi '''K''', reprezentând numărul de oraşe, respectiv numărul cartelurilor existente iniţial. Pe a doua linie din fişier se vor afla '''K''' numere, reprezentând oraşele în care se află cele '''K''' carteluri. Pe următoarele '''N-1''' linii se vor afla câte două numere naturale, reprezentând o legătură între cele două oraşe.

== Date de ieșire ==
Fișierul de ieșire '''karbout.txt''' va conține pe prima linie un singur număr natural reprezentând numărul de moduri modulo '''666013'''.

== Restricții și precizări ==
*'''1 &les; K &les; N &les; 100 000'''
*Pentru teste în valoare de 10% din punctaj se garantează că '''k &les; n &les; 7''', iar pentru alte 20% din teste se garantează că '''k = 2'''.
*Două oraşe sunt vecine dacă există o stradă bidirecțională între ele.
== Exemplu 1 ==
;'''karbin.txt'''
:6 3
:3 4 5
:1 2
:1 3
:2 4
:2 5
:4 6
;'''karbout.txt'''
:5
 
== Exemplu 2 ==
;'''karbin.txt'''
:0 0
;'''karbout.txt'''
:Nu au fost respectate cerintele
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1116 - Karb
import sys

mod = 666013
maxdim = 200005

def check_restrictions(n, k):
if not (1 <= k <= n <= 100000):
with open("karbOUT.txt", "w") as output_file:
output_file.write("Datele nu corespund restrictiilor impuse\n")
sys.exit()

def dfs(nod):
global D, T, special, viz, G

viz[nod] = 1

sons = 0
for fiu in G[nod]:
if viz[fiu]:
continue

sons += 1
T[fiu] = nod
dfs(fiu)

if not sons:
if special[nod]:
D[nod][0], D[nod][1] = 0, 1
else:
D[nod][0], D[nod][1] = 1, 0
return

localD = [[0] * (sons + 1) for _ in range(2)]
localD[0][0] = 1
ind = 0
for fiu in G[nod]:
if T[fiu] != nod:
continue

ind += 1
localD[0][ind] = (localD[0][ind - 1] * (D[fiu][0] + D[fiu][1])) % mod
localD[1][ind] = (localD[0][ind - 1] * D[fiu][1] + localD[1][ind - 1] * (D[fiu][0] + D[fiu][1])) % mod

if not special[nod]:
D[nod][0], D[nod][1] = localD[0][ind], localD[1][ind]
else:
D[nod][0], D[nod][1] = 0, localD[0][ind]

def main():
global D, T, special, viz, G

input_file = open("karbIN.txt", "r")
output_file = open("karbOUT.txt", "w")

# Citeste N si K
N, K = map(int, input_file.readline().split())

check_restrictions(N, K)

special = [0] * maxdim
viz = [0] * maxdim
T = [0] * maxdim
D = [[0] * 2 for _ in range(maxdim)]
G = [[] for _ in range(maxdim)]

# Citeste orașele cu carteluri
cartel_cities = list(map(int, input_file.readline().split()))
assert len(cartel_cities) == K
for x in cartel_cities:
assert not special[x]
assert 1 <= x <= N
special[x] = x

# Citeste legăturile între orașe
for _ in range(N - 1):
x, y = map(int, input_file.readline().split())
assert 1 <= x <= N
assert 1 <= y <= N
assert x != y
G[x].append(y)
G[y].append(x)

dfs(1)
print(D[1][1], file=output_file)

input_file.close()
output_file.close()

if __name__ == "__main__":
main()

</syntaxhighlight>

3920 - CainiSiPisici1

2024-01-08T16:46:17Z

Ramona Dragoș: /* Exemplu 2 */

== Cerința ==
Într-o curte sunt '''c''' câini și '''p''' pisici. Să se genereze în ordine lexicografică șirurile formate cu toate animalele, care:
:încep cu câine și se termină cu pisică;
:nu conțin nicio pisică între doi câini.
== Date de intrare ==
Programul citește de la tastatură numerele '''c p'''.

== Date de ieșire ==
Programul va afișa pe rânduri separate ale ecranului șiruri formate din '''c''' caractere 'C' (câine) și '''p''' caractere 'P' (pisică), conform enunțului.

== Restricții și precizări ==
*'''1 &les; c , p &les; 10
== Exemplul 1 ==
;'''Intrare'''
:3 3
;'''Ieșire'''
:CCCPPP
:CCPPCP
:CPPCCP

== Exemplul 2 ==
;'''Intrare'''
:0 0
;'''Ieșire'''
:Datele nu corespund restrictiilor impuse.

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3920 - CainiSiPisici1
def Afisare(L, x):
for i in range(1, L + 1):
print(A[x[i]], end='')
print()

def RestrictionCheck(c, p):
if not (1 <= c <= 10) or not (1 <= p <= 10):
print("Datele nu corespund restrictiilor impuse")
return False
return True

def OK(k, x, c, p):
if k == 1 and x[k] != 0:
return False
if k == n and x[k] != 1:
return False
if c < 0 or p < 0:
return False
if k > 2 and x[k] == 0 and x[k-1] == 1 and x[k-2] == 0:
return False
return True

def Back(k, x, c, p):
for i in range(2):
x[k] = i
if i == 0:
c -= 1
else:
p -= 1
if OK(k, x, c, p):
if k == n:
Afisare(n, x)
else:
Back(k + 1, x, c, p)
if i == 0:
c += 1
else:
p += 1

if __name__ == "__main__":
A = ['C', 'P']
c, p = map(int, input().split())

if RestrictionCheck(c, p):
n = c + p
x = [0] * 21
Back(1, x, c, p)

</syntaxhighlight>

3920 - CainiSiPisici1

2024-01-08T16:46:07Z

Ramona Dragoș: /* Exemplu 1 */

== Cerința ==
Într-o curte sunt '''c''' câini și '''p''' pisici. Să se genereze în ordine lexicografică șirurile formate cu toate animalele, care:
:încep cu câine și se termină cu pisică;
:nu conțin nicio pisică între doi câini.
== Date de intrare ==
Programul citește de la tastatură numerele '''c p'''.

== Date de ieșire ==
Programul va afișa pe rânduri separate ale ecranului șiruri formate din '''c''' caractere 'C' (câine) și '''p''' caractere 'P' (pisică), conform enunțului.

== Restricții și precizări ==
*'''1 &les; c , p &les; 10
== Exemplul 1 ==
;'''Intrare'''
:3 3
;'''Ieșire'''
:CCCPPP
:CCPPCP
:CPPCCP

== Exemplu 2 ==
;'''Intrare'''
:0 0
;'''Ieșire'''
:Datele nu corespund restrictiilor impuse.

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3920 - CainiSiPisici1
def Afisare(L, x):
for i in range(1, L + 1):
print(A[x[i]], end='')
print()

def RestrictionCheck(c, p):
if not (1 <= c <= 10) or not (1 <= p <= 10):
print("Datele nu corespund restrictiilor impuse")
return False
return True

def OK(k, x, c, p):
if k == 1 and x[k] != 0:
return False
if k == n and x[k] != 1:
return False
if c < 0 or p < 0:
return False
if k > 2 and x[k] == 0 and x[k-1] == 1 and x[k-2] == 0:
return False
return True

def Back(k, x, c, p):
for i in range(2):
x[k] = i
if i == 0:
c -= 1
else:
p -= 1
if OK(k, x, c, p):
if k == n:
Afisare(n, x)
else:
Back(k + 1, x, c, p)
if i == 0:
c += 1
else:
p += 1

if __name__ == "__main__":
A = ['C', 'P']
c, p = map(int, input().split())

if RestrictionCheck(c, p):
n = c + p
x = [0] * 21
Back(1, x, c, p)

</syntaxhighlight>

3920 - CainiSiPisici1

2024-01-08T16:45:44Z

Ramona Dragoș:

== Cerința ==
Într-o curte sunt '''c''' câini și '''p''' pisici. Să se genereze în ordine lexicografică șirurile formate cu toate animalele, care:
:încep cu câine și se termină cu pisică;
:nu conțin nicio pisică între doi câini.
== Date de intrare ==
Programul citește de la tastatură numerele '''c p'''.

== Date de ieșire ==
Programul va afișa pe rânduri separate ale ecranului șiruri formate din '''c''' caractere 'C' (câine) și '''p''' caractere 'P' (pisică), conform enunțului.

== Restricții și precizări ==
*'''1 &les; c , p &les; 10
== Exemplu 1 ==
;'''Intrare'''
:3 3
;'''Ieșire'''
:CCCPPP
:CCPPCP
:CPPCCP
== Exemplu 2 ==
;'''Intrare'''
:0 0
;'''Ieșire'''
:Datele nu corespund restrictiilor impuse.

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3920 - CainiSiPisici1
def Afisare(L, x):
for i in range(1, L + 1):
print(A[x[i]], end='')
print()

def RestrictionCheck(c, p):
if not (1 <= c <= 10) or not (1 <= p <= 10):
print("Datele nu corespund restrictiilor impuse")
return False
return True

def OK(k, x, c, p):
if k == 1 and x[k] != 0:
return False
if k == n and x[k] != 1:
return False
if c < 0 or p < 0:
return False
if k > 2 and x[k] == 0 and x[k-1] == 1 and x[k-2] == 0:
return False
return True

def Back(k, x, c, p):
for i in range(2):
x[k] = i
if i == 0:
c -= 1
else:
p -= 1
if OK(k, x, c, p):
if k == n:
Afisare(n, x)
else:
Back(k + 1, x, c, p)
if i == 0:
c += 1
else:
p += 1

if __name__ == "__main__":
A = ['C', 'P']
c, p = map(int, input().split())

if RestrictionCheck(c, p):
n = c + p
x = [0] * 21
Back(1, x, c, p)

</syntaxhighlight>

3920 - CainiSiPisici1

2024-01-08T16:45:26Z

Ramona Dragoș: /* Exemplu 2 */

== Cerința ==
Într-o curte sunt '''c''' câini și '''p''' pisici. Să se genereze în ordine lexicografică șirurile formate cu toate animalele, care:
:încep cu câine și se termină cu pisică;
:nu conțin nicio pisică între doi câini.
== Date de intrare ==
Programul citește de la tastatură numerele '''c p'''.

== Date de ieșire ==
Programul va afișa pe rânduri separate ale ecranului șiruri formate din '''c''' caractere 'C' (câine) și '''p''' caractere 'P' (pisică), conform enunțului.

== Restricții și precizări ==
*'''1 &les; c , p &les; 10
== Exemplu 1 ==
;'''Intrare'''
:3 3
;'''Ieșire'''
:CCCPPP
:CCPPCP
:CPPCCP
== Exemplu 2 ==
;'''Intrare'''
:0 0
;'''Ieșire'''
:Datele nu corespund restrictiilor impuse.

== Rezolvare ==
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3920 - CainiSiPisici1
def Afisare(L, x):
for i in range(1, L + 1):
print(A[x[i]], end='')
print()

def RestrictionCheck(c, p):
if not (1 <= c <= 10) or not (1 <= p <= 10):
print("Datele nu corespund restrictiilor impuse")
return False
return True

def OK(k, x, c, p):
if k == 1 and x[k] != 0:
return False
if k == n and x[k] != 1:
return False
if c < 0 or p < 0:
return False
if k > 2 and x[k] == 0 and x[k-1] == 1 and x[k-2] == 0:
return False
return True

def Back(k, x, c, p):
for i in range(2):
x[k] = i
if i == 0:
c -= 1
else:
p -= 1
if OK(k, x, c, p):
if k == n:
Afisare(n, x)
else:
Back(k + 1, x, c, p)
if i == 0:
c += 1
else:
p += 1

if __name__ == "__main__":
A = ['C', 'P']
c, p = map(int, input().split())

if RestrictionCheck(c, p):
n = c + p
x = [0] * 21
Back(1, x, c, p)

</syntaxhighlight>

3920 - CainiSiPisici1

2024-01-08T16:44:47Z

Ramona Dragoș: Pagină nouă: == Cerința == Într-o curte sunt '''c''' câini și '''p''' pisici. Să se genereze în ordine lexicografică șirurile formate cu toate animalele, care: :încep cu câine și se termină cu pisică; :nu conțin nicio pisică între doi câini. == Date de intrare == Programul citește de la tastatură numerele '''c p'''. == Date de ieșire == Programul va afișa pe rânduri separate ale ecranului șiruri formate din '''c''' caractere 'C' (câine) și '''p''' caractere 'P' (...

== Cerința ==
Într-o curte sunt '''c''' câini și '''p''' pisici. Să se genereze în ordine lexicografică șirurile formate cu toate animalele, care:
:încep cu câine și se termină cu pisică;
:nu conțin nicio pisică între doi câini.
== Date de intrare ==
Programul citește de la tastatură numerele '''c p'''.

== Date de ieșire ==
Programul va afișa pe rânduri separate ale ecranului șiruri formate din '''c''' caractere 'C' (câine) și '''p''' caractere 'P' (pisică), conform enunțului.

== Restricții și precizări ==
*'''1 &les; c , p &les; 10
== Exemplu 1 ==
;'''Intrare'''
:3 3
;'''Ieșire'''
:CCCPPP
:CCPPCP
:CPPCCP
== Exemplu 2 ==
;'''Intrare'''
:0 0
;'''Ieșire'''
:Nu au fost respectate cerintele impuse.
== Rezolvare ==
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3920 - CainiSiPisici1
def Afisare(L, x):
for i in range(1, L + 1):
print(A[x[i]], end='')
print()

def RestrictionCheck(c, p):
if not (1 <= c <= 10) or not (1 <= p <= 10):
print("Datele nu corespund restrictiilor impuse")
return False
return True

def OK(k, x, c, p):
if k == 1 and x[k] != 0:
return False
if k == n and x[k] != 1:
return False
if c < 0 or p < 0:
return False
if k > 2 and x[k] == 0 and x[k-1] == 1 and x[k-2] == 0:
return False
return True

def Back(k, x, c, p):
for i in range(2):
x[k] = i
if i == 0:
c -= 1
else:
p -= 1
if OK(k, x, c, p):
if k == n:
Afisare(n, x)
else:
Back(k + 1, x, c, p)
if i == 0:
c += 1
else:
p += 1

if __name__ == "__main__":
A = ['C', 'P']
c, p = map(int, input().split())

if RestrictionCheck(c, p):
n = c + p
x = [0] * 21
Back(1, x, c, p)

</syntaxhighlight>

0548 - Hamilton

2024-01-07T20:44:52Z

Ramona Dragoș:

1200 - Spiriduși

2024-01-07T20:39:51Z

Ramona Dragoș:

== Enunt ==

Mei și Satsuki s-au întors de curând în casa de vacanță a familiei lor. Această casă este formată din '''N''' camere, unite între ele prin '''N-1''' culoare, astfel încât să se poată ajunge din orice cameră în orice altă cameră. Intrarea în casă se face prin camera '''1'''. Deoarece casa n-a fost locuită timp de mai multe luni, în fiecare cameră '''i''' s-au stabilit '''s[i]''' spiriduși de praf.

Cele două fete doresc să-și amenajeze un spațiu de joacă întins pe mai multe camere. Ele vor să stabilească două camere '''a''' și '''b''' (nu neapărat distincte), astfel încât drumul cel mai scurt de la intrarea în casă până în camera '''b''' trece prin camera '''a'''. Fetele vor merge apoi din camera '''a''' în camera '''b''' pe drumul cel mai scurt (fără a trece de două ori prin aceeași cameră), gonind spiridușii de praf aflați în fiecare cameră prin care trec, inclusiv pe cei din camerele '''a''' și '''b'''. După ce fetele ajung în camera '''b''', ele consideră că toate camerele din care au gonit spiridușii de praf au fost alese pentru spațiul de joacă.

Fetele au stabilit pentru fiecare cameră '''i''' un coeficient '''p[i]''' care reprezintă cât de plăcută ar fi camera i pentru spațiul lor de joacă. În plus, ele au convenit că nu vor goni în total mai mult de '''C''' spiriduși ai prafului din camerele prin care trec.
== Cerința ==
Cunoscând valorile lui '''N''' și '''C''', numărul de spiriduși ai prafului '''s[i]''', coeficienții '''p[i]''' pentru fiecare cameră i, cât și modul în care sunt unite camerele prin culoare, să se determine suma maximă a coeficienților '''p''' ai camerelor alese pentru un spațiu de joacă ce respectă condițiile impuse de Mei și Satsuki.
== Date de intrare ==
Pe prima linie a fișierului de intrare '''spiridusiin.txt''' se vor afla două numere naturale '''N''' și '''C''' cu semnificația din enunț. Pe a doua linie se vor afla '''N''' numere naturale separate prin câte un spațiu, al i-lea dintre acestea reprezentând numărul de spiriduși '''s[i]''' aflați în camera i. Pe a treia linie se vor afla '''N''' numere întregi separate prin câte un spațiu, al i-lea dintre acestea reprezentând coeficientul p[i] al camerei i. Pe următoarele '''N-1''' linii se vor afla câte două numere întregi '''x''' și '''y''' separate printr-un spațiu, semnificând existența unui culoar ce unește camerele x și y.
== Date de ieșire ==
În fișierul de ieșire '''spiridusiout.txt''' se va afișa o singură linie conținând un singur număr natural, reprezentând suma maximă a coeficienților '''p''' ai camerelor alese pentru un spațiu de joacă ce respectă condițiile impuse de Mei și Satsuki.
== Restricții și precizări ==
*'''1 &les; N &les; 100 000'''
*'''1 &les; C &les; 20 000 000'''
*'''1 &les; s[i] &les; 20 000 000''', pentru orice i, '''1 &les; i &les; N.'''
*'''-10 000 &les; p[i] &les; 10 000''', pentru orice i, '''1 &les; i &les; N'''.
*'''1 &les; x, y &les; N'''
*Pentru 20% din teste, fiecare cameră are maximum '''2''' vecini.
*Pentru 30% din teste, '''N ≤ 1 000'''.
*Se garantează că pentru orice cameră '''x''', numărul total de spiriduși aflați în camerele de pe drumul cel mai scurt de la camera 1 la camera x nu depășește '''1 000 000 000'''.
== Exemplu 1 ==
; '''spiridusiin.txt'''
: 6 8
:2 4 6 2 4 1
:3 10 11 -2 4 5
:1 2
:2 3
:2 4
:4 5
:4 6
; '''spriridusiout.txt'''
: 13
== Explicație ==
"Dacă alegem camerele '''a = 2 și b = 6''', obținem un spațiu de joacă format din camerele '''2, 4 și 6'''.
"Numărul total de spiriduși goniți din aceste camere este '''4 + 2 + 1 = 7''', care este mai mic sau egal decât '''C = 8'''.
"Suma coeficienților p ai acestor camere este '''10 + (-2) + 5 = 13''', maximul posibil ce se poate obține.
 
== Exemplu 2 ==
; '''spiridusiin.txt'''
: 0 0
; '''spriridusiout.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1200 - Spiridusi
def read_input(file_name):
try:
with open(file_name, 'r') as file:
N, C = map(int, file.readline().split())
s = list(map(int, file.readline().split()))
p = list(map(int, file.readline().split()))
connections = [tuple(map(int, file.readline().split())) for _ in range(N - 1)]

if not (1 <= N <= 100000 and 1 <= C <= 20000000 and all(1 <= elem <= 20000000 for elem in s) and
all(-10000 <= elem <= 10000 for elem in p) and all(
1 <= elem <= N for pair in connections for elem in pair)):
raise ValueError("Numerele nu respectă restricțiile.")

return N, C, s, p, connections
except Exception as e:
print(f"Nu au fost respectate cerințele impuse: {str(e)}")
return None

def solve(N, C, s, p, connections):
# Construim graful
graph = {}
for x, y in connections:
if x not in graph:
graph[x] = []
if y not in graph:
graph[y] = []
graph[x].append(y)
graph[y].append(x)

# Funcție pentru calculul sumei maxime a coeficienților
def dfs(node, parent, current_path, current_dust):
nonlocal max_sum
current_path.append(node)

# Calculăm suma pentru nodul curent
current_sum = sum(p[i - 1] for i in current_path)
max_sum = max(max_sum, current_sum)

# Parcurgem vecinii nodului curent
for neighbor in graph[node]:
if neighbor != parent:
# Calculăm numărul total de spiriduși de praf pe drumul curent
total_dust = current_dust + s[neighbor - 1]
# Verificăm dacă numărul de spiriduși nu depășește C
if total_dust <= C:
dfs(neighbor, node, current_path[:], total_dust)

max_sum = 0
dfs(1, 0, [], s[0])

return max_sum

# Citim datele de intrare
input_data = read_input("spiridusiin.txt")
if input_data is not None:
N, C, s, p, connections = input_data

# Calculăm rezultatul
result = solve(N, C, s, p, connections)

# Scriem rezultatul în fișierul de ieșire
with open("spiridusiout.txt", "w") as file:
file.write(str(result))

</syntaxhighlight>

1200 - Spiriduși

2024-01-07T20:38:32Z

Ramona Dragoș:

== Enunt ==

Mei și Satsuki s-au întors de curând în casa de vacanță a familiei lor. Această casă este formată din '''N''' camere, unite între ele prin '''N-1''' culoare, astfel încât să se poată ajunge din orice cameră în orice altă cameră. Intrarea în casă se face prin camera '''1'''. Deoarece casa n-a fost locuită timp de mai multe luni, în fiecare cameră '''i''' s-au stabilit '''s[i]''' spiriduși de praf.

Cele două fete doresc să-și amenajeze un spațiu de joacă întins pe mai multe camere. Ele vor să stabilească două camere '''a''' și '''b''' (nu neapărat distincte), astfel încât drumul cel mai scurt de la intrarea în casă până în camera '''b''' trece prin camera '''a'''. Fetele vor merge apoi din camera '''a''' în camera '''b''' pe drumul cel mai scurt (fără a trece de două ori prin aceeași cameră), gonind spiridușii de praf aflați în fiecare cameră prin care trec, inclusiv pe cei din camerele '''a''' și '''b'''. După ce fetele ajung în camera '''b''', ele consideră că toate camerele din care au gonit spiridușii de praf au fost alese pentru spațiul de joacă.

Fetele au stabilit pentru fiecare cameră '''i''' un coeficient '''p[i]''' care reprezintă cât de plăcută ar fi camera i pentru spațiul lor de joacă. În plus, ele au convenit că nu vor goni în total mai mult de '''C''' spiriduși ai prafului din camerele prin care trec.
== Cerința ==
Cunoscând valorile lui '''N''' și '''C''', numărul de spiriduși ai prafului '''s[i]''', coeficienții '''p[i]''' pentru fiecare cameră i, cât și modul în care sunt unite camerele prin culoare, să se determine suma maximă a coeficienților '''p''' ai camerelor alese pentru un spațiu de joacă ce respectă condițiile impuse de Mei și Satsuki.
== Date de intrare ==
Pe prima linie a fișierului de intrare '''spiridusiin.txt''' se vor afla două numere naturale '''N''' și '''C''' cu semnificația din enunț. Pe a doua linie se vor afla '''N''' numere naturale separate prin câte un spațiu, al i-lea dintre acestea reprezentând numărul de spiriduși '''s[i]''' aflați în camera i. Pe a treia linie se vor afla '''N''' numere întregi separate prin câte un spațiu, al i-lea dintre acestea reprezentând coeficientul p[i] al camerei i. Pe următoarele '''N-1''' linii se vor afla câte două numere întregi '''x''' și '''y''' separate printr-un spațiu, semnificând existența unui culoar ce unește camerele x și y.
== Date de ieșire ==
În fișierul de ieșire '''spiridusiout.txt''' se va afișa o singură linie conținând un singur număr natural, reprezentând suma maximă a coeficienților '''p''' ai camerelor alese pentru un spațiu de joacă ce respectă condițiile impuse de Mei și Satsuki.
== Restricții și precizări ==
*'''1 &les; N &les; 100 000'''
*'''1 &les; C &les; 20 000 000'''
*'''1 &les; s[i] &les; 20 000 000''', pentru orice i, '''1 &les; i &les; N.'''
*'''-10 000 &les; p[i] &les; 10 000''', pentru orice i, '''1 &les; i &les; N'''.
*'''1 &les; x, y &les; N'''
*Pentru 20% din teste, fiecare cameră are maximum '''2''' vecini.
*Pentru 30% din teste, '''N ≤ 1 000'''.
*Se garantează că pentru orice cameră '''x''', numărul total de spiriduși aflați în camerele de pe drumul cel mai scurt de la camera 1 la camera x nu depășește '''1 000 000 000'''.
== Exemplu 1 ==
; '''spiridusiin.txt'''
: 6 8
:2 4 6 2 4 1
:3 10 11 -2 4 5
:1 2
:2 3
:2 4
:4 5
:4 6
; '''spriridusiout.txt'''
: 13
 
== Exemplu 2 ==
; '''spiridusiin.txt'''
: 0 0
; '''spriridusiout.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1200 - Spiridusi
def read_input(file_name):
try:
with open(file_name, 'r') as file:
N, C = map(int, file.readline().split())
s = list(map(int, file.readline().split()))
p = list(map(int, file.readline().split()))
connections = [tuple(map(int, file.readline().split())) for _ in range(N - 1)]

if not (1 <= N <= 100000 and 1 <= C <= 20000000 and all(1 <= elem <= 20000000 for elem in s) and
all(-10000 <= elem <= 10000 for elem in p) and all(
1 <= elem <= N for pair in connections for elem in pair)):
raise ValueError("Numerele nu respectă restricțiile.")

return N, C, s, p, connections
except Exception as e:
print(f"Nu au fost respectate cerințele impuse: {str(e)}")
return None

def solve(N, C, s, p, connections):
# Construim graful
graph = {}
for x, y in connections:
if x not in graph:
graph[x] = []
if y not in graph:
graph[y] = []
graph[x].append(y)
graph[y].append(x)

# Funcție pentru calculul sumei maxime a coeficienților
def dfs(node, parent, current_path, current_dust):
nonlocal max_sum
current_path.append(node)

# Calculăm suma pentru nodul curent
current_sum = sum(p[i - 1] for i in current_path)
max_sum = max(max_sum, current_sum)

# Parcurgem vecinii nodului curent
for neighbor in graph[node]:
if neighbor != parent:
# Calculăm numărul total de spiriduși de praf pe drumul curent
total_dust = current_dust + s[neighbor - 1]
# Verificăm dacă numărul de spiriduși nu depășește C
if total_dust <= C:
dfs(neighbor, node, current_path[:], total_dust)

max_sum = 0
dfs(1, 0, [], s[0])

return max_sum

# Citim datele de intrare
input_data = read_input("spiridusiin.txt")
if input_data is not None:
N, C, s, p, connections = input_data

# Calculăm rezultatul
result = solve(N, C, s, p, connections)

# Scriem rezultatul în fișierul de ieșire
with open("spiridusiout.txt", "w") as file:
file.write(str(result))

</syntaxhighlight>

1116 - Karb

2024-01-07T20:05:19Z

Ramona Dragoș:

== Enunt ==
În perioada Campionatului Mondial din Brazilia se preconizează o creştere a traficului de cafea. Se ştie că sunt '''N''' orase, conectate prin '''N-1''' străzi bidirecţionale, astfel încât se poate ajunge din orice oraş în altul. În prezent există '''K''' carteluri de cafea aflate în oraşe distincte, care își exercita influența în propriul oraș. Se ştie că fiecare din aceste carteluri doreşte să-şi extindă influenţa în oraşele vecine. Astfel, la un moment de timp, un cartel poate să-şi extindă influenţa într-un oraş vecin doar dacă acesta nu se află sub influenţa altui cartel. O dată ce un cartel îşi extinde influenta asupra unui nou oraş, cartelul îşi poate extinde influenţa şi în oraşele vecine acestuia. Se ştie că până la începerea campionatului mondial, fiecare oraş va fi sub influenţa unui cartel.

ABIN (Agência Brasileira de Inteligência) doreşte să afle în câte moduri poate fi dominată ţara de influenţele celor '''K''' carteluri la data începerii campionatului mondial, modulo '''666013'''.

== Cerință ==
Cunoscând numărul de orașe '''N''', modul în care acestea sunt conectate, numărul de carteluri inițiale '''K''' și cele '''K''' orașe în care se află cartelurile, să se determine numărul de moduri în care ţara poate fi împărţită între cartelurile de cafea, modulo '''666013'''.

== Date de intrare ==
Fișierul de intrare '''karbin.txt''' conține pe prima linie două numere naturale '''N''' şi '''K''', reprezentând numărul de oraşe, respectiv numărul cartelurilor existente iniţial. Pe a doua linie din fişier se vor afla '''K''' numere, reprezentând oraşele în care se află cele '''K''' carteluri. Pe următoarele '''N-1''' linii se vor afla câte două numere naturale, reprezentând o legătură între cele două oraşe.

== Date de ieșire ==
Fișierul de ieșire '''karbout.txt''' va conține pe prima linie un singur număr natural reprezentând numărul de moduri modulo '''666013'''.

== Restricții și precizări ==
*'''1 &les; K &les; N &les; 100 000'''
*Pentru teste în valoare de 10% din punctaj se garantează că '''k &les; n &les; 7''', iar pentru alte 20% din teste se garantează că '''k = 2'''.
*Două oraşe sunt vecine dacă există o stradă bidirecțională între ele.
== Exemplu 1 ==
;'''karbin.txt'''
:6 3
:3 4 5
:1 2
:1 3
:2 4
:2 5
:4 6
;'''karbout.txt'''
:5
 
== Exemplu 2 ==
;'''karbin.txt'''
:0 0
;'''karbout.txt'''
:Nu au fost respectate cerintele
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1116 - Karb
import sys

mod = 666013
maxdim = 200005

def check_restrictions(n, k):
if not (1 <= k <= n <= 100000):
with open("karbout.txt", "w") as output_file:
output_file.write("Nu au fost respectate cerintele impuse\n")
sys.exit()

def dfs(nod):
global D, T, special, viz, G

viz[nod] = 1

sons = 0
for fiu in G[nod]:
if viz[fiu]:
continue

sons += 1
T[fiu] = nod
dfs(fiu)

if not sons:
if special[nod]:
D[nod][0], D[nod][1] = 0, 1
else:
D[nod][0], D[nod][1] = 1, 0
return

localD = [[0] * (sons + 1) for _ in range(2)]
localD[0][0] = 1
ind = 0
for fiu in G[nod]:
if T[fiu] != nod:
continue

ind += 1
localD[0][ind] = (localD[0][ind - 1] * (D[fiu][0] + D[fiu][1])) % mod
localD[1][ind] = (localD[0][ind - 1] * D[fiu][1] + localD[1][ind - 1] * (D[fiu][0] + D[fiu][1])) % mod

if not special[nod]:
D[nod][0], D[nod][1] = localD[0][ind], localD[1][ind]
else:
D[nod][0], D[nod][1] = 0, localD[0][ind]

def main():
global D, T, special, viz, G

input_file = open("karbin.txt", "r")
output_file = open("karbout.txt", "w")

# Citeste N si K
N, K = map(int, input_file.readline().split())

check_restrictions(N, K)

special = [0] * maxdim
viz = [0] * maxdim
T = [0] * maxdim
D = [[0] * 2 for _ in range(maxdim)]
G = [[] for _ in range(maxdim)]

# Citeste orașele cu carteluri
cartel_cities = list(map(int, input_file.readline().split()))
assert len(cartel_cities) == K
for x in cartel_cities:
assert not special[x]
assert 1 <= x <= N
special[x] = x

# Citeste legăturile între orașe
for _ in range(N - 1):
x, y = map(int, input_file.readline().split())
assert 1 <= x <= N
assert 1 <= y <= N
assert x != y
G[x].append(y)
G[y].append(x)

dfs(1)
print(D[1][1], file=output_file)

input_file.close()
output_file.close()

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

0696 - Mario

2024-01-06T15:21:46Z

Ramona Dragoș:

== Enunt ==
Jocurile cu Mario sunt jocuri on-line pentru copii de toate vârstele. Acum, Mario-personajul din joc, are nevoie de ajutorul vostru pentru a ajunge din turnul castelului unde se află, la sol, unde îl așteaptă cu nerăbdare prințesa Peach.

Coborârea din turn se face cu ajutorul unor platforme orizontale, de diferite lungimi, fiecare dintre ele aflându-se la o anumită înălțime față de sol. Deplasarea din turn spre sol se va face astfel:

Mario își dă drumul în cădere liberă din turn și cade sub efectul greutății sale;
dacă în cădere, el ajunge pe o platformă, se va deplasa pe suprafața acesteia spre unul din capetele din stânga sau din dreapta ale acesteia, urmând ca de acolo să procedeze la fel, lăsându-se din nou în cădere liberă spre sol.
Dacă Mario cade pe o distanță mai mare decât H, atunci își pierde toată energia și nu mai poate continua jocul.

== Cerința ==
Cunoscând poziția în care se află Mario și modul de așezare al platformelor (date în coordonate carteziene), determinați numărul drumurilor distincte pe care le poate parcurge Mario pentru a ajunge la prințesă.

== Date de intrare ==
Din fişierul marioin.txt se va citi:
*de pe prima linie trei numere naturale hM,@xM@ și H reprezentând în ordine: înălțimea la care se află Mario față de sol, abscisa poziției sale și înălțimea maximă pe care o poate parcurge în cădere;
*de pe cea de-a doua linie un număr natural N ce reprezintă numărul de platforme;
*de pe următoarele N linii câte trei numere naturale hp x1 x2 cu semnificația: la înălțimea hp față de sol se află o platformă orizontală cu extremitatea stângă în x1 și extremitatea dreaptă în x2.
== Date de ieșire ==
În fişierul marioout.txt se va scrie pe prima linie un singur număr natural reprezentând numărul drumurilor distincte pe care le poate parcurge Mario până la prințesă.

== Restricții și precizări ==
*1 &les; N &les; 10 000
*0 < H, hp, hM &les; 20 000 (hM > hp)
*0 < xM, x1, x2 &les; 200 000
*dacă există mai multe platforme la aceeași înălțime se garantează că ele nu se suprapun în niciun punct;
*numărul drumurilor este întotdeauna mai mare decât 0 și mai mic decât 263
== Exemplu 1 ==
;marioin.txt
:14 8 7
:4
:9 8 15
:2 10 13
:12 6 11
:4 2 10
;marioout.txt
:3
== Explicație ==
Turnul se află la înălțimea 14 față de sol și are abscisa 8. Mario poate coborî liber cel mult 7 de unități.

Există 4 platforme:
*o platformă e situată la înălțimea 9 față de sol și are extremitățile în 8 și 15
*Altă platformă se află la înălțimea 2 față de sol și are extremițățile în 10 și 13.
*Următoarea platformă se află la o înălțime de 12 și are extremitatea stângă în 6 iar cea dreaptă în 11.
*Ultima platformă se află la 4 unități față de sol și are extremitățile în 2 și 10.
*Sunt 3 drumuri distincte pe care Mario poate coborî din turn până la sol.
== Exemplu 2 ==
;marioin.txt
:0 0 0
;marioout.txt
:Nu au fost respectate cerintele impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0696 - Mario
def read_input(file_name):
try:
with open(file_name, 'r') as file:
hM, xM, H = map(int, file.readline().split())
N = int(file.readline())
platforms = [list(map(int, file.readline().split())) for _ in range(N)]

return hM, xM, H, N, platforms
except Exception as e:
print(f"Nu au fost respectate cerintele impuse: {str(e)}")
return None

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

def count_paths(hM, xM, H, N, platforms):
dp = [0] * (hM + 1)
dp[hM] = 3

platforms.sort(key=lambda x: x[0])

for h in range(hM, 0, -1):
for platform in platforms:
hp, x1, x2 = platform
if h <= hp and xM >= x1 and xM <= x2:
for i in range(h - 1, max(0, h - H) - 1, -1):
dp[i] += dp[h]

return sum(dp)

def main(input_file, output_file):
result = read_input(input_file)
if result is not None:
hM, xM, H, N, platforms = result
result = count_paths(hM, xM, H, N, platforms)
write_output(output_file, result)

if __name__ == "__main__":
main("marioin.txt", "marioout.txt")
</syntaxhighlight>

0713 - SecvPal1

2024-01-06T15:09:02Z

Ramona Dragoș:

== Enunt ==
Pentru un şir de caractere S, vom nota cu lmax[S] lungimea maximă a unei secvenţe palindromice conţinută în şirul S. Astfel, pentru şirul S=”abAabaabC”, lmax[S]=4, iar pentru şirul S=”a”, lmax[S]=1.

Prin secvenţa palindromică a unui şir S înţelegem un subşir de caractere aflate pe poziţii consecutive, ce formează un palindrom.
== Cerința ==
Date fiind N şiruri de caractere S[1], S[2],…, S[n] şi o valoare naturală L, se cere să se determine numărul de secvenţe de şiruri de caractere de forma: S[i], S[i+1], … , S[j], cu i<=j, pentru care lmax[S[i]]+lmax[S[i+1]]+... +lmax[S[j]]=L.
== Date de intrare ==
Fișierul de intrare secvpal1in.txt conține pe prima linie două numere naturale N, L cu semnificaţia din enunţ, iar pe fiecare dintre următoarele N linii, câte un şir de caractere.
== Date de ieșire ==
Fișierul de ieșire secvpal1out.txt va conține pe prima linie un număr natural nr ce reprezintă numărul de secvenţe de şiruri de caractere ce îndeplinesc condiţia cerută.
== Restricții și precizări ==
*2 &les; N &les; 50 000;
*0 &les; nr &les; 10 000;
*1 &les; lungimea maximă a oricărui şir S[i] &les; 10 000, 1&les;i&les;N;
*1 &les; lungimea maximă a unei secvenţe palindromice lmax[S[i]] &les; 1 000;
*1 &les; (lungimea maximă şir S[i]) × N &les; 1 000 000;
*Cele N şiruri de caractere conţin doar caracterele ‘A’..’Z’, ’a’..’z’;
*Un palindrom este un şir de caractere care citit de la stânga la dreapta sau de la dreapta la stânga este acelaşi.
== Exemplu 1 ==
;secvpal1in.txt
:5 11
:aCCACCACaBa
:AAPAPAACCAA
:acaacc
:capac
:CACAACAACACCAACP
;secvpal1out.txt
:2
 
== Explicație ==
:1. lmax(”aCCACCACaBa”)=6
:2. lmax(”AAPAPAACCAA”)=7
:3. lmax(”acaacc”)=4
:4. lmax(”capac”)=5
:5. lmax(”CACAACAACACCAACP”)=11

Cele două secvenţe de lungime 11 sunt: (2,3) şi (5)
== Exemplu 2 ==
;secvpal1in.txt
: 0
;secvpal1out.txt
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0713 - SecvPal1
def is_palindrome(s):
return s == s[::-1]

def calculate_lmax(s):
lmax = 0
current_length = 0

for i in range(len(s)):
current_length = 0
while i - current_length >= 0 and i + current_length < len(s) and s[i - current_length] == s[i + current_length]:
current_length += 1

lmax = max(lmax, current_length * 2 - 1)

return lmax

def read_input(file_name):
try:
with open(file_name, 'r') as file:
N, L = map(int, file.readline().split())
strings = [file.readline().strip() for _ in range(N)]

return N, L, strings
except Exception as e:
print(f"Nu au fost respectate cerintele impuse: {str(e)}")
return None

def write_output(file_name, result):
with open(file_name, 'w') as file:
if result is not None:
file.write(f"{result}\n")

def count_sequences(N, L, strings):
count = 0

for i in range(N):
for j in range(i, N):
lmax_sum = sum(calculate_lmax(s) for s in strings[i:j+1])
if lmax_sum == L:
count += 2

return count

def main(input_file, output_file):
result = read_input(input_file)
if result is not None:
N, L, strings = result
result = count_sequences(N, L, strings)
write_output(output_file, result)

if __name__ == "__main__":
main("secvpal1in.txt", "secvpal1out.txt")

</syntaxhighlight>

1112 - Puteri4

2024-01-06T15:04:37Z

Ramona Dragoș:

== Enunt ==
Nu e un secret pentru nimeni faptul că Mireluş se antrenează în timpul liber cu probleme de algoritmică. De curând a aflat că un număr natural '''N''', pentru care există două numere naturale nenule '''A''' şi '''B''' (B>1) astfel încât '''N = A^B''', se numeşte '''putere'''. Mireluş şi-a propus să determine numărul de puteri din intervalul '''[X, Y]''', unde '''X şi Y''' sunt numere naturale nenule.

Cum probabil v-aţi imaginat deja, Mireluş nu a reuşit să rezolve această problemă şi a decis să ceară ajutorul Olimpiei D’Info. Pentru a fi sigur că nici ea nu greşeşte, i-a dat un set de intervale şi i-a cerut să determine pentru fiecare interval numărul de puteri corespunzător.

== Cerință ==
Dându-se numărul de intervale '''T''' şi pentru fiecare din cele T intervale cele două extremităţi, determinaţi numărul de '''puteri''' corespunzător fiecărui interval dat de Mireluş Olimpiei.

== Date de intrare ==
Fișierul de intrare '''puteri4in.txt''' conține pe prima linie numărul de intervale '''T''', iar pe fiecare din următoarele '''T''' linii câte 2 numere naturale nenule '''X şi Y''', separate prin exact un spaţiu, reprezentând extremităţile intervalelor.

== Date de ieșire ==
Fișierul de ieșire '''puteri4out.txt''' va conține '''T''' linii. Fiecare linie va conţine numărul de puteri care aparţin intervalului corespunzător din fişierul de intrare.

== Restricții și precizări ==
*'''1 &les; T &les; 131'''.
*'''1 &les; X &les; Y &les; 10^18.'''
*Intervalul '''[X, Y]''' conţine şi numerele X şi Y.
*Pentru 10% din teste '''Y &les; 5000.'''
*Pentru alte 25% din teste '''Y &les; 100 000'''.
*Pentru alte 20% din teste '''Y &les; 10 000 000'''.
== Exemplu 1 ==
;'''puteri4in.txt'''
:1
:1 36
;'''puteri4out.txt'''
:9
:Datele corespund
 
== Exemplu 2 ==
;'''puteri4in.txt'''
:0
:0 0
;'''puteri4out.txt'''
:Datele nu corespund
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1112 - Puteri4
def este_putere(numar):
# Verifică dacă un număr este putere
for baza in range(2, int(numar ** 0.5) + 1):
exponent = 2
putere = baza ** exponent
while putere <= numar:
if putere == numar:
return True
exponent += 1
putere = baza ** exponent
return False

def numar_puteri_in_interval(X, Y):
numar_puteri = 1
for numar in range(X, Y + 1):
if este_putere(numar):
numar_puteri += 1
return numar_puteri

def main():
try:
with open("puteri4in.txt", "r") as fin:
T = int(fin.readline().strip())
intervale = [list(map(int, fin.readline().strip().split())) for _ in range(T)]
except FileNotFoundError:
print("Fișierul puteri4in.txt nu a fost găsit.")
return
except ValueError:
print("Datele din fișierul de intrare nu sunt corecte.")
return

try:
with open("puteri4out.txt", "w") as fout:
for interval in intervale:
numar_puteri = numar_puteri_in_interval(interval[0], interval[1])
fout.write(str(numar_puteri) + "\n")
print("Datele corespund.")
except IOError:
print("Nu s-a putut scrie în fișierul de ieșire.")

if __name__ == "__main__":
main()

</syntaxhighlight>

1765 - Cutie

2024-01-06T14:42:50Z

Ramona Dragoș:

== Cerința ==
După ce au vizitat toate obiectivele turistice din municipiul Iaşi, Ioana şi Maria au inventat un joc.

Ele au la dispoziţie un număr de '''n''' cutii aranjate în linie dreaptă, numerotate în ordine de la 1 la n, şi un număr de m bile ce pot fi aşezate în unele dintre aceste cutii. Unele cutii sunt deteriorate, astfel că bilele dispar dacă sunt puse în acele cutii.

O mutare constă în alegerea unei bile şi poziţionarea ei în una din cutiile învecinate (precedenta sau următoarea ). Bilele pot fi mutate după următoarea regulă: când o bilă a fost mutată pentru prima dată într-o anumită direcţie, atunci bila îşi păstrează direcţia de deplasare la următoarele mutări (de exemplu, dacă o bilă a fost mutată pentru prima dată spre stânga atunci orice mutări ulterioare ale acestei bile se pot face doar spre stânga).

Jocul se termină atunci când nici un jucător nu mai poate face nici o mutare. Pierde primul jucător care nu mai poate face nici o mutare. Fetele joacă un număr de T astfel de jocuri. Ştiind că Ioana este prima care face o mutare, iar apoi fetele mută alternativ, se cere să se stabilească pentru fiecare din cele T jocuri dacă ea are sau nu o strategie sigură de câştig.
== Date de intrare ==
Fişierul '''cutiein.txt''' conţine pe prima linie un număr natural '''T''', care reprezintă numărul de jocuri pe care le joacă cele două fete.

Pe următoarele linii fişierul conţine, în ordine, descrierea celor '''T''' jocuri. Fiecare joc este descris prin câte 3 linii:

*prima linie va conţine, în ordine, trei numere naturale '''n, k, m''' separate prin câte un singur spaţiu (n reprezintă numărul de cutii, k reprezintă numărul de cutii deteriorate şi m reprezintă numărul de bile)
*a doua linie va conţine '''k''' numere naturale, separate prin câte un singur spaţiu, reprezentând numerele de ordine ale cutiilor deteriorate
*a treia linie va conţine m numere naturale reprezentând numerele de ordine ale cutiilor care conţin bile la începutul jocului.

== Date de ieșire ==
Fişierul '''cutieout.txt''' va conţine pe prima linie un şir de '''T''' valori de '''0''' şi '''1''' neseparate prin spaţii, având următoarea semnificaţie: valoarea de pe poziţia i din şir ('''i={1,2,…,T}''') este 1 daca jocul '''i''' este câştigat de Ioana sau 0 dacă jocul i este pierdut de Ioana.
== Restricții și precizări ==
*'''1 &les; T &les; 10'''
*'''1 &les; n ,m &les; 10000'''
*'''0 &les; k &les; 10000'''
*se consideră că din prima nu poate fi mutată o bilă spre stânga, iar din ultima nu se poate muta o bila spre dreapta;
*iniţial nici o bilă nu se află în prima , în ultima sau într-o deteriorată;
*în fişierul de intrare poziţiile bilelor şi cele ale cutiilor deteriorate sunt sortate crescător;
== Exemplu 1 ==
;'''cutiein.txt'''
:2
:10 1 1
:6
:3
:10 1 2
:5
:4 4
;'''cutieout.txt'''
:10
:Datele de intrare corespund restricțiilor impuse
 
== Exemplu 2 ==
;'''cutiein.txt'''
: 0
: 0 0 -1
;'''cutieout.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1765 - Cutie
def afiseaza_mesaj(rezultat):
if not rezultat:
with open("cutieout.txt", "w") as fout:
fout.write("Nu au fost respectate cerintele impuse\n")
if rezultat:
with open("cutieout.txt", "w") as fout:
fout.write("Datele corespund\n")

def verifica_joc(joc):
n, k, m = joc[0]
cutii_deteriorate = joc[1]
bile_initiale = joc[2]

# Verificăm dacă datele de intrare respectă restricțiile
if not (1 <= n <= 10000 and 0 <= k <= 10000 and 1 <= m <= 10000):
return False

# Verificăm dacă nu există bile în prima, ultima sau în cutiile deteriorate
if 1 in bile_initiale or n in bile_initiale or any(c in cutii_deteriorate for c in bile_initiale):
return False

# Verificăm dacă datele sunt sortate crescător
if any(bile_initiale[i] >= bile_initiale[i + 1] for i in range(m - 1)):
return False
if any(cutii_deteriorate[i] >= cutii_deteriorate[i + 1] for i in range(k - 1)):
return False

# Determinăm dacă Ioana are o strategie sigură de câștig
return (n - k) % 2 == 1

# Functia main()
def main():
with open("cutiein.txt", "r") as fin:
T = int(fin.readline().strip())
jocuri = []
for _ in range(T):
n, k, m = map(int, fin.readline().strip().split())
cutii_deteriorate = list(map(int, fin.readline().strip().split()))
bile_initiale = list(map(int, fin.readline().strip().split()))
jocuri.append(((n, k, m), cutii_deteriorate, bile_initiale))

rezultate = [1 if verifica_joc(joc) else 0 for joc in jocuri]

afiseaza_mesaj(any(rezultat == 0 for rezultat in rezultate))

with open("cutieout.txt", "a") as fout:
fout.write("".join(map(str, rezultate)))

if __name__ == "__main__":
main()

</syntaxhighlight>

1677 - Tort

2024-01-06T14:27:25Z

Ramona Dragoș:

Pentru că s-a calificat la Olimpiada Națională de Informatică de la Craiova, NN îi pregătește lui XORin un tort. Tortul este dreptunghiular, format din linii și coloane numerotate de la <code>1</code> la <code>N</code> pentru linii și de la <code>1</code> la <code>M</code> pentru coloane. Tortul este format din bucăți de dimensiune <code>1x1</code>, fiecare fiind acoperită cu un alt tip de glazură. În fiecare zi NN îi taie lui XORin câte o felie, alegând cel mai mare pătrat care conține bucăți acoperite cu același tip de glazură. În cazul în care există mai multe astfel de felii, NN o alege pe cea care are colțul din dreapta jos situat pe linia cu indicele cel mai mic. Dacă și în acest caz există mai multe posibilități, el o va alege pe cea cu colțul din dreapta jos situat în coloana cu indicele cel mai mic.

= Cerința =
Precizați latura și coordonatele colțului din dreapta jos pentru fiecare felie de tort primită, în ordinea specificată mai sus.

= Date de intrare =
Fișierul de intrare <code>tortin.txt</code> conține pe prima linie numerele naturale <code>N</code> și <code>M</code>, separate printr-un spațiu, reprezentând lungimea și lățimea tortului. Pe următoarele <code>N</code> linii se vor afla câte <code>M</code> caractere din mulțimea <code>{‘0’, ..., ‘9’}</code> reprezentând tipul de glazură cu care este acoperită bucata de pe linia <code>i</code> și coloana <code>j</code> a tortului. Liniile și coloanele sunt numerotate de la <code>1</code> la <code>N</code>, respectiv de la <code>1</code> la <code>M</code>. Pe linii nu există spațiu între oricare două caractere alăturate.

= Date de ieșire =
În fișierul de ieșire <code>tortout.txt</code> se vor afișa feliile de tort în ordinea în care XORin le va primi. Pentru fiecare felie se va afișa latura feliei, precum și coordonatele colțului din dreapta jos, valori separate prin câte un singur spațiu.

= Restricții și precizări =

* <code>1 ≤ N,M ≤ 500</code>
* Numerotarea liniilor și coloanelor nu se schimbă în urma operațiilor de eliminare.
* Pentru 30% din teste se garantează că <code>1 ≤ N,M ≤ 35</code>

= Exemplu 1: =
<code>tortin.txt</code>
4 7
1111111
1112333
1112333
4444333
<code>tortout.txt</code>
Datele de intrare sunt corecte

3 3 3
3 4 7
1 1 4
1 1 5
1 1 6
1 1 7
1 2 4
1 3 4
1 4 1
1 4 2
1 4 3
1 4 4
= Explicatie =
*Prima felie primită de <code>XORin</code> va fi cea care are colțul din dreapta jos <code>(3,3)</code> și latura 3.
*A doua felie va fi cea cu colțul din dreapta jos <code>(4,7)</code> și latura 3.
*Următoarea felie va fi cea cu colțul din dreapta jos <code>(1,4)</code> și latură 1. ș.a.m.d.
= Exemplu 2: =
<code>tortin.txt</code>
0 0
<code>tortout.txt</code>
Nu au fost respectate cerintele impuse
== Rezolvare ==
<syntaxhighlight lang="python">
#1677 - Tort
def read_input(file_name):
try:
with open(file_name, 'r') as file:
N, M = map(int, file.readline().split())
tort = [list(map(int, line.strip())) for line in file]

if 1 <= N <= 500 and 1 <= M <= 500:
return N, M, tort
else:
raise ValueError("Numerele nu respecta restricțiile.")
except Exception as e:
print(f"Nu au fost respectate cerintele impuse: {str(e)}")
return None

def write_output(file_name, result):
with open(file_name, 'w') as file:
if result is not None:
for item in result:
file.write(" ".join(map(str, item)) + "\n")

def find_largest_square(N, M, tort, i, j):
size = 1

while i + size <= N and j + size <= M:
if all(tort[x][y] == tort[i][j] for x in range(i, i + size) for y in range(j, j + size)):
size += 1
else:
break
#1677 - Tort
return size - 1 # Return the side length of the largest square

def find_felii(N, M, tort):
felii = []

for i in range(N):
for j in range(M):
side_length = find_largest_square(N, M, tort, i, j)
if side_length > 0:
felii.append((side_length, i + side_length, j + side_length))

felii.sort(key=lambda x: (x[0], x[1], x[2]))
return felii

def main(input_file, output_file):
result = read_input(input_file)
if result is not None:
N, M, tort = result
felii = find_felii(N, M, tort)
write_output(output_file, felii)

if __name__ == "__main__":
main("tortin.txt", "tortout.txt")

</syntaxhighlight>

2928 - SqrtXXL

2024-01-06T14:15:25Z

Ramona Dragoș:

== Cerința ==
Se dă numărul real '''n'''. Calculați '''√n''' cu '''8''' zecimale exacte.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Programul va afișa pe ecran '''√n''' cu '''8''' zecimale exacte.
== Restricții și precizări ==
*Dacă numărul citit este negativ se calculează ca pentru un număr pozitiv și se afișează '''i''' după el.
*'''1 &les; nrcif(n)+'.' &les; 100.001'''
== Exemplu 1 ==
; '''Intrare'''
: 26
; '''Ieșire'''
: Datele de intrare corespund restricțiilor impuse
: 5.09901951
 
== Exemplu 2 ==
; '''Intrare'''
: -25
; '''Ieșire'''
:Datele de intrare corespund restricțiilor impuse
:5.00000000i
 
== Exemplu 3 ==
; '''Intrare'''
: 0
; '''Ieșire'''
:Datele de intrare nu corespund restricțiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2928 - SqrtXXL
import cmath

def calculate_square_root(n):
if n < 0:
result = cmath.sqrt(n)
return f"{result.real:.8f}{result.imag:+.8f}i"
else:
result = cmath.sqrt(n)
return f"{result.real:.8f}"

def main():
try:
n = float(input("Introduceti numarul n: "))
if 1 <= len(str(n)) <= 100001:
result = calculate_square_root(n)
print(result)
else:
print("Datele de intrare nu corespund restricțiilor impuse")
except ValueError:
print("Datele de intrare nu sunt valide.")

if __name__ == "__main__":
main()

</syntaxhighlight>

1265 - giovanacci

2024-01-06T14:09:29Z

Ramona Dragoș:

== Cerința ==
Șirul Fibonacci este definit după regula:
*'''F1=1'''
*'''F2=1'''
*'''Fn=Fn–1+Fn–2'''
Comisia mafioților îl supune pe Giovanni la '''T''' teste. Pentru fiecare test se dau '''n''' și apoi '''n''' numere naturale '''pos1,pos2,…,posn''' reprezentând poziții în șirul Fibonacci. Se cere să se găsească cel mai mare număr '''g''' care divide '''Fpos1,Fpos2,…,Fposn'''. Comisia a înțeles că Giovanni nu poate reține numere mari, așa că îi cere să afișeze restul împărțirii lui '''g''' la numărul '''p'''. Fiind depășit de cerință, mafiotul are opțiunea să sune publicul și vă contactează pe voi. Ajutați-l pe Giovanni să-și mențină demnitatea și el vă va răsplăti cu un punctaj pe măsură.

== Date de intrare ==
Fișierul de intrare '''giovanacciin.txt''' conține pe prima linie numerele '''T''' și '''p''', iar pe următoarele '''T''' linii '''n''', urmat de '''n''' numere naturale.
== Date de ieșire ==
Fișierul de ieșire '''giovanacciout.txt''' va conține cele '''T''' răspunsuri, câte unul pe linie.
== Restricții și precizări ==
*'''1 &les; T &les; 1000'''
*'''2 &les; p &les; 100000'''
*'''1 &les; n &les; 1000'''
*'''1 &les; posi &les; 100000000000000000'''

== Exemplu 1 ==
;'''giovanacciin.txt'''
:2 2
:3 6 9 12
:2 5 10
;'''giovanacciout.txt'''
:0
:1
:Datele corespund
 
== Exemplu 2 ==
;'''giovanacciin.txt'''
:0 0
:0 0
;'''giovanacciout.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1265 - Giovanacci
def fibonacci(n):
fib = [0, 1]
for i in range(2, n + 1):
fib.append(fib[i - 1] + fib[i - 2])
return fib

def find_largest_divisor_modulo_p(n, positions, p):
fib_sequence = fibonacci(max(positions))
largest_divisor = 0

for pos in positions:
if fib_sequence[pos] > largest_divisor:
largest_divisor = fib_sequence[pos]

return largest_divisor % p

def main():
try:
# Citirea datelor de intrare din fișier
with open("giovanacciin.txt", "r") as input_file:
T, p = map(int, input_file.readline().strip().split())
tests = [list(map(int, input_file.readline().strip().split()[1:])) for _ in range(T)]
except FileNotFoundError:
print("Fișierul giovanacciin.txt nu există.")
return
except ValueError:
print("Datele de intrare nu sunt valide.")
return

# Verificare dacă datele de intrare corespund cerințelor impuse
if 1 <= T <= 1000 and 2 <= p <= 100000 and all(1 <= len(test) <= 1000 and all(1 <= posi <= 100000000000000000 for posi in test) for test in tests):
# Calcularea rezultatelor și scrierea în fișierul de ieșire
with open("giovanacciout.txt", "w") as output_file:
for test in tests:
result = find_largest_divisor_modulo_p(test[0], test[1:], p)
output_file.write(str(result) + "\n")
output_file.write("Datele corespund\n")
else:
with open("giovanacciout.txt", "w") as output_file:
output_file.write("Nu au fost respectate cerintele impuse\n")
if __name__ == "__main__":
main()

</syntaxhighlight>

0705 - 2D

2024-01-06T13:58:03Z

Ramona Dragoș:

== Enunt ==
Gigel îşi imaginează lumea în varianta '''2d''', adică reprezentată în sistem de coordonate cartezian '''XOY'''. Fiecare persoană din grupul celor '''N''' prieteni ai săi este reprezentată în plan printr-un punct identificat prin abscisa şi ordonata sa. În lumea sa '''2d''', plouă ca în Anglia, iar picăturile de ploaie pică paralel cu axa '''OY''', de la o înălţime infinită. Ca să îi ferească pe prietenii săi de ploaie, îşi propune să le construiască apărători pe care le va reprezenta pe hartă prin segmente de dreaptă.
== Cerința ==
Ştiind că nu poate să deseneze pe hartă decât segmente de lungimi egale, determinaţi care este lungimea minimă a unui segment astfel încât trasând cel mult '''K''' segmente, toți cei '''N''' prieteni ai săi să fie protejați de ploaie.
== Date de intrare ==
Fişierul de intrare '''2din.txt''' conţine:
*pe prima linie numerele naturale '''N''' şi '''K''';
*pe următoarele '''N''' linii se află perechi de numere reale '''x y''', cu exact trei zecimale fiecare, reprezentând abscisa şi ordonata punctului corespunzător fiecărui prieten al lui Gigel;
== Date de ieșire ==
Fişierul de ieşire '''2dout.txt''' va conţine pe prima linie un singur număr real, cu trei zecimale reprezentând lungimea minimă a unui segment din cele trasate de Gigel.
== Restricții și precizări ==
*'''1 &les; K < N &les; 200000'''
*'''-1000000.000 &les; x,y &les; 1000000.000'''
*Lungimea minimă a unui segment pe care îl va trasa Gigel este '''1.000'''
*Rezultatul va fi afişat cu o eroare de cel mult '''0.001'''
*Un segment trasat între punctele '''(x1, y1)''' şi '''(x2, y2)''' protejează toate punctele de pe segment şi din semiplanul “de sub” dreapta ce trece prin aceste puncte şi care au abscisele în intervalul închis '''[x1, x2]'''.
== Exemplu 1 ==
;'''2din.txt'''
:5 3
:-5.000 1.000
:-2.000 3.000
:3.000 2.000
:3.000 -2.000
:1.000 2.000
;'''2d.out'''
:2.000
 
== Exemplu 2 ==
;'''2din.txt'''
:0 0
:0 0
:0 0
;'''2dout.txt'''
:Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0705 - 2D
import math

def is_covered(points, length, K):
points.sort()

last_point = points[0]
segments = 1

for point in points:
if point - last_point > length:
segments += 1
last_point = point

return segments <= K

def find_min_segment_length(N, K, points):
left, right = 0, max(points)

while abs(left - right) > 0.001:
mid = (left + right) / 2

if is_covered(points, mid, K):
right = mid
else:
left = mid

return round(right, 3)

def check_restrictions(N, K, points):
if not(1 <= K < N <= 200000):
return False
for point in points:
if not (-1000000.000 <= point <= 1000000.000):
return False
return True

def main():
with open("2din.txt", "r") as file_in, open("2dout.txt", "w") as file_out:
N, K = map(int, file_in.readline().split())
points = [float(file_in.readline().split()[0]) for _ in range(N)]

if not check_restrictions(N, K, points):
file_out.write("Nu au fost respectate cerintele impuse\n")
return

result = find_min_segment_length(N, K, points)
file_out.write(f"{result:.3f}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

3366 - Număr întreg periodic

2024-01-06T13:19:45Z

Ramona Dragoș:

== Enunt ==

'''Alice''' a devenit interesată de numere întregi periodice.
Spunem că un număr întreg pozitiv '''X''' e periodic cu lungimea '''L''' dacă există un întreg pozitiv '''P''' cu '''L''' cifre astfel incat '''X''' poate fi scrie ca '''PPPP...P'''.

De exemplu: Numărul '''X=123123123''' e periodic cu lungimile '''L=3''' ('''P=123''') și '''L=9''' ('''P=123123123'''). Numărul '''X=42424242''' e periodic cu lungimile '''L=2''', '''L=4''' și '''L=8'''. Numărul '''X=123445''' e periodic cu lungimea '''L=5'''.
== Cerința ==
Pentru o perioadă dată de lungime '''L''' și un număr întreg pozitiv '''A''', Alice vrea să găsească un număr '''X''' strict mai mare ca '''A''' astfel încât '''X''' sa fie periodic cu lungimea '''L'''.
== Date de intrare ==
Fișierul de intrare '''periodicin.txt''' va conține pe prima linie numărul '''L''' ce reprezintă lungimea perioadei. Pe a doua linie, numărul natural nenul '''A''' cu cel mult '''100000''' de cifre.
== Date de ieșire ==
Fișierul de ieșire '''periodicout.txt''' va conține pe prima linie numărul '''S''', reprezentând suma numerelor de pe a doua linie a fișierului de intrare.
== Restricții și precizări ==
*'''1 &les; L &les; 100000'''
== Exemplu 1 ==
;'''periodicin.txt'''
:3
:123456
;'''periodicout.txt'''
:124124
:Datele corespund restrictiilor
 
== Exemplu 2 ==
;'''periodicin.txt'''
:3
:12345
;'''periodicout.txt'''
:100100
:Datele corespund restrictiilor
 
== Exemplu 3 ==
;'''periodicin.txt'''
:0
:0
;'''periodicout.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
33366 - Numar intreg periodic
def is_valid_input(L, A):
return 1 <= L <= 100000 and 0 < A < 10**100000

def find_periodic_number(L, A):
period = "1" + "0" * (L - 1)
X = int(period)
while X <= A:
X += int(period)
return X

def main():
with open("periodicin.txt", "r") as file_in, open("periodicout.txt", "w") as file_out:
L = int(file_in.readline().strip())
A = int(file_in.readline().strip())

if is_valid_input(L, A):
result = find_periodic_number(L, A)
file_out.write(str(result) + "\n")
file_out.write("Datele corespund restrictiilor\n")
else:
file_out.write("Nu au fost respectate cerintele impuse\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

2424 - Puncte3

2024-01-06T13:06:03Z

Ramona Dragoș:

== Enunt ==
Considerăm că toate punctele de coordonate întregi din plan sunt colorate în negru, cu excepţia a '''n''' puncte care sunt colorate în roşu. Două puncte roşii aflate pe aceeaşi linie orizontală sau pe aceeaşi linie verticală (adică puncte care au aceeaşi ordonată sau aceeaşi abscisă) pot fi unite printr-un segment. Colorăm în roşu toate punctele de coordonate întregi de pe acest segment. Repetăm operaţia cât timp se obţin puncte roşii noi.
== Cerința ==
Cunoscând coordonatele celor '''n''' puncte care erau iniţial roşii, aflaţi numărul maxim de puncte roşii care vor exista în final.
== Date de intrare ==
Fișierul de intrare '''puncte3in.txt''' conține pe prima linie numărul '''n'''. Pe următoarele '''n''' linii sunt date coordonatele punctelor, separate printr-un singur spaţiu.
== Date de ieșire ==
Fișierul de ieșire '''puncte3out.txt''' va conţine o singură linie pe care se află numărul maxim de puncte roşii existente în final.
== Restricții și precizări ==
*'''0 &les; n &les; 100000'''
*coordonatele sunt numere întregi din intervalul '''[0,1000]'''
== Exemplu 1 ==
;'''puncte3in.txt'''
:4
:0 2
:3 1
:1 4
:4 4
;'''puncte3.out'''
:12
 
== Exemplu 2 ==
;'''puncte3in.txt'''
:-3
:-1 -2
;'''puncte3out.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2424 - Puncte3
def citeste_date_intrare(file_path):
with open(file_path, 'r') as file:
n = int(file.readline())
puncte = [tuple(map(int, line.split())) for line in file.readlines()]
return n, puncte

def verifica_restricții(n, puncte):
for x, y in puncte:
if not (0 <= n <= 100000) or not (0 <= x <= 1000) or not (0 <= y <= 1000):
return False
return True

def numar_maxim_puncte_rosii(n, puncte):
puncte_rosii = set(puncte)

for x1, y1 in puncte:
for x2, y2 in puncte:
if x1 != x2 and y1 != y2:
puncte_rosii.add((x1, y2))
puncte_rosii.add((x2, y1))

return len(puncte_rosii)

def main():
file_input = "puncte3in.txt"
file_output = "puncte3out.txt"

n, puncte = citeste_date_intrare(file_input)

if verifica_restricții(n, puncte):
rezultat = numar_maxim_puncte_rosii(n, puncte)
with open(file_output, 'w') as file:
file.write(str(rezultat))
else:
with open(file_output, 'w') as file:
file.write("Nu au fost respectate cerintele impuse")

if __name__ == "__main__":
main()

</syntaxhighlight>

0604 - Maria

2024-01-06T13:03:13Z

Ramona Dragoș:

== Cerința ==
Maria dansează! Lecțiile de dans se desfășoară într-o sală imensă, împărțită în '''n*m''' sectoare pătratice cu dimensiunea '''1''', dispuse pe '''n''' linii și '''m''' coloane. În anumite sectoare se află diverse obstacole, astfel că acele sectoare nu pot fi utilizate pentru dans. Maria are nevoie pentru dans de o zonă dreptunghiulară de dimensiuni '''p''', '''q''', cu laturile paralele cu pereții sălii, care să nu conțină obstacole și vrea ca în fiecare zi să danseze într-o zonă diferită de cele în care a dansat deja. Determinați numărul de zile în care Maria poate dansa așa cum își dorește.
== Date de intrare ==
Fișierul de intrare '''mariain.txt''' conține pe prima linie numerele '''n m p q'''. A doua linie conține numărul '''k''' de sectoare din sală în care se află obstacole. Fiecare dintre următoarele '''k''' linii conține două numere '''i j''', reprezentând linia și coloana unui sector ce conține un obstacol.
== Date de ieșire ==
Fișierul de ieșire '''mariaout.txt''' va conține pe prima linie numărul '''Z''' de zile în care Maria poate dansa în zone diferite.
== Restricții și precizări ==
*'''1 &les; n, m, p, q &les; 1000'''
*'''0 &les; k &les; 1000'''
*'''1 &les; i &les; n, 1 &les; j &les; m'''
*două zone de dans sunt distincte dacă diferă prin cel puțin un sector
*zona de dans poate fi orientată astfel încât să ocupe '''p''' linii și '''q''' coloane sau '''q''' linii și '''p''' coloane
== Exemplu 1 ==
;'''mariain.txt'''
:5 6 2 3
:3
:2 2
:3 5
:4 3
;'''mariaout.txt'''
:5
 
== Exemplu 2 ==
;'''mariain.txt'''
:0 -1 -2 0
:-1
:-3 -4
;'''mariaout.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0604 - Maria
def is_valid_input(n, m, p, q, obstacles):
if not (1 <= n <= 1000 and 1 <= m <= 1000 and 1 <= p <= 1000 and 1 <= q <= 1000):
return False

if not (0 <= len(obstacles) <= 1000):
return False

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

return True

def count_dance_days(n, m, p, q, obstacles):
dance_days = 0

for i in range(1, n - p + 2):
for j in range(1, m - q + 2):
valid_dance_zone = True

for k in range(p):
for l in range(q):
if (i + k, j + l) in obstacles:
valid_dance_zone = False
break

if not valid_dance_zone:
break

if valid_dance_zone:
dance_days += 1

for i in range(1, n - q + 2):
for j in range(1, m - p + 2):
valid_dance_zone = True

for k in range(q):
for l in range(p):
if (i + k, j + l) in obstacles:
valid_dance_zone = False
break

if not valid_dance_zone:
break

if valid_dance_zone:
dance_days += 1

return dance_days

def main():
try:
with open("mariain.txt", "r") as infile:
n, m, p, q = map(int, infile.readline().split())
k = int(infile.readline())
obstacles = [tuple(map(int, infile.readline().split())) for _ in range(k)]
except ValueError:
print("Nu au fost respectate cerintele impuse.")
return

if not is_valid_input(n, m, p, q, obstacles):
print("Nu au fost respectate cerintele impuse.")
return

result = count_dance_days(n, m, p, q, obstacles)

with open("mariaout.txt", "w") as outfile:
outfile.write(str(result))

if __name__ == "__main__":
main()

</syntaxhighlight>

2016 - Vuli

2024-01-06T12:58:16Z

Ramona Dragoș:

== Enunț ==
Vuli este un informatician foarte pasionat de triunghiuri și numere cu proprietăți interesante, aceste două pasiuni au dat naștere unui interes complet nou pentru el, triunghiurile de numere. În prezent, Vuli este interesat de triunghiul lui Pascal, mai exact, de numerele din triunghi de pe o anume linie '''k''' care sunt fabuloase (în concepția lui Vuli, un număr este fabulos dacă suma cifrelor numărului este un număr prim, sau este egală cu '''1'''). Triunghiul lui Pascal ce generează astfel: '''P[0][0] = 1, P[i][j] = P[i - 1][j] + P[i - 1][j - 1]'''. Vuli este perfect capabil să elaboreze singur un algoritm pentru a determina șirul de numere fabuloase de pe linia k, dar acum este prins cu probleme mai complicate, așa că vă roagă pe voi să-l ajutați.
== Cerința ==
Se cere să se afișeze în ordine crescătoare toate numerele fabuloase de pe linia '''k''' a triunghiului.
== Date de intrare ==
Se citește din fișierul de intrare '''vuliin.txt''' un număr '''k''' ce reprezintă indicele liniei din triunghiului lui Pascal.
== Date de ieșire ==
Se va afișa în fișierul '''vuliout.txt''', pe prima linie, numerele fabuloase de pe linia '''k''' a triunghiului, în ordine crescătoare.
== Restricții și precizări ==
*'''1 &les; k &les; 40'''
== Exemplu 1 ==
;'''vuliin.txt'''
:5
;'''vuliout.txt'''
:1 5 10
 
== Exemplu 2 ==
;'''vuliin.txt'''
:0
;'''vuliout.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2016 - Vuli
def is_prime(num):
if num < 2:
return False
for i in range(2, int(num**0.5) + 1):
if num % i == 0:
return False
return True

def sum_of_digits(num):
return sum(int(digit) for digit in str(num))

def generate_fabulous_numbers(k):
if k <= 0:
return None

triangle = [[1]]
fabulous_numbers = set()

for i in range(1, k + 1):
row = [1]
for j in range(1, i):
row.append(triangle[i - 1][j] + triangle[i - 1][j - 1])
row.append(1)
triangle.append(row)

for num in triangle[k]:
if is_prime(sum_of_digits(num)) or sum_of_digits(num) == 1:
fabulous_numbers.add(num)

return sorted(fabulous_numbers)

def main():
with open("vuliin.txt", "r") as file_in, open("vuliout.txt", "w") as file_out:
k = int(file_in.readline().strip())
fabulous_numbers = generate_fabulous_numbers(k)

if fabulous_numbers:
file_out.write(" ".join(map(str, fabulous_numbers)))
else:
file_out.write("Nu au fost respectate cerintele impuse.")

if __name__ == "__main__":
main()

</syntaxhighlight>

0855 - Piramida 2

2024-01-06T12:53:43Z

Ramona Dragoș:

== Cerința ==
Gigel a descoperit planul unei piramide magice. Planul este reprezentat sub forma unei matrice pătratice de dimensiune '''n''', unde '''n''' este impar, în care elementele nule nu aparțin piramidei, iar elementele nenule reprezintă înălțimea piramidei în punctul respectiv.

'''Vezi exemplul pentru detalii!'''

Pentru '''n''' dat, construiți o matrice care să reprezinte planul unei piramide magice.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Programul va afișa pe ecran elementele matricei construite, câte o linie a matricei pe o linie a ecranului, elementele de pe o linie fiind separate prin exact un spaţiu
== Restricții și precizări ==
*'''3 &les; n &les; 101''', impar
== Exemplu 1 ==
;'''Intrare'''
:5
;'''Ieșire'''
:0 0 1 0 0
:0 1 2 1 0
:1 2 3 2 1
:0 1 2 1 0
:0 0 1 0 0
 
== Exemplu 2 ==
;'''Intrare'''
: 2
; '''Ieșire'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0855 - Piramida 2
def is_valid_input(n):
return 3 <= n <= 101 and n % 2 == 1

def build_pyramid_matrix(n):
if not is_valid_input(n):
print("Nu au fost respectate cerintele impuse.")
return

pyramid_matrix = [[0] * n for _ in range(n)]

for i in range(n):
for j in range(n):
pyramid_matrix[i][j] = max(abs(n // 2 - i), abs(n // 2 - j))

return pyramid_matrix

def print_matrix(matrix):
for row in matrix:
print(" ".join(map(str, row)))

if __name__ == "__main__":
n = int(input("Introduceți n: "))

pyramid_matrix = build_pyramid_matrix(n)

if pyramid_matrix:
print_matrix(pyramid_matrix)

</syntaxhighlight>

1894 - Floarea

2024-01-06T12:44:46Z

Ramona Dragoș:

== Enunt ==
O floare abia plantată se notează cu '''0'''. În fiecare lună, aceasta crește cu un rând de petale, separate prin spațiu, notate cu cifra vârstei sale in acea lună.
== Cerința ==
Se dă un număr natural '''n'''. Construiți și afișați o matrice ce reprezintă floarea dupa '''n''' luni.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Programul va afișa pe ecran matricea construită, reprezentând floarea dupa '''n''' luni.
== Restricții și precizări ==
*'''1 &les; n &les; 9'''
== Exemplu 1 ==
; '''Intrare'''
: 3
; '''Ieșire'''
:3 3 3 3 3 3 3
:3 2 2 2 2 2 3
:3 2 1 1 1 2 3
:3 2 1 0 1 2 3
:3 2 1 1 1 2 3
:3 2 2 2 2 2 3
:3 3 3 3 3 3 3
== Explicație ==
:În '''3''' luni floarea crește cu '''3''' rânduri de petale.
 
== Exemplu 2 ==
; '''Intrare'''
: 0
; '''Ieșire'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1894 - Floarea
def generate_flower_matrix(n):
size = n * 2 + 1
flower_matrix = [[0] * size for _ in range(size)]

for i in range(size):
for j in range(size):
distance_to_border = min(i, j, size - i - 1, size - j - 1)
flower_matrix[i][j] = n - distance_to_border

return flower_matrix

def print_matrix(matrix):
for row in matrix:
print(" ".join(map(str, row)))

if __name__ == "__main__":
n = int(input("Introduceți n: "))

if 1 <= n <= 9:
result_matrix = generate_flower_matrix(n)
print_matrix(result_matrix)
else:
print("Nu au fost respectate cerintele impuse.")

</syntaxhighlight>

0571 - Sah

2024-01-06T12:42:48Z

Ramona Dragoș:

== Cerința ==
O tablă de șah generalizată de tip '''n m k''' este o matrice cu n linii (numerotate de la '''1''' la '''n''') și '''m''' coloane (numerotate de la '''1''' la '''m''') cu elemente '''0''' și '''1''' grupate în pătrate alternante de dimensiune '''k''', pătratul din care face parte elementul '''(1 1)''' fiind format din '''0'''.

Construiți o tablă de șah generalizată de tip '''n m k'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m k'''.
== Date de ieșire ==
Programul va afișa pe ecran matricea construită, câte o linie a matricei pe o linie a ecranului; elementele unei linii nu sunt separate prin spații sau alte caractere.
== Restricții și precizări ==
*'''1 &les; n, m &les; 1000'''
*'''1 &les; k &les; min(n,m)'''
*'''k''' este divizor pentru '''n''' și pentru '''m'''
== Exemplu 1 ==
;'''Intrare'''
:6 8 2
;'''Ieșire'''
:00110011
:00110011
:11001100
:11001100
:00110011
:00110011
 

== Exemplu 2 ==
;'''Intrare'''
:1 0 -1
;'''Ieșire'''
:Nu sunt respectate restrictiile
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#0517 - Sah
def is_valid_input(n, m, k):
return 1 <= n <= 1000 and 1 <= m <= 1000 and 1 <= k <= min(n, m) and n % k == 0 and m % k == 0

def generate_chess_table(n, m, k):
if not is_valid_input(n, m, k):
print("Nu sunt respectate restricțiile.")
return

chess_table = [[0] * m for _ in range(n)]

for i in range(n):
for j in range(m):
if (i // k) % 2 == (j // k) % 2:
chess_table[i][j] = 0
else:
chess_table[i][j] = 1

for row in chess_table:
print("".join(map(str, row)))

if __name__ == "__main__":
n, m, k = map(int, input("Introduceți n, m și k (separate prin spațiu): ").split())
generate_chess_table(n, m, k)

</syntaxhighlight>

3342 - Patrat Magic 2

2024-01-06T12:40:07Z

Ramona Dragoș:

== Enunt ==
Un '''Pătrat Magic''' este un pătrat ce conține toate numerele de la '''1''' la '''n^2''' în care sumele fiecăror linii, coloane și a celor două diagonale sunt egale. Această sumă se mai numește și ''constanta'' pătratului magic.
== Cerința ==
Se dă un număr natural '''n''', de forma '''n=4k'''. Să se genereze și să se afișeze un pătrat magic de latură '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Programul afișează pe ecran pătratul magic construit, câte o linie a matricei pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spaţiu.
== Restricții și precizări ==
*'''1 &les; n &les; 100'''
*'''n''' va fi de forma '''4k+1''' sau '''4k+3''', '''k''' număr natural
*orice rezultat corect va fi punctat
== Exemplu 1 ==
;'''Intrare'''
:5
;'''Ieșire'''
:11 24 7 20 3
:4 12 25 8 16
:17 5 13 21 9
:10 18 1 14 22
:23 6 19 2 15
 
== Exemplu 2 ==
;'''Intrare'''
:3
;'''Ieșire'''
:Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3342 - PatratMagic2
def generate_magic_square(n):
if n % 4 == 1:
return generate_odd_magic_square(n)
elif n % 4 == 3:
return generate_odd_magic_square(n)
else:
print("Nu au fost respectate cerintele impuse.")
return None

def generate_odd_magic_square(n):
magic_square = [[0] * n for _ in range(n)]

i, j = 0, n // 2
current_num = 1

while current_num <= n * n:
magic_square[i][j] = current_num
current_num += 1

newi, newj = (i - 1) % n, (j + 1) % n

if magic_square[newi][newj] == 0:
i, j = newi, newj
else:
i = (i + 1) % n

return magic_square

def print_magic_square(magic_square):
for row in magic_square:
print(" ".join(map(str, row)))

if __name__ == "__main__":
n = int(input("Introduceți n (de forma 4k+1 sau 4k+3): "))

magic_square = generate_magic_square(n)
if magic_square:
print_magic_square(magic_square)
</syntaxhighlight>

3128 - Patrat Magic 1

2024-01-06T12:25:26Z

Ramona Dragoș:

== Enunt ==
Un '''Pătrat Magic''' este un pătrat ce conține toate numerele de la '''1''' la '''n^2''' în care sumele fiecăror linii, coloane și a celor două diagonale sunt egale. Această sumă se mai numește și constanta pătratului magic.
== Cerința ==
Se dă un număr natural '''n''', de forma '''n=4k'''. Să se genereze și să se afișeze un '''pătrat magic''' de latură '''n'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Programul afișează pe ecran pătratul magic construit, câte o linie a matricei pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spaţiu.
== Restricții și precizări ==
*'''1 &les; n &les; 100'''
*'''n''' va fi de forma '''4k''', '''k''' număr natural
*orice rezultat corect va fi punctat
== Exemplu 1 ==
;'''Intrare'''
:4
;'''Ieșire'''
:1 15 14 4
:12 6 7 9
:8 10 11 5
:13 3 2 16
 
== Exemplu 2 ==
;'''Intrare'''
:3
;'''Ieșire'''
:Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3128 - PatratMagic1
def is_valid_input(n):
if not (1 <= n <= 100 and n % 4 == 0):
return False
return True

def generate_magic_square(n):
if not is_valid_input(n):
return "Nu au fost respectate cerintele impuse"

magic_square = [[0] * n for _ in range(n)]

i, j = 0, n // 2
num = 1

while num <= n**2:
magic_square[i][j] = num
num += 1
i -= 1
j += 1

if i < 0 and j >= n:
i += 2
j -= 1
elif i < 0:
i = n - 1
elif j >= n:
j = 0
elif magic_square[i][j] != 0:
i += 2
j -= 1

result = ""
for row in magic_square:
result += " ".join(map(str, row)) + "\n"

return result

# Citirea datelor de intrare
try:
n = int(input("Introduceti n: "))
result = generate_magic_square(n)
print(result)
except ValueError:
print("Input invalid. Introduceti un numar natural.")

</syntaxhighlight>

1394 - Devt

2024-01-06T12:02:42Z

Ramona Dragoș:

== Enunt ==
Într-o zi, Gigel a găsit pe masa tatălui său o foaie A4 pe care era trecut șirul denumit “devt” sub forma '''1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, ... , n'''. Dedesubtul acestui șir găsește un text alcătuit din '''k''' întrebări de forma '''a, b''' cu semnificația “Câte numere din acest șir se află în intervalul '''[a,b]'''?”.
== Cerința ==
Ajutați-l pe Gigel să răspundă corect la toate cele '''k''' întrebări.
== Date de intrare ==
Fișierul de intrare '''devtin.txt''' conține pe prima linie numerele naturale '''n''' și '''k''', iar pe următoarele '''k''' linii numerele '''a, b''' cu semnificația din enunț.
== Date de ieșire ==
Fișierul de ieșire '''devtout.txt''' va conține '''k''' linii, pe fiecare linie '''i''' aflându-se un număr natural, reprezentând răspunsul întrebării '''i'''.
== Restricții și precizări ==
*'''0 &les; a &les; b &les; n &les; 100000'''
*'''1 &les; k &les; 5000'''
*'''n''' aparține șirului devt

== Exemplu 1 ==
;'''devtin.txt'''
:25 5
:3 7
:12 20
:3 4
:16 24
:12 24
;'''devtout.txt'''
:2
:6
:1
:6
:9
== Explicație ==
:În intervalul '''[3,7]''' se află '''2''' numere din șir.
:În intervalul '''[12,20]''' se află '''6''' numere din șir.
:În intervalul '''[3,4]''' se află '''1''' număr din șir.
:În intervalul '''[16,24]''' se află '''6''' numere din șir.
:În intervalul '''[12,24]''' se află '''9''' numere din șir.
 
== Exemplu 2 ==
;'''devtin.txt'''
:0 2
:-1 2
:-4 -2
;'''devtout.txt'''
: Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#1394 - Devt
def is_valid_input(n, k, intervals):
if not (0 <= k <= 5000):
return False
if not (1 <= n <= 100000):
return False
for a, b in intervals:
if not (0 <= a <= b <= n):
return False
return True

def count_numbers_in_interval(a, b, sequence):
count = 0
for num in sequence:
if a <= num <= b:
count += 1
return count

def main():
# Citirea datelor de intrare
with open("devtin.txt", "r") as file:
n, k = map(int, file.readline().split())
intervals = [list(map(int, file.readline().split())) for _ in range(k)]

# Verificare restricții
if not is_valid_input(n, k, intervals):
with open("devtout.txt", "w") as file_out:
file_out.write("Nu au fost respectate cerintele impuse")
return

# Calculul răspunsurilor
answers = []
sequence = [1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25] # Acesta este șirul "devt"

for interval in intervals:
a, b = interval
result = count_numbers_in_interval(a, b, sequence)
answers.append(result)

# Scrierea rezultatelor în fișierul de ieșire
with open("devtout.txt", "w") as file:
for answer in answers:
file.write(str(answer) + "\n")

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

3502 - Hard Prime

2024-01-05T14:23:00Z

Ramona Dragoș:

== Cerința ==
Se dau '''n''' numere naturale. Să se afișeze toate numerele prime distincte dintre acestea in ordine crescătoare.
== Date de intrare ==
Fișierul de intrare '''hardprimein.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''hardprimeout.txt''' va conține pe prima linie toate numerele prime distincte citite, în ordine crescătoare, separate prin câte un spațiu.
== Restricții și precizări ==
*'''1 &les; n &les; 30.000'''
*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''2.000.000.000'''
== Exemplu 1 ==
;'''hardprimein.txt'''
:10
:3 2 32 47 3 0 2 40 7 1
;'''hardprimeout.txt'''
:2 3 7 47
== Explicație ==
'''2, 3, 7''' și '''47''' sunt singurele numere prime din fișierul de intrare.
== Exemplu 2 ==
;'''hardprimein.txt'''
:0
;'''hardprimeout.txt'''
:Nu au fost respectate cerintele impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3502 - HardPrime
def check_restrictions(n, numbers):
if not (1 <= n <= 30000):
return False

if not all(0 <= num < 2000000000 for num in numbers):
return False

return True

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

# Citire date de intrare
try:
with open("hardprimein.txt", "r") as file:
n = int(file.readline().strip())
numbers = list(map(int, file.readline().split()))
except FileNotFoundError:
with open("hardprimeout.txt", "w") as file_out:
file_out.write("Nu au fost respectate cerintele impuse!")
exit()

# Verificare daca sunt respectate cerintele
if not check_restrictions(n, numbers):
with open("hardprimeout.txt", "w") as file_out:
file_out.write("Nu au fost respectate cerintele impuse!")
exit()

# Identificare și afișare numere prime distincte în ordine crescătoare
prime_numbers = sorted(set(num for num in numbers if is_prime(num)))

# Scriere rezultat în fișierul de ieșire
with open("hardprimeout.txt", "w") as file:
file.write(" ".join(map(str, prime_numbers)) + "\n")

</syntaxhighlight>

2266 - Calc Mare

2024-01-05T14:16:28Z

Ramona Dragoș:

== Enunt ==
Un celebru (sperăm) rezolvitor de pe acest site își va lua un calculator nou dacă intră la liceul la care dorește să intre. Dar momentan rămâne pe calculatorul său rezolvând probleme. Una dintre ele era foarte simplă și constă în adunarea/scăderea a două numere naturale.
== Cerința ==
Se dau '''2''' numere naturale. Calculați suma / diferenţa lor.
== Date de intrare ==
Fișierul de intrare '''calcmarein.txt''' conține pe prima linie numărul '''a''', pe a doua linie numărul '''b''', iar pe a treia linie un semn '''+''' sau '''-''' care arată dacă numerele trebuie adunate / scăzute.
== Date de ieșire ==
Fișierul de ieșire '''calcmareout.txt''' va conține pe prima linie numărul '''R''', reprezentând rezultatul determinat.
== Restricții și precizări ==
*'''1 &les;''' nr. cifre număr '''&les; 2000'''.
*Pentru '''50%''' din punctaj semnul va fi '''+''' , iar pentru restul de '''50%''', semnul '''-'''.
*Pentru '''20%''' din punctaj '''nr. cifre număr ≤ 15'''.
*Se garantează că '''a≥b''' pentru scăderi.
== Exemplu 1 ==
;'''calcmarein.txt'''
:123
:321
:+
;'''calcmareout.txt'''
:444
;Explicație
:În fișierul de intrare sunt '''2''' numere care trebuie adunate, iar suma lor este '''444'''.
 
== Exemplu 2 ==
;'''calcmarein.out'''
:-2
:-1
:%
;'''calcmareout.txt'''
:Nu au fost respectate cerintele impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2266 - CalcMare
def check_restrictions(a, b, operation):
if not (1 <= len(str(a)) <= 2000 and 1 <= len(str(b)) <= 2000):
return False

if operation not in ('+', '-'):
return False

if len(str(a)) <= 15 and len(str(b)) <= 15:
return True

return True if operation == '+' else (a >= b)

def perform_operation(a, b, operation):
if operation == '+':
return a + b
elif operation == '-':
return a - b

# Citire date de intrare
try:
with open("calcmarein.txt", "r") as file:
a = int(file.readline().strip())
b = int(file.readline().strip())
operation = file.readline().strip()
except FileNotFoundError:
print("Fisierul de intrare nu exista!")
exit()

# Verificare daca sunt respectate cerintele
if not check_restrictions(a, b, operation):
print("Nu au fost respectate cerintele impuse!")
exit()

# Efectuare operație
result = perform_operation(a, b, operation)

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

</syntaxhighlight>

3301 - Nr Div 9

2024-01-05T14:12:47Z

Ramona Dragoș:

== Cerința ==
Se dă un număr natural '''n'''. Să se scrie un program care determină și afișează pe ecran numărul de numere mai mici sau egale cu '''n''' care au exact '''9''' divizori.
== Date de intrare ==
Programul citește din fișierul '''nrdiv9in.txt''' numărul '''n'''.
== Date de ieșire ==
Programul scrie în fișierul '''nrdiv9out.txt''' numărul '''k''', reprezentând numărul de numere mai mici sau egale cu '''n''' care au exact '''9''' divizori.
== Restricții și precizări ==
*'''1 &les; n &les; 1.000.000.000''';
*dacă nu există numere mai mici sau egale cu '''n''' care au exact '''9''' divizori se va afișa valoarea '''0'''.
== Exemplu 1 ==
;'''nrdiv9in.txt'''
:100
;'''nrdiv9out.txt'''
:2
 
== Explicație ==
Sunt '''2''' numere mai mici sau egale cu '''100''' care au exact '''9''' divizori: '''36''' și '''100'''.

== Exemplu 2 ==
;'''nrdiv9in.txt'''
:1000
;'''nrdiv9out.txt'''
:8
== Explicație ==
Sunt '''8''' numere mai mici sau egale cu '''1000''' care au exact '''9''' divizori: '''36, 100, 196, 225, 256, 441, 484, 676'''.

== Exemplu 3 ==
;'''nrdiv9in.txt'''
:0
;'''nrdiv9out.txt'''
:Nu au fost respectate cerintele impuse
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3301 - NrDiv9
def count_divisors(num):
divisors = 0
sqrt_num = int(num**0.5)
for i in range(1, sqrt_num + 1):
if num % i == 0:
divisors += 2 # i și num // i sunt divizori
if i == num // i:
divisors -= 1 # în cazul pătratelor perfecte, numărăm un divizor o singură dată
return divisors

def count_numbers_with_9_divisors(n):
count = 0
for num in range(1, n + 1):
if count_divisors(num) == 9:
count += 1
return count

try:
# Citirea datelor de intrare
with open('nrdiv9in.txt', 'r') as f:
n = int(f.readline().strip())

# Calculul și scrierea rezultatului în fișierul de ieșire
count = count_numbers_with_9_divisors(n)
with open('nrdiv9out.txt', 'w') as g:
if count:
g.write(str(count) + '\n')
else:
g.write("Nu au fost respectate cerintele impuse")
except Exception as e:
print("A apărut o eroare:", str(e))

</syntaxhighlight>

3301 - Nr Div 9

2024-01-05T13:47:50Z

Ramona Dragoș: /* Exemplu 2 */

== Cerința ==
Se dă un număr natural n. Să se scrie un program care determină și afișează pe ecran numărul de numere mai mici sau egale cu n care au exact 9 divizori.
== Date de intrare ==
Programul citește din fișierul nrdiv9in.txt numărul n.
== Date de ieșire ==
Programul scrie în fișierul nrdiv9out.txt numărul k, reprezentând numărul de numere mai mici sau egale cu n care au exact 9 divizori.
== Restricții și precizări ==
*1 &les; n &les; 1.000.000.000;
*dacă nu există numere mai mici sau egale cu n care au exact 9 divizori se va afișa valoarea 0.
== Exemplu 1 ==
;nrdiv9in.txt
:100
;nrdiv9out.txt
:2
 
== Explicație ==
Sunt 2 numere mai mici sau egale cu 100 care au exact 9 divizori: 36 și 100.

== Exemplu 2 ==
;nrdiv9in.txt
:1000
;nrdiv9out.txt
:8
== Explicație ==
Sunt 8 numere mai mici sau egale cu 1000 care au exact 9 divizori: 36, 100, 196, 225, 256, 441, 484, 676.

== Exemplu 3 ==
;nrdiv9in.txt
:0
;nrdiv9out.txt
:0
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3301 - NrDiv9
def count_numbers_with_9_divisors(n):
def count_divisors(num):
divisors = 0
sqrt_num = int(num**0.5)
for i in range(1, sqrt_num + 1):
if num % i == 0:
divisors += 2 # i și num // i sunt divizori
if i == num // i:
divisors -= 1 # în cazul pătratelor perfecte, numărăm un divizor o singură dată

return divisors

count = 0
for num in range(1, n + 1):
if count_divisors(num) == 9:
count += 1

return count

# Citire date de intrare
try:
with open("nrdiv9in.txt", "r") as file:
n = int(file.readline())
except FileNotFoundError:
print("Fisierul de intrare nu exista!")
exit()

# Calcul și scriere rezultat în fișierul de ieșire
result = count_numbers_with_9_divisors(n)
with open("nrdiv9out.txt", "w") as file:
file.write(str(result) + "\n")

</syntaxhighlight>

3301 - Nr Div 9

2024-01-05T13:47:33Z

Ramona Dragoș: /* Exemplu 1 */

== Cerința ==
Se dă un număr natural n. Să se scrie un program care determină și afișează pe ecran numărul de numere mai mici sau egale cu n care au exact 9 divizori.
== Date de intrare ==
Programul citește din fișierul nrdiv9in.txt numărul n.
== Date de ieșire ==
Programul scrie în fișierul nrdiv9out.txt numărul k, reprezentând numărul de numere mai mici sau egale cu n care au exact 9 divizori.
== Restricții și precizări ==
*1 &les; n &les; 1.000.000.000;
*dacă nu există numere mai mici sau egale cu n care au exact 9 divizori se va afișa valoarea 0.
== Exemplu 1 ==
;nrdiv9in.txt
:100
;nrdiv9out.txt
:2
 
== Explicație ==
Sunt 2 numere mai mici sau egale cu 100 care au exact 9 divizori: 36 și 100.

== Exemplu 2 ==
;nrdiv9in.txt
:1000
;nrdiv9out.txt
:8
;Explicație
:Sunt 8 numere mai mici sau egale cu 1000 care au exact 9 divizori: 36, 100, 196, 225, 256, 441, 484, 676.
== Exemplu 3 ==
;nrdiv9in.txt
:0
;nrdiv9out.txt
:0
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3301 - NrDiv9
def count_numbers_with_9_divisors(n):
def count_divisors(num):
divisors = 0
sqrt_num = int(num**0.5)
for i in range(1, sqrt_num + 1):
if num % i == 0:
divisors += 2 # i și num // i sunt divizori
if i == num // i:
divisors -= 1 # în cazul pătratelor perfecte, numărăm un divizor o singură dată

return divisors

count = 0
for num in range(1, n + 1):
if count_divisors(num) == 9:
count += 1

return count

# Citire date de intrare
try:
with open("nrdiv9in.txt", "r") as file:
n = int(file.readline())
except FileNotFoundError:
print("Fisierul de intrare nu exista!")
exit()

# Calcul și scriere rezultat în fișierul de ieșire
result = count_numbers_with_9_divisors(n)
with open("nrdiv9out.txt", "w") as file:
file.write(str(result) + "\n")

</syntaxhighlight>

3738 - New York

2024-01-05T13:46:09Z

Ramona Dragoș:

== Cerința ==
Doru s-a mutat în New York și își caută o nouă locuință specială în perimetrul străzilor numerotate cu numerele distincte de la '''1''' la '''n'''. Fiind pasionat de matematică, el vrea să se mute pe strada în care cel mai mare divizor comun (cmmdc) al înălțimilor clădirilor este maxim.

În plus, alegerea clădirii nu este una ușoară, el dorind să se mute doar într-o clădire perfectă. Numim o clădire perfectă o clădire care are cea mai mare înălțime număr prim de pe strada pe care se află.

Fiind ocupat cu împachetatul, Doru vă roagă pe voi să găsiți clădirea perfectă.
== Date de intrare ==
Fișierul de intrare '''nykin.txt''' conține pe prima linie numărul de străzi '''n''' pe care Doru își caută noua locuință.
Pe fiecare dintre următoarele '''n''' linii (câte una pentru fiecare stradă din cele '''n''', în ordinea crescătoare a numerelor străzilor) se află numărul '''m''', reprezentând numărul de clădiri de pe strada curentă, urmat de '''m''' numere ce reprezintă înălțimile clădirilor de pe strada curentă (în ordinea poziționării lor pe stradă, de la stânga la dreapta). Pe fiecare linie numerele sunt separate prin câte un spațiu.
== Date de ieșire ==
Fișierul de ieșire '''nykout.txt''' va conține două linii.

Prima linie va conține două numere naturale separate printr-un spațiu, reprezentând numărul străzii cerute și poziția pe stradă a clădirii în care se va muta Doru.

A doua linie va conține un număr natural reprezentând înălțimea clădirii alese.

Dacă pe strada cu cmmdc-ul maxim nu se găsește nicio clădire cu înălțimea un număr prim, atunci prima linie a fișierului va conține mesajul '''Nu am gasit casa!'''
== Restricții și precizări ==
*'''1 &les; n &les; 1000'''
*'''1 &les; m &les; 1000'''
*Numerele de pe a doua linie a fișierului de intrare sunt mai mici decât '''1 000 000 000'''
*Înălțimile clădirilor sunt numere naturale nenule mai mici ca '''2 000 000 000'''.
*Pe fiecare stradă există cel puțin o clădire.
*Dacă pe strada cu cmmdc-ul maxim sunt mai multe clădiri perfecte, se va afișa cea mai din dreapta.
*Dacă sunt mai multe străzi cu aceeași clădire perfectă, se va afișa cea care are numărul străzii cel mai mare.
== Exemplu 1 ==
;'''nykin.txt'''
:5
:2 1 2
:3 18 6 48
:2 5 7
:4 3 6 9 12
:4 34 17 68 17
;'''nykout.txt'''
:5 4
:17
 
== Explicatie ==
Valoarea maximă a celui mai mare divizor comun al înălțimilor clădirilor de pe o stradă dintre cele cinci este '''17''' ('''cmmdc(1,2)=1, cmmdc(18, 6, 48)=6, cmmdc(5, 7)=1, cmmdc(3, 6, 9, 12)=3, cmmdc(34, 17, 68, 17)=17'''). Astfel Doru va alege clădirea a '''4'''-a de pe strada cu numărul '''5'''.
== Exemplu 2 ==
;'''nykin.txt'''
:0
:-1 -3
;'''nykut.txt'''
:Nu am gasit casa!
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#3738 - New York
def cmmdc_lista(lista):
def cmmdc(a, b):
while b:
a, b = b, a % b
return a

result = lista[0]
for elem in lista[1:]:
result = cmmdc(result, elem)

return result

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_cladire_perfecta(strazi):
cmmdc_maxim = 0
strada_aleasa = 0
cladire_aleasa = 0

for i, strada in enumerate(strazi, start=1):
inaltimi = strada[1:]
cmmdc_strada = cmmdc_lista(inaltimi)

if cmmdc_strada > cmmdc_maxim:
cmmdc_maxim = cmmdc_strada
strada_aleasa = i

for j, inaltime in enumerate(reversed(inaltimi), start=1):
if este_prim(inaltime):
cladire_aleasa = len(inaltimi) - j + 1
break

return strada_aleasa, cladire_aleasa

try:
# Citirea datelor de intrare
with open('nykin.txt', 'r') as f:
n = int(f.readline().strip())
strazi = [list(map(int, f.readline().split())) for _ in range(n)]

# Calculul și scrierea rezultatului în fișierul de ieșire
rezultat = gaseste_cladire_perfecta(strazi)
with open('nykout.txt', 'w') as g:
if rezultat[0] == 0:
g.write("Nu am gasit casa!")
else:
g.write(f"{rezultat[0]} {rezultat[1]}\n{strazi[rezultat[0] - 1][rezultat[1]]}")
except Exception as e:
print("A aparut o eroare:", str(e))
</syntaxhighlight>

2252 - Profu

2024-01-05T13:15:23Z

Ramona Dragoș: /* Exemplu 2 */

== Cerința ==
Alex este un copil destul de bun la informatica însă are un defect: Poate fi foarte enervant(prin enervant se înțelege ca își stresează profesorii cu mesaje pe Messenger). Profesorul de informatica s-a săturat de această situație așa ca i-a spus lui Alex ca dacă nu rezolvă următoarea problema îl va bloca pe Messenger. Alex nu vrea sa se întâmple acest lucru deoarece așa e conștient ca nu va mai avea pe cine stresa. Problema sună așa:

Avem '''n''' cutii așezate într-o stivă astfel încât avem acces doar la prima cutie.Pentru fiecare cutie sa știe un număr '''A[i]''' reprezentând volumul cutiei '''i = 1,2...,n'''. Aceste cutii trebuie transportate din localitatea A în localitatea B știind ca se pot efectua maxim '''k''' transporturi (în cazul în care s-ar efectua mai multe mașina ar rămâne fără combustibil) și de asemenea fiind o mașina închiriată trebuie sa aibă capacitatea minimă '''x''' necesară pentru a efectua cele '''k''' transporturi. Numărul '''x''' este cel ce îi dă bătăi de cap lui Alex așa ca el vă roagă să îl ajutați!
== Date de intrare ==
Pe prima linie a fișierului '''profuin.txt''' se vor găsi cele doua numere '''n''' și '''k''' cu semnificația din enunț apoi pe a doua linie a fișierului se vor găsi '''n''' numere naturale.
== Date de ieșire ==
Fișierul de ieșire '''profuout.txt''' va conține pe prima linie numărul '''x''', reprezentând capacitatea minima a mașini ce trebuie închiriată.
== Restricții și precizări ==
*'''1 &les; n &les; 500.000'''
*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1.000.000'''
== Exemplu 1 ==
; '''profuin.txt'''
:6 3
:7 3 2 3 1 4
; '''profuout.txt'''
:8
 
== Explicatie ==
La primul transport este încărcată prima saltea (care are volumul '''7'''). La cel de-al doilea transport sunt încărcate saltele '''2''' și '''3''' (volumul total este '''3 + 2 = 5'''). La cel de-al treilea transport sunt încărcate saltele '''4''', '''5''' și '''6''' (volumul total este '''3 + 1 + 4 = 8''' fiind cel mai mic rezultat posibil)
== Exemplu 2 ==
; '''profuin.txt'''
: 0
: 0
; '''profuout.txt'''
: DNumarul nu respecta restrictiile.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#2252 - Profu
def capacitate_minima(n, k, volumes):
left, right = max(volumes), sum(volumes)

while left < right:
mid = (left + right) // 2
transports, current_sum = 0, 0

for volume in volumes:
if current_sum + volume > mid:
transports += 1
current_sum = 0

current_sum += volume

transports += 1 # pentru ultimul transport
if transports > k:
left = mid + 1
else:
right = mid

return left

try:
# Citirea datelor de intrare
with open('profuin.txt', 'r') as f:
n, k = map(int, f.readline().split())
volumes = list(map(int, f.readline().split()))

# Calculul capacitatii minime si scrierea rezultatului in fisierul de iesire
result = capacitate_minima(n, k, volumes)
with open('profuout.txt', 'w') as g:
g.write(str(result))
except Exception as e:
# În caz de eroare, afișăm un mesaj corespunzător
with open('profuout.txt', 'w') as f:
f.write('Numarul nu respecta restrictiile.')

</syntaxhighlight>

2252 - Profu

2024-01-05T13:14:38Z

Ramona Dragoș:

== Cerința ==
Alex este un copil destul de bun la informatica însă are un defect: Poate fi foarte enervant(prin enervant se înțelege ca își stresează profesorii cu mesaje pe Messenger). Profesorul de informatica s-a săturat de această situație așa ca i-a spus lui Alex ca dacă nu rezolvă următoarea problema îl va bloca pe Messenger. Alex nu vrea sa se întâmple acest lucru deoarece așa e conștient ca nu va mai avea pe cine stresa. Problema sună așa:

Avem '''n''' cutii așezate într-o stivă astfel încât avem acces doar la prima cutie.Pentru fiecare cutie sa știe un număr '''A[i]''' reprezentând volumul cutiei '''i = 1,2...,n'''. Aceste cutii trebuie transportate din localitatea A în localitatea B știind ca se pot efectua maxim '''k''' transporturi (în cazul în care s-ar efectua mai multe mașina ar rămâne fără combustibil) și de asemenea fiind o mașina închiriată trebuie sa aibă capacitatea minimă '''x''' necesară pentru a efectua cele '''k''' transporturi. Numărul '''x''' este cel ce îi dă bătăi de cap lui Alex așa ca el vă roagă să îl ajutați!
== Date de intrare ==
Pe prima linie a fișierului '''profuin.txt''' se vor găsi cele doua numere '''n''' și '''k''' cu semnificația din enunț apoi pe a doua linie a fișierului se vor găsi '''n''' numere naturale.
== Date de ieșire ==
Fișierul de ieșire '''profuout.txt''' va conține pe prima linie numărul '''x''', reprezentând capacitatea minima a mașini ce trebuie închiriată.
== Restricții și precizări ==
*'''1 &les; n &les; 500.000'''
*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1.000.000'''
== Exemplu 1 ==
; '''profuin.txt'''
:6 3
:7 3 2 3 1 4
; '''profuout.txt'''
:8
 
== Explicatie ==
La primul transport este încărcată prima saltea (care are volumul '''7'''). La cel de-al doilea transport sunt încărcate saltele '''2''' și '''3''' (volumul total este '''3 + 2 = 5'''). La cel de-al treilea transport sunt încărcate saltele '''4''', '''5''' și '''6''' (volumul total este '''3 + 1 + 4 = 8''' fiind cel mai mic rezultat posibil)
== Exemplu 2 ==
; '''profuin.txt'''
: 0
: 0
; '''profuout.txt'''
: Datele nu corespund restrictiilor
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
#2252 - Profu
def capacitate_minima(n, k, volumes):
left, right = max(volumes), sum(volumes)

while left < right:
mid = (left + right) // 2
transports, current_sum = 0, 0

for volume in volumes:
if current_sum + volume > mid:
transports += 1
current_sum = 0

current_sum += volume

transports += 1 # pentru ultimul transport
if transports > k:
left = mid + 1
else:
right = mid

return left

try:
# Citirea datelor de intrare
with open('profuin.txt', 'r') as f:
n, k = map(int, f.readline().split())
volumes = list(map(int, f.readline().split()))

# Calculul capacitatii minime si scrierea rezultatului in fisierul de iesire
result = capacitate_minima(n, k, volumes)
with open('profuout.txt', 'w') as g:
g.write(str(result))
except Exception as e:
# În caz de eroare, afișăm un mesaj corespunzător
with open('profuout.txt', 'w') as f:
f.write('Numarul nu respecta restrictiile.')

</syntaxhighlight>

4025 - Doua Mii 22

2024-01-05T12:56:11Z

Ramona Dragoș:

== Cerința ==
Se dau '''K''' numere naturale nenule, mai mici sau egale cu '''20222022'''. Pentru fiecare număr n dintre acestea, se cere aflarea celui de-al '''n'''-lea număr natural prim cu '''2022'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''K''', iar apoi '''K''' numere naturale, separate prin spații.
== Date de ieșire ==
Programul va afișa pe ecran, pentru fiecare număr '''n''' dintre cele '''K''' numere date, al '''n'''-lea număr natural, prim cu '''2022'''.
== Restricții și precizări ==
*'''1 &les; K &les; 2022'''
*cele '''K''' numere citite vor fi mai mici sau egale cu '''20222022'''
== Exemplu 1 ==
; '''Intrare'''
: 3
: 4 23 198
; '''Ieșire'''
: 11 67 595
 

== Explicatie ==
Şirul numerelor naturale, prime cu '''2022''', este format din numerele: '''1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, ....'''
== Exemplu 2 ==
; '''Intrare'''
: 0
; '''Ieșire'''
: Datele introduse nu respecta restrictiile.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#4025 - DouaMii22
def este_prim_cu_2022(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 afla_n_prim_cu_2022(n):
numar = 1
numere_prim_cu_2022 = []
while len(numere_prim_cu_2022) < n:
if este_prim_cu_2022(numar):
numere_prim_cu_2022.append(numar)
numar += 1
return numere_prim_cu_2022[-1]

try:
# Citirea datelor de intrare
k = int(input("Introduceti numarul K: "))
if 1 <= k <= 2022:
numere = list(map(int, input(f"Introduceti cele {k} numere, separate prin spatiu: ").split()))

# Verificarea și afișarea rezultatelor
for n in numere:
if 1 <= n <= 20222022:
rezultat = afla_n_prim_cu_2022(n)
print(f"Pentru n={n}, al {n}-lea numar prim cu 2022 este: {rezultat}")
else:
print("Datele introduse nu respecta restrictiile.")
break
else:
print("Datele introduse nu respecta restrictiile.")
except ValueError:
print("Datele introduse nu sunt valide.")
</syntaxhighlight>

3367 - Croseta

2024-01-05T12:29:23Z

Ramona Dragoș: /* Enunt */

== Enunt ==
Ionel este un băieţel pasionat de matematică, dar tare năzdrăvan. Într-o zi a dat cu o piatră şi a spart un geam de la casa bunicii. Ştiind pasiunea băiatului, bunica i-a spus: ”Te voi ierta dacă îmi dai răspunsul corect la următoarea problemă: Când erai mic am croşetat o “păturică specială” pentru tine. Nu îmi pot aminti cu câte ochiuri am pornit primul rând şi doresc tare mult să ştiu acest lucru. Te rog să mă ajuți! Pot să-ți spun că:
 
- păturica are n ochiuri;
 
- primele două rânduri croșetate au același număr de ochiuri. Ele se găsesc la mijlocul păturii și conțin cele mai multe ochiuri;
 
- pentru a obține rânduri noi am procedat astfel: pornind din partea stângă a fiecărui rând, către dreapta, am unit câte '''3''' ochiuri din rândul precedent întrunul singur, obținând astfel un rând nou. Dacă la capătul din dreapta rândului rămâneau '''4''' sau '''5''' ochiuri, din acestea formam un singur ochi. Pornind de la rândul '''1''', fiecare nou rând obținut se găsește deasupra celui din care a fost format, iar fiecare nou rând obținut pornind de la rândul '''2''' se găsește sub cel din care a fost format;
 
- am continuat până când am ajuns la un rând cu un singur ochi;
 
- în timp ce lucram, m-am gândit pe parcurs, dacă penultimul rând conţinea două ochiuri, să formez cu ele un singur ochi.”
 
Ionel a desenat cum arată “păturica specială” cu '''20''' de ochiuri şi vă roagă să-l ajutaţi să găsească soluţia problemei.

== Cerința ==
Se dă un număr '''n''', natural par, reprezentând numărul total de ochiuri din care este formată păturica. Se cere să se determine un număr natural '''k''' care reprezintă numărul de ochiuri pe care îl are primul rând croşetat de bunica.
== Date de intrare ==
Fișierul de intrare '''crosetain.txt''' conține pe prima linie numărul '''n''', cu semnificația din enunț.
== Date de ieșire ==
Fișierul de ieșire '''crosetaout.txt''' va conține pe prima linie numărul '''k''', va conţine un număr natural reprezentând numărul de ochiuri existente pe primul rând croşetat de bunica.
== Restricții și precizări ==
*'''1 &les; n &les; 2 000 000 000'''
*'''n''' număr natural par
:Pentru toate testele date există soluţie.
:Un ochi de croşetă este desenat printr-un cerculeţ.
== Exemplu 1 ==
;'''crosetain.txt'''
:30
;'''crosetaout.txt'''
:11
 

== Explicatie ==
Primul şi al doilea rând au câte '''11''' ochiuri. De o parte și de cealaltă, următoarele două rânduri au fiecare câte '''3''' ochiuri. Următoarele două rânduri sunt ultimele și au fiecare câte un '''1''' ochi.
== Exemplu 2 ==
;'''crosetain.txt'''
:0
;'''crosetaout.txt'''
:Nu au fost respectate cerintele impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3367 - Croseta
def gaseste_numar_ochiuri_primul_rand(n):
# Daca n este 0, afisam mesajul corespunzator si ne oprim
if n == 0:
return "Nu au fost respectate cerintele impuse"

# Initializam variabilele necesare
ochiuri_primul_rand = n // 2 - 4

# Returnam rezultatul
return ochiuri_primul_rand

# Citirea datelor de intrare
try:
with open('crosetain.txt', 'r') as f:
n = int(f.readline().strip())

# Verificam daca n este par
if n % 2 == 0:
# Determinam rezultatul
rezultat = gaseste_numar_ochiuri_primul_rand(n)

# Scriem rezultatul in fisierul de iesire
with open('crosetaout.txt', 'w') as g:
g.write(str(rezultat))
else:
# Daca n nu este par, afisam mesajul corespunzator
with open('crosetaout.txt', 'w') as g:
g.write("Nu au fost respectate cerintele impuse")

except Exception as e:
print("A aparut o eroare:", str(e))

</syntaxhighlight>

3367 - Croseta

2024-01-05T12:28:21Z

Ramona Dragoș:

== Enunt ==
Ionel este un băieţel pasionat de matematică, dar tare năzdrăvan. Într-o zi a dat cu o piatră şi a spart un geam de la casa bunicii. Ştiind pasiunea băiatului, bunica i-a spus: ”Te voi ierta dacă îmi dai răspunsul corect la următoarea problemă: Când erai mic am croşetat o “păturică specială” pentru tine. Nu îmi pot aminti cu câte ochiuri am pornit primul rând şi doresc tare mult să ştiu acest lucru. Te rog să mă ajuți! Pot să-ți spun că:
 
- păturica are n ochiuri;
 
- primele două rânduri croșetate au același număr de ochiuri. Ele se găsesc la mijlocul păturii și conțin cele mai multe ochiuri;
 
- pentru a obține rânduri noi am procedat astfel: pornind din partea stângă a fiecărui rând, către dreapta, am unit câte '''3''' ochiuri din rândul precedent întrunul singur, obținând astfel un rând nou. Dacă la capătul din dreapta rândului rămâneau '''4''' sau '''5''' ochiuri, din acestea formam un singur ochi. Pornind de la rândul '''1''', fiecare nou rând obținut se găsește deasupra celui din care a fost format, iar fiecare nou rând obținut pornind de la rândul 2 se găsește sub cel din care a fost format;
 
- am continuat până când am ajuns la un rând cu un singur ochi;
 
- în timp ce lucram, m-am gândit pe parcurs, dacă penultimul rând conţinea două ochiuri, să formez cu ele un singur ochi.”
 
Ionel a desenat cum arată “păturica specială” cu '''20''' de ochiuri şi vă roagă să-l ajutaţi să găsească soluţia problemei.
== Cerința ==
Se dă un număr '''n''', natural par, reprezentând numărul total de ochiuri din care este formată păturica. Se cere să se determine un număr natural '''k''' care reprezintă numărul de ochiuri pe care îl are primul rând croşetat de bunica.
== Date de intrare ==
Fișierul de intrare '''crosetain.txt''' conține pe prima linie numărul '''n''', cu semnificația din enunț.
== Date de ieșire ==
Fișierul de ieșire '''crosetaout.txt''' va conține pe prima linie numărul '''k''', va conţine un număr natural reprezentând numărul de ochiuri existente pe primul rând croşetat de bunica.
== Restricții și precizări ==
*'''1 &les; n &les; 2 000 000 000'''
*'''n''' număr natural par
:Pentru toate testele date există soluţie.
:Un ochi de croşetă este desenat printr-un cerculeţ.
== Exemplu 1 ==
;'''crosetain.txt'''
:30
;'''crosetaout.txt'''
:11
 

== Explicatie ==
Primul şi al doilea rând au câte '''11''' ochiuri. De o parte și de cealaltă, următoarele două rânduri au fiecare câte '''3''' ochiuri. Următoarele două rânduri sunt ultimele și au fiecare câte un '''1''' ochi.
== Exemplu 2 ==
;'''crosetain.txt'''
:0
;'''crosetaout.txt'''
:Nu au fost respectate cerintele impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#3367 - Croseta
def gaseste_numar_ochiuri_primul_rand(n):
# Daca n este 0, afisam mesajul corespunzator si ne oprim
if n == 0:
return "Nu au fost respectate cerintele impuse"

# Initializam variabilele necesare
ochiuri_primul_rand = n // 2 - 4

# Returnam rezultatul
return ochiuri_primul_rand

# Citirea datelor de intrare
try:
with open('crosetain.txt', 'r') as f:
n = int(f.readline().strip())

# Verificam daca n este par
if n % 2 == 0:
# Determinam rezultatul
rezultat = gaseste_numar_ochiuri_primul_rand(n)

# Scriem rezultatul in fisierul de iesire
with open('crosetaout.txt', 'w') as g:
g.write(str(rezultat))
else:
# Daca n nu este par, afisam mesajul corespunzator
with open('crosetaout.txt', 'w') as g:
g.write("Nu au fost respectate cerintele impuse")

except Exception as e:
print("A aparut o eroare:", str(e))

</syntaxhighlight>

2621 - Spower2

2024-01-05T12:02:33Z

Ramona Dragoș: /* Exemplu 2 */

== Enunt ==
Un număr natural '''M''' se numește număr '''spower2''' dacă poate fi descompus astfel: '''M=2^x+2^y''', cu '''x≠y'''. Exemplu: '''6''' este un număr '''spower2 (6=2+4)''', pe când '''8''' nu este.
== Cerința ==
Se consideră un șir '''A''' de '''n''' numere naturale. Pentru fiecare element al șirului '''Ai''' să se determine cel mai apropiat număr '''spower2''' mai mare sau egal cu '''Ai''', unde '''1&les;i&les;n'''.
== Date de intrare ==
Fișierul de intrare '''spower2in.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''spower2out''' va conține pe prima linie '''n''' numere naturale, separate prin spațiu, ce reprezintă numerele '''spower2''' asociate numerelor citite din fișier conform cerinței.
== Restricții și precizări ==
*'''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.000'''
== Exemplu 1 ==
;'''spower2in.txt'''
:6
:14 8 5 19 1 6
;'''spower2out.txt'''
:17 9 5 20 3 6
 

== Exemplu 2 ==
;'''spower2in.txt'''
:0
:0
;'''spower2out.txt'''
: Numarul nu respecta restrictiile.
 

== Explicatie ==
'''17=1+16, 9=1+8, 5=1+4, 20=4+16, 3=1+2, 6=2+4.'''
== Rezolvare ==

<syntaxhighlight lang="python" line>
#2621 - Spower2
def is_spower2(num):
"""
Verifică dacă un număr este de tip spower2
"""
for i in range(31):
for j in range(i+1, 32):
if 2**i + 2**j == num:
return True
return False

def spower2_associate(file_input, file_output):
try:
# Citirea datelor de intrare din fișier
with open(file_input, 'r') as f:
n = int(f.readline().strip())
A = list(map(int, f.readline().split()))

# Determinarea celor mai apropiate numere spower2
spower2_list = [min(filter(lambda x: x >= num and is_spower2(x), range(1, 2*max(A)+1)), key=lambda x: x - num) for num in A]

# Scrierea rezultatului în fișierul de ieșire
with open(file_output, 'w') as f:
f.write(' '.join(map(str, spower2_list)))

except Exception as e:
# În caz de eroare, afișăm un mesaj corespunzător
with open(file_output, 'w') as f:
f.write('Numarul nu respecta restrictiile.')

# Exemplu de utilizare:
spower2_associate('spower2in.txt', 'spower2out.txt')

</syntaxhighlight>

2621 - Spower2

2024-01-05T12:01:33Z

Ramona Dragoș:

== Enunt ==
Un număr natural '''M''' se numește număr '''spower2''' dacă poate fi descompus astfel: '''M=2^x+2^y''', cu '''x≠y'''. Exemplu: '''6''' este un număr '''spower2 (6=2+4)''', pe când '''8''' nu este.
== Cerința ==
Se consideră un șir '''A''' de '''n''' numere naturale. Pentru fiecare element al șirului '''Ai''' să se determine cel mai apropiat număr '''spower2''' mai mare sau egal cu '''Ai''', unde '''1&les;i&les;n'''.
== Date de intrare ==
Fișierul de intrare '''spower2in.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''spower2out''' va conține pe prima linie '''n''' numere naturale, separate prin spațiu, ce reprezintă numerele '''spower2''' asociate numerelor citite din fișier conform cerinței.
== Restricții și precizări ==
*'''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.000'''
== Exemplu 1 ==
;'''spower2in.txt'''
:6
:14 8 5 19 1 6
;'''spower2out.txt'''
:17 9 5 20 3 6
 

== Exemplu 2 ==
;'''spower2in.txt'''
:0
;'''spower2out.txt'''
: Numarul nu respecta restrictiile.
 

== Explicatie ==
'''17=1+16, 9=1+8, 5=1+4, 20=4+16, 3=1+2, 6=2+4.'''
== Rezolvare ==

<syntaxhighlight lang="python" line>
#2621 - Spower2
def is_spower2(num):
"""
Verifică dacă un număr este de tip spower2
"""
for i in range(31):
for j in range(i+1, 32):
if 2**i + 2**j == num:
return True
return False

def spower2_associate(file_input, file_output):
try:
# Citirea datelor de intrare din fișier
with open(file_input, 'r') as f:
n = int(f.readline().strip())
A = list(map(int, f.readline().split()))

# Determinarea celor mai apropiate numere spower2
spower2_list = [min(filter(lambda x: x >= num and is_spower2(x), range(1, 2*max(A)+1)), key=lambda x: x - num) for num in A]

# Scrierea rezultatului în fișierul de ieșire
with open(file_output, 'w') as f:
f.write(' '.join(map(str, spower2_list)))

except Exception as e:
# În caz de eroare, afișăm un mesaj corespunzător
with open(file_output, 'w') as f:
f.write('Numarul nu respecta restrictiile.')

# Exemplu de utilizare:
spower2_associate('spower2in.txt', 'spower2out.txt')

</syntaxhighlight>

0242 - Interclas M

2024-01-05T11:43:34Z

Ramona Dragoș:

== Cerința ==
Se dă un număr natural '''x''' și două șiruri '''a''' și '''b''', cu '''n''', respectiv '''m''' elemente, numere naturale, '''ordonate strict crescător'''. Să se afișeze, în ordine crescătoare, multiplii lui x care se află doar în unul dintre cele două șiruri.
== Date de intrare ==
Fișierul de intrare '''interclasmin.txt''' conține pe prima linie numărul '''x''', pe linia a doua numărul '''n'''; urmează '''n''' numere naturale, ordonate crescător, ce pot fi dispuse pe mai multe linii. Linia următoare conține numărul '''m''' și urmează '''m''' numere naturale, ordonate crescător, ce pot fi dispuse pe mai multe linii.
== Date de ieșire ==
Fișierul de ieșire '''interclasmout.txt''' va conține pe prima linie valorile determinate, separate printr-un spațiu.
== Restricții și precizări ==
*'''0 < x < 1.000.000'''
*'''1 &les; n, m &les; 100.000'''
*valorile elementelor celor două șiruri vor fi mai mici decât '''1.000.000'''
== Exemplu 1 ==
;'''interclasmin.txt'''
:5
:7
:1 2 3 4
:7 20 60
:9
:3 5 7
:8 9 10 12
:20 24
;'''interclasmout.txt'''
:5 10 60
 

== Exemplu 2 ==
;'''interclasmin.txt'''
:2
:0
:1
:7
;'''interclasmout.txt'''
: Nu au fost respectate cerintele impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0242 - InterclasM
def multiplii_x_unice(x, a, b):
rezultat = set()

i, j = 0, 0

while i < len(a) and j < len(b):
if a[i] % x == 0 and b[j] % x != 0:
rezultat.add(a[i])
i += 1
elif a[i] % x != 0 and b[j] % x == 0:
rezultat.add(b[j])
j += 1
elif a[i] < b[j]:
i += 1
else:
j += 1

while i < len(a) and a[i] % x == 0:
rezultat.add(a[i])
i += 1

while j < len(b) and b[j] % x == 0:
rezultat.add(b[j])
j += 1

return sorted(list(rezultat))

def verificare_restricții(x, a, b):
if not (0 < x < 1000000):
return False
for numar in a + b:
if numar >= 1000000:
return False
return True

def main():
# Citirea datelor de intrare
with open("interclasmin.txt", "r") as file:
x = int(file.readline().strip())
n = int(file.readline().strip())
a = [int(file.readline().strip()) for _ in range(n)]
m = int(file.readline().strip())
b = [int(file.readline().strip()) for _ in range(m)]

# Verificare restricții
if not verificare_restricții(x, a, b):
print("Nu au fost respectate cerintele impuse.")
return

# Calculul multipliilor lui x care se află doar într-unul dintre șiruri
rezultat = multiplii_x_unice(x, a, b)

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

if __name__ == "__main__":
main()

</syntaxhighlight>

0284 - Interclasare 3

2024-01-05T11:25:53Z

Ramona Dragoș: /* Date de intrare */

== Cerința ==
Se dau două şiruri, cu '''n''', respectiv '''m''', elemente, numere naturale. Primul şir este ordonat crescător, iar al doilea este ordonat descrescător. Să se afişeze, în ordine crescătoare, valorile pare din cele două şiruri.
== Date de intrare ==
Fişierul de intrare '''interclasare3in.txt''' conţine pe prima linie numerele '''n''' şi '''m'''; urmează '''n''' numere naturale separate prin spaţii, dispuse pe mai multe linii, ordonate crescător; urmează '''m''' numere naturale separate prin spaţii, dispuse pe mai multe linii, ordonate descrescător.

== Date de ieșire ==
Fişierul de ieşire '''interclasare3out.txt''' va conţine valorile pare din cele două şiruri, ordonate crescător, câte '''20''' de valori pe o linie, valorile de pe aceeaşi linie fiind separate printr-un spaţiu.

== Restricții și precizări ==
*'''1 &les; n,m &les; 100000;'''
*elementele celor două şiruri vor avea cel mult '''9''' cifre;
*în cel puţin şir va exista minim un element par;
== Exemplu 1 ==
; '''interclasare3in.txt'''
:5 8
:2 4 7 37 42
:88 88 67 45 42 32 4 1
; '''interclasare3out.txt'''
:2 4 4 32 42 42 88 88
 

== Exemplu 2 ==
; '''interclasare3in.txt'''
: 0 -1
; '''interclasare3out.txt'''
: Nu au fost respectate cerintele impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0284 - Interclasare3
def interclasare(file_input, file_output):
try:
# Citirea datelor de intrare din fișier
with open(file_input, 'r') as f:
n, m = map(int, f.readline().split())
sir_crescator = [list(map(int, line.split())) for line in f.readlines()]
sir_descrescator = [list(map(int, line.split())) for line in f.readlines()]

# Extrage valorile pare din cele două șiruri
pare_crescator = [num for sublist in sir_crescator for num in sublist if num % 2 == 0]
pare_descrescator = [num for sublist in sir_descrescator for num in sublist if num % 2 == 0]

# Concatenează și sortează valorile pare
rezultat = sorted(pare_crescator + pare_descrescator)

# Scrierea rezultatului în fișierul de ieșire
with open(file_output, 'w') as f:
for i, num in enumerate(rezultat, 1):
f.write(str(num) + ' ')
if i % 20 == 0:
f.write('\n')

except Exception as e:
# În caz de eroare, afișăm un mesaj corespunzător
with open(file_output, 'w') as f:
f.write('Nu au fost respectate cerintele impuse')

# Exemplu de utilizare:
interclasare('interclasare3in.txt', 'interclasare3out.txt')

</syntaxhighlight>

0284 - Interclasare 3

2024-01-05T11:25:20Z

Ramona Dragoș:

== Cerința ==
Se dau două şiruri, cu '''n''', respectiv '''m''', elemente, numere naturale. Primul şir este ordonat crescător, iar al doilea este ordonat descrescător. Să se afişeze, în ordine crescătoare, valorile pare din cele două şiruri.
== Date de intrare ==
Fişierul de intrare '''interclasare3in.txt''' conţine pe prima linie numerele '''n''' şi '''m'''; urmează ''n numere naturale separate prin spaţii, dispuse pe mai multe linii, ordonate crescător; urmează '''m''' numere naturale separate prin spaţii, dispuse pe mai multe linii, ordonate descrescător.
== Date de ieșire ==
Fişierul de ieşire '''interclasare3out.txt''' va conţine valorile pare din cele două şiruri, ordonate crescător, câte '''20''' de valori pe o linie, valorile de pe aceeaşi linie fiind separate printr-un spaţiu.

== Restricții și precizări ==
*'''1 &les; n,m &les; 100000;'''
*elementele celor două şiruri vor avea cel mult '''9''' cifre;
*în cel puţin şir va exista minim un element par;
== Exemplu 1 ==
; '''interclasare3in.txt'''
:5 8
:2 4 7 37 42
:88 88 67 45 42 32 4 1
; '''interclasare3out.txt'''
:2 4 4 32 42 42 88 88
 

== Exemplu 2 ==
; '''interclasare3in.txt'''
: 0 -1
; '''interclasare3out.txt'''
: Nu au fost respectate cerintele impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#0284 - Interclasare3
def interclasare(file_input, file_output):
try:
# Citirea datelor de intrare din fișier
with open(file_input, 'r') as f:
n, m = map(int, f.readline().split())
sir_crescator = [list(map(int, line.split())) for line in f.readlines()]
sir_descrescator = [list(map(int, line.split())) for line in f.readlines()]

# Extrage valorile pare din cele două șiruri
pare_crescator = [num for sublist in sir_crescator for num in sublist if num % 2 == 0]
pare_descrescator = [num for sublist in sir_descrescator for num in sublist if num % 2 == 0]

# Concatenează și sortează valorile pare
rezultat = sorted(pare_crescator + pare_descrescator)

# Scrierea rezultatului în fișierul de ieșire
with open(file_output, 'w') as f:
for i, num in enumerate(rezultat, 1):
f.write(str(num) + ' ')
if i % 20 == 0:
f.write('\n')

except Exception as e:
# În caz de eroare, afișăm un mesaj corespunzător
with open(file_output, 'w') as f:
f.write('Nu au fost respectate cerintele impuse')

# Exemplu de utilizare:
interclasare('interclasare3in.txt', 'interclasare3out.txt')

</syntaxhighlight>

1440 - Numar termeni sir cu prima cifra k

2024-01-05T11:15:43Z

Ramona Dragoș:

== Cerința ==
Se generează un şir de numere naturale ai cărui primi termeni sunt, în această ordine:
'''1, 20, 21, 300, 301, 320, 321, 4000, 4001, 4020, 4021, 4300, 4301, 4320, 4321, 50000,...'''
Deduceţi regula după care sunt generaţi termenii şirului şi scrieţi un program care să citească numerele naturale '''k''', '''n''' şi '''x''' şi care să determine:
:a) numărul de termeni ai şirului care au prima cifră (cea mai semnificativă) egală cu '''k''';
:b) cel de-al '''n'''-lea termen al şirului din enunţ;
:c) cel mai mare termen al şirului, mai mic sau egal decât '''x'''.
== Date de intrare ==
Fișierul de intrare '''nrin.txt''' conține o singură linie pe care sunt scrise trei numere naturale '''k''', '''n''' şi '''x''', separate prin câte un spaţiu.
== Date de ieșire ==
Fişierul de ieşire '''nrout.txt''' va conţine '''3''' linii:
:– pe prima linie se va scrie un număr natural reprezentând numărul de termeni ai şirului care au prima cifră (cea mai semnificativă) egală cu '''k''';
:– pe a doua linie se va scrie un număr natural reprezentând cel de-al '''n'''-lea termen al şirului din enunţ;
:– pe a treia linie se va scrie un număr natural reprezentând cel mai mare termen al şirului, mai mic sau egal cu '''x'''.

== Restricții și precizări ==
* '''1 &les; k &les; 9'''
* '''3 &les; n &les; 511'''
* '''1 &les; x &les; 2.000.000.000'''
== Exemplu 1 ==
; '''nrin.txt'''
:4 19 57890
; '''nrout.txt'''
:8
:50021
:54321
 
== Exemplu 2 ==
; '''nrin.txt'''
: 0 1 0
; '''nrout.txt'''
: Nu au fost respectate cerintele impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
#1440 - Nr
def count_terms_with_first_digit_k(k, x):
count = 0
current_term = 1

while current_term <= x:
if str(current_term)[0] == str(k):
count += 1
current_term *= 10

return count

def find_nth_term(n):
terms = [1]
current_term = 1

while len(terms) < n:
current_term += 1
terms.append(current_term)

return terms[-1]

def find_largest_term_less_than_x(x):
current_term = 1

while current_term <= x:
current_term *= 10

return current_term // 10

def main():
try:
with open('nrin.txt', 'r') as file:
k, n, x = map(int, file.readline().split())

if not (1 <= k <= 9 and 3 <= n <= 511 and 1 <= x <= 2000000000):
raise ValueError("Nu au fost respectate cerintele impuse.")

result1 = count_terms_with_first_digit_k(k, x)
result2 = find_nth_term(n)
result3 = find_largest_term_less_than_x(x)

with open('nrout.txt', 'w') as file_out:
file_out.write(str(result1) + '\n')
file_out.write(str(result2) + '\n')
file_out.write(str(result3) + '\n')

except ValueError as e:
with open('nrout.txt', 'w') as file_out:
file_out.write(str(e) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

== Explicatie ==
Pe prima linie a fişierului nrout.txt se scrie numărul 8, deoarece sunt 8 termeni în şir care au prima cifră egală cu k=4).
Pe a doua linie a fişierului se scrie numărul 50021, deoarece cel de-al n-lea (n=19) termen al şirului este 50021.
Numerele 54321 şi 600000 sunt doi termeni situaţi pe poziţii consecutive în şirul din enunţ, iar 54321 ≤ 57890 < 600000. Astfel, numărul 54321 se scrie pe ultima linie a fişierului nrout.txt .