Bitnami MediaWiki - User contributions [en]

3341 - oaste2

2024-08-11T06:47:22Z

RaulOtet: Pagină nouă: Pe un continent reprezentat printr-o matrice cu <code>n</code> linii și <code>m</code> coloane se află mai multe state, toate în conflict. Astfel, fiecare si-a mobilizat oastea. Fiecare element al matricei reprezintă o regiune. Două elemente, din matrice, învecinate pe linie sau pe coloană (nu si pe diagonală) reprezintă două regiuni care aparțin aceluiași stat. Un element din matrice ce contine cifra <code>0</code> este o regiune neutră care delimitează stat...

Pe un continent reprezentat printr-o matrice cu <code>n</code> linii și <code>m</code> coloane se află mai multe state, toate în conflict. Astfel, fiecare si-a mobilizat oastea. Fiecare element al matricei reprezintă o regiune.

Două elemente, din matrice, învecinate pe linie sau pe coloană (nu si pe diagonală) reprezintă două regiuni care aparțin aceluiași stat.

Un element din matrice ce contine cifra <code>0</code> este o regiune neutră care delimitează statele si nu are soldați.

Elementul ce conține o cifră <code>c</code> nenulă este o regiune ce aparține unui stat și are <code>c</code> soldați.

= Cerința =
Să se determine numărul <code>S</code> maxim de soldați dintr-un stat al continentului precum și numărul <code>R</code> minim de regiuni pe care le poate avea un stat cu <code>S</code> soldati.

= Date de intrare =
Fișierul de intrare <code>oaste2.in</code> conține pe prima linie numerele naturale <code>n</code> si <code>m</code>, iar pe fiecare dintre următoarele <code>n</code> linii conține câte <code>m</code> cifre, separate prin câte un spațiu.

= Date de ieșire =
Fișierul de ieșire <code>oaste2.out</code> va conține pe prima linie cele două numere <code>S R</code> separate printr-un spațiu, cu semnificația din enunț

= Restricții și precizări =

* <code>n</code> si <code>m</code> vor fi numere naturale cu valori intre <code>1</code> si <code>100</code> inclusiv;
* fiecare element al matricei va avea valori naturale cuprinse intre <code>0</code> si <code>9</code> inclusiv;
* există cel puțin o cifră nenula în matrice

= Exemplu: =
<code>oaste2.in</code>
4 6
0 1 1 0 2 9
9 0 2 0 1 0
0 1 1 0 0 2
0 0 1 1 1 1
<code>oaste2.out</code>
12 3

=== Explicație ===
Harta din fișierul de intrare contine <code>3</code> state având: <code>12</code> soldați (culoarea rosu – <code>10</code> regiuni), <code>12</code> soldați (culoare galben – <code>3</code> regiuni), <code>9</code> soldați (culoare verde – <code>1</code> regiune)

<syntaxhighlight lang="python" line="1">
def in_bounds(x, y, n, m):
return 0 <= x < n and 0 <= y < m

def dfs(matrix, visited, x, y, n, m):
stack = [(x, y)]
visited[x][y] = True
soldiers_sum = 0
region_size = 0
directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
state_value = matrix[x][y]

while stack:
cx, cy = stack.pop()
soldiers_sum += matrix[cx][cy]
region_size += 1

for dx, dy in directions:
nx, ny = cx + dx, cy + dy
if in_bounds(nx, ny, n, m) and not visited[nx][ny] and matrix[nx][ny] == state_value:
visited[nx][ny] = True
stack.append((nx, ny))

return soldiers_sum, region_size

def find_strongest_state(matrix):
n = len(matrix)
m = len(matrix[0])
visited = [[False] * m for _ in range(n)]

max_soldiers = 0
min_regions = float('inf')

for i in range(n):
for j in range(m):
if matrix[i][j] != 0 and not visited[i][j]:
soldiers, regions = dfs(matrix, visited, i, j, n, m)
if soldiers > max_soldiers:
max_soldiers = soldiers
min_regions = regions
elif soldiers == max_soldiers:
min_regions = min(min_regions, regions)

return max_soldiers, min_regions

# Exemplu de utilizare:
matrix = [
[1, 1, 0, 3],
[1, 0, 3, 3],
[2, 2, 2, 0],
[2, 0, 0, 0]
]

max_soldiers, min_regions = find_strongest_state(matrix)
print(f"Număr maxim de soldați: {max_soldiers}, Număr minim de regiuni: {min_regions}")
</syntaxhighlight>

2385 - oaste

2024-08-11T06:46:07Z

RaulOtet: Pagină nouă: Pe un continent reprezentat printr-o matrice cu <code>n</code> linii și <code>m</code> coloane se află mai multe state, toate în conflict. Astfel, fiecare si-a mobilizat oastea. Fiecare element al matricei memorează câte o cifră. Două elemente învecinate pe linie sau pe coloană (nu si pe diagonală) aparțin aceluiași stat și se numesc regiuni. O poziție <code>(i,j)</code> a unei regiuni din matrice este dată de indicele <code>i</code> de linie și indicele <...

Pe un continent reprezentat printr-o matrice cu <code>n</code> linii și <code>m</code> coloane se află mai multe state, toate în conflict. Astfel, fiecare si-a mobilizat oastea.

Fiecare element al matricei memorează câte o cifră. Două elemente învecinate pe linie sau pe coloană (nu si pe diagonală) aparțin aceluiași stat și se numesc regiuni.

O poziție <code>(i,j)</code> a unei regiuni din matrice este dată de indicele <code>i</code> de linie și indicele <code>j</code> coloană al elementului din matrice corespunzător acestei regiuni.

O poziție din matrice ce contine cifra <code>0</code> este o regiune neutră si nu are soldați, iar poziția ce conține o cifră <code>c</code> nenulă este o regiune ce aparține unui stat și are <code>c</code> soldați.

= Cerința =
Să se determine numărul maxim de soldați dintr-o regiune a statului care are cei mai mulți soldați, precum și poziția acestei regiuni în matrice (linia și coloana).

= Date de intrare =
Fișierul de intrare <code>oaste.in</code> conține pe prima linie numerele naturale <code>n</code> si <code>m</code>, iar pe fiecare dintre următoarele <code>n</code> linii conține câte <code>m</code> cifre, separate prin câte un spațiu.

= Date de ieșire =
Fișierul de ieșire <code>oaste.out</code> va conține pe prima linie trei numere separate prin cate un spațiu, reprezentând numărul maxim de soldați dintr-o regiune a statului care are cei mai mulți soldați, respectiv linia și coloana poziției acestei regiuni in matrice.

= Restricții și precizări =

* <code>n</code> si <code>m</code> vor fi numere naturale cu valori intre <code>1</code> si <code>100</code> inclusiv;
* fiecare element al matricei va avea valori naturale cuprinse intre <code>0</code> si <code>9</code> inclusiv;
* există cel puțin o cifră nenula în matrice
* spunem ca un stat are coordonatele <code>(i,j)</code> în matrice dacă regiunea din poziția <code>(i,j)</code> aparține acestui stat și este regiunea cu cea mai mică poziție în sens lexicografic dintre regiunile statului.
* perechea <code>(i,j)</code> este mai mică în sens lexicografic ca perechea <code>(x,y)</code> dacă <code>i<x</code> sau dacă <code>i=x</code> și <code>j<y</code>
* dacă există două state cu același număr de soldați și același număr maxim de soldați într-o regiune, se va lua în considerare regiunea cu cea mai mică poziție din statul cu coordonatele cele mai mici în sens lexicografic

= Exemplu: =
<code>oaste.in</code>
4 6
0 1 1 0 2 5
9 0 2 0 1 0
0 1 1 0 0 2
0 0 1 1 1 1
<code>oaste.out</code>
2 2 3

=== Explicație ===
Harta din fișierul de intrare contine <code>3</code> state. Statul cu culoarea rosie in imagine are cei mai multi soldati iar regiunea din pozitia <code>(2,3)</code> are cei mai multi soldati referitor la celelalte regiuni din acest stat.

<syntaxhighlight lang="python" line="1">
def in_bounds(x, y, n, m):
return 0 <= x < n and 0 <= y < m

def dfs(matrix, visited, x, y, n, m):
stack = [(x, y)]
visited[x][y] = True
soldiers_sum = 0
positions = [(x, y)]
directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

while stack:
cx, cy = stack.pop()
soldiers_sum += matrix[cx][cy]
for dx, dy in directions:
nx, ny = cx + dx, cy + dy
if in_bounds(nx, ny, n, m) and not visited[nx][ny] and matrix[nx][ny] == matrix[cx][cy]:
visited[nx][ny] = True
stack.append((nx, ny))
positions.append((nx, ny))

return soldiers_sum, positions[0]

def find_strongest_region(matrix):
n = len(matrix)
m = len(matrix[0])
visited = [[False] * m for _ in range(n)]

max_soldiers = 0
best_position = (-1, -1)

for i in range(n):
for j in range(m):
if matrix[i][j] != 0 and not visited[i][j]:
soldiers, position = dfs(matrix, visited, i, j, n, m)
if soldiers > max_soldiers:
max_soldiers = soldiers
best_position = position

return max_soldiers, best_position

# Exemplu de utilizare:
matrix = [
[1, 1, 0, 3],
[1, 0, 3, 3],
[2, 2, 2, 0],
[2, 0, 0, 0]
]

max_soldiers, position = find_strongest_region(matrix)
print(f"Maxim soldați: {max_soldiers}, Poziție: {position}")
</syntaxhighlight>

3569 - Cern

2024-08-08T06:12:29Z

RaulOtet: Pagină nouă: „CERN este un acronim folosit pentru a desemna Laboratorul European pentru Fizica Particulelor Elementare. Acronimul s-a păstrat de la vechea denumire în limba franceză, şi anume Conseil Européen pour la Recherche Nucléaire. Acesta este cel mai mare laborator de cercetare a particulelor elementare din lume, situat în suburbia nord-vestică a Genevei, chiar pe graniţa dintre Elveţia şi Franţa. Funcţia primară a complexului CERN este de a furniza acceleratoare de...

„CERN este un acronim folosit pentru a desemna Laboratorul European pentru Fizica Particulelor Elementare. Acronimul s-a păstrat de la vechea denumire în limba franceză, şi anume Conseil Européen pour la Recherche Nucléaire. Acesta este cel mai mare laborator de cercetare a particulelor elementare din lume, situat în suburbia nord-vestică a Genevei, chiar pe graniţa dintre Elveţia şi Franţa. Funcţia primară a complexului CERN este de a furniza acceleratoare de particule elementare şi alte tipuri de infrastructuri necesare fizicii particulelor de energii înalte.”

Acceleratorul de particule CERN este dispus sub forma a <code>3</code> cercuri cu aceeaşi rază, tangente exterioare două câte două, numerotate pe figură cu <code>1</code>, <code>2</code>, <code>3</code>. Traiectoria unei particule elementare porneşte din unul din punctele marcate pe figură cu <code>A</code>, <code>B</code>, <code>C</code>, <code>D</code>, <code>E</code>, <code>F</code> şi se deplasează cu viteză constantă de

/unitatea de timp numai pe circumferinţa cercurilor. La trecerea printr-un punct de tangenţă dintre două cercuri particula îşi schimbă atât sensul de deplasare, cât şi cercul pe care se deplasează. Astfel, dacă sensul de deplasare a fost la un moment dat trigonometric, la trecerea printr-un punct de tangenţă devine invers trigonometric şi dacă sensul de deplasare a fost invers trigonometric, la trecerea printr-un punct de tangenţă devine trigonometric.

= Cerința =
Ştiind că cercurile ce formează acceleratorul sunt marcate din grad în grad începând cu
, în sens trigonometric (aşa cum se indică în figura alăturată), să se scrie un program, care, cunoscând punctul iniţial şi sensul de deplasare al unei particule, să determine poziţia particulei în accelerator după un număr dat de unităţi de timp.

= Date de intrare =
Prima linie a fişierului de intrare <code>cern.in</code> conţine un caracter <code>p</code> ce indică punctul de plecare al particulei.

A doua linie a fişierului de intrare conţine două numere întregi <code>s</code> şi <code>t</code>, separate printr-un spaţiu, ce indică sensul de deplasare (<code>1</code> pentru sens trigonometric şi <code>-1</code> pentru sens invers trigonometric), respectiv numărul de unităţi de timp cât durează deplasarea.

= Date de ieșire =
Pe prima linie a fişierului de ieşire <code>cern.out</code> se vor scrie două numere naturale <code>g</code> şi <code>c</code>, separate printr-un spaţiu, ce reprezintă numărul de grade, în sens trigonometric, respectiv cercul, corespunzătoare poziţiei finale unde se va găsi particula după trecerea celor <code>t</code> unităţi de timp.

= Restricții și precizări =

* <code>p ∈ {’A’,’B’,’C’,’D’,’E’,’F’}</code>.
* <code>s ∈ {-1, 1}</code>.
* <code>0 ≤ t ≤ 1.000.000.000</code>.
* <code>0 ≤ g ≤ 359</code>.
* <code>c ∈ {1, 2, 3}</code>.
* Pentru toate seturile de date de intrare, poziţia finală a particulei nu coincide cu unul dintre punctele de tangenţă dintre cercuri.

= Exemplu: =
<code>cern.in</code>
A
1 320
<code>cern.out</code>
200 3

=== Explicație ===
Particula pleacă din punctul <code>A</code> în sens trigonometric şi are traseul:

*

* pe cercul <code>1</code> în sens trigonometric;
*
* pe cercul <code>2</code> în sens invers trigonometric;
*

* pe cercul <code>3</code> în sens trigonometric.

Poziţia finală este la
pe cercul <code>3</code>.

<syntaxhighlight lang="python" line="1">
def determine_position(start_point, start_circle, start_direction, time_units):
# Define circle tangents in degrees
tangents = {0, 120, 240}

# Define movement per unit time
movement_per_unit = 10

# Initialize current position, circle and direction
current_position = start_point
current_circle = start_circle
current_direction = start_direction

# Perform movement for each time unit
for _ in range(time_units):
if current_direction == 'trigonometric':
current_position = (current_position + movement_per_unit) % 360
else:
current_position = (current_position - movement_per_unit) % 360

# Check if we hit a tangent point
if current_position in tangents:
# Change circle
current_circle = 1 if current_circle == 3 else current_circle + 1
# Change direction
if current_direction == 'trigonometric':
current_direction = 'inverse trigonometric'
else:
current_direction = 'trigonometric'

return current_position, current_circle

# Example usage
start_point = 0 # Initial position in degrees
start_circle = 1 # Starting on circle 1
start_direction = 'trigonometric' # Starting direction
time_units = 30 # Number of time units

final_position, final_circle = determine_position(start_point, start_circle, start_direction, time_units)
print(f"Final position: {final_position} degrees on circle {final_circle}")
</syntaxhighlight>

3574 - Perspic

2024-08-08T06:10:21Z

RaulOtet: Pagină nouă: Se consideră o matrice pătratică cu <code>N</code> linii şi <code>N</code> coloane ce conţine toate numerele naturale de la <code>1</code> la <code>N*N</code>. Asupra matricei se definesc trei tipuri de operaţii codificate astfel: * <code>C i j</code> – interschimbarea coloanelor <code>i</code> şi <code>j</code> ale matricei * <code>R i j</code> – interschimbarea liniilor <code>i</code> şi <code>j</code> ale matricei * <code>E i j x y</code> – interschimbarea...

Se consideră o matrice pătratică cu <code>N</code> linii şi <code>N</code> coloane ce conţine toate numerele naturale de la <code>1</code> la <code>N*N</code>.

Asupra matricei se definesc trei tipuri de operaţii codificate astfel:

* <code>C i j</code> – interschimbarea coloanelor <code>i</code> şi <code>j</code> ale matricei
* <code>R i j</code> – interschimbarea liniilor <code>i</code> şi <code>j</code> ale matricei
* <code>E i j x y</code> – interschimbarea elementului de pe linia <code>i</code> şi coloana <code>j</code> cu elementul de pe linia <code>x</code> şi coloana <code>y</code>.

Asupra matricei se efectuează un set de <code>M</code> astfel de operaţii.

= Cerința =
Se cere să se determine numărul minim de aplicări complete ale acestui set de operaţii după care se ajunge din nou în starea iniţială. În cadrul setului operaţiile se efectuează mereu în aceeaşi ordine şi nu se poate sări peste o operaţie. Deoarece numărul acesta poate fi foarte mare se cere restul împărţirii sale la <code>13007</code>.

= Date de intrare =
Fişierul de intrare <code>perspic.in</code> conţine pe prima linie numerele naturale <code>N</code> şi <code>M</code>, separate printr-un spaţiu, reprezentând dimensiunea matricei şi respectiv numărul de operaţii dintr-un set. Pe următoarele <code>M</code> linii se descriu operaţiile setului.

= Date de ieșire =
Fişierul de ieşire <code>perspic.out</code> va conţine restul împărţirii la <code>13007</code> al numărului minim determinat.

= Restricții și precizări =

* <code>1 ≤ N ≤ 100</code>
* <code>1 ≤ M ≤ 10.000</code>
* Pentru <code>60%</code> din teste numărul minim de aplicări ale setului de operaţii necesare va fi mai mic ca <code>2.000.000.000</code>.

= Exemplu: =
<code>perspic.in</code>
2 2
C 1 2
R 1 2
<code>perspic.out</code>
2
<syntaxhighlight lang="python" line="1">
def gcd(a, b):
while b:
a, b = b, a % b
return a

def lcm(a, b):
return a * b // gcd(a, b)

def find_cycles(permutation):
visited = [False] * len(permutation)
cycles = []
for i in range(len(permutation)):
if not visited[i]:
cycle_length = 0
x = i
while not visited[x]:
visited[x] = True
x = permutation[x]
cycle_length += 1
cycles.append(cycle_length)
return cycles

def main():
import sys
input = sys.stdin.read
data = input().strip().split()

idx = 0
N = int(data[idx])
idx += 1
M = int(data[idx])
idx += 1

permutation = list(range(N * N))

for _ in range(M):
operation = data[idx]
if operation == 'C':
i = int(data[idx + 1]) - 1
j = int(data[idx + 2]) - 1
idx += 3
for row in range(N):
permutation[row * N + i], permutation[row * N + j] = permutation[row * N + j], permutation[row * N + i]
elif operation == 'R':
i = int(data[idx + 1]) - 1
j = int(data[idx + 2]) - 1
idx += 3
for col in range(N):
permutation[i * N + col], permutation[j * N + col] = permutation[j * N + col], permutation[i * N + col]
elif operation == 'E':
i = int(data[idx + 1]) - 1
j = int(data[idx + 2]) - 1
x = int(data[idx + 3]) - 1
y = int(data[idx + 4]) - 1
idx += 5
permutation[i * N + j], permutation[x * N + y] = permutation[x * N + y], permutation[i * N + j]

cycles = find_cycles(permutation)
result = 1
for cycle_length in cycles:
result = lcm(result, cycle_length)

print(result % 13007)

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

2475 - Mosquito

2024-08-08T06:08:32Z

RaulOtet: Pagină nouă: Supărat că fata de care-i plăcea l-a respins, Bogdan și-a făcut bagajele și a pornit într-o excursie de-a lungul întregii lumi. Acesta a vizitat mai toate continentele, însă acum este blocat în Africa din cauza faptului că Bogdan, băiat mai neastâmpărat din fire, s-a apucat să se bată cu țânțarii Mosquito.Bineînțeles că a fost înțepat și că acum trebuie să caute antidot pentru venin, altfel Bogdan se va transforma și el în Mosquito. Acesta s-a du...

Supărat că fata de care-i plăcea l-a respins, Bogdan și-a făcut bagajele și a pornit într-o excursie de-a lungul întregii lumi. Acesta a vizitat mai toate continentele, însă acum este blocat în Africa din cauza faptului că Bogdan, băiat mai neastâmpărat din fire, s-a apucat să se bată cu țânțarii Mosquito.Bineînțeles că a fost înțepat și că acum trebuie să caute antidot pentru venin, altfel Bogdan se va transforma și el în Mosquito. Acesta s-a dus să-i ceară ajutorul lui Aashiq, care îi spune următoarele: “Te voi vindeca de înțepături dacă reușești să duci la bun sfârșit sarcina pe care ți-o dau.”, însă Bogdan nu prea se pricepe la sarcini complicate, așa că vă roagă să rezolvați voi cerința în locul lui.

= Cerința =
Dându-se trei numere naturale, <code>a</code>, <code>n</code>, <code>k</code>, trebuie să aflați valoarea următoarei expresii: <code>ak•ak+2k•...•ak+2k+...+nk</code>. Antidotul pentru înțepăturile de Mosquito necesită foarte multă muncă, motiv pentru care vor trebui îndeplinite <code>t</code> teste.

= Date de intrare =
Fișierul de intrare <code>mosquito.in</code> conține pe prima linie numărul <code>t</code>, reprezentând numărul de teste.Pe următoarele <code>t</code> linii se vor afla câte trei numere <code>a</code>, <code>n</code>, <code>k</code>, separate prin spații, reprezentând valorile pentru expresia cu numărul <code>t</code>. Fiind un număr foarte mare, rezultatul se va tipări modulo <code>1000000007</code>.

= Date de ieșire =
Fișierul de ieșire <code>mosquito.out</code> va conține pe linia <code>t</code> răspunsul pentru testul nu numărul de ordine <code>t</code>.

= Restricții și precizări =

* <code>1 ≤ t ≤ 5</code>
* <code>1 ≤ a, n, k, ≤ 109</code>
* Se garantează faptul că niciuna dintre puterile lui <code>a</code> nu va depăși <code>1018</code>

= Exemplul 1: =
<code>mosquito.in</code>
1
2 3 1
<code>mosquito.out</code>
1024

= Exemplul 2: =
<code>mosquito.in</code>
1
3 4 1
<code>mosquito.out</code>
486784380
<syntaxhighlight lang="python" line="1">
MOD = 10**9 + 7

def solve_test(a, n, k):
exponent = k * (pow(2, n, MOD - 1) - 1)
return pow(a, exponent, MOD)

def main():
import sys
input = sys.stdin.read
data = input().strip().split()

t = int(data[0])
results = []
index = 1

for _ in range(t):
a = int(data[index])
n = int(data[index + 1])
k = int(data[index + 2])
index += 3
result = solve_test(a, n, k)
results.append(result)

for result in results:
print(result)

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

1189 - Lenes

2024-08-04T13:24:15Z

RaulOtet: Pagină nouă: Leneşul este un animal foarte leneş. El se deplasează numai în linie dreaptă, dar face din când în când câte un popas. În această problemă leneşul trebuie să traverseze de la nord la sud şi înapoi un teren reprezentat de o matrice de dimensiuni <code>M×N</code> cu valori numere naturale. Valorile reprezintă efortul cerut pentru traversarea zonei respective. Leneşul va alege o coloană pentru traversarea matricei, iar pentru popasuri, în număr de <code>k1...

Leneşul este un animal foarte leneş. El se deplasează numai în linie dreaptă, dar face din când în când câte un popas. În această problemă leneşul trebuie să traverseze de la nord la sud şi înapoi un teren reprezentat de o matrice de dimensiuni <code>M×N</code> cu valori numere naturale. Valorile reprezintă efortul cerut pentru traversarea zonei respective. Leneşul va alege o coloană pentru traversarea matricei, iar pentru popasuri, în număr de <code>k1</code>, va alege zone alăturate drumului din coloana din stânga sau cea din dreapta. În cazul în care se va întoarce va proceda la fel, dar va face <code>k2</code> popasuri. Regulile problemei cer ca cele două drumuri să nu aibă zone comune.

= Cerințe =
Cunoscând dimensiunile <code>M</code>, <code>N</code> ale terenului, numărul de popasuri <code>k1</code>, <code>k2</code> și efortul pentru traversarea fiecărei zone a terenului, să se determine:

# Efortul minim de parcurgere a terenului de la Nord la Sud, folosind <code>k1</code> popasuri.
# Efortul minim de parcurgere a terenului de la Nord la Sud și înapoi de la Sud la Nord, folosind <code>k1</code> popasuri la deplasarea Nord – Sud, respectiv <code>k2</code> popasuri la deplasarea Sud – Nord.

= Date de intrare =
Fișierul de intrare <code>lenes.in</code> conține:

* Pe prima linie un număr natural <code>p</code> reprezentând cerința de rezolvare. Pentru toate testele de intrare numărul <code>p</code> poate avea doar valoarea <code>1</code> sau <code>2</code>.
* Pe linia a doua sunt <code>4</code> numere naturale <code>M</code>, <code>N</code>, <code>k1</code>, <code>k2</code>, separate prin câte un spațiu cu semnificaţia de mai sus.
* Pe următoarele <code>M</code> linii se găsesc câte <code>N</code> numere naturale separate prin câte un spațiu, reprezentând eforturile de traversare a fiecărei zone a terenului.

= Date de ieșire =
Dacă valoarea lui <code>p</code> este <code>1</code>, se va rezolva numai cerința 1. În acest caz fişierul <code>lenes.out</code> va conţine un singur număr natural reprezentând efortul minim necesar pentru traversarea terenului în condiţiile date de la Nord la Sud.

Dacă valoarea lui <code>p</code> este <code>2</code>, se va rezolva numai cerința 2. În acest caz fişierul <code>lenes.out</code> va conţine un singur număr natural reprezentând efortul minim necesar pentru traversarea terenului în condiţiile date în ambele sensuri de la Nord la Sud și de la Sud la Nord.

= Restricții și precizări =

* <code>3 ≤ M, N ≤ 500</code>
* <code>0 ≤ k1, k2 ≤ M</code>
* Valorile din matrice sunt numere naturale din intervalul <code>[1, 1000]</code>.
* Leneșul poate să facă popasuri pe aceeaşi linie în ambele celule din stânga şi din dreapta coloanei parcurse.
* Deplasarea între ultima zonă a drumului parcurs de la Nord la Sud şi prima zonă a drumului parcurs de la Sud la Nord la întoarcere se face cu efort <code>0</code>.

= Exemplul 1 =
<code>lenes.in</code>
1
4 7 2 3
99 1 33 9 2 4 7
99 1 44 8 1 2 3
98 1 55 8 2 3 2
97 1 66 4 3 2 1
<code>lenes.out</code>
12

= Explicație =
<code>p = 1</code>

Leneșul traversează terenul de la Nord la Sud pe coloana a <code>5</code>-a cu popas în zonele <code>(2, 6)</code> și <code>(4, 6)</code>.

'''Atenție! Pentru acest test se rezolvă doar cerința 1.'''

= Exemplul 2 =
<code>lenes.in</code>
2
4 7 3 2
99 1 33 9 2 4 7
99 1 44 8 1 2 3
98 1 55 8 2 2 2
97 1 66 4 3 2 1
<code>lenes.out</code>
35

= Explicație =
<code>p = 2</code>

Leneșul traversează terenul de la Nord la Sud pe coloana a <code>7</code>-a cu popasuri în zonele <code>(3, 6)</code>, <code>(1, 6)</code>, <code>(4, 6)</code>, iar de la Sud la Nord pe coloana a <code>5</code> – a, cu popas în zonele <code>(4, 4)</code> și <code>(2, 6)</code>.

'''Atenție! Pentru acest test se rezolvă doar cerința 2.'''

<syntaxhighlight lang="python" line="1">
import numpy as np

def min_effort_nord_sud(matrix, k1):
M, N = len(matrix), len(matrix[0])
inf = float('inf')

# dp[c][r][p]: efort minim pentru a ajunge la (c, r) cu p popasuri rămase
dp = np.full((M, N, k1 + 1), inf)

# Inițializare
for r in range(N):
dp[0][r][k1] = matrix[0][r]

for c in range(1, M):
for r in range(N):
for p in range(k1 + 1):
# Deplasare pe coloana curentă
if dp[c-1][r][p] < inf:
dp[c][r][p] = min(dp[c][r][p], dp[c-1][r][p] + matrix[c][r])

# Popasuri (stânga/dreapta)
if r > 0 and p > 0:
dp[c][r][p-1] = min(dp[c][r][p-1], dp[c-1][r-1][p] + matrix[c][r])
if r < N - 1 and p > 0:
dp[c][r][p-1] = min(dp[c][r][p-1], dp[c-1][r+1][p] + matrix[c][r])

return min(dp[M-1][r][0] for r in range(N))

def min_effort_nord_sud_sud_nord(matrix, k1, k2):
M, N = len(matrix), len(matrix[0])
inf = float('inf')

# Minim efort Nord-Sud
min_effort_nord_sud_val = min_effort_nord_sud(matrix, k1)

# Inversăm matricea pentru Sud-Nord
matrix_reversed = matrix[::-1]

# Minim efort Sud-Nord
min_effort_sud_nord_val = min_effort_nord_sud(matrix_reversed, k2)

return min_effort_nord_sud_val + min_effort_sud_nord_val

# Exemple de utilizare
M, N = 4, 5
k1 = 2
k2 = 1
matrix = [
[2, 4, 1, 8, 3],
[6, 3, 2, 5, 1],
[5, 2, 6, 7, 9],
[8, 4, 2, 1, 5]
]

# Efort minim pentru traversarea Nord-Sud
effort_nord_sud = min_effort_nord_sud(matrix, k1)
print(f"Efort minim pentru traversarea Nord-Sud: {effort_nord_sud}")

# Efort minim pentru traversarea Nord-Sud și Sud-Nord
effort_nord_sud_sud_nord = min_effort_nord_sud_sud_nord(matrix, k1, k2)
print(f"Efort minim pentru traversarea Nord-Sud și Sud-Nord: {effort_nord_sud_sud_nord}")
</syntaxhighlight>

1185 - Cub2

2024-08-04T13:23:05Z

RaulOtet: Pagină nouă: Sărbătorile de iarnă tocmai s-au încheiat. Florinel dorește să-și ajute părinții la despodobirea bradului. Tubul luminos pe care l-au folosit anul acesta este mai special. Are <code>N3</code> becuri luminoase numerotate de la <code>1</code> la <code>N3</code>, iar fiecare bec care este inscripționat cu un număr prim, va rămâne mereu aprins. Cutia în care trebuie strâns tubul este un cub de latură <code>N</code>. Becul cu numărul <code>1<...

Sărbătorile de iarnă tocmai s-au încheiat. Florinel dorește să-și ajute părinții la despodobirea bradului. Tubul luminos pe care l-au folosit anul acesta este mai special. Are <code>N3</code> becuri luminoase numerotate de la <code>1</code> la <code>N3</code>, iar fiecare bec care este inscripționat cu un număr prim, va rămâne mereu aprins. Cutia în care trebuie strâns tubul este un cub de latură <code>N</code>. Becul cu numărul <code>1</code>, trebuie pus în colțul de coordonate <code>(1,1,1)</code>, restul în spirală până la umplerea nivelului, apoi nivelul următor în sens invers, ș.a.m.d.

=== Exemplu – <code>N = 3</code> ===
'''Nivel 1'''
1 2 3
8 9 4
7 6 5
'''Nivel 2'''
18 17 16
11 10 15
12 13 14
'''Nivel 3'''
19 20 21
26 27 22
25 24 23
'''Fața 1 (spate)'''
21, 20, 19,
16, 17, 18,
3, 2, 1
'''Fața 2 (dreapta)'''
23, 22, 21
14, 15, 16,
5, 4, 3,
'''Fața 3 (frontal)'''
25, 24, 23,
12, 13, 14,
7, 6, 5,
'''Fața 4 (stânga)'''
19, 26, 25,
18, 11, 12,
1, 8, 7,

= Cerința =
Cunoscând latura <code>N</code> a cubului, să se umple cubul cu tubul luminos (becurile fiind legate crescător), apoi să se determine:

1. Coordonatele <code>(x,y,z)</code> ale becului cu numărul <code>V</code>. (<code>x</code>-linia, <code>y</code>-coloana, <code>z</code>-înălțimea)

2. Numărul de becuri luminoase situate pe fiecare față a cubului.

= Date de intrare =
Fişierul de intrare <code>cub2.in</code> conţine pe prima linie un număr natural <code>p</code>. Pentru toate testele de intrare, numărul <code>p</code> poate avea doar valoarea <code>1</code> sau valoarea <code>2</code>.

Pe a doua linie a fișierului de intrare, sunt scrise două numere naturale <code>N</code> și <code>V</code> separate printr-un spațiu reprezentând dimensiunea cubului și valoarea becului pentru care trebuie determinate coordonatele.

= Date de ieșire =
Dacă valoarea lui <code>p</code> este <code>1</code>, se va rezolva numai cerinţa 1. În acest caz, în fişierul de ieşire <code>cub2.out</code> se vor scrie trei numere naturale <code>x y z</code>, separate prin câte un spațiu, reprezentând coordonatele becului cu valoarea <code>V</code>.

Dacă valoarea lui <code>p</code> este <code>2</code>, se va rezolva numai cerinţa <code>2</code>. În acest caz, fişierul de ieşire <code>cub2.out</code> va conține <code>4</code> linii. Pe fiecare linie <code>i</code>, se va scrie câte un număr natural <code>fi</code>, reprezentând numărul de becuri inscripționate cu numere prime de pe fața <code>i</code>.

natural <code>fi</code>, reprezentând numărul de becuri inscripționate cu numere prime de pe fața <code>i</code>.

= Restricții și precizări =

* <code>1 ≤ N ≤ 200</code>
* <code>1 ≤ V ≤ N3</code>
* Pentru rezolvarea corectă a primei cerinţe se acordă 20 de puncte, iar pentru cerința a doua se acordă 80 de puncte.
* Pentru 20% dintre teste: <code>1 ≤ N ≤ 20</code>
* Pentru 30% dintre teste: <code>21 ≤ N ≤ 100</code>
* Pentru 50% dintre teste: <code>101 ≤ N ≤ 200</code>

= Exemple =
<code>cub2.in</code>
1
3 10
<code>cub2.out</code>
2 2 2

= Explicație =
'''Atenție! Pentru acest test se rezolvă doar cerința 1).'''

linia <code>2</code>, coloana <code>2</code>, nivel <code>2</code> – este becul <code>10</code>

<code>cub2.in</code>
2
3 10
<code>cub2.out</code>
4
3
4
3

= Explicație =
'''Atenție! Pentru acest test se rezolvă doar cerința 2).'''

<code>4</code> – becuri inscripționate cu numere prime pe fața 1: <code>2, 3, 17, 19</code>

<code>3</code> – becuri inscripționate cu numere prime pe fața 2: <code>3, 5, 23</code>

<code>4</code> – becuri inscripționate cu numere prime pe fața 3: <code>5, 7, 13, 23</code>

<code>3</code> – becuri inscripționate cu numere prime pe fața 4: <code>7, 11, 19</code>

<syntaxhighlight lang="python" line="1">
def generate_spiral_layer(n, start_val):
""" Generate a spiral layer of size n x n starting from start_val """
layer = [[0] * n for _ in range(n)]
num = start_val
for layer_idx in range((n + 1) // 2):
for i in range(layer_idx, n - layer_idx):
layer[layer_idx][i] = num
num += 1
for i in range(layer_idx + 1, n - layer_idx):
layer[i][n - layer_idx - 1] = num
num += 1
for i in range(n - layer_idx - 2, layer_idx - 1, -1):
layer[n - layer_idx - 1][i] = num
num += 1
for i in range(n - layer_idx - 2, layer_idx, -1):
layer[i][layer_idx] = num
num += 1
return layer

def generate_cube(N):
""" Generate a cube of size N x N x N filled in spiral order """
cube = [[[0] * N for _ in range(N)] for _ in range(N)]
num = 1
for z in range(N):
layer = generate_spiral_layer(N, num)
for y in range(N):
for x in range(N):
cube[z][y][x] = layer[y][x]
num += N * N
return cube

def find_coordinates(cube, V):
""" Find coordinates (x, y, z) of the value V in the cube """
N = len(cube)
for z in range(N):
for y in range(N):
for x in range(N):
if cube[z][y][x] == V:
return (x + 1, y + 1, z + 1)
return None

def count_lights_on_faces(cube):
""" Count the number of lights on each face of the cube """
N = len(cube)
counts = {'front': 0, 'back': 0, 'left': 0, 'right': 0, 'top': 0, 'bottom': 0}

# Counting lights on each face
for z in range(N):
counts['top'] += N
counts['bottom'] += N

for y in range(N):
counts['front'] += N
counts['back'] += N

for x in range(N):
counts['left'] += N
counts['right'] += N

return counts

# Example Usage
N = 3
V = 7 # Example value to find coordinates for
cube = generate_cube(N)

coordinates = find_coordinates(cube, V)
face_counts = count_lights_on_faces(cube)

print(f"Coordinates of the light with number {V}: {coordinates}")
print(f"Number of lights on each face: {face_counts}")
</syntaxhighlight>

2588 - Iepuras1

2024-08-04T13:21:40Z

RaulOtet: Pagină nouă: Un iepuraş se găseşte într-o grădină plină de surprize. Harta grădinii poate fi reprezentată sub forma unei table dreptunghiulare cu <code>m</code> linii, numerotate de la <code>1</code> la <code>m</code> de sus în jos, şi <code>n</code> coloane, numerotate de la <code>1</code> la <code>n</code> de la stânga la dreapta. În fiecare celulă a acestei grădini se poate găsi cel mult una dintre următoarele surprize: săgeată, pom, zid, trapă, morcov, bombă. O s...

Un iepuraş se găseşte într-o grădină plină de surprize. Harta grădinii poate fi reprezentată sub forma unei table dreptunghiulare cu <code>m</code> linii, numerotate de la <code>1</code> la <code>m</code> de sus în jos, şi <code>n</code> coloane, numerotate de la <code>1</code> la <code>n</code> de la stânga la dreapta. În fiecare celulă a acestei grădini se poate găsi cel mult una dintre următoarele surprize: săgeată, pom, zid, trapă, morcov, bombă.

O săgeată indică una din direcţiile nord, sud, est, vest. Odată ajuns într-o celulă conţinând o astfel de săgeată iepuraşul îşi va continua deplasarea în sensul indicat de săgeată, iar aceasta dispare.

Într-o celulă în care se găseşte un pom sau un zid iepuraşul nu poate să pătrundă, însă dacă se “loveşte” de un pom, el îşi păstrează direcţia, însă schimbă sensul (dacă se deplasa spre nord, îşi va schimba sensul spre sud, dacă se deplasa spre est, se va deplasa după aceea spre vest etc).

Dacă iepuraşul intră într-o celulă conţinând o trapă, toate zidurile aflate pe teren dispar şi vor apărea alte ziduri, în poziţii precizate. Dacă iepuraşul va trece din nou printr-o celulă conţinând o trapă, zidurile nou construite dispar şi vor reapărea zidurile iniţiale. Mai exact există două grupe de ziduri care comută la fiecare trecere printr-o celulă care conţine o trapă.

Dacă iepuraşul va trece de două ori prin vecinătatea unei celule conţinând o bombă (adică prin celulele învecinate la sud, nord, est sau vest cu celula conţinând bombă), bomba va exploda iar iepuraşul se transformă instantaneu în îngeraş. De asemenea, dacă iepuraşul întră într-o celulă conţinând o bombă se transformă instantaneu în îngeraș.

Iepuraşul va ronţăi toţi morcovii care îi ies în cale. Evident că dacă trece a doua oară prin aceeaşi celulă, la a doua trecere nu va mai găsi morcov.

Surprizele din grădină sunt codificate astfel: '''1''' pentru <code>săgeată spre nord</code>, '''2''' pentru <code>săgeată spre vest</code>, '''3''' pentru <code>săgeată spre sud</code>, '''4''' pentru <code>săgeată spre est</code>, '''5''' pentru <code>pom</code>, '''6''' pentru <code>bombă</code>, '''7''' pentru <code>morcov</code>, '''8''' pentru <code>zid</code>, '''9''' pentru <code>trapă</code>. <code>Căsuţele libere</code> de pe harta grădinii se codifică cu '''0'''.

Iniţial, se cunosc poziţia şi sensul de deplasare ale iepuraşului. Expediţia acestuia se termină în următoarele situaţii:

* la explozia unei bombe, caz in care se transforma in ingeras;
* la parasirea gradinii (adica la iesirea in afara zonei dreptunghiulare date), caz in care se rataceste;
* in momentul in care reuseste sa rontaie toti morcovii, caz in care este fericit.

= Cerința =
Fiind data harta grădinii se cere să se determine starea finală a iepuraşului (îngeraş, rătăcit respectiv fericit), numărul de morcovi ronţăiţi până în momentul terminării expediţiei, precum şi numărul de paşi pe care îi face iepuraşul până la acest moment.

= Date de intrare =
Pe prima linie a fişierului de intrare <code>iepuras1.in</code> se găsesc două numere întregi <code>m</code> şi <code>n</code>, separate printr-un spaţiu, reprezentând numărul de linii, respectiv numărul de coloane ale hărţii.

Linia a doua a fişierului conţine trei numere naturale, separate prin câte un spaţiu, reprezentând linia si coloana poziţiei iniţiale a iepuraşului pe hartă precum şi direcţia spre care acesta este orientat. Direcţia este codificată astfel: '''1''' pentru <code>nord</code>, '''2''' pentru <code>vest</code>, '''3''' pentru <code>sud</code>, '''4''' pentru <code>est</code>.

Următoarele m linii conţin câte <code>n</code> numere întregi separate prin câte un spaţiu, reprezentând codificarea hărţii grădinii, conform celor precizate mai sus.

Următoarea linie conţine un singur număr natural <code>t</code> reprezentând numărul de celule ce vor conţine ziduri după prima trecere printr-o celulă conţinând o trapă. Următoarele <code>t</code> linii conţin câte două numere naturale <code>i</code> şi <code>j</code>, separate printr-un spaţiu, reprezentând coordonatele câte unei celule ce va conţine zid după o primă trecere printr-o celulă conţinând o trapă.

= Date de ieșire =
Fişierul de ieşire <code>iepuras1.out</code> va conţine pe prima sa linie unul dintre cuvintele <code>INGERAS</code>, <code>RATACIT</code> respectiv <code>FERICIT</code>, corespunzător stării finale a iepuraşului. A doua linie a fişierului va conţine două numere întregi separate printr-un spaţiu, reprezentând linia şi coloana ultimei poziţii de pe teren a iepuraşului, adică poziţia în care a murit, sau în care a devenit fericit, respectiv ultima poziţie a sa de pe teren, înainte de a se rătăci.

A treia linie a fişierului va conţine două numere întregi separate printr-un spaţiu, reprezentând numărul de morcovi culeşi până în momentul terminării expediţiei, respectiv numărul de paşi pe care îi face iepuraşul până ajunge în starea finală.

= Restricții și precizări =

* poziţia iniţială a iepuraşului este una validă, adică este o celulă liberă din interiorul terenului;
* pentru datele de test, se asigură că iepuraşul va face un număr finit de paşi până la terminarea expediţiei sale;
* <code>1 ≤ m, n ≤ 200</code>
* <code>0 ≤ t ≤ 20</code>
* numărul maxim de ziduri aflate la un moment dat pe teren este de cel mult 50, şi este posibil ca la un moment dat să nu existe niciun zid pe teren.
* Se garantează că pentru datele de intrare iepuraşul nu poate ajunge simultan în două din cele trei stări.
* Pomii şi trapele sunt obiecte care rămân permanent în teren, în poziţiile lor iniţiale.
* Într-o celulă a grădinii se poate găsi la un moment dat o singură surpriză (<code>pom</code>, <code>zid</code>, <code>trapă</code>, <code>morcov</code>, <code>săgeată</code>, <code>bombă</code>).

= Exemplu1: =
<code>iepuras1.in</code>
10 15
7 1 4
0 0 6 0 5 5 0 7 0 0 0 0 0 0 0
0 0 0 0 5 5 0 0 4 0 0 0 0 0 3
0 5 5 0 5 5 0 0 0 0 0 0 0 0 0
0 5 5 0 5 5 0 1 7 0 0 7 0 0 2
0 0 0 0 5 5 0 0 0 0 0 0 0 0 0
0 0 0 0 0 5 0 0 0 0 0 0 0 0 0
0 3 0 0 0 5 6 0 0 5 5 5 0 0 0
0 7 0 0 0 0 0 0 0 0 0 0 0 5 0
0 4 0 0 0 7 0 0 3 5 0 0 0 5 0
0 6 0 0 0 0 0 0 1 5 0 0 0 5 0
0
<code>iepuras1.out</code>
FERICIT
1 8
5 37
<syntaxhighlight lang="python" line="1">
def simulare_gradina(m, n, gradina, poz_initiala, directie_initiala):
# Direcțiile de mișcare: nord, vest, sud, est
directii = {
'nord': (-1, 0),
'vest': (0, -1),
'sud': (1, 0),
'est': (0, 1)
}

# Mapare coduri săgeți la direcții
sageata_la_directie = {
1: 'nord',
2: 'vest',
3: 'sud',
4: 'est'
}

# Poziția curentă și direcția curentă
x, y = poz_initiala
directie = directie_initiala

# Contoare
morcovi_ronțăiți = 0
pasi = 0
treceri_pe_langa_bombe = {}
starea_finala = 'rătăcit' # implicit

# Funcție pentru verificarea granițelor
def in_gradina(x, y):
return 0 <= x < m and 0 <= y < n

# Pozițiile inițiale ale zidurilor
ziduri_initiale = set()
for i in range(m):
for j in range(n):
if gradina[i][j] == 8:
ziduri_initiale.add((i, j))

# Pozițiile zidurilor alternative
ziduri_alternative = set()

# Inițial, zidurile sunt cele inițiale
ziduri_curente = ziduri_initiale.copy()

# Traseul iepurașului
while True:
if not in_gradina(x, y):
starea_finala = 'rătăcit'
break

pasi += 1
celula = gradina[x][y]

if celula == 7: # morcov
morcovi_ronțăiți += 1
gradina[x][y] = 0

elif celula in sageata_la_directie: # săgeată
directie = sageata_la_directie[celula]
gradina[x][y] = 0

elif celula == 5: # pom
dx, dy = directii[directie]
x -= dx
y -= dy
directie = {'nord': 'sud', 'sud': 'nord', 'vest': 'est', 'est': 'vest'}[directie]

elif celula == 6: # bombă
starea_finala = 'îngeraș'
break

elif celula == 9: # trapă
ziduri_curente = ziduri_alternative if ziduri_curente == ziduri_initiale else ziduri_initiale

# Verificăm dacă trece pe lângă o bombă
vecini = [(x-1, y), (x+1, y), (x, y-1), (x, y+1)]
for vx, vy in vecini:
if in_gradina(vx, vy) and gradina[vx][vy] == 6:
if (vx, vy) not in treceri_pe_langa_bombe:
treceri_pe_langa_bombe[(vx, vy)] = 0
treceri_pe_langa_bombe[(vx, vy)] += 1
if treceri_pe_langa_bombe[(vx, vy)] == 2:
starea_finala = 'îngeraș'
return starea_finala, morcovi_ronțăiți, pasi

# Deplasarea iepurașului
dx, dy = directii[directie]
x += dx
y += dy

# Verificăm dacă toate morcovii au fost mâncați
if all(all(cell != 7 for cell in row) for row in gradina):
starea_finala = 'fericit'
break

return starea_finala, morcovi_ronțăiți, pasi

# Exemplu de utilizare
m = 4
n = 4
gradina = [
[0, 7, 0, 0],
[2, 5, 3, 0],
[0, 6, 0, 7],
[0, 0, 0, 0]
]
poz_initiala = (0, 0)
directie_initiala = 'est'

rezultat = simulare_gradina(m, n, gradina, poz_initiala, directie_initiala)
print(rezultat)
</syntaxhighlight>

1421 - tabel

2024-08-04T13:20:05Z

RaulOtet: Pagină nouă: = Enunț = După cum probabil ştiţi, contabilii îşi ţin datele sub formă de tabele şi calculează tot felul de sume pe linii şi pe coloane. Contabilul nostru Atnoc şi-a organizat valorile sub forma unui tabel cu <code>n</code> linii (numerotate de la <code>1</code> la <code>n</code>) şi <code>m</code> coloane (numerotate de la <code>1</code> la <code>m</code>). Elementele de pe ultima coloană sunt sumele elementelor de pe linii (mai exact, elementul de pe linia <co...

= Enunț =
După cum probabil ştiţi, contabilii îşi ţin datele sub formă de tabele şi calculează tot felul de sume pe linii şi pe coloane. Contabilul nostru Atnoc şi-a organizat valorile sub forma unui tabel cu <code>n</code> linii (numerotate de la <code>1</code> la <code>n</code>) şi <code>m</code> coloane (numerotate de la <code>1</code> la <code>m</code>). Elementele de pe ultima coloană sunt sumele elementelor de pe linii (mai exact, elementul de pe linia <code>i</code> şi coloana <code>m</code> este egal cu suma elementelor de pe linia <code>i</code> aflate pe coloanele <code>1</code>, <code>2</code>, …, <code>m-1</code>), iar elementele de pe ultima linie sunt sumele elementelor de pe coloane (mai exact, elementul de pe linia <code>n</code> şi coloana <code>i</code> este egal cu suma elementelor de pe coloana <code>i</code> aflate pe liniile <code>1</code>, <code>2</code>, …, <code>n-1</code>). Un exemplu de astfel de tabel este dat în figura următoare.
{| class="wikitable"
|<code>2</code>
|<code>5</code>
|<code>7</code>
|<code>14</code>
|-
|<code>11</code>
|<code>6</code>
|<code>6</code>
|<code>23</code>
|-
|<code>13</code>
|<code>11</code>
|<code>13</code>
|<code>37</code>
|}
Din păcate, Atnoc a stropit cu apă minunatul său tabel şi astfel o parte dintre numerele din tabel au devenit ilizibile.

= Cerința =
Scrieţi un program care să reconstituie toate datele din tabel.

= Date de intrare =
Pe prima linie a fişierului text de intrare <code>tabel.in</code> se află două numere naturale <code>n</code> şi <code>m</code>, separate printr-un spaţiu, ce reprezintă numărul de linii şi respectiv numărul de coloane ale tabelului. Pe cea de a doua linie a fişierului de intrare se află un număr natural <code>p</code> care reprezintă numărul de valori nedeteriorate din tabel. Pe fiecare dintre următoarele <code>p</code> linii se află câte trei numere naturale, separate prin câte un spaţiu <code>l c v</code>, unde <code>l</code> este numărul liniei, <code>c</code> este numărul coloanei şi <code>v</code> este valoarea elementului de pe linia <code>l</code> şi coloana <code>c</code> din tabel.

= Date de ieșire =
În fişierul text de ieşire <code>tabel.out</code> se va scrie tabelul reconstituit, pe <code>n</code> linii câte <code>m</code> valori separate prin câte un spaţiu.

= Restricții și precizări =

* <code>1<n, m<51</code>
* Valorile din tabel sunt numere naturale <code>< 32000</code>
* În toate testele datele din tabel pot fi reconstituite.

= Exemplu: =
<code>tabel.in</code>
3 4
10
1 1 2
1 2 5
1 3 7
1 4 14
2 2 6
2 4 23
3 1 13
3 2 11
3 3 13
3 4 37
<code>tabel.out</code>
2 5 7 14
11 6 6 23
13 11 13 37
<syntaxhighlight lang="python" line="1">
def reconstruct_table(table):
n = len(table) # numărul de linii
m = len(table[0]) # numărul de coloane

# Functie pentru a calcula suma unei linii
def calculate_row_sum(row):
return sum(x for x in row if x is not None)

# Functie pentru a calcula suma unei coloane
def calculate_col_sum(table, col):
return sum(table[i][col] for i in range(n-1) if table[i][col] is not None)

# Pasul 1: Completarea liniilor folosind suma liniei
for i in range(n-1):
row_sum = table[i][m-1]
current_sum = calculate_row_sum(table[i])
missing_count = table[i][:m-1].count(None)
if missing_count == 1:
for j in range(m-1):
if table[i][j] is None:
table[i][j] = row_sum - current_sum

# Pasul 2: Completarea coloanelor folosind suma coloanei
for j in range(m-1):
col_sum = table[n-1][j]
current_sum = calculate_col_sum(table, j)
missing_count = sum(1 for i in range(n-1) if table[i][j] is None)
if missing_count == 1:
for i in range(n-1):
if table[i][j] is None:
table[i][j] = col_sum - current_sum

# Pasul 3: Calcularea sumei pe ultima linie și ultima coloană
for i in range(n-1):
table[i][m-1] = calculate_row_sum(table[i])

for j in range(m-1):
table[n-1][j] = calculate_col_sum(table, j)

# Calcularea colțului de jos-dreapta
table[n-1][m-1] = sum(table[n-1][j] for j in range(m-1))

return table

# Exemplu de utilizare:
table = [
[2, 5, 7, 14],
[11, None, 6, 23],
[None, 11, 13, 37]
]

reconstructed_table = reconstruct_table(table)
for row in reconstructed_table:
print(row)
</syntaxhighlight>

2461 - V

2024-08-04T13:18:06Z

RaulOtet: Pagină nouă: Se consideră un tablou bidimensional cu <code>m</code> linii şi <code>n</code> coloane. Se numeşte traseu în <code>V</code> o parcurgere prin elementele tabloului astfel: * se pleacă întotdeauna dintr-un element de pe prima linie a tabloului, se ajunge în final într-un alt element de pe prima linie a tabloului, trecând prin cel puţin 3 elemente, fără a trece printr-un element de mai multe ori; * parcurgerea elementelor tabloului se face în forma unei singure lit...

Se consideră un tablou bidimensional cu <code>m</code> linii şi <code>n</code> coloane. Se numeşte traseu în <code>V</code> o parcurgere prin elementele tabloului astfel:

* se pleacă întotdeauna dintr-un element de pe prima linie a tabloului, se ajunge în final într-un alt element de pe prima linie a tabloului, trecând prin cel puţin 3 elemente, fără a trece printr-un element de mai multe ori;
* parcurgerea elementelor tabloului se face în forma unei singure litere <code>V</code> ca în desen, dintr-un element putându-se trece doar într-un alt element imediat vecin pe diagonală.

Fiecare element al tabloului conţine valori întregi. La parcurgerea traseului se calculează suma elementelor de pe traseu.

= Cerința =
Determinaţi traseul în <code>V</code> care are suma maximă. În cazul în care există mai multe trasee de sumă maximă, se va alege traseul care parcurge cele mai puţine elemente. Dacă şi în acest caz există mai multe soluţii, se alege traseul cel mai din stânga (cel cu indicele coloanei de pornire cel mai mic).

= Date de intrare =
Din fişierul de intrare <code>v.in</code> se citesc de pe prima linie valorile naturale <code>m</code> şi <code>n</code>, separate printr-un spaţiu, reprezentând numărul de linii şi numărul de coloane ale tabloului. Pe următoarele <code>m</code> linii se află câte <code>n</code> valori întregi separate prin spaţii, reprezentând elementele tabloului.

= Date de ieșire =
Fişierul de ieşire <code>v.out</code> va conţine o singură linie pe care vor fi scrise trei valori naturale <code>S C L</code>, reprezentând suma maximă, coloana de pornire şi respectiv linia pe care se află vârful <code>V</code>-ului traseului determinat.

= Restricții și precizări =

* <code>1 ≤ m, n ≤ 1500</code>
* <code>-60000 ≤</code> valorile elementelor tabloului <code>≤ 60000</code>
* Pentru datele de test suma valorilor din elementele oricărui traseu va fi între <code>-2 000 000 000</code> şi <code>2 000 000 000</code> .
* Pentru 50% din teste <code>1 ≤ m, n ≤ 101</code>
* Pentru 70% din teste <code>1 ≤ m, n ≤ 1000</code>
* Nota: Această problemă conține restricții și teste îmbunătățite

= Exemplu: =
'''v.in'''
5 9
3 4 12 4 6 7 9 5 12
0 4 5 7 9 -5 1 1 5
0 98 34 0 1 7 7 1 1
6 7 8 -9 0 2 3 5 22
47 62 31 55 0 83 23 77 10
'''v.out'''
54 1 3
<syntaxhighlight lang="python" line="1">
def find_best_v_path(matrix):
m = len(matrix)
n = len(matrix[0])

# Step 3: Calculate dp_down
dp_down = [[float('-inf')] * n for _ in range(m)]
dp_down[0] = matrix[0][:]

for i in range(1, m):
for j in range(n):
if j > 0:
dp_down[i][j] = max(dp_down[i][j], dp_down[i-1][j-1] + matrix[i][j])
if j < n - 1:
dp_down[i][j] = max(dp_down[i][j], dp_down[i-1][j+1] + matrix[i][j])

# Step 4: Calculate dp_up
dp_up = [[float('-inf')] * n for _ in range(m)]
dp_up[m-1] = matrix[m-1][:]

for i in range(m-2, -1, -1):
for j in range(n):
if j > 0:
dp_up[i][j] = max(dp_up[i][j], dp_up[i+1][j-1] + matrix[i][j])
if j < n - 1:
dp_up[i][j] = max(dp_up[i][j], dp_up[i+1][j+1] + matrix[i][j])

# Step 5: Find the maximum sum path
max_sum = float('-inf')
min_length = float('inf')
best_path_start = -1
best_path_end = -1

for i in range(m):
for j in range(n):
if dp_down[i][j] == float('-inf') or dp_up[i][j] == float('-inf'):
continue
total_sum = dp_down[i][j] + dp_up[i][j] - matrix[i][j]
length = 2 * i + 1
if total_sum > max_sum or (total_sum == max_sum and length < min_length):
max_sum = total_sum
min_length = length
best_path_start = j
best_path_end = j

return max_sum, best_path_start, best_path_end

# Exemplu de utilizare:
matrix = [
[3, 1, 7],
[2, 5, 4],
[1, 6, 2]
]

result = find_best_v_path(matrix)
print(result)
</syntaxhighlight>

2425 - Peri

2024-07-31T12:56:09Z

RaulOtet:

Se consideră o matrice dreptunghiulară <code>A</code> cu <code>m</code> linii şi <code>n</code> coloane cu valori <code>0</code> sau <code>1</code>, liniile şi coloanele fiind numerotate de la <code>1</code> la <code>m</code>, respectiv de la <code>1</code> la <code>n</code>. Numim dreptunghi de colţuri <code>(x1, y1) (x2,y2)</code> cu <code>x1 < x2</code> şi <code>y1 < y2</code> mulţimea elementelor <code>A[i][j]</code> cu <code>x1 ≤ i ≤ x2</code> si <code>y1 ≤ j ≤ y2</code>. Numim perimetru al dreptunghiului de colţuri <code>(x1, y1) (x2, y2)</code> mulţimea elementelor <code>A[i][j]</code> pentru care (<code>i = x1</code> şi <code>y1 ≤ j ≤ y2</code>) sau (<code>i = x2</code> şi <code>y1 ≤ j ≤ y2</code>) sau (<code>j = y1</code> şi <code>x1 ≤ i ≤ x2</code>) sau (<code>j = y2</code> şi <code>x1 ≤ i ≤ x2</code>).

= Cerința =
Determinaţi diferenţa maximă dintre numărul de elemente egale cu <code>1</code> şi numărul de elemente egale cu <code>0</code> aflate pe perimetrul aceluiaşi dreptunghi, precum şi numărul de dreptunghiuri pentru care se obţine această diferenţă.

= Date de intrare =
Fișierul de intrare <code>peri.in</code> conține pe prima linie numerele <code>m</code> şi <code>n</code>, separate printr-un singur spaţiu. Pe următoarele <code>m</code> linii este dată matricea <code>A</code>, numerele de pe aceeaşi linie fiind separate de câte un spaţiu.
= Date de ieșire =
Fișierul de ieșire <code>peri.out</code> va conţine o singură linie pe care se află două numere întregi separate printr-un spaţiu. Primul număr este diferenţa maximă dintre numărul de elemente <code>1</code> şi numărul de elemente <code>0</code> de pe perimetrul unui dreptunghi. Al doilea întreg este numărul de dreptunghiuri pentru care diferenţa dintre numărul de elemente <code>1</code> şi numărul de elemente <code>0</code> de pe perimetru este maximă.

= Restricții și precizări =

* <code>1 ≤ m, n ≤ 250</code>
* Prin diferenţă nu se înţelege diferenţă în valoare absolută!

= Exemplu: =
<code>peri.in</code>
4 5
1 0 0 1 0
0 1 1 0 0
0 1 0 1 0
1 1 1 0 1
<code>peri.out</code>
4 2
<syntaxhighlight lang="python" line="1">
def max_perimeter_diff(matrix):
m = len(matrix)
n = len(matrix[0])
max_diff = float('-inf')
count_max_diff_rects = 0

# Helper function to count 1's and 0's on the perimeter
def count_perimeter(x1, y1, x2, y2):
ones = 0
zeros = 0
for j in range(y1, y2 + 1):
if matrix[x1][j] == 1:
ones += 1
else:
zeros += 1
if matrix[x2][j] == 1:
ones += 1
else:
zeros += 1
for i in range(x1 + 1, x2):
if matrix[i][y1] == 1:
ones += 1
else:
zeros += 1
if matrix[i][y2] == 1:
ones += 1
else:
zeros += 1
return ones, zeros

# Iterate over all possible top-left corners (x1, y1)
for x1 in range(m - 1):
for y1 in range(n - 1):
# Iterate over all possible bottom-right corners (x2, y2)
for x2 in range(x1 + 1, m):
for y2 in range(y1 + 1, n):
ones, zeros = count_perimeter(x1, y1, x2, y2)
diff = ones - zeros
if diff > max_diff:
max_diff = diff
count_max_diff_rects = 1
elif diff == max_diff:
count_max_diff_rects += 1

return max_diff, count_max_diff_rects

# Exemplu de utilizare
matrix = [
[0, 1, 0, 1],
[1, 0, 1, 0],
[0, 1, 0, 1],
[1, 0, 1, 0]
]

max_diff, count_max_diff_rects = max_perimeter_diff(matrix)
print(f"Diferența maximă: {max_diff}")
print(f"Numărul de dreptunghiuri: {count_max_diff_rects}")
</syntaxhighlight>

2425 - Peri

2024-07-31T12:55:23Z

RaulOtet: Pagină nouă: Se consideră o matrice dreptunghiulară <code>A</code> cu <code>m</code> linii şi <code>n</code> coloane cu valori <code>0</code> sau <code>1</code>, liniile şi coloanele fiind numerotate de la <code>1</code> la <code>m</code>, respectiv de la <code>1</code> la <code>n</code>. Numim dreptunghi de colţuri <code>(x1, y1) (x2,y2)</code> cu <code>x1 < x2</code> şi <code>y1 < y2</code> mulţimea elementelor <code>A[i][j]</code> cu <code>x1 ≤ i ≤ x2</code> si <code>y1 ≤...

Se consideră o matrice dreptunghiulară <code>A</code> cu <code>m</code> linii şi <code>n</code> coloane cu valori <code>0</code> sau <code>1</code>, liniile şi coloanele fiind numerotate de la <code>1</code> la <code>m</code>, respectiv de la <code>1</code> la <code>n</code>. Numim dreptunghi de colţuri <code>(x1, y1) (x2,y2)</code> cu <code>x1 < x2</code> şi <code>y1 < y2</code> mulţimea elementelor <code>A[i][j]</code> cu <code>x1 ≤ i ≤ x2</code> si <code>y1 ≤ j ≤ y2</code>. Numim perimetru al dreptunghiului de colţuri <code>(x1, y1) (x2, y2)</code> mulţimea elementelor <code>A[i][j]</code> pentru care (<code>i = x1</code> şi <code>y1 ≤ j ≤ y2</code>) sau (<code>i = x2</code> şi <code>y1 ≤ j ≤ y2</code>) sau (<code>j = y1</code> şi <code>x1 ≤ i ≤ x2</code>) sau (<code>j = y2</code> şi <code>x1 ≤ i ≤ x2</code>).

= Cerința =
Determinaţi diferenţa maximă dintre numărul de elemente egale cu <code>1</code> şi numărul de elemente egale cu <code>0</code> aflate pe perimetrul aceluiaşi dreptunghi, precum şi numărul de dreptunghiuri pentru care se obţine această diferenţă.

= Date de intrare =
Fișierul de intrare <code>peri.in</code> conține pe prima linie numerele <code>m</code> şi <code>n</code>, separate printr-un singur spaţiu. Pe următoarele <code>m</code> linii este dată matricea <code>A</code>, numerele de pe aceeaşi linie fiind separate de câte un spaţiu.<syntaxhighlight lang="python" line="1">
def max_perimeter_diff(matrix):
m = len(matrix)
n = len(matrix[0])
max_diff = float('-inf')
count_max_diff_rects = 0

# Helper function to count 1's and 0's on the perimeter
def count_perimeter(x1, y1, x2, y2):
ones = 0
zeros = 0
for j in range(y1, y2 + 1):
if matrix[x1][j] == 1:
ones += 1
else:
zeros += 1
if matrix[x2][j] == 1:
ones += 1
else:
zeros += 1
for i in range(x1 + 1, x2):
if matrix[i][y1] == 1:
ones += 1
else:
zeros += 1
if matrix[i][y2] == 1:
ones += 1
else:
zeros += 1
return ones, zeros

# Iterate over all possible top-left corners (x1, y1)
for x1 in range(m - 1):
for y1 in range(n - 1):
# Iterate over all possible bottom-right corners (x2, y2)
for x2 in range(x1 + 1, m):
for y2 in range(y1 + 1, n):
ones, zeros = count_perimeter(x1, y1, x2, y2)
diff = ones - zeros
if diff > max_diff:
max_diff = diff
count_max_diff_rects = 1
elif diff == max_diff:
count_max_diff_rects += 1

return max_diff, count_max_diff_rects

# Exemplu de utilizare
matrix = [
[0, 1, 0, 1],
[1, 0, 1, 0],
[0, 1, 0, 1],
[1, 0, 1, 0]
]

max_diff, count_max_diff_rects = max_perimeter_diff(matrix)
print(f"Diferența maximă: {max_diff}")
print(f"Numărul de dreptunghiuri: {count_max_diff_rects}")
</syntaxhighlight>

= Date de ieșire =
Fișierul de ieșire <code>peri.out</code> va conţine o singură linie pe care se află două numere întregi separate printr-un spaţiu. Primul număr este diferenţa maximă dintre numărul de elemente <code>1</code> şi numărul de elemente <code>0</code> de pe perimetrul unui dreptunghi. Al doilea întreg este numărul de dreptunghiuri pentru care diferenţa dintre numărul de elemente <code>1</code> şi numărul de elemente <code>0</code> de pe perimetru este maximă.

= Restricții și precizări =

* <code>1 ≤ m, n ≤ 250</code>
* Prin diferenţă nu se înţelege diferenţă în valoare absolută!

= Exemplu: =
<code>peri.in</code>
4 5
1 0 0 1 0
0 1 1 0 0
0 1 0 1 0
1 1 1 0 1
<code>peri.out</code>
4 2

1702 - Cristale

2024-07-31T12:53:55Z

RaulOtet: Pagină nouă: Pietrele preţioase au fascinat omenirea încă din timpuri străvechi iar cele mai renumite dintre ele, cristalele, au devenit atât simbolul durităţii cât şi al eternităţii. În urma unui studiu ştiinţific, pe un eşantion de formă dreptunghiulară se pot observa diferite tipuri de molecule, dispuse într-o geometrie perfectă, pe <code>M</code> rânduri a câte <code>N</code> molecule fiecare, aliniate una lângă alta. O formaţiune cristalizabilă este alcătui...

Pietrele preţioase au fascinat omenirea încă din timpuri străvechi iar cele mai renumite dintre ele, cristalele, au devenit atât simbolul durităţii cât şi al eternităţii. În urma unui studiu ştiinţific, pe un eşantion de formă dreptunghiulară se pot observa diferite tipuri de molecule, dispuse într-o geometrie perfectă, pe <code>M</code> rânduri a câte <code>N</code> molecule fiecare, aliniate una lângă alta. O formaţiune cristalizabilă este alcătuită din <code>3</code> molecule de acelaşi tip, învecinate două câte două, având una dintre cele patru forme din imaginea alăturată (fig.1).

Fiecare formaţiune este înconjurată de jur-împrejur, ca în fig.2, de un înveliş special format şi el din molecule identice, de alt tip decât cele din formaţiunea cristalizabilă pe care o înconjoară şi o izolează de restul formaţiunilor moleculare. În acest fel, fiecare moleculă din formaţiunea cristalizabilă se învecinează la Nord, Sud, Est şi Vest cu o moleculă din aceeaşi formaţiune cristalizabilă sau cu o moleculă din învelişul special.

Fiecare formaţiune cristalizabilă se bombardează cu raze <code>X</code> şi în acest fel are loc cristalizarea, proces prin care învelişul special se extinde peste formaţiunea cristalizabilă pe care o înconjoară, formând o singură structură din care se va dezvolta cristalul.

= Cerințe =

# Determinaţi numărul formaţiunilor cristalizabile ce pot fi identificate pe eşantionul analizat.
# Afişaţi eşantionul rezultat după cristalizare.

= Date de intrare =
Fișierul de intrare <code>cristale.in</code> conține pe prima linie un număr natural <code>c</code> reprezentând cerinţa care trebuie să fie rezolvată (1 sau 2). Pe cea de-a doua linie se află două numere naturale <code>M</code> şi <code>N</code>, separate printr-un spaţiu, având semnificaţia din enunţ. Pe următoarele <code>M</code> linii se află câte <code>N</code> numere naturale, separate prin câte un spaţiu, reprezentând moleculele din eşantionul analizat.

= Date de ieșire =
Dacă valoarea lui <code>c</code> este <code>1</code>, atunci se va rezolva numai cerinţa 1, caz în care pe prima linie a fişierului <code>cristale.out</code> va fi scris un număr natural reprezentând numărul formaţiunilor cristalizabile identificate pe eşantionul analizat. Dacă valoarea lui <code>c</code> este <code>2</code>, atunci se va rezolva numai cerinţa 2. În acest caz, fişierul de ieşire <code>cristale.out</code> va conţine pe fiecare dintre primele <code>M</code> linii, câte <code>N</code> numere naturale separate prin câte un spaţiu, reprezentând moleculele eşantionului rezultat după cristalizare.

= Restricții și precizări =

* <code>4 ≤ M,N ≤ 800</code> şi tipul fiecărei molecule este exprimat printr-un număr natural din intervalul <code>[1,16]</code>;
* pe marginea eşantionului nu pot fi identificate formaţiuni cristalizabile; există cel puţin o formaţiune cristalizabilă pe eşantionul analizat;
* eşantionul nu conţine formaţiuni cristalizabile lipite (cu celule vecine pe una din cele patru direcţii);
* pentru rezolvarea corectă a cerinţei 1 se acordă 30% din punctaj, iar pentru rezolvarea corectă a cerinţei 2 se acordă 70% din punctaj.

= Exemplul 1 =
<code>cristale.in</code>
1
6 8
5 6 6 1 5 2 6 5
6 9 9 6 1 7 1 2
6 6 9 6 3 4 1 6
2 2 6 3 4 7 4 2
8 8 2 4 7 7 4 6
8 2 7 2 4 4 2 5
<code>cristale.out</code>
2

=== Explicație ===
Se va rezolva cerinţa 1 a problemei.

Eşantionul are <code>6</code> rânduri cu câte <code>8</code> molecule pe fiecare rând. Pe acest eşantion observăm o formaţiune cristalizabilă cu celule de tip <code>9</code>, izolată de învelişul special format din celule identice, toate de tip <code>6</code> şi o formaţiune cristalizabilă cu celule de tip <code>7</code>, izolată de învelişul special format din celule identice, toate de tip <code>4</code>.

Formaţiunea de <code>3</code> molecule de tip <code>8</code> nu este o formaţiune cristalizabilă întrucât se află pe marginea eşantionului.

= Exemplul 1 =
<code>cristale.in</code>
1
6 8
5 6 6 1 5 2 6 5
6 9 9 6 1 7 1 2
6 6 9 6 3 4 1 6
2 2 6 3 4 7 4 2
8 8 2 4 7 7 4 6
8 2 7 2 4 4 2 5
<code>cristale.out</code>
2

=== Explicație ===
Se va rezolva cerinţa 1 a problemei.

Eşantionul are <code>6</code> rânduri cu câte <code>8</code> molecule pe fiecare rând. Pe acest eşantion observăm o formaţiune cristalizabilă cu celule de tip <code>9</code>, izolată de învelişul special format din celule identice, toate de tip <code>6</code> şi o formaţiune cristalizabilă cu celule de tip <code>7</code>, izolată de învelişul special format din celule identice, toate de tip <code>4</code>.

Formaţiunea de <code>3</code> molecule de tip <code>8</code> nu este o formaţiune cristalizabilă întrucât se află pe marginea eşantionului.

<syntaxhighlight lang="python" line="1">
def is_valid_position(x, y, M, N):
return 0 <= x < M and 0 <= y < N

def identify_crystalline_formations(sample, M, N):
directions = [
[(0, 0), (0, 1), (0, 2)], # Orizontal
[(0, 0), (1, 0), (2, 0)], # Vertical
[(0, 0), (0, 1), (1, 0)], # L form
[(0, 0), (1, 0), (1, 1)], # Inverse L form
]

formations = []

for i in range(M):
for j in range(N):
for direction in directions:
molecules = set()
valid = True
for dx, dy in direction:
x, y = i + dx, j + dy
if not is_valid_position(x, y, M, N):
valid = False
break
molecules.add(sample[x][y])

if valid and len(molecules) == 1:
formations.append((i, j, direction))

return formations

def apply_crystallization(sample, formations, M, N):
for (i, j, direction) in formations:
surrounding_type = None
formation_type = sample[i][j]

# Identify the surrounding type
for dx, dy in direction:
x, y = i + dx, j + dy
for nx, ny in [(x-1, y), (x+1, y), (x, y-1), (x, y+1)]:
if is_valid_position(nx, ny, M, N) and sample[nx][ny] != formation_type:
surrounding_type = sample[nx][ny]
break
if surrounding_type:
break

# Apply the crystallization
if surrounding_type:
for dx, dy in direction:
x, y = i + dx, j + dy
sample[x][y] = surrounding_type

def print_sample(sample):
for row in sample:
print(' '.join(map(str, row)))

# Exemplu de utilizare
M = 5
N = 5
sample = [
[1, 1, 1, 2, 3],
[1, 4, 2, 3, 2],
[4, 2, 3, 2, 2],
[2, 2, 3, 1, 4],
[3, 1, 4, 4, 4],
]

formations = identify_crystalline_formations(sample, M, N)
print(f"Formațiuni cristalizabile: {formations}")
apply_crystallization(sample, formations, M, N)
print("Eșantion după cristalizare:")
print_sample(sample)
</syntaxhighlight>

1699 - Robotel

2024-07-31T12:51:51Z

RaulOtet: Pagină nouă: Tudor a primit un joc educaţional numit “Roboţel” cu ajutorul căruia va învăţa punctele cardinale Nord, Est, Sud, Vest. Jocul constă dintr-un roboţel care se deplasează pe o tablă de forma unei matrici pătratice, împărţită în <code>R</code> linii şi <code>R</code> coloane. Fiecare căsuţă, aflată la intersecţia dintre o linie şi o coloană, este fie căsuță „liberă”, fie căsuță „semnalizator”, caz în care este etichetată cu una din li...

Tudor a primit un joc educaţional numit “Roboţel” cu ajutorul căruia va învăţa punctele cardinale Nord, Est, Sud, Vest. Jocul constă dintr-un roboţel care se deplasează pe o tablă de forma unei matrici pătratice, împărţită în <code>R</code> linii şi <code>R</code> coloane. Fiecare căsuţă, aflată la intersecţia dintre o linie şi o coloană, este fie căsuță „liberă”, fie căsuță „semnalizator”, caz în care este etichetată cu una din literele <code>N</code>, <code>E</code>, <code>S</code>, <code>V</code>, reprezentând <code>4</code> sensuri posibile de deplasare. Când roboțelul ajunge într-o „căsuţă semnalizator”, el îşi schimbă sensul de deplasare astfel:

* Dacă căsuţa este etichetată cu <code>N</code> atunci roboţelul se va deplasa în continuare de jos în sus;
* Dacă căsuţa este etichetată cu <code>E</code> atunci roboţelul se va deplasa în continuare de la stânga la dreapta;
* Dacă căsuţa este etichetată cu <code>S</code> atunci roboţelul se va deplasa în continuare de sus în jos;
* Dacă căsuţa este etichetată cu <code>V</code> atunci roboţelul se va deplasa în continuare de la dreapta la stânga.

Două căsuțe semnalizator formează o pereche „'''blocantă'''” dacă:

* Se află pe aceeași linie și conțin literele <code>E</code> și <code>V</code>, căsuța cu <code>E</code> are coloana mai mică decât a celei etichetate cu <code>V</code> și între ele, pe aceeași linie nu există alte căsuțe semnalizatoare.
* Se află pe aceeași coloană și conțin literele <code>S</code> și <code>N</code>, căsuța cu <code>S</code> are linia mai mică decât a celei etichetate cu <code>N</code> și între ele, pe aceeași coloană nu există alte căsuțe semnalizatoare.

În figura 1, de exemplu, sunt <code>2</code> perechi blocante: Perechea <code>(1,2) (5.2)</code> și perechea <code>(2,3) (2,5)</code>.

Roboţelul porneşte din căsuţa <code>(1,1)</code>, aflată pe prima linie și prima coloană şi dacă aceasta este liberă, se deplasează, în cadrul primei linii, de la stânga la dreapta. În cazul în care căsuța de pornire <code>(1,1)</code> este semnalizator, atunci roboțelul se va deplasa pe direcția indicată de litera cu care este etichetată. Considerând că roboțelul se deplasează pe tablă, el se oprește doar în următoarele situații:

* Roboţelul intră într-o căsuţă liberă aflată pe prima sau ultima linie, respectiv prima sau ultima coloană, caz în care dacă s-ar menține sensul deplasării actuale roboțelul ar părăsi tabla;
* Roboțelul intră într-o „căsuţă semnalizator” a unei perechi blocantă și se va opri în cealaltă căsuță a perechii.

De exemplu, în Figura 2, roboțelul ajunge în căsuța liberă <code>(3,5)</code> unde se oprește. În Figura 3, roboțelul se va opri în căsuța <code>(4,1)</code> deoarece dacă ar schimba sensul spre Est, ar reveni în ultima căsuță semnalizator vizitată, <code>(4,3)</code>.

Roboțelul înaintează o căsuță într-un pas, în sensul de deplasare.

= Cerința =
Scrieţi un program care, cunoscând numărul <code>R</code> de linii şi coloane și cele <code>K</code> căsuţe semnalizator, determină:

# Toate perechile blocante de pe tablă;
# Numărul de pași efectuați pe fiecare sens în parte: Nord, Est, Sud și Vest

= Date de intrare =
Fișierul de intrare <code>robotel.in</code> conține pe prima linie numărul natural <code>P</code> reprezentând cerința din problemă care trebuie rezolvată, pe a doua linie, separate printr-un spaţiu numărul natural <code>R</code> şi numărul natural <code>K</code>, iar pe următoarele <code>K</code> linii, două numere naturale și un caracter, separate prin câte un spațiu reprezentând, în ordine, linia, coloana şi litera unei căsuţe semnalizator.

= Date de ieșire =
Dacă valoarea lui <code>P</code> este <code>1</code>, se va rezolva doar cerința 1). Fişierul de ieşire <code>robotel.out</code> va conține perechile blocante, pentru fiecare pereche de căsuțe afișându-se <code>4</code> numere naturale separate printr-un spaţiu, reprezentând, în ordine, linia, coloana primei căsuțe semnalizator, respectiv linia și coloana celei de-a doua căsuțe semnalizator. Perechile de căsuțe vor fi afișate pe linii ordonat după regula: o pereche <code>L1 C1 L2 C2</code> va fi afișată înaintea perechii <code>L3 C3 L4 C4</code> dacă <code>L1<L3</code> sau <code>L1=L3</code> și <code>C1<C3</code>, adică se va afișa mai întâi perechea cu prima căsuță având linia mai mică decât a primei căsuțe din cealaltă pereche sau la linii egale, va fi afișată perechea cu coloana mai mică. Dacă nu există astfel de perechi de căsuțe, în fișierul de ieșire se va afișa valoarea <code>0</code>.

Dacă valoarea lui <code>P</code> este <code>2</code>, se va rezolva doar cerința 2). Fişierul de ieşire <code>robotel.out</code> va conţine <code>4</code> numere naturale separate printr-un spaţiu, reprezentând, în ordine, numărul de pași parcurși de roboţel în sensurile Nord, Est, Sud, și Vest.

= Restricții și precizări =

* <code>2 ≤ R ≤ 200</code> și <code>1 ≤ K ≤ R*R</code>
* Pentru rezolvarea corectă a fiecărei cerinţe se obțin câte 50 de puncte
* O căsuță semnalizator conține o singură literă
* Pentru cerința 2 se garantează că în toate testele deplasarea roboțelului se oprește!

= Exemplu =
<code>robotel.in</code>
1
5 4
1 3 S
3 1 E
5 1 N
5 3 V
<code>robotel.out</code>
0

=== Explicație ===
Nu există perechi blocante pe tablă care ar putea opri roboţelul.

<syntaxhighlight lang="python" line="1">
def find_blocking_pairs(R, semnalizatori):
# Găsirea perechilor blocante
perechi_blocante = []

# Parcurgerea liniilor pentru perechi E-V
for i in range(R):
e_index = -1
for j in range(R):
if (i, j) in semnalizatori and semnalizatori[(i, j)] == 'E':
e_index = j
elif (i, j) in semnalizatori and semnalizatori[(i, j)] == 'V':
if e_index != -1:
perechi_blocante.append(((i, e_index), (i, j)))
e_index = -1 # Resetăm indexul pentru următoarea pereche

# Parcurgerea coloanelor pentru perechi S-N
for j in range(R):
s_index = -1
for i in range(R):
if (i, j) in semnalizatori and semnalizatori[(i, j)] == 'S':
s_index = i
elif (i, j) in semnalizatori and semnalizatori[(i, j)] == 'N':
if s_index != -1:
perechi_blocante.append(((s_index, j), (i, j)))
s_index = -1 # Resetăm indexul pentru următoarea pereche

return perechi_blocante

def simulate_robot(R, semnalizatori, perechi_blocante):
# Direcțiile Nord, Est, Sud, Vest
directions = {'N': (-1, 0), 'E': (0, 1), 'S': (1, 0), 'V': (0, -1)}
steps_count = {'N': 0, 'E': 0, 'S': 0, 'V': 0}

# Poziția inițială și direcția inițială
x, y = 0, 0
direction = 'E'

visited = set()

while True:
# Marcați poziția curentă ca vizitată
visited.add((x, y))

# Verificați dacă poziția curentă este o căsuță semnalizator
if (x, y) in semnalizatori:
direction = semnalizatori[(x, y)]

# Calculați următoarea poziție
dx, dy = directions[direction]
new_x, new_y = x + dx, y + dy

# Verificați dacă următoarea poziție este în afara grilei
if not (0 <= new_x < R and 0 <= new_y < R):
break

# Verificați dacă se întâlnește o pereche blocantă
for (ax, ay), (bx, by) in perechi_blocante:
if (x, y) == (ax, ay) and (new_x, new_y) == (bx, by):
x, y = bx, by
break
elif (x, y) == (bx, by) and (new_x, new_y) == (ax, ay):
x, y = ax, ay
break
else:
# Dacă nu se întâlnește o pereche blocantă, actualizați poziția
x, y = new_x, new_y

# Incrementați contorul de pași pentru direcția curentă
steps_count[direction] += 1

return steps_count

# Exemplu de utilizare
R = 5
semnalizatori = {
(0, 1): 'E', (4, 1): 'V', # Pereche blocantă (0,1) (4,1)
(1, 2): 'S', (1, 4): 'N', # Pereche blocantă (1,2) (1,4)
(3, 2): 'N', (4, 2): 'S', # Nu formează pereche blocantă
}
perechi_blocante = find_blocking_pairs(R, semnalizatori)
steps_count = simulate_robot(R, semnalizatori, perechi_blocante)

print(f"Perechi blocante: {perechi_blocante}")
print(f"Numărul de pași în fiecare direcție: {steps_count}")
</syntaxhighlight>

1383 - Avioane

2024-07-31T12:48:04Z

RaulOtet: Pagină nouă: “Avioane pe hârtie” este un joc ce se joacă în doi, fiecare jucător având la dispoziţie o foaie de hârtie (de matematică) şi ceva de scris. Pe foaia ta de matematică, ai desenat un caroiaj cu <code>N</code> linii şi <code>N</code> coloane. La un moment al jocului, în acest caroiaj sunt deja plasate <code>M</code> avioane, numerotate de la <code>1</code> la <code>M</code>. Fiecare avion e format din exact <code>10</code> celule (o celulă cabina, apoi <code>5<...

“Avioane pe hârtie” este un joc ce se joacă în doi, fiecare jucător având la dispoziţie o foaie de hârtie (de matematică) şi ceva de scris.

Pe foaia ta de matematică, ai desenat un caroiaj cu <code>N</code> linii şi <code>N</code> coloane. La un moment al jocului, în acest caroiaj sunt deja plasate <code>M</code> avioane, numerotate de la <code>1</code> la <code>M</code>. Fiecare avion e format din exact <code>10</code> celule (o celulă cabina, apoi <code>5</code> celule aripa mare, o celulă culoar şi <code>3</code> celule aripa mică). Avioanele desenate nu se suprapun şi în funcţie de modul în care sunt amplasate pot fi de <code>4</code> tipuri:

* <code>1</code> – cabina orientată spre nord;
* <code>2</code> – cabina orientată spre est.
* <code>3</code> – cabina orientată spre sud;
* <code>4</code> – cabina orientată spre vest.

Pentru a putea identifica un avion pe foaie, toate celulele acoperite de avion sunt marcate cu numărul de ordine al avionului. Poziţiile neacoperite de avioane au valoarea <code>0</code>.

Adversarul, fără a vedea foaia ta, lansează <code>L</code> lovituri. Fiecare lovitură afectează o singură celulă a caroiajului. Dacă loviturile afectează cel puţin una dintre celulele acoperite de un avion, se consideră că avionul a fost avariat. Un avion avariat este considerat avion doborât dacă a fost lovită cabina sa sau cel puțin <code>5</code> celule dintre cele <code>10</code> ale sale.

Dată fiind configuraţia caroiajului şi poziţiile loviturilor lansate de adversar, să se determine:

a. numărul total de avioane desenate în caroiaj;

b. numărul de avioane de fiecare tip;

c. numărul de avioane avariate, fără a fi doborâte;

d. numărul de avioane doborâte.

= Date de intrare =
Fişierul <code>avioane.in</code> conţine pe prima linie numerele naturale <code>N L</code>, reprezentând dimensiunea caroiajului, respectiv numărul de lovituri lansate de adversar. Pe următoarele <code>N</code> linii se vor găsi câte <code>N</code> numere naturale, reprezentând configuraţia caroiajului, conform specificaţiilor din enunţ. Pe următoarele <code>L</code> linii se află câte două numere naturale <code>X Y</code>, reprezentând linia, respectiv coloana unei celule lovite. Numerele scrise pe aceeaşi linie sunt separate prin spaţii.

= Date de ieșire =
Fişierul <code>avioane.out</code> va conţine pe prima linie numărul total de avioane de pe foaie; pe următoarele <code>4</code> linii se vor scrie <code>4</code> numere naturale, câte unul pe linie, reprezentând în ordine numărul avioanelor de tip <code>1</code>, tip <code>2</code>, tip <code>3</code> și respectiv tip <code>4</code>. Pe următoarea linie se va scrie numărul de avioane avariate, care nu au fost doborâte, iar pe ultima linie va fi scris numărul de avioane doborâte.

= Restricții și precizări =

* <code>8 ≤ N ≤ 300</code>
* <code>N/2 ≤ L ≤ 2*N</code>
* Liniile şi respectiv coloanele caroiajului sunt numerotate de la <code>1</code> la <code>N</code>.

= Exemplu: =
<code>avioane.in</code>
8 5
0 0 0 0 0 0 0 0
0 0 0 0 1 1 1 0
0 0 0 0 0 1 0 0
0 0 0 1 1 1 1 1
0 0 2 2 2 1 0 0
0 0 0 2 0 0 0 0
0 2 2 2 2 2 0 0
0 0 0 2 0 0 0 0
6 6
5 3
3 6
7 3
8 5
<code>avioane.out</code>
2
0
0
2
0
2
0

=== Explicație ===
În matricea de <code>8x8</code> avem <code>2</code> avioane, ambele de tip <code>3</code>. Cabinele sunt în coordonatele <code>(5,6)</code> și <code>(8,4)</code>. Deci pe prima linie în fișierul de ieșire va fi <code>2</code>, iar pe următoarele <code>4</code> linii numărul avioanelor de fiecare tip: <code>0</code>, <code>0</code>, <code>2</code>, <code>0</code>, fiecare pe linie nouă.

În această reprezentare avem <code>5</code> lovituri. Cu cele <code>5</code> lovituri am reușit să lovim ambele avioane, fără a lovi cabina sau cel puțin <code>5</code> lovituri/avion. Astfel următoarele <code>2</code> valori din fișierul de ieșire sunt <code>2</code> și <code>0</code>.

În această diagramă nu mai putem adăuga un avion de tip <code>1</code> astfel pe ultima linie vom avea valoarea <code>0</code>.

<syntaxhighlight lang="python" line="1">
def process_game(N, M, avioane, L, lovituri):
# Initializare matrice
matrice = [[0] * N for _ in range(N)]

# Plasarea avioanelor în matrice
avion_celule = {}
avion_tip = {}

for avion in avioane:
id, tip, linie, coloana = avion
avion_celule[id] = []
avion_tip[id] = tip

if tip == 1: # cabina spre nord
coords = [(linie, coloana), (linie+1, coloana-2), (linie+1, coloana-1), (linie+1, coloana),
(linie+1, coloana+1), (linie+1, coloana+2), (linie+2, coloana),
(linie+3, coloana-1), (linie+3, coloana), (linie+3, coloana+1)]
elif tip == 2: # cabina spre est
coords = [(linie, coloana), (linie-2, coloana-1), (linie-1, coloana-1), (linie, coloana-1),
(linie+1, coloana-1), (linie+2, coloana-1), (linie, coloana-2),
(linie-1, coloana-3), (linie, coloana-3), (linie+1, coloana-3)]
elif tip == 3: # cabina spre sud
coords = [(linie, coloana), (linie-1, coloana-2), (linie-1, coloana-1), (linie-1, coloana),
(linie-1, coloana+1), (linie-1, coloana+2), (linie-2, coloana),
(linie-3, coloana-1), (linie-3, coloana), (linie-3, coloana+1)]
elif tip == 4: # cabina spre vest
coords = [(linie, coloana), (linie-2, coloana+1), (linie-1, coloana+1), (linie, coloana+1),
(linie+1, coloana+1), (linie+2, coloana+1), (linie, coloana+2),
(linie-1, coloana+3), (linie, coloana+3), (linie+1, coloana+3)]

for coord in coords:
r, c = coord
if 0 <= r < N and 0 <= c < N:
matrice[r][c] = id
avion_celule[id].append((r, c))

# Procesarea loviturilor
lovituri_set = set(lovituri)

avioane_doborate = 0
avioane_avariate = 0

for id, celule in avion_celule.items():
lovituri_in_celule = [celula for celula in celule if celula in lovituri_set]
numar_lovituri = len(lovituri_in_celule)
cabina_lovita = celule[0] in lovituri_set

if numar_lovituri >= 5 or cabina_lovita:
avioane_doborate += 1
elif numar_lovituri > 0:
avioane_avariate += 1

# Numărarea tipurilor de avioane
tipuri_avioane = {1: 0, 2: 0, 3: 0, 4: 0}
for tip in avion_tip.values():
tipuri_avioane[tip] += 1

return M, tipuri_avioane, avioane_avariate, avioane_doborate

# Exemplu de utilizare
N = 10
M = 2
avioane = [
(1, 1, 2, 2), # avion 1, tip 1 (nord), cabina la (2, 2)
(2, 2, 5, 5) # avion 2, tip 2 (est), cabina la (5, 5)
]
L = 3
lovituri = [(2, 2), (5, 5), (4, 5)]

total_avioane, tipuri_avioane, avioane_avariate, avioane_doborate = process_game(N, M, avioane, L, lovituri)
print(f"Numărul total de avioane: {total_avioane}")
print(f"Numărul de avioane de fiecare tip: {tipuri_avioane}")
print(f"Numărul de avioane avariate, fără a fi doborâte: {avioane_avariate}")
print(f"Numărul de avioane doborâte: {avioane_doborate}")
</syntaxhighlight>

3632 - Matrix replace

2024-07-31T12:45:54Z

RaulOtet: Pagină nouă: Aky, un elev pasionat de matematică, analiza într-o zi curios o matrice pătratică de dimensiune <code>N</code>. Acesta a observat că această matrice are anumite submatrice, la rândul lor pătratice, ale căror elemente sunt egale. Astfel și-a pus o întrebare: pentru o matrice dată, care este submatricea pătratică de dimensiune maximă a acesteia cu toate elementele egale pe care o pot obține, știind că am voie să schimb valoarea a maxim <code>K</code> elemente...

Aky, un elev pasionat de matematică, analiza într-o zi curios o matrice pătratică de dimensiune <code>N</code>. Acesta a observat că această matrice are anumite submatrice, la rândul lor pătratice, ale căror elemente sunt egale. Astfel și-a pus o întrebare: pentru o matrice dată, care este submatricea pătratică de dimensiune maximă a acesteia cu toate elementele egale pe care o pot obține, știind că am voie să schimb valoarea a maxim <code>K</code> elemente din matricea dată cu orice valoare consider și care este numărul minim de elemente ce trebuie schimbate pentru a obține o astfel de submatrice. Acesta ar rezolva problema de unul singur, dar este ocupat chiar acum deci vă cere vouă ajutorul!

= Date de intrare =
Fișierul de intrare <code>matrix_replace.in</code> conține pe prima linie numerele <code>N</code> și <code>K</code>, reprezentând dimensiunea matricei inițiale, respectiv câte elemente am voie maxim să schimb din aceasta, iar pe următoarele <code>N</code> linii câte <code>N</code> numere naturale reprezentând elementele matricei inițiale.

= Date de ieșire =
Fișierul de ieșire <code>matrix_replace.out</code> va conține pe prima linie numărele <code>D M</code>, reprezentând dimesiunea maximă a unei submatrice cu proprietatea din enunț, respectiv numărul minim de elemente ale căror valori trebuie schimbate pentru a obține această submatrice.

= Restricții și precizări =

* <code>1 ≤ N ≤ 150</code>
* <code>0 ≤ K ≤ N * N</code>
* elementele matricei vor fi numere naturale mai mici sau egale ca <code>100</code>
* pentru o matrice dată, o submatrice a acesteia având coordonatele colțului stânga-sus <code>x1 y1</code> și coordonatele colțului dreapta-jos <code>x2 y2</code> este formată din toate elementele din matrice având indicele liniei în intervalul <code>[x1, x2]</code> și indicele coloanei în intervalul <code>[y1, y2]</code>. Această submatrice se numește submatrice pătratică dacă are același număr de linii și coloane
* '''Subtask 1''': pentru <code>20</code> de puncte <code>N ≤ 20</code>
* '''Subtask 2''': pentru alte <code>10</code> de puncte numărul de valori distince din matrice este <code>2</code>, <code>K = 0</code> și <code>N ≤ 150</code>
* '''Subtask 3''': pentru alte <code>20</code> de puncte pot exista oricâte valori distincte în matrice, <code>N ≤ 100</code>, <code>K ≤ N * N</code> și valoarea maximă din matrice este mai mică sau egală decât <code>10</code>
* '''Subtask 4''': pentru restul punctelor se păstrează condițiile inițiale: <code>1 ≤ N ≤ 150</code>, <code>0 ≤ K ≤ N * N</code> și elementele matricei vor fi numere naturale nenule mai mici sau egale ca <code>100</code>

= Exemplu: =
<code>matrix_replace.in</code>
3 5
1 2 3
4 5 6
7 8 9
<code>matrix_replace.out</code>
2 3

=== Explicație ===
Putem de exemplu obține o submatrice pătratică de dimenisiune <code>2</code> schimbând valorile elementelor de coordonate: <code>1 2</code>, <code>2 1</code>, respectiv <code>2 2</code> cu <code>1</code>. Observăm că numărul minim de schimbări de elemente este <code>3</code>, deci în acest caz <code>K = 5</code>, numărul de schimbări maxime pe care le putem efectua, nu este atins.

<syntaxhighlight lang="python" line="1">
def preprocess_matrix(matrix, N):
# Compute the prefix sum matrix
prefix_sum = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(N):
for j in range(N):
prefix_sum[i + 1][j + 1] = matrix[i][j] + prefix_sum[i + 1][j] + prefix_sum[i][j + 1] - prefix_sum[i][j]
return prefix_sum

def num_changes_to_uniform(matrix, prefix_sum, N, size, top, left):
# Calculate the number of changes to make the submatrix uniform
total_elements = size * size
sum_elements = (prefix_sum[top + size][left + size] - prefix_sum[top + size][left]
- prefix_sum[top][left + size] + prefix_sum[top][left])
# The most frequent element will be the target, so calculate changes needed
# Assume the target value is 1
changes_if_target_1 = total_elements - sum_elements
# Assume the target value is 0
changes_if_target_0 = sum_elements
return min(changes_if_target_1, changes_if_target_0)

def find_max_square_submatrix(matrix, N, K):
prefix_sum = preprocess_matrix(matrix, N)

max_size = 0
min_changes = float('inf')

for size in range(1, N + 1):
for i in range(N - size + 1):
for j in range(N - size + 1):
changes = num_changes_to_uniform(matrix, prefix_sum, N, size, i, j)
if changes <= K:
if size > max_size:
max_size = size
min_changes = changes
elif size == max_size:
min_changes = min(min_changes, changes)

return max_size, min_changes

# Exemplu de utilizare
N = 4
K = 3
matrix = [
[1, 0, 0, 1],
[0, 1, 0, 0],
[1, 1, 1, 0],
[1, 0, 1, 1]
]

max_size, min_changes = find_max_square_submatrix(matrix, N, K)
print(f"Dimensiunea maximă: {max_size}")
print(f"Numărul minim de schimbări: {min_changes}")
</syntaxhighlight>

1221 - PieseSah

2024-07-31T05:50:41Z

RaulOtet: Pagină nouă: = Cerința = Se consideră o tablă de șah de dimensiune <code>n</code> (alcătuită din <code>n</code> linii si <code>n</code> coloane), pe care se află <code>m</code> piese de șah, fiecare putând fi: pion, rege, regină, nebun, tură sau cal). Se dau coordonatele a <code>t</code> căsuțe de pe tablă și se cere să se verifice pentru fiecare dacă este atacată, ocupată sau neatacată de piesele care se află pe tablă . = Date de intrare = Fișierul de intrare <cod...

= Cerința =
Se consideră o tablă de șah de dimensiune <code>n</code> (alcătuită din <code>n</code> linii si <code>n</code> coloane), pe care se află <code>m</code> piese de șah, fiecare putând fi: pion, rege, regină, nebun, tură sau cal). Se dau coordonatele a <code>t</code> căsuțe de pe tablă și se cere să se verifice pentru fiecare dacă este atacată, ocupată sau neatacată de piesele care se află pe tablă .

= Date de intrare =
Fișierul de intrare <code>piesesah.in</code> conține pe prima linie trei numere <code>n m t</code>. Următoarele <code>m</code> linii conțin un caracter, literă mică (reprezentând tipul piesei) urmat de două numere naturale reprezentând coordonatele piesei. Următoarele <code>t</code> linii conțin câte două numere naturale reprezentând coordonatele unei căsuțe care trebuie verificată.

= Date de ieșire =
Fișierul de ieșire <code>piesesah.out</code> va conține pe <code>t</code> linii câte un singur număr natural <code>0</code> , <code>1</code> sau <code>2</code>, după cum căsuța corespunzătoare este neatacată, atacată sau ocupată.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* <code>1 ≤ m < n * n</code>
* <code>1 ≤ t ≤ 50000</code>
* Nu vor exista două piese pe aceeași poziție;
* Caracterele care precizează piesele de pe tablă pot fi:
** <code>p</code> – pion;
** <code>r</code> – rege;
** <code>q</code> – regină;
** <code>n</code> – nebun;
** <code>t</code> – tură;
** <code>c</code> – cal;
* Piesele de pe tablă atacă astfel:
** regele atacă oricare dintre cele <code>8</code> căsuțe vecine pe linie, coloană sau diagonale, situate pe tablă;
** pionul atacă oricare dintre cele <code>4</code> căsuțe vecine pe diagonale, situate pe tablă;
** calul atacă oricare dintre <code>8</code> căsuțe, situate pe tablă, în care poate ajunge sărind în <code>L</code>;
** regina atacă orice căsuță de pe tablă aflată pe aceeași linie, coloană sau diagonală cu ea, dar până la întâlnirea altei piese;
** nebunul atacă orice căsuță de pe tablă aflată pe aceeași diagonală cu el, dar până la întâlnirea altei piese;
** tura atacă orice căsuță de pe tablă aflată pe aceeași linie sau coloană cu ea, dar până la întâlnirea altei piese;

= Exemplu =
<code>piesesah.in</code>
10 6 10
p 1 1
r 8 9
q 3 2
n 6 7
t 2 9
c 9 3
1 1
5 5
2 3
5 2
9 6
8 9
10 10
9 2
2 2
7 2
<code>piesesah.out</code>
2
0
1
1
0
2
0
1
1
1

=== Explicație ===
Tabla de șah arată astfel:
2 1 0 1 0 0 0 0 1 0
1 1 1 1 1 1 1 1 2 1
1 2 1 1 1 1 1 1 1 1
1 1 1 0 1 0 0 0 1 0
0 1 0 1 0 1 0 1 1 0
0 1 0 0 1 0 2 0 1 0
0 1 0 1 0 1 0 1 1 1
1 1 0 0 1 0 1 1 2 1
0 1 2 1 0 0 0 1 1 1
1 1 1 0 1 0 0 0 1 0
<syntaxhighlight lang="python" line="1">
def attack_positions_pawn(x, y, color, n):
attacks = []
if color == 'white':
if x > 0 and y > 0:
attacks.append((x - 1, y - 1))
if x > 0 and y < n - 1:
attacks.append((x - 1, y + 1))
else: # black
if x < n - 1 and y > 0:
attacks.append((x + 1, y - 1))
if x < n - 1 and y < n - 1:
attacks.append((x + 1, y + 1))
return attacks

def attack_positions_king(x, y, n):
attacks = []
for dx in range(-1, 2):
for dy in range(-1, 2):
if dx == 0 and dy == 0:
continue
if 0 <= x + dx < n and 0 <= y + dy < n:
attacks.append((x + dx, y + dy))
return attacks

def attack_positions_knight(x, y, n):
moves = [(2, 1), (1, 2), (-1, 2), (-2, 1), (-2, -1), (-1, -2), (1, -2), (2, -1)]
attacks = []
for dx, dy in moves:
if 0 <= x + dx < n and 0 <= y + dy < n:
attacks.append((x + dx, y + dy))
return attacks

def attack_positions_bishop(x, y, n):
attacks = []
for i in range(1, n):
if 0 <= x + i < n and 0 <= y + i < n:
attacks.append((x + i, y + i))
if 0 <= x - i < n and 0 <= y + i < n:
attacks.append((x - i, y + i))
if 0 <= x + i < n and 0 <= y - i < n:
attacks.append((x + i, y - i))
if 0 <= x - i < n and 0 <= y - i < n:
attacks.append((x - i, y - i))
return attacks

def attack_positions_rook(x, y, n):
attacks = []
for i in range(1, n):
if 0 <= x + i < n:
attacks.append((x + i, y))
if 0 <= x - i < n:
attacks.append((x - i, y))
if 0 <= y + i < n:
attacks.append((x, y + i))
if 0 <= y - i < n:
attacks.append((x, y - i))
return attacks

def attack_positions_queen(x, y, n):
return attack_positions_bishop(x, y, n) + attack_positions_rook(x, y, n)

def is_attacked(board, x, y):
return board[x][y] == 1

def main():
# Citirea dimensiunii tablei de șah
n = int(input().strip())

# Citirea numărului de piese
m = int(input().strip())

# Inițializarea tablei de șah
board = [[0] * n for _ in range(n)]

# Citirea pieselor și plasarea lor pe tabla de șah
for _ in range(m):
piece_info = input().strip().split()
piece_type = piece_info[0]
x = int(piece_info[1]) - 1 # Transformare la index 0
y = int(piece_info[2]) - 1 # Transformare la index 0
color = piece_info[3] if len(piece_info) > 3 else None # doar pentru pion

# Marcare poziție ocupată
board[x][y] = 2

# Obținerea pozițiilor atacate
if piece_type == "pion":
attacks = attack_positions_pawn(x, y, color, n)
elif piece_type == "rege":
attacks = attack_positions_king(x, y, n)
elif piece_type == "regina":
attacks = attack_positions_queen(x, y, n)
elif piece_type == "nebun":
attacks = attack_positions_bishop(x, y, n)
elif piece_type == "tura":
attacks = attack_positions_rook(x, y, n)
elif piece_type == "cal":
attacks = attack_positions_knight(x, y, n)

# Marcare poziții atacate
for ax, ay in attacks:
board[ax][ay] = max(board[ax][ay], 1)

# Citirea coordonatelor ce trebuiesc verificate
t = int(input().strip())
for _ in range(t):
x, y = map(int, input().strip().split())
x -= 1 # Transformare la index 0
y -= 1 # Transformare la index 0

if board[x][y] == 2:
print("ocupata")
elif board[x][y] == 1:
print("atacata")
else:
print("neatacata")

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

3972 - Wall

2024-07-31T05:48:51Z

RaulOtet: Pagină nouă: = Cerința = Se dă un șir de <code>N</code> numere întregi. Să se afle numărul de subsecvențe ale șirului pentru care diferența dintre elementul lor de valoare maximă și cel de valoare minimă este mai mică sau egală decât un număr întreg <code>T</code> dat. = Date de intrare = Programul citește de la tastatură numerele <code>N</code> și <code>T</code>, iar apoi <code>N</code> numere întregi, separate prin spații. = Date de ieșire = Programul va afișa...

= Cerința =
Se dă un șir de <code>N</code> numere întregi. Să se afle numărul de subsecvențe ale șirului pentru care diferența dintre elementul lor de valoare maximă și cel de valoare minimă este mai mică sau egală decât un număr întreg <code>T</code> dat.

= Date de intrare =
Programul citește de la tastatură numerele <code>N</code> și <code>T</code>, iar apoi <code>N</code> numere întregi, separate prin spații.

= Date de ieșire =
Programul va afișa pe ecran numărul de subsecvențe ale șirului dat care respectă condiția din enunț.

= Restricții și precizări =

* <code>1 ≤ N ≤ 1.000.000</code>
* <code>0 ≤ T ≤ 2.000.000.000</code>
* cele <code>N</code> numere citite vor fi din intervalul <code>[-1.000.000.000, 1.000.000.000]</code>
* se numește subsecvență a unui șir o succesiune de elemente consecutive din acesta, considerate în ordinea în care apar în șir
* pentru teste în valoare de <code>30</code> de puncte <code>N ≤ 10.000</code>
* pentru teste în valoare de <code>70</code> de puncte <code>N ≤ 600.000</code>

= Exemplu: =
'''Intrare'''
5 2
1 7 2 3 4
'''Ieșire'''
8

=== Explicație ===
Cele <code>8</code> subsecvențe care respectă condiția din enunț sunt toate cele <code>5</code> care conțin un singur element(diferența dintre elementul maxim și cel minim fiind astfel <code>0</code>), respectiv cele delimitate de perechile de indecși <code>[3, 4], [3, 5], [4, 5]</code>(șirul se consideră a fi indexat de la <code>1</code>).

<syntaxhighlight lang="python" line="1">
from collections import deque

def num_subsequences_with_condition(arr, N, T):
min_deque = deque()
max_deque = deque()
start = 0
count = 0

for end in range(N):
while min_deque and arr[min_deque[-1]] >= arr[end]:
min_deque.pop()
while max_deque and arr[max_deque[-1]] <= arr[end]:
max_deque.pop()

min_deque.append(end)
max_deque.append(end)

while arr[max_deque[0]] - arr[min_deque[0]] > T:
start += 1
if min_deque[0] < start:
min_deque.popleft()
if max_deque[0] < start:
max_deque.popleft()

count += (end - start + 1)

return count

# Citirea datelor de intrare
N = int(input())
arr = list(map(int, input().split()))
T = int(input())

# Calcularea și afișarea rezultatului
result = num_subsequences_with_condition(arr, N, T)
print(result)
</syntaxhighlight>

0726 - Acoperire 1

2024-07-31T05:47:36Z

RaulOtet: Pagină nouă: Dintr-o suprafaţă pătrată cu latura de <code>N</code> unităţi care este formată din <code>N*N</code> pătrăţele cu latura de o unitate se decupează cele <code>4</code> pătrăţele din colţuri. = Cerința = Determinaţi o modalitate de a acoperi suprafaţa în întregime cu piese de arie <code>4</code> unităţi care au forma următoare: Piesele pot fi si rotite sau întoarse putând astfel să folosim toate cele <code>8</code> moduri de a le aşeza. = Date de i...

Dintr-o suprafaţă pătrată cu latura de <code>N</code> unităţi care este formată din <code>N*N</code> pătrăţele cu latura de o unitate se decupează cele <code>4</code> pătrăţele din colţuri.

= Cerința =
Determinaţi o modalitate de a acoperi suprafaţa în întregime cu piese de arie <code>4</code> unităţi care au forma următoare:

Piesele pot fi si rotite sau întoarse putând astfel să folosim toate cele <code>8</code> moduri de a le aşeza.

= Date de intrare =
Fișierul de intrare <code>acoperire1.in</code> conține pe prima linie un număr natural <code>N</code>, cu semnificaţia din enunţ.

= Date de ieșire =
Fișierul de ieșire <code>acoperire1.out</code> va conține valoarea <code>-1</code> pe prima linie dacă problema nu are soluţie, iar în caz contrar va avea următoarea structură: <code>N</code> linii cu câte <code>N</code> valori fiecare reprezentând codificarea suprafeţei. Numerele de pe aceeaşi linie sunt separate prin câte un spaţiu. Poziţiile ocupate de prima piesă aşezată se vor codifica cu <code>1</code>, poziţiile ocupate de a doua piesă aşezată se vor codifica cu <code>2</code> etc. Corespunzător colţurilor lipsă se va scrie valoarea <code>0</code>.

= Restricții și precizări =

* <code>6 ≤ n ≤ 200</code>
* Piesele trebuie să fie complet în interiorul zonei;
* Zona trebuie acoperită integral;
* Două piese nu se pot suprapune complet sau parţial;

= Exemplu: =
<code>acoperire1.in</code>
6
<code>acoperire1.out</code>
0 7 2 2 2 0
3 7 2 4 4 4
3 7 7 4 5 5
3 3 6 1 1 5
6 6 6 8 1 5
0 8 8 8 1 0
<syntaxhighlight lang="python" line="1">
def place_l_tiles(board, n, top_left_row, top_left_col):
# n - dimension of the current board (n x n)
if n == 2:
# Base case: only one tile can fit, as 4 cells are considered and one corner is missing
for i in range(2):
for j in range(2):
if board[top_left_row + i][top_left_col + j] == 0:
board[top_left_row + i][top_left_col + j] = 1
return

half = n // 2
# Find the center tile to place the L-shaped tromino around
# (middle of the top-left, top-right, bottom-left, bottom-right quarters)
center_r, center_c = top_left_row + half - 1, top_left_col + half - 1

# Determine which quadrant is missing the corner cell
if board[top_left_row][top_left_col] == -1:
missing_quad = 0
elif board[top_left_row][top_left_col + n - 1] == -1:
missing_quad = 1
elif board[top_left_row + n - 1][top_left_col] == -1:
missing_quad = 2
elif board[top_left_row + n - 1][top_left_col + n - 1] == -1:
missing_quad = 3

# Fill the center of the current board with a L-shaped tromino
tiles = [(center_r, center_c), (center_r, center_c + 1), (center_r + 1, center_c), (center_r + 1, center_c + 1)]
# We have four quadrants (0: top-left, 1: top-right, 2: bottom-left, 3: bottom-right)
for idx, (i, j) in enumerate(tiles):
if idx != missing_quad:
board[i][j] = 1

# Recursively fill each of the four quadrants
# Top-left quadrant
place_l_tiles(board, half, top_left_row, top_left_col)
# Top-right quadrant
place_l_tiles(board, half, top_left_row, top_left_col + half)
# Bottom-left quadrant
place_l_tiles(board, half, top_left_row + half, top_left_col)
# Bottom-right quadrant
place_l_tiles(board, half, top_left_row + half, top_left_col + half)

# Initialize the board
N = 4 # Example value, should be a power of 2
board = [[0 for _ in range(N)] for _ in range(N)]

# Remove corners
board[0][0] = -1
board[0][N-1] = -1
board[N-1][0] = -1
board[N-1][N-1] = -1

# Place L-shaped tiles starting from the top-left corner of the board
place_l_tiles(board, N, 0, 0)

# Print the board
for row in board:
print(' '.join(str(cell) for cell in row))
</syntaxhighlight>

4128 - Iluminat

2024-07-31T05:46:06Z

RaulOtet: Pagină nouă: Primarul orașului X dorește să aibă un iluminat public modern. Pentru aceasta, realizează o schiță sub forma unui pătrat cu <code>n</code> linii și <code>n</code> coloane în care fiecare element situat la intersecția unei linii cu o coloană reprezintă un cartier. Primarul a calculat pentru fiecare cartier care este numărul de stâlpi de iluminat public din acel cartier. Fiecare stâlp are un singur bec care inițial este aprins. Acesta a observat un lucru inter...

Primarul orașului X dorește să aibă un iluminat public modern. Pentru aceasta, realizează o schiță sub forma unui pătrat cu <code>n</code> linii și <code>n</code> coloane în care fiecare element situat la intersecția unei linii cu o coloană reprezintă un cartier.

Primarul a calculat pentru fiecare cartier care este numărul de stâlpi de iluminat public din acel cartier. Fiecare stâlp are un singur bec care inițial este aprins. Acesta a observat un lucru interesant: toate cartierele au un număr diferit de stâlpi de iluminare, iar valoarea maximă a numărului de stâlpi dintr-un cartier este <code>n2</code>.

Pentru a fi realizată într-un mod cât mai eficient, stingerea becurilor se realizează în următorul mod:

* în prima etapă se sting becurile din cartierul cu număr maxim de stâlpi de iluminat, ceea ce duce la stingerea becurilor din cartierele de pe aceeași linie precum și din cele pe aceeași coloană cu cartierul cu număr maxim de stâlpi.
* procedeul se reia la fiecare etapă pentru toate cartierele în care nu au fost stinse becurile, până când rămâne un singur cartier iluminat.

= Cerința =
Cunoscând numerele naturale nenule <code>n</code> și <code>k</code>, precum și numărul de stâlpi de iluminat din fiecare cartier, să se determine:

* Câți stâlpi de iluminat se află în cartierul cu număr maxim de stâlpi de iluminat la etapa cu numărul <code>k</code> din procedeul de stingere a becurilor?
* Câte becuri se sting, în total, la etapa cu numărul <code>k</code>?
* Care este numărul maxim de becuri aprinse într-o zonă pătratică a orașului de dimensiune <code>k x k</code>, înainte de a începe stingerea becurilor?

= Date de intrare =
Fișierul de intrare <code>iluminat.in</code> conține pe prima linie o cifră <code>c</code> (<code>1</code>, <code>2</code> sau <code>3</code>), reprezentând cerința cerută. Pe linia următoare se găsesc două numere naturale nenule <code>n</code> și <code>k</code>, separate printr-un spațiu. Pe următoarele <code>n</code> linii se află <code>n2</code> numere naturale distincte, câte <code>n</code> pe fiecare linie, separate prin câte un spațiu, cu semnificația din enunț.

= Date de ieșire =
În fișierul de ieșire <code>iluminat.out</code> se va afișa răspunsul în funcție de cerință:

* dacă <code>c = 1</code> se va afișa pe prima linie un singur număr reprezentând numărul de stâlpi de iluminat din cartierul cu număr maxim de stâlpi de iluminat la etapa <code>k</code>
* dacă <code>c = 2</code> se va afișa pe prima linie un singur număr reprezentând câte becuri se sting, în total, la etapa cu numărul <code>k</code>
* dacă <code>c = 3</code> se va afișa numărul maxim de becuri aprinse într-o zonă pătratică de dimensiune <code>k x k</code> înainte de stingerea becurilor

= Restricții și precizări =

* <code>c ∈ {1, 2, 3}</code>
* <code>1 ≤ k < n ≤ 1000</code>
* Numărul de becuri din fiecare cartier este mai mic sau egal cu <code>n2</code>

= Exemplu: =
<code>iluminat.in</code>
1
4 2
1 2 3 4
16 13 5 6
12 9 7 14
10 11 8 15
<code>iluminat.out</code>
15

=== Explicație ===
Cerința este <code>1</code>. Se sting becurile din cartierul având <code>16</code> stâlpi de iluminat, ceea ce duce la stingerea becurilor de pe stâlpii din linia <code>2</code> și din coloana <code>1</code>. Tabloul devine:

<code>0 2 3 4</code>

<code>0 0 0 0</code>

<code>0 9 7 14</code>

<code>0 11 8 15</code>

La etapa a doua, primul cartier în care se sting becurile are <code>15</code> stâlpi de iluminat.

<syntaxhighlight lang="python" line="1">
import numpy as np

def generate_matrix(n):
return np.arange(1, n*n + 1).reshape(n, n)

def find_max_and_sting(matrix):
max_value = np.max(matrix)
max_index = np.unravel_index(np.argmax(matrix, axis=None), matrix.shape)
row, col = max_index
matrix[row, :] = 0
matrix[:, col] = 0
return max_value, np.count_nonzero(matrix == 0)

def max_bulbs_in_kxk(matrix, k):
max_sum = 0
for i in range(matrix.shape[0] - k + 1):
for j in range(matrix.shape[1] - k + 1):
submatrix_sum = np.sum(matrix[i:i+k, j:j+k])
if submatrix_sum > max_sum:
max_sum = submatrix_sum
return max_sum

def stage_results(n, k):
matrix = generate_matrix(n)
original_matrix = matrix.copy()

max_value_at_k = 0
total_sting_at_k = 0

for stage in range(1, k + 1):
max_value, sting_count = find_max_and_sting(matrix)
if stage == k:
max_value_at_k = max_value
total_sting_at_k = sting_count

max_in_kxk_before_sting = max_bulbs_in_kxk(original_matrix, k)

return max_value_at_k, total_sting_at_k, max_in_kxk_before_sting

# Citirea datelor de intrare
n = int(input())
k = int(input())

# Calcularea și afișarea rezultatelor
max_value_at_k, total_sting_at_k, max_in_kxk_before_sting = stage_results(n, k)

print(max_value_at_k)
print(total_sting_at_k)
print(max_in_kxk_before_sting)
</syntaxhighlight>

3651 - Ghem

2024-07-31T05:44:04Z

RaulOtet: Pagină nouă: Se consideră un tablou cu <code>N</code> linii și <code>N</code> coloane ce conține numerele naturale de la <code>1</code> la <code>N2</code> așezate consecutiv, întâi pe linii și apoi pe coloane, începând cu <code>1</code> în colțul din stânga sus, conform exemplului alăturat (<code>N = 4</code>). Dacă se derulează elemente tabloului, asemănător cu un ghem, prin rotirea tabloului în jurul centrului (intersecția diagonalelor), trăgând de unul...

Se consideră un tablou cu <code>N</code> linii și <code>N</code> coloane ce conține numerele naturale de la <code>1</code> la <code>N2</code> așezate consecutiv, întâi pe linii și apoi pe coloane, începând cu <code>1</code> în colțul din stânga sus, conform exemplului alăturat (<code>N = 4</code>).

Dacă se derulează elemente tabloului, asemănător cu un ghem, prin rotirea tabloului în jurul centrului (intersecția diagonalelor), trăgând de unul din colțurile sale pe orizontală sau pe verticală, către exterior, se obține un șir cu numerele de la <code>1</code> la <code>N2</code>, într-o anumită ordine.

Exemple: dacă <code>N = 4</code> și se va trage de:

* colțul din stânga sus – pe orizontală, se va obține șirul: <code>1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10</code>;
* colțul din dreapta jos – pe verticală, se va obține șirul: <code>16 12 8 4 3 2 1 5 9 13 14 15 11 7 6 10</code>;

= Cerința =
Să se scrie un program care citește:

* un numărul natural <code>N</code>, ce reprezintă numărul de linii și de coloane al unui tablou ce conține numerele naturale de la <code>1</code> la <code>N2</code>;
* două numere naturale <code>X</code> și <code>Y</code>, ce reprezintă coordonatele colțului de unde se face derularea: { <code>(1,1) – stânga sus</code>; <code>(1,N) – dreapta sus</code>; <code>(N,N) – dreapta jos</code>; <code>(N,1) – stânga jos;</code>}
* un caracter <code>D</code> (majusculă), ce reprezintă direcția pe care se face tragerea (<code>O</code> – orizontală și <code>V</code> – verticală).

și afișează șirul de numere ce rezultă din desfășurarea tabloului, începând cu colțul de unde se face tragerea și pe

direcția de tragere.

= Date de intrare =
Fișierul de intrare <code>ghem.in</code> conţine pe prima linie numărul natural <code>N</code>, pe a doua linie două numere naturale <code>X</code> și <code>Y</code> despărțite printr-un spațiu, iar pe a treia linie caracterul <code>D</code>, având semnificația de mai sus.

= Date de ieșire =
Fișierul de ieșire <code>ghem.out</code> va conţine pe primul rând șirul de numere obținut prin desfășurarea tabloului.

Între oricare două numere succesive va exista un singur spațiu.

= Restricții și precizări =

* <code>2 ≤ N ≤ 500</code>• <code>(X,Y)</code> aparține mulțimii <code>{(1,1), (1,N), (N,N), (N,1)}</code>; • <code>D</code> aparține mulțimii <code>{’O’,’V’}</code> – majuscule;

= Exemplu: =
<code>ghem.in</code>
4
1 1
O
<code>ghem.out</code>
1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10

=== Explicație ===
Matricea alăturată se desfășoară “trăgând” de colțul din stânga sus în direcție orizontală obținându-se șirul: <code>1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10</code>

<syntaxhighlight lang="python" line="1">
def generate_matrix(N):
matrix = []
num = 1
for i in range(N):
row = []
for j in range(N):
row.append(num)
num += 1
matrix.append(row)
return matrix

def spiral_from_top_left(matrix, N):
result = []
top, left, bottom, right = 0, 0, N - 1, N - 1
while top <= bottom and left <= right:
for i in range(left, right + 1):
result.append(matrix[top][i])
top += 1
for i in range(top, bottom + 1):
result.append(matrix[i][right])
right -= 1
if top <= bottom:
for i in range(right, left - 1, -1):
result.append(matrix[bottom][i])
bottom -= 1
if left <= right:
for i in range(bottom, top - 1, -1):
result.append(matrix[i][left])
left += 1
return result

def spiral_from_bottom_right(matrix, N):
result = []
bottom, right, top, left = N - 1, N - 1, 0, 0
while bottom >= top and right >= left:
for i in range(right, left - 1, -1):
result.append(matrix[bottom][i])
bottom -= 1
for i in range(bottom, top - 1, -1):
result.append(matrix[i][left])
left += 1
if bottom >= top:
for i in range(left, right + 1):
result.append(matrix[top][i])
top += 1
if right >= left:
for i in range(top, bottom + 1):
result.append(matrix[i][right])
right -= 1
return result

def spiral_from_top_right(matrix, N):
result = []
top, right, bottom, left = 0, N - 1, N - 1, 0
while top <= bottom and right >= left:
for i in range(top, bottom + 1):
result.append(matrix[i][right])
right -= 1
for i in range(right, left - 1, -1):
result.append(matrix[bottom][i])
bottom -= 1
if right >= left:
for i in range(bottom, top - 1, -1):
result.append(matrix[i][left])
left += 1
if top <= bottom:
for i in range(left, right + 1):
result.append(matrix[top][i])
top += 1
return result

def spiral_from_bottom_left(matrix, N):
result = []
bottom, left, top, right = N - 1, 0, 0, N - 1
while bottom >= top and left <= right:
for i in range(left, right + 1):
result.append(matrix[bottom][i])
bottom -= 1
for i in range(bottom, top - 1, -1):
result.append(matrix[i][right])
right -= 1
if left <= right:
for i in range(right, left - 1, -1):
result.append(matrix[top][i])
top += 1
if bottom >= top:
for i in range(top, bottom + 1):
result.append(matrix[i][left])
left += 1
return result

def get_spiral_order(N, X, Y, D):
matrix = generate_matrix(N)

if (X, Y) == (1, 1):
if D == 'O':
return spiral_from_top_left(matrix, N)
else:
return spiral_from_bottom_left(matrix, N)[::-1]
elif (X, Y) == (1, N):
if D == 'O':
return spiral_from_top_right(matrix, N)
else:
return spiral_from_top_left(matrix, N)[::-1]
elif (X, Y) == (N, N):
if D == 'O':
return spiral_from_bottom_right(matrix, N)
else:
return spiral_from_top_right(matrix, N)[::-1]
elif (X, Y) == (N, 1):
if D == 'O':
return spiral_from_bottom_left(matrix, N)
else:
return spiral_from_bottom_right(matrix, N)[::-1]

# Citirea datelor de intrare
N = int(input())
X = int(input())
Y = int(input())
D = input().strip()

# Generarea și afișarea șirului de numere
result = get_spiral_order(N, X, Y, D)
print(" ".join(map(str, result)))
</syntaxhighlight>

1129 - Tinta

2024-07-30T15:08:26Z

RaulOtet: Pagină nouă: Alex are o pasiune pentru trasul la țintă. Jucându-se cu numere, visează la o nouă tablă pentru pasiunea sa. Tabla visată este de formă pătrată cu <code>n</code> linii și <code>n</code> coloane, iar numerele, de la <code>1</code> la <code>n * n</code>, le poziționează în țintă, ca în imaginea alăturată. Alex, fiind un foarte bun țintaș, nu nimerește niciodată pe pătrățelele de pe contur. Când țintește o pătrățică din interior, el obține dre...

Alex are o pasiune pentru trasul la țintă. Jucându-se cu numere, visează la o nouă tablă pentru pasiunea sa. Tabla visată este de formă pătrată cu <code>n</code> linii și <code>n</code> coloane, iar numerele, de la <code>1</code> la <code>n * n</code>, le poziționează în țintă, ca în imaginea alăturată.

Alex, fiind un foarte bun țintaș, nu nimerește niciodată pe pătrățelele de pe contur. Când țintește o pătrățică din interior, el obține drept punctaj suma valorilor din cele opt pătrățele vecine.

= Cerinţă =
Cunoscând n numărul de linii și de coloane ale țintei:

'''a.''' Ajutați-l pe Alex să construiască ținta visată.

'''b.''' Câte punctaje distincte poate să obțină Alex dacă are o singură săgeată?

'''c.''' Afișați punctajele distincte găsite.

= Date de intrare =
Fișierul de intrare <code>tinta.in</code> conține pe prima linie numărul natural <code>n</code>, indicând numărul de linii și de coloane ale țintei.

= Date de ieșire =
Fișierul de ieșire <code>tinta.out</code> va conține pe primele <code>n</code> linii câte <code>n</code> numere naturale, separate prin câte un spațiu, reprezentând numerele de pe cele <code>n</code> linii ale țintei. Pe linia <code>n+1</code> se va afișa un singur număr <code>p</code> reprezentând numărul de punctaje distincte. Pe linia <code>n+2</code> se vor afișa <code>p</code> numere naturale separate prin câte un spațiu și ordonate strict crescător, reprezentând punctajele distincte.

= Restricții și precizări =

* <code>3 ≤ n ≤ 1000</code>
* Pentru prima cerinţă afişată corect se va acorda 40% din punctaj; pentru a doua cerință se va acorda 20% din punctaj; pentru cea de-a treia cerință se va acorda 40% din punctaj.

= Exemplul 1 =
<code>tinta.in</code>
3
<code>tinta.out</code>
1 2 6
3 5 7
4 8 9
1
40

= Explicație =
Alex poate ținti doar în pătrățelul interior (cel pe care avem <code>5</code>), deci obține un singur punctaj, iar suma este <code>40</code>.

= Exemplul 2 =
<code>tinta.in</code>
4
<code>tinta.out</code>
1 2 6 7
3 5 8 13
4 9 12 14
10 11 15 16
3
45 68 91

= Explicație =
Alex poate ținti doar pătrăţelele <code>5</code>, <code>8</code>, <code>9</code> sau <code>12</code>.

<syntaxhighlight lang="python" line="1">
def create_spiral_matrix(n):
matrix = [[0] * n for _ in range(n)]
num = 1
left, right, top, bottom = 0, n - 1, 0, n - 1

while left <= right and top <= bottom:
for i in range(left, right + 1):
matrix[top][i] = num
num += 1
top += 1
for i in range(top, bottom + 1):
matrix[i][right] = num
num += 1
right -= 1
for i in range(right, left - 1, -1):
matrix[bottom][i] = num
num += 1
bottom -= 1
for i in range(bottom, top - 1, -1):
matrix[i][left] = num
num += 1
left += 1

return matrix

def calculate_scores(matrix, n):
scores = set()
for i in range(1, n - 1):
for j in range(1, n - 1):
score = (matrix[i - 1][j - 1] + matrix[i - 1][j] + matrix[i - 1][j + 1] +
matrix[i][j - 1] + matrix[i][j + 1] +
matrix[i + 1][j - 1] + matrix[i + 1][j] + matrix[i + 1][j + 1])
scores.add(score)
return scores

def main():
n = int(input("Introduceți valoarea lui n: "))
spiral_matrix = create_spiral_matrix(n)

print("Matricea spirală:")
for row in spiral_matrix:
print(' '.join(map(str, row)))

if n < 3:
print("Nu există pătrățele din interior pentru n < 3.")
return

scores = calculate_scores(spiral_matrix, n)
print(f"Numărul de punctaje distincte: {len(scores)}")
print("Punctajele distincte sunt:")
for score in sorted(scores):
print(score)

main()
</syntaxhighlight>

3430 - Bpj 2020

2024-07-30T15:06:43Z

RaulOtet: Pagină nouă: Gigel a descoperit noul joc Block Puzzle Jewel. Jocul se desfășoară astfel: * avem o tablă de joc sub forma unei matrice <code>8x8</code>; * sunt <code>17</code> tipuri de piese care arată așa: * după ce Gigel adaugă o piesa, pătrățelele din care este formată piesa vor ocupa zonele corespunzătoare din tabla de joc iar, iar numărul de pătrățele din care este formată piesa se va adăuga la scorul lui Gigel. De exemplu, dacă Gigel vrea să mute o piesă de t...

Gigel a descoperit noul joc Block Puzzle Jewel. Jocul se desfășoară astfel:

* avem o tablă de joc sub forma unei matrice <code>8x8</code>;
* sunt <code>17</code> tipuri de piese care arată așa:
* după ce Gigel adaugă o piesa, pătrățelele din care este formată piesa vor ocupa zonele corespunzătoare din tabla de joc iar, iar numărul de pătrățele din care este formată piesa se va adăuga la scorul lui Gigel. De exemplu, dacă Gigel vrea să mute o piesă de tipul <code>16</code> atunci ea va ocupa locurile <code>m[i][j]</code> , <code>m[i][j+1]</code> , <code>m[i][j+2]</code> , <code>m[i+1][j+2]</code> și <code>m[i+2][j+2]</code> iar scorul lui Gigel va crește cu <code>5</code> puncte sau dacă Gigel vrea să mute o piesă de tipul <code>15</code> atunci ea va ocupa locurile <code>m[i][j] , m[i][j+1] , m[i+1][j-1]</code> și <code>m[i+1][j]</code> iar scorul lui Gigel va crește cu <code>4</code> puncte.
* dacă o linie sau o coloana este completată cu pătratele atunci ea se eliberează (se elimină pătrățelele care ocupă linia/coloana).
* modul de a pozitiona o piesă este așa : <code>a l c</code>, unde <code>a</code> este tipul piesei, <code>l</code> și <code>c</code> reprezintă linia și coloana unde se va afla pătrățelul din stânga sus al piesei respective în matrice
* Dacă la o mutare se elimină:
** o linie sau o coloană , atunci Gigel primeste <code>10</code> puncte
** <code>2</code> linii și coloane liberate, atunci Gigel primește <code>30</code> de puncte
** <code>3</code> linii și coloane eliberate, atunci Gigel primește <code>60</code> de puncte
** <code>4</code> linii și coloane eliberate, atunci Gigel primește <code>100</code> de puncte
** <code>5</code> linii și coloane eliberate, atunci Gigel primește <code>150</code> de puncte
** <code>6</code> linii și coloane eliberate, atunci Gigel primește <code>500</code> de puncte

Dându-se <code>n</code>, numărul de piese pe care le va muta Gigel și piesele pe care le va muta Gigel (folosind numerele <code>a</code>, <code>l</code> și <code>c</code>), să se determine scorul final al lui Gigel.

= Date de intrare =
Fișierul de intrare <code>bpj2020.in</code> conține pe prima linie numărul <code>n</code>, iar pe următoarele <code>n</code> linii câte <code>3</code> numere <code>a l c</code> cu semnificația din enunț.

= Date de ieșire =
Fișierul de ieșire <code>bpj2020.out</code> va conține pe prima linie numărul <code>S</code>, reprezentând scorul final al lui Gigel.

= Restricții și precizări =

* <code>1 ≤ n ≤ 50</code>
* <code>1 ≤ l , c ≤ 8</code>
* <code>1 ≤ a ≤ 17</code>
* nu o să existe o piesa suprapusă peste alta și nici piese care să iasă din tabla de joc
* la început tabla de joc este goală

= Exemplu =
<code>bpj2020.in</code>
9
17 7 1
5 8 4
3 7 2
10 5 5
12 4 4
1 6 4
7 4 1
6 5 6
16 4 6
<code>bpj2020.out</code>
108
<syntaxhighlight lang="python" line="1">
# Definirea pieselor și pozițiilor lor relative
pieces = {
1: [(0, 0)],
2: [(0, 0), (0, 1)],
3: [(0, 0), (1, 0)],
4: [(0, 0), (0, 1), (1, 0)],
5: [(0, 0), (0, 1), (0, 2)],
6: [(0, 0), (1, 0), (2, 0)],
7: [(0, 0), (0, 1), (1, 1)],
8: [(0, 0), (1, 0), (1, 1)],
9: [(0, 0), (0, 1), (1, 0), (1, 1)],
10: [(0, 0), (0, 1), (0, 2), (1, 0)],
11: [(0, 0), (0, 1), (0, 2), (1, 2)],
12: [(0, 0), (1, 0), (1, 1), (1, 2)],
13: [(0, 0), (1, 0), (2, 0), (2, 1)],
14: [(0, 0), (1, 0), (2, 0), (2, -1)],
15: [(0, 0), (0, 1), (1, -1), (1, 0)],
16: [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)],
17: [(0, 0), (1, 0), (2, 0), (2, 1), (2, 2)],
}

def check_and_clear(board, n):
cleared_lines = 0
rows_to_clear = [i for i in range(n) if all(board[i][j] for j in range(n))]
cols_to_clear = [j for j in range(n) if all(board[i][j] for i in range(n))]

for row in rows_to_clear:
for j in range(n):
board[row][j] = 0
cleared_lines += 1

for col in cols_to_clear:
for i in range(n):
board[i][col] = 0
cleared_lines += 1

score_bonus = [0, 10, 30, 60, 100, 150, 500]
return cleared_lines, score_bonus[cleared_lines]

def play_game(n, moves):
board = [[0] * 8 for _ in range(8)]
score = 0

for a, l, c in moves:
for dx, dy in pieces[a]:
x, y = l + dx - 1, c + dy - 1
board[x][y] = 1
score += 1

cleared_lines, bonus = check_and_clear(board, 8)
score += bonus

return score

# Citirea inputului
n = int(input())
moves = [tuple(map(int, input().split())) for _ in range(n)]

# Calcularea scorului final
final_score = play_game(n, moves)
print(final_score)
</syntaxhighlight>

4197 - AB

2024-07-30T15:03:46Z

RaulOtet: Pagină nouă: Alice tocmai s-a decis să-și impresioneze fratele mai mic, Bob, cu abilitățile sale de deducție matematică. Astfel, ea așează într-o matrice cu <code>N</code> linii și <code>M</code> coloane toate numerele <code>1</code>, <code>2</code>, …, <code>N × M</code>, astfel încât fiecare linie și respectiv fiecare coloană, să fie sortată strict crescător. O matrice cu aceste proprietăți se numește o '''matrice AB'''. Alice îi cere apoi lui Bob să elimine <co...

Alice tocmai s-a decis să-și impresioneze fratele mai mic, Bob, cu abilitățile sale de deducție matematică. Astfel, ea așează într-o matrice cu <code>N</code> linii și <code>M</code> coloane toate numerele <code>1</code>, <code>2</code>, …, <code>N × M</code>, astfel încât fiecare linie și respectiv fiecare coloană, să fie sortată strict crescător. O matrice cu aceste proprietăți se numește o '''matrice AB'''. Alice îi cere apoi lui Bob să elimine <code>K</code> valori din matrice, care sa nu fie adiacente orizontal sau adiacente vertical. Apoi, ea va încerca să reintroducă aceste <code>K</code> valori în matrice astfel încât sa rămână o matrice AB. După câteva încercări, Alice realizează că, în anumite situații pot exista mai multe moduri de a aranja cele <code>K</code> numere pe pozițiile libere.

= Cerința =
Scrieți un program care, cunoscând matricea AB inițială și <code>Q</code> interogări, constând fiecare dintr-o listă de elemente eliminate din matrice, determină pentru fiecare interogare dacă există o soluție unică de a aranja elementele eliminate în matrice astfel încât aceasta să fie matrice AB.

= Date de intrare =
Prima linie a datelor de intrare conține trei numere naturale <code>N</code>, <code>M</code> și <code>Q</code>, separate prin câte un spațiu, având semnificația din enunț. Pe următoarele <code>N</code> linii se află câte <code>M</code> valori, separate prin câte un spațiu, reprezentând matricea AB construită de Alice. Urmează apoi <code>Q</code> interogări, fiecare interogare fiind descrisă pe două linii. Prima linie care descrie o interogare conține numărul natural <code>K</code>, reprezentând numărul de valori eliminate de către Bob. Pe a doua linie din descrierea interogării se află cele <code>K</code> numere eliminate, separate prin câte un spațiu.

= Date de ieșire =
Veți afișa <code>Q</code> linii, fiecare reprezentând un număr întreg. Cea de a <code>i</code>-a linie va conține răspunsul pentru a <code>i</code>-a interogare: răspunsul va fi <code>1</code> dacă există o soluție unică de a aranja elementele eliminate astfel încât să se obțină o matrice AB, respectiv <code>0</code> în caz contrar.

= Restricții și precizări =

* <code>1 ≤ N, M ≤ 2.000</code>
* <code>1 ≤ Q ≤ 25</code>
* <code>K ≥ 1</code>
* Se garantează că în orice interogare numerele eliminate sunt distincte și respectă condiția din enunț (nu sunt adiacente orizontal sau vertical).
* Numărul total al valorilor din interogări nu depășește <code>4.000.000</code>.
* Punctajul pentru un test va fi acordat doar dacă răspunsurile pentru toate interogările din testul respectiv sunt corecte.
* Datorită dimensiunilor mari ale datelor de intrare, doar unele teste au fost adăugate.

= Exemplu: =
'''Intrare'''
3 3 2
1 2 4
3 5 8
6 7 9
3
1 5 9
3
5 4 6
'''Ieșire'''
1
0

=== Explicație ===
Prima interogare presupune eliminarea numerelor <code>1</code>, <code>5</code> și <code>9</code>, matricea după eliminare arătând astfel:

<code>? 2 4</code>

<code>3 ? 8</code>

<code>6 7 ?</code>

Se observă că aranjarea celor trei numere este unică, obținându-se matricea originală.

A doua interogare presupune eliminarea valorilor <code>5</code>, <code>4</code> și <code>6</code>:

<code>1 2 ?</code>

<code>3 ? 8</code>

<code>? 7 9</code>

Rearanjarea nu este unică, o soluție alternativă fiind:

<code>1 2 5</code>

<code>3 6 8</code>

<code>4 7 9</code>

<syntaxhighlight lang="python" line="1">
def is_unique_solution(N, M, queries):
results = []
for query in queries:
if len(query) == 0:
results.append("YES")
continue

positions = [(val - 1) // M, (val - 1) % M for val in query]
sorted_query = sorted(query)

for i in range(1, len(sorted_query)):
pos1 = positions[sorted_query[i-1] - 1]
pos2 = positions[sorted_query[i] - 1]

if pos1[0] == pos2[0] and pos1[1] + 1 == pos2[1]:
results.append("NO")
break
if pos1[1] == pos2[1] and pos1[0] + 1 == pos2[0]:
results.append("NO")
break
else:
results.append("YES")

return results

# Example usage:
N, M = 3, 3
queries = [
[5, 7, 9],
[1, 3, 6],
[2, 4, 8]
]
print(is_unique_solution(N, M, queries))
</syntaxhighlight>

4171 - Loop Over

2024-07-30T15:01:45Z

RaulOtet: Pagină nouă: Baxibilian în timp ce învață la informatică a descoperit jocul '''Loopover'''. Acest joc poate fi descris prin următoarele reguli: * Jocul se desfășoară pe o tabelă pătratică de <code>n x n</code> celule, în care atât rândurile cât și coloanele sunt numerotate de la <code>1</code>; * În starea inițială a tabelei, în fiecare celulă se află câte un număr de la <code>1</code> la <code>n^2</code>, astfel încât <code>M[i,j] = (i - 1) * n + j</code> * As...

Baxibilian în timp ce învață la informatică a descoperit jocul '''Loopover'''. Acest joc poate fi descris prin următoarele reguli:

* Jocul se desfășoară pe o tabelă pătratică de <code>n x n</code> celule, în care atât rândurile cât și coloanele sunt numerotate de la <code>1</code>;
* În starea inițială a tabelei, în fiecare celulă se află câte un număr de la <code>1</code> la <code>n^2</code>, astfel încât <code>M[i,j] = (i - 1) * n + j</code>
* Asupra tabelei se pot aplica patru tipuri de operații de oricâte ori:

- <code>L x</code> – Toate valorile din celulele de pe linia <code>x</code> se vor deplasa ciclic la stânga cu o unitate, adică <code>M[x,i] = M[x,i+1]</code> pentru <code>i < n</code> și <code>M[x,n] = M[x,1]</code>

- <code>R x</code> – Toate valorile din celulele de pe linia <code>x</code> se vor deplasa ciclic la dreapta cu o unitate, adică <code>M[x,i] = M[x,i-1]</code> pentru <code>i > 1</code> și <code>M[x,1] = M[x,n]</code>

- <code>U x</code> – Toate valorile din celulele de pe coloana <code>x</code> se vor deplasa ciclic în sus cu o unitate, adică <code>M[i,x] = M[i+1,x]</code> pentru <code>i < n</code> și <code>M[n,x] = M[1,x]</code>

- <code>D x</code> – Toate valorile din celulele de pe coloana <code>x</code> se vor deplasa ciclic în jos cu o unitate, adică <code>M[i,x] = M[i-1,x]</code> pentru <code>i > 1</code> și <code>M[1,x] = M[n,x]</code>

= Cerința =
Cum Baxibilian nu are timp să analizeze prea mult jocul Loopover, deoarece are de învățat, el dorește să știe următoarele lucruri:

* Fiind dată starea unei tabele asupra căreia s-au făcut fie doar operații asupra liniilor, fie doar operații asupra coloanelor, care este numărul minim de operații pe care Baxibilian ar trebui să le aplice pentru a reveni în starea inițială?
* Fiind dată o secvență de <code>m</code> operații, care este numărul minim de aplicări ale acestei secvențe asupra unei tabele de dimensiune <code>n x n</code> aflate în starea inițială astfel încât starea finală să fie aceeași ca starea inițială? Întrucât rezultatul poate fi un număr foarte mare, Baxibilian este mulțumit dacă află doar restul împărțirii acestui număr la <code>1.000.000.007</code>.

= Date de intrare =
De pe prima linie a fișierului <code>loopover.in</code> se vor afla două numere separate printr-un spațiu <code>t</code> cerința care trebuie rezolvată și <code>n</code> dimensiunea tabelei. În continuare:

* Dacă <code>t = 1</code>, pe următoarele <code>n</code> linii se vor afla, câte <code>n</code> numere separate prin câte un spațiu, reprezentând configurația tabelei.
* Dacă <code>t = 2</code>, pe ce-a de-a doua linie se va afla un singur număr <code>m</code>, iar pe următoarele <code>m</code> linii se vor afla, separate prin câte un spațiu, un caracter <code>ci</code> <code>∈ {L,R,U,D}</code> reprezentând tipul operației și un număr <code>xi</code> reprezentând indexul liniei sau coloanei asupra căreia se aplică operația <code>i</code>.

= Date de ieșire =
În fișierul <code>loopover.out</code> se va afișa în funcție de cerință:

* dacă <code>t = 1</code>, un singur număr reprezentând numărul minim de operații pentru a aduce tabela în starea inițială.
* dacă <code>t = 2</code>, un singur număr reprezentând restul împărțirii la <code>1.000.000.007</code> al numărului minim de aplicări ale secvenței de operații asupra tabelei pentru ca aceasta să ajungă înapoi în starea inițială.

= Restricții și precizări =

* <code>2 ≤ n ≤ 1000</code>
* <code>1 ≤ m ≤ 1000</code>
* <code>t ∈ {1, 2}</code>
* <code>1 ≤ xi</code> <code>≤ n</code> pentru orice <code>1 ≤ i ≤ m</code>

= Exemplul 1: =
<code>loopover.in</code>
1 4
2 3 4 1
8 5 6 7
11 12 9 10
13 14 15 16
<code>loopover.out</code>
4

=== Explicație ===
Operațiile ce trebuie aplicate sunt:

<code>R 1</code>

<code>L 2</code>

<code>L 3</code>

<code>L 3</code>

= Exemplul 2: =
<code>loopover.in</code>
1 3
7 8 6
1 2 9
4 5 3
<code>loopover.out</code>
3

=== Explicație ===
Operațiile ce trebuie aplicate sunt:

<code>U 1</code>

<code>U 2</code>

<code>D 3</code>

= Exemplul 3: =
<code>loopover.in</code>
2 3
5
U 1
R 1
U 2
R 1
L 2
<code>loopover.out</code>
6

=== Explicație ===
După aplicarea secvenței de <code>5</code> operații, matricea obținută de Baxibilian este:

<code>2 3 5</code>

<code>8 6 7</code>

<code>1 4 9</code>

Numărul minim de aplicări ale secvenței pentru a ajunge la matricea identitate este <code>6</code>.

= Exemplul 4: =
<code>loopover.in</code>
2 8
10
R 6
L 8
R 4
U 3
L 3
L 1
R 3
U 5
U 6
U 3
<code>loopover.out</code>
4284

=== Explicație ===
Sunt necesare <code>4284</code> de aplicări ale secvenței pentru a reveni în starea inițială.

<syntaxhighlight lang="python" line="1">
MOD = 1000000007

def gcd(a, b):
while b:
a, b = b, a % b
return a

def lcm(a, b):
return a * b // gcd(a, b)

def min_operations_to_initial(n, grid, is_row_operations):
if is_row_operations:
operations_needed = 0
for row in grid:
for j in range(n):
if row[j] != (row[0] + j) % n:
shift_amount = (j - row.index(1)) % n
operations_needed = gcd(operations_needed, shift_amount)
return operations_needed
else:
operations_needed = 0
for j in range(n):
col = [grid[i][j] for i in range(n)]
for i in range(n):
if col[i] != (col[0] + i * n) % (n * n):
shift_amount = (i - col.index(1)) % n
operations_needed = gcd(operations_needed, shift_amount)
return operations_needed

def min_apply_sequence(n, sequence):
length_sequence = len(sequence)
current_pos = list(range(n * n))
for op in sequence:
direction, idx = op.split()
idx = int(idx) - 1
if direction == 'L':
row = current_pos[idx * n:(idx + 1) * n]
current_pos[idx * n:(idx + 1) * n] = row[1:] + row[:1]
elif direction == 'R':
row = current_pos[idx * n:(idx + 1) * n]
current_pos[idx * n:(idx + 1) * n] = row[-1:] + row[:-1]
elif direction == 'U':
col = current_pos[idx::n]
current_pos[idx::n] = col[1:] + col[:1]
elif direction == 'D':
col = current_pos[idx::n]
current_pos[idx::n] = col[-1:] + col[:-1]
target_pos = list(range(n * n))
if current_pos == target_pos:
return 1
cycle_length = 1
while True:
current_pos = list(range(n * n))
for _ in range(cycle_length):
for op in sequence:
direction, idx = op.split()
idx = int(idx) - 1
if direction == 'L':
row = current_pos[idx * n:(idx + 1) * n]
current_pos[idx * n:(idx + 1) * n] = row[1:] + row[:1]
elif direction == 'R':
row = current_pos[idx * n:(idx + 1) * n]
current_pos[idx * n:(idx + 1) * n] = row[-1:] + row[:-1]
elif direction == 'U':
col = current_pos[idx::n]
current_pos[idx::n] = col[1:] + col[:1]
elif direction == 'D':
col = current_pos[idx::n]
current_pos[idx::n] = col[-1:] + col[:-1]
if current_pos == target_pos:
return cycle_length % MOD
cycle_length += 1

# Exemplu de utilizare
n = 4
grid = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]
]
sequence = ["L 1", "D 2", "R 3", "U 4"]

print(min_operations_to_initial(n, grid, True)) # Operații pe linii
print(min_operations_to_initial(n, grid, False)) # Operații pe coloane
print(min_apply_sequence(n, sequence))
</syntaxhighlight>

4134 - Raza 1

2024-07-30T14:30:12Z

RaulOtet: Pagină nouă: Pe planeta Quadratia, locuitorii folosesc forme pătrate în tot ceea ce construiesc. Ei au trimis pe solul planetei <code>N</code> mașini speciale de apărare, numite '''rovere''', care se deplasează pe traiectorii ce descriu pătrate. Harta planetei poate fi privită ca un tablou bidimensional cu număr infinit de linii și coloane, numerotarea acestora începând cu <code>1</code>. Fiecare element al acestui tablou se identifică prin numărul liniei, respectiv numărul...

Pe planeta Quadratia, locuitorii folosesc forme pătrate în tot ceea ce construiesc. Ei au trimis pe solul planetei <code>N</code> mașini speciale de apărare, numite '''rovere''', care se deplasează pe traiectorii ce descriu pătrate. Harta planetei poate fi privită ca un tablou bidimensional cu număr infinit de linii și coloane, numerotarea acestora începând cu <code>1</code>. Fiecare element al acestui tablou se identifică prin numărul liniei, respectiv numărul coloanei pe care se găsește.

Fiecare rover este descris prin <code>3</code> numere naturale nenule <code>L</code>, <code>C</code> și <code>R</code>, reprezentând poziția (linia <code>L</code> și coloana <code>C</code>) elementului din colțul din stânga-sus al pătratului ce descrie traiectoria, respectiv lungimea <code>R</code> a laturii acestuia. Toate roverele pornesc inițial din elementul din colțul stânga-sus al pătratului ce descrie traiectoria, pe care o parcurg în sensul acelor de ceasornic, traversând câte un element pe secundă. Ele sunt programate să parcurgă această traiectorie fără a se opri. Este posibil ca mai multe rovere să se afle, la un moment dat, la aceeași poziție de pe hartă.

Rectilinienii sunt singurii dușmani ai quadratienilor, ei deosebindu-se de aceștia prin folosirea consecventă a liniilor drepte în tot ceea ce construiesc. Rectilinienii au construit o armă laser de mare putere, pe care vor să o folosească la distrugerea roverelor quadratiene. Arma a fost adusă în poziția <code>(1,1)</code> de pe harta planetei, adică elementul de pe prima linie și prima coloană.

Arma poate emite '''o singură''' rază distructivă, timp de o secundă, dezafectând în acest timp toate roverele aflate în secunda respectivă pe diagonala principală a tabloului care descrie harta planetei. Arma nu poate fi detectată în primele <code>S</code> secunde. Traiectoria roverelor poate trece prin poziția în care a fost amplasată arma, fără a o putea detecta în primele <code>S</code> secunde.

În imagine avem două rovere, acestea fiind identificate prin tripletele de numere <code>4, 2, 6</code>, respectiv <code>6, 9, 4</code>. Traiectoria primului rover începe din poziția <code>(4, 2)</code> și are latura <code>6</code>. Numerele de pe traiectorie reprezintă secunda la care se parcurge respectivul element al tabloului. Roverul va ajunge din nou în poziția inițială la secundele <code>21, 41, 61, ...</code> Primul rover intersectează, la prima sa trecere, diagonala principală în două puncte: <code>(4, 4)</code> la secunda <code>3</code> și <code>(7, 7)</code> la secunda <code>9</code>. Al doilea rover intersectează diagonala principală într-un singur punct, <code>(9, 9)</code> la secundele <code>10, 22, 34, ...</code>

= Cerința =
Scrieţi un program care să rezolve următoarele cerințe:

* Determină numărul roverelor a căror traiectorie se intersectează cu diagonala principală a tabloului ce descrie harta.
* Determină numărul maxim de rovere, care pot fi distruse simultan, într-o singură secundă, înainte de trecerea celor <code>S</code> secunde, precum și secunda minimă în care se poate realiza acest lucru.

= Date de intrare =
Datele de intrare se citesc din fișierul <code>raza.in</code>, care are următoarea structură:

* pe prima linie se află numărul natural <code>T ∈ {1, 2}</code>, semnificând numărul cerinței de rezolvat.
* pe a doua linie se află numerele naturale nenule <code>N</code> și <code>S</code>, separate printr-un spațiu, reprezentând numărul roverelor, respectiv numărul de secunde în care arma nu este detectată.
* pe următoarele <code>N</code> linii se află câte 3 numere naturale nenule, <code>L</code> <code>C</code> <code>R</code>, separate prin câte un spațiu, reprezentând coordonatele poziției inițiale, respectiv lungimea laturii traiectoriei fiecărui rover.

= Date de ieșire =
Datele de ieșire se vor afișa în fișierul <code>raza.out</code>, care are următoarea structură în funcție de cerință:

* dacă <code>T = 1</code>, pe prima linie se va afișa numărul roverelor a căror traiectorie se intersectează cu diagonala principală;
* dacă <code>T = 2</code>, pe prima linie se vor afișa două numere naturale, separate printr-un spațiu, reprezentând numărul maxim de rovere dezactivate și secunda minimă în care se poate realiza acest lucru.

= Restricții și precizări =

* <code>1 ≤ N ≤ 10.000</code>
* <code>1 ≤ S ≤ 100.000</code>
* <code>1 ≤ L, C ≤ 50.000</code>
* <code>3 ≤ R ≤ 1000</code>
* <code>1 ≤ Numărul maxim de rovere care se intersectează cu raza armei ≤ 1000</code>.
* Pentru 28 de puncte, <code>T = 1</code>
* Pentru 72 de puncte, <code>T = 2</code>

= Exemplu: =
<code>raza.in</code>
1
2 100
4 2 6
6 9 4
<code>raza.out</code>
2

=== Explicație ===
Cerința este 1. Exemplul reprezintă desenul din enunț.

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

def calculate_trajectory(L, C, R):
trajectory = []
for t in range(4 * R):
if t < R:
trajectory.append((L, C + t))
elif t < 2 * R:
trajectory.append((L + t - R, C + R - 1))
elif t < 3 * R:
trajectory.append((L + R - 1, C + R - 1 - (t - 2 * R)))
else:
trajectory.append((L + R - 1 - (t - 3 * R), C))
return trajectory

def solve(N, rovers, S):
diagonal_intersections = defaultdict(list)

for rover in rovers:
L, C, R = rover
trajectory = calculate_trajectory(L, C, R)
for i, (x, y) in enumerate(trajectory):
if x == y:
t = i + 1
diagonal_intersections[t].append((L, C, R))

count_per_second = defaultdict(int)
for t, rovers_at_t in diagonal_intersections.items():
if t <= S:
count_per_second[t] += len(rovers_at_t)

if not count_per_second:
return 0, None, None

max_destructions = max(count_per_second.values())
min_time = min(t for t in count_per_second if count_per_second[t] == max_destructions)

return len(diagonal_intersections), max_destructions, min_time

# Example usage
N = 2
rovers = [(4, 2, 6), (6, 9, 4)]
S = 10
print(solve(N, rovers, S))
</syntaxhighlight>

3766 - Zid

2024-07-28T09:00:11Z

RaulOtet: Pagină nouă: Un zid ornamental de formă dreptunghiulară este alcătuit din <code>N</code> rânduri de cărămizi, fiecare rând având câte <code>M</code> cărămizi identice, așezate una lângă alta. Fiecare cărămidă este colorată într-una dintre culorile <code>{0, 1, 2, ..., Cmaxg}</code>. Un pătrat de latură <code>L</code> în acest zid este constituit din cărămizile situate pe <code>L</code> rânduri consecutive și <code>L</code> coloane consecutive. Spunem c...

Un zid ornamental de formă dreptunghiulară este alcătuit din <code>N</code> rânduri de cărămizi, fiecare rând având câte <code>M</code> cărămizi identice, așezate una lângă alta. Fiecare cărămidă este colorată într-una dintre culorile <code>{0, 1, 2, ..., Cmaxg}</code>. Un pătrat de latură <code>L</code> în acest zid este constituit din cărămizile situate pe <code>L</code> rânduri consecutive și <code>L</code> coloane consecutive. Spunem că un pătrat este colorat uniform dacă el conține același număr de cărămizi din fiecare culoare care apare în pătratul respectiv.

= Cerința =
Scrieți un program care, cunoscând configurația zidului, determină în acest zid un pătrat de latură maximă, colorat uniform.

= Date de intrare =
Fișierul de intrare <code>zid.in</code> conține pe prima linie numerele naturale <code>N M Cmax</code>, reprezentând numărul de rânduri de cărămizi, numărul de cărămizi de pe fiecare rând, respectiv culoarea maximă. Pe următoarele <code>N</code> linii este descrisă configurația zidului, de sus în jos; pe fiecare linie dintre cele <code>N</code> se află câte <code>M</code> numere naturale, reprezentând culorile cărămizilor de pe rândul respectiv, în ordine, de la stânga la dreapta. Valorile scrise pe aceeași linie sunt separate prin câte un spațiu.

= Date de ieșire =
Fișierul de ieșire <code>zid.out</code> va conține o singură linie pe care vor fi scrise trei numere naturale <code>Nr R C</code>, separate prin câte un singur spațiu, reprezentând numărul de cărămizi existente într-un pătrat colorat uniform de latură maximă, respectiv rândul și cărămida de pe rând situată în colțul din stânga-sus al pătratului colorat uniform de latură maximă.

= Restricții și precizări =

* <code>2 ≤ N, M ≤ 250</code>• <code>1 ≤ Cmax ≤ 9</code> • Rândurile sunt numerotate de sus în jos de la <code>1</code> la <code>N</code>. Cărămizile situate pe un rând sunt numerotate de la stânga la dreapta de la <code>1</code> la <code>M</code>. • Dacă există mai multe pătrate colorate uniform de latură maximă se va alege pătratul pentru care numărul rândului este minim. Dacă există mai multe pătrate colorate uniform de latură maximă care au colțul din stânga-sus pe același rând minim, se va alege pătratul cel mai din stânga.

= Exemplu: =
<code>zid.in</code>
6 8 5
1 2 3 5 1 2 3 5
1 2 1 2 3 5 3 5
1 1 1 2 2 3 3 3
1 2 3 5 5 3 2 1
3 3 1 1 2 2 5 5
2 1 2 3 2 5 2 2
<code>zid.out</code>
9 2 4

=== Explicație ===
Pătratul colorat uniform de latură maximă, situat pe rândul cel mai de sus, cel mai în stânga este:

<code>2 3 5</code>

<code>2 2 3</code>

<code>5 5 3</code>

El conține <code>9</code> cărămizi, în care apar culorile <code>2</code>, <code>3</code>, <code>5</code> de câte <code>3</code> ori fiecare. Acest pătrat are colțul din

stânga-sus situat pe rândul al doilea, în a patra cărămidă de pe rând (a patra coloană). Există și alte pătrate colorate uniform formate din <code>9</code> cărămizi, de exemplu:

<code>1 2 3</code>

<code>3 3 1</code>

<code>2 1 2</code>

dar acesta are colțul din stânga-sus pe rândul <code>4</code>.

<syntaxhighlight lang="python" line="1">
def citire_date():
N, M, Cmax = map(int, input().split())
zid = [list(map(int, input().split())) for _ in range(N)]
return N, M, Cmax, zid

def construieste_matrice_cumulative(N, M, Cmax, zid):
cumulative = [[[0] * (Cmax + 1) for _ in range(M + 1)] for _ in range(N + 1)]

for i in range(1, N + 1):
for j in range(1, M + 1):
culoare = zid[i-1][j-1]
for c in range(Cmax + 1):
cumulative[i][j][c] = cumulative[i-1][j][c] + cumulative[i][j-1][c] - cumulative[i-1][j-1][c]
cumulative[i][j][culoare] += 1

return cumulative

def verifica_uniformitatea(cumulative, x1, y1, x2, y2, Cmax):
counts = [0] * (Cmax + 1)

for c in range(Cmax + 1):
counts[c] = (cumulative[x2][y2][c]
- cumulative[x1-1][y2][c]
- cumulative[x2][y1-1][c]
+ cumulative[x1-1][y1-1][c])

unique_counts = [count for count in counts if count > 0]
return len(set(unique_counts)) == 1

def gaseste_patrat_maxim_uniform(N, M, Cmax, zid):
cumulative = construieste_matrice_cumulative(N, M, Cmax, zid)

latura_maxima = min(N, M)

for latura in range(latura_maxima, 0, -1):
for i in range(1, N - latura + 2):
for j in range(1, M - latura + 2):
if verifica_uniformitatea(cumulative, i, j, i + latura - 1, j + latura - 1, Cmax):
return latura

return 0

def main():
N, M, Cmax, zid = citire_date()
latura_maxima = gaseste_patrat_maxim_uniform(N, M, Cmax, zid)
print(latura_maxima)

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

3438 - Triunghi 5

2024-07-28T08:58:29Z

RaulOtet: Pagină nouă: Se consideră <code>A</code> un tablou bidimensional cu <code>n</code> linii, <code>n</code> coloane și elemente numere naturale. O zonă triunghiulară a tabloului, reprezentată de tripletul <code>(lin, col, k)</code>, este o zonă de forma unui triunghi dreptunghic cu catetele de lungime egală cu <code>|k|</code>, definită astfel: # Pentru <code>k>0</code>, zona este compusă din <code>k</code> linii: #* pe prima linie a zonei se află elementele <code>A[lin][col]</cod...

Se consideră <code>A</code> un tablou bidimensional cu <code>n</code> linii, <code>n</code> coloane și elemente numere naturale. O zonă triunghiulară a tabloului, reprezentată de tripletul <code>(lin, col, k)</code>, este o zonă de forma unui triunghi dreptunghic cu catetele de lungime egală cu <code>|k|</code>, definită astfel:

# Pentru <code>k>0</code>, zona este compusă din <code>k</code> linii:
#* pe prima linie a zonei se află elementele <code>A[lin][col]</code>, <code>A[lin][col+1]</code>, …, <code>A[lin][col+k-1]</code>;
#* pe a doua linie a zonei se află elementele <code>A[lin+1][col]</code>, <code>A[lin+1][col+1]</code>, …, <code>A[lin+1][col+k-2]</code>;
#* pe a treia linie a zonei se află elementele <code>A[lin+2][col]</code>, <code>A[lin+2][col+1]</code>, …, <code>A[lin+2][col+k-3]</code>;
#* …
#* pe ultima linie a zonei se află elementul <code>A[lin+k-1][col]</code>.
# Pentru <code>k<0</code>, zona este compusă din <code>|k|=-k</code> linii:
#* pe prima linie a zonei se află elementul <code>A[lin-|k|+1][col]</code>;
#* pe a doua linie a zonei se află elementele <code>A[lin-|k|+2][col-1]</code>, <code>A[lin-|k|+2][col]</code>;
#* …
#* pe ultima linie a zonei se află elementele <code>A[lin][col-|k|+1]</code>, <code>A[lin][col-|k|+2]</code>,…, <code>A[lin][col]</code>.

Suma elementelor ce compun o zonă triunghiulară se numește suma zonei.

= Cerința =
Scrieţi un program care, cunoscând tabloul <code>A</code> şi <code>Q</code> zone triunghiulare, determină cea mai mare dintre sumele zonelor.

= Date de intrare =
Fișierul de intrare <code>triunghi.in</code> conține pe prima linie numărul natural <code>n</code>, cu semnificaţia din enunţ. Pe următoarele <code>n</code> linii se găsesc câte n valori naturale, reprezentând elementele tabloului <code>A</code>. Pe linia <code>n+2</code> se află numărul natural <code>Q</code>, reprezentând numărul zonelor triunghiulare. Pe următoarele <code>Q</code> linii se găsesc tripletele de valori <code>lin col k</code>, care reprezintă cele <code>Q</code> zone, în forma descrisă în enunţ. Valorile aflate pe aceeaşi linie a fişierului sunt separate prin câte un spațiu.

= Date de ieșire =
Fișierul de ieșire <code>triunghi.out</code> va conține o singură linie pe care va fi scris un număr natural reprezentând suma maximă cerută.

= Restricții și precizări =

* <code>3 ≤ n ≤ 1000</code>; <code>1 ≤ Q ≤ 100000</code>; <code>2 ≤ |k| ≤ n</code>
* Valorile din tablou sunt numere naturale din intervalul <code>[1,100]</code>.
* Liniile şi coloanele tabloului <code>A</code> sunt numerotate de la <code>1</code> la <code>n</code> (liniile de sus în jos, iar coloanele de la stânga la dreapta).
* <code>|k|</code> reprezintă modulul numărului <code>k</code> (<code>k</code>, pentru <code>k≥0</code>, respectiv <code>-k</code>, pentru <code>k<0</code>).
* Se garantează că orice zonă triunghiulară dintre cele <code>Q</code> este complet inclusă în tabloul <code>A</code>.

= Exemplu: =
<code>triunghi.in</code>
6
5 8 10 4 9 4
2 10 10 2 4 8
8 10 3 4 6 6
4 6 9 7 1 9
6 7 2 2 10 6
10 4 6 1 10 4
3
4 1 3
4 4 -4
6 5 -2
<code>triunghi.out</code>
59

=== Explicație ===
Zona triunghiulară de sumă maximă (<code>59</code>) este reprezentată de tripletul <code>(4 4 -4)</code> și conține

valorile evienţiate: <code>59=4+(10+2)+(10+3+4)+(4+6+9+7)</code>.

<syntaxhighlight lang="python" line="1">
def suma_zona_triunghiulara(A, lin, col, k):
suma = 0
n = len(A)

if k > 0:
# Zona triunghiulară pentru k > 0
for i in range(k):
for j in range(k - i):
suma += A[lin + i][col + j]
else:
# Zona triunghiulară pentru k < 0
k = -k
for i in range(k):
for j in range(i + 1):
suma += A[lin - i + (k - 1)][col - j + (k - 1)]

return suma

def cea_mai_mare_suma(A, interogari):
max_suma = float('-inf')

for (lin, col, k) in interogari:
suma = suma_zona_triunghiulara(A, lin, col, k)
if suma > max_suma:
max_suma = suma

return max_suma

# Citire date
n = int(input())
A = [list(map(int, input().split())) for _ in range(n)]
Q = int(input())
interogari = [tuple(map(int, input().split())) for _ in range(Q)]

# Calculare cea mai mare sumă
result = cea_mai_mare_suma(A, interogari)
print(result)
</syntaxhighlight>

2961 - Deminare

2024-07-28T08:57:09Z

RaulOtet: Pagină nouă: Pe un teren de formă dreptunghiulară format din <code>L</code> linii și <code>C</code> coloane sunt plantate <code>M</code> mine. Liniile sunt numerotate de sus în jos cu valori de la <code>1</code> la <code>L</code> iar coloanele sunt numerotate de la stânga la dreapta cu valori de la <code>1</code> la <code>C</code>. Deoarece războiul s-a terminat, specialiștii vor să demineze terenul și să-l redea utilizării publice. Mutarea unei mine reprezintă operația de tr...

Pe un teren de formă dreptunghiulară format din <code>L</code> linii și <code>C</code> coloane sunt plantate <code>M</code> mine. Liniile sunt numerotate de sus în jos cu valori de la <code>1</code> la <code>L</code> iar coloanele sunt numerotate de la stânga la dreapta cu valori de la <code>1</code> la <code>C</code>. Deoarece războiul s-a terminat, specialiștii vor să demineze terenul și să-l redea utilizării publice. Mutarea unei mine reprezintă operația de transfer a unei mine de la linia <code>x1</code> și coloana <code>y1</code> la o poziție liberă, dată de linia <code>x2</code> și coloana <code>y2</code>, unde <code>1 ≤ x1, x2 ≤ L</code> și <code>1 ≤ y1, y2 ≤ C</code>. Deoarece mutarea unei mine este periculoasă, trebuie determinat numărul minim de mine care trebuie mutate din poziția inițială astfel încât toate minele de pe teren să fie așezate unele lângă altele într-o zonă compactă dreptunghiulară, oriunde în cadrul terenului dat, pentru ca apoi să fie detonate împreună.

Spre exemplu: dacă <code>L = 4</code>, <code>C = 5</code>, <code>M = 8</code> și minele sunt așezate inițial conform figurii de mai jos (zonele colorate cu negru arată pozițiile minelor), pentru a se ajunge la o așezare a minelor într-o zonă compactă de formă dreptunghiulară numărul minim de mine mutate este <code>3</code>.

= Cerința =
Cunoscând numărul de linii <code>L</code> și de coloane <code>C</code> ale terenului minat, numărul de mine <code>M</code>, precum și poziția fiecărei mine, să se scrie un program care determină:

1. linia sau liniile pe care se găsesc cele mai multe mine;

2. numărul minim de mine mutate, pentru ca toate minele de pe teren să fie așezate într-o zonă compactă cu formă dreptunghiulară.

= Date de intrare =
Fișierul de intrare este <code>deminare.in</code> și conține:

- pe prima linie numărul natural <code>V</code> a cărui valoare poate fi doar <code>1</code> sau <code>2</code>;

- pe a doua linie două numere naturale <code>L</code> și <code>C</code>, cu semnificația din enunț;

- pe a treia linie numărul natural <code>M</code>, cu semnificația din enunț;

- pe fiecare din următoarele <code>M</code> linii, câte o pereche de valori <code>xi</code> și <code>yi</code>, <code>1 ≤ i ≤ M</code>, reprezentând linia, respectiv coloana, unde se află o mină;

Numerele aflate pe aceeași linie a fișierului sunt separate prin câte un spațiu.

= Date de ieșire =
Fișierul de ieșire este <code>deminare.out</code>.

Dacă valoarea lui <code>V</code> este <code>1</code> atunci prima linie a fișierului de ieșire va conține numărul liniei pe care se găsesc cele mai multe mine. Dacă există două sau mai multe astfel de linii, se vor afișa toate numerele acestora, în ordine crescătoare, separate prin câte un spațiu.

Dacă valoarea lui <code>V</code> este <code>2</code> atunci fișierul de ieșire va conține pe prima linie numărul minim cerut de mine mutate. Dacă minele nu pot fi așezate într-o zonă compactă de formă dreptunghiulară, în fișierul de ieșire se va scrie valoarea <code>-1</code>.

= Restricții și precizări =

* <code>1 ≤ L, C ≤ 500</code>
* <code>1 ≤ M ≤ L • C</code>
* O zonă în care se află mine așezate pe coloane consecutive, pe aceeași linie sau așezate pe linii consecutive, pe aceeași coloană se consideră că formează o zonă compactă de formă dreptunghiulară.
* O zonă compactă de formă dreptunghiulară poate avea numărul de linii ocupate egal cu numărul de coloane ocupate.
* Pentru teste valorând <code>20</code> de puncte, avem <code>V = 1</code>
* Pentru teste valorând <code>70</code> de puncte, avem <code>V = 2</code>
* Pentru teste valorând <code>20</code> de puncte, avem <code>V = 2</code> și <code>L • C ≤ 10.000</code>
* Pentru teste valorând <code>32</code> de puncte, avem <code>V = 2</code> și <code>L • C ≤ 100.000</code>
* În concurs s-au acordat <code>10</code> puncte din oficiu. Aici se acordă pentru exemplele din enunț.

= Exemplul: =
<code>deminare.in</code>
1
4 5
8
1 2
1 5
2 1
3 2
3 5
4 3
4 4
4 5
<code>deminare.out</code>
4

=== Explicație ===
<code>V = 1</code>, deci se rezolvă doar cerința 1. <code>L = 4</code>, <code>C = 5</code>, <code>M = 8</code>.

Minele sunt plasate la pozițiile <code>(1,2)</code>, <code>(1,5)</code>, <code>(2,1)</code>, <code>(3,2)</code>, <code>(3,5)</code>, <code>(4,3)</code>, <code>(4,4)</code> și <code>(4,5)</code>.

Pe linia <code>1</code> sunt amplasate <code>2</code> mine;

Pe linia <code>2</code> este amplasată <code>1</code> mină;

Pe linia <code>3</code> sunt amplasate <code>2</code> mine;

Pe linia <code>4</code> sunt amplasate <code>3</code> mine;

Deci, există o singură linie pe care sunt amplasate un număr maxim de mine și anume linia <code>4</code>.

<syntaxhighlight lang="python" line="1">
def citire_date():
L, C, M = map(int, input().split())
mine = []
for _ in range(M):
x, y = map(int, input().split())
mine.append((x-1, y-1)) # Ajustare la indexare zero-based
return L, C, M, mine

def linii_cu_cele_mai_multe_mine(L, mine):
count_per_line = [0] * L
for (x, y) in mine:
count_per_line[x] += 1
max_mine = max(count_per_line)
linii_max = [i + 1 for i, count in enumerate(count_per_line) if count == max_mine]
return linii_max

def mutari_minime(L, C, mine):
mine_set = set(mine)
mine_positions = [(x, y) for x, y in mine]

def mine_in_rect(x1, y1, x2, y2):
count = 0
for x in range(x1, x2 + 1):
for y in range(y1, y2 + 1):
if (x, y) in mine_set:
count += 1
return count

min_moves = float('inf')
for x1 in range(L):
for y1 in range(C):
for x2 in range(x1, L):
for y2 in range(y1, C):
total_in_rect = mine_in_rect(x1, y1, x2, y2)
if total_in_rect == len(mine):
min_moves = 0
break
current_moves = len(mine) - total_in_rect
min_moves = min(min_moves, current_moves)

return min_moves

def main():
L, C, M, mine = citire_date()
linii_max = linii_cu_cele_mai_multe_mine(L, mine)
min_mutari = mutari_minime(L, C, mine)

print("Linii cu cele mai multe mine:", " ".join(map(str, linii_max)))
print("Număr minim de mine mutate:", min_mutari)

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

2898 - Nave

2024-07-28T08:55:16Z

RaulOtet: Pagină nouă: Echipajul navei Enterprise, a descoperit pe planeta Marte, zona în care sunt amplasate b baze militare care adăpostesc navele de luptă ale marțienilor. Echipajul navei a reușit să cartografieze zona și a împărțit harta planetei în <code>n x m</code> zone de latură 1, dispuse pe n linii (numerotate de sus în jos de la <code>1</code> la <code>n</code>) și m coloane (numerotate de la stânga la dreapta de la <code>1</code> la <code>m</code>). Astfel fiecare zonă p...

Echipajul navei Enterprise, a descoperit pe planeta Marte, zona în care sunt amplasate b baze militare care adăpostesc navele de luptă ale marțienilor. Echipajul navei a reușit să cartografieze zona și a împărțit harta planetei în <code>n x m</code> zone de latură 1, dispuse pe n linii (numerotate de sus în jos de la <code>1</code> la <code>n</code>) și m coloane (numerotate de la stânga la dreapta de la <code>1</code> la <code>m</code>). Astfel fiecare zonă poate fi identificată prin numărul liniei și al coloanei pe care se află. În fiecare astfel de zonă se află o bază a marțienilor ce adăpostește un număr de nave. Căpitanul navei Enterprise, Jean-Luc Picard a elaborat o strategie de atac terestru a acestor baze militare.

Nava Enterprise poate ateriza într-o zonă în care nu se află o bază marțiană și poate lansa un singur atac (deoarece după primul atac bazele marțiene își vor activa scuturile de protecție). La un atac se vor emite simultan 2 raze laser care vor distruge toate navele marțiene existente în bazele aflate pe direcția acestor raze, în ambele sensuri. Razele sunt emise din centrul zonei în care a aterizat Enterprise și fac unghiuri de <code>45o</code>, respectiv <code>135o</code> cu linia pe care se află Enterprise.

= Cerința =
Scrieți un program care, cunoscând configurația bazelor marțiene, determină numărul maxim de nave marțiene pe care Enterprise le poate distruge la un singur atac, precum și linia și coloana zonei în care poate ateriza nava Enterprise astfel încât să distrugă un număr maxim de nave; dacă există mai multe zone în care poate ateriza convenabil pentru Enterprise este să aleagă zona pentru care linia este maximă; dacă există mai multe zone pe linia maximă, se va alege cea pentru care coloana este maximă.

= Date de intrare =
Fișierul de intrare <code>nave.in</code> conține pe prima linie trei numere naturale <code>n</code>, <code>m</code> și <code>b</code>, separate prin câte un spațiu, reprezentând numărul de linii, numărul de coloane ale hărții planetei Marte, respectiv numărul de baze marțiene. Pe fiecare dintre următoarele <code>b</code> linii este descrisă câte o bază marțiană sub forma a trei numere naturale separate prin câte un spațiu <code>lin col nr</code>, reprezentând linia și coloana pe care se află baza marțiană, respectiv numărul de nave aflate în baza marțiană respectivă.

= Date de ieșire =
Fișierul de ieșire <code>nave.out</code> va conține pe prima linie trei numere naturale <code>nrmax</code>, <code>linmax</code>, <code>colmax</code>, separate prin câte un spațiu, reprezentând numărul maxim de nave marțiene pe care Enterprise le poate distruge la un singur atac, precum și linia și coloana zonei în care poate ateriza nava Enterprise astfel încât să distrugă un număr maxim de nave; dacă există mai multe zone în care poate ateriza convenabil pentru Enterprise este să aleagă zona pentru care linia este maximă; dacă există mai multe zone pe linia maximă, se va alege cea pentru care coloana este maximă.

= Restricții și precizări =

* <code>1 ≤ n, m ≤ 100</code>
* <code>n x m ≤ b2</code>
* <code>b ≤ n * m / 2</code>
* <code>1 ≤ lin ≤ n</code>; <code>1 ≤ col ≤ m</code>; <code>1 ≤ nr ≤ 1000</code>

= Exemplu: =
<code>nave.in</code>
5 4 9
1 1 3
1 2 5
2 2 7
2 4 9
3 1 6
3 3 8
4 1 1
5 1 4
5 3 2
<code>nave.out</code>
29 4 2

=== Explicație ===
Harta zonei unde se găsesc bazele marțiene este:

Dacă nava Enterprise aterizează în zona situată pe linia <code>4</code> și coloana <code>2</code>, va distruge un număr maxim de nave (<code>29</code>).

<syntaxhighlight lang="python" line="1">
def read_input():
n, m = map(int, input().split())
harta = []
for _ in range(n):
linie = list(map(int, input().split()))
harta.append(linie)
return n, m, harta

def calculeaza_sume_diagonale(n, m, harta):
diag1 = [[0] * m for _ in range(n)]
diag2 = [[0] * m for _ in range(n)]

# Sume diagonale 45° (/)
for i in range(n):
for j in range(m):
if i > 0 and j > 0:
diag1[i][j] = harta[i][j] + diag1[i-1][j-1]
else:
diag1[i][j] = harta[i][j]

# Sume diagonale 135° (\)
for i in range(n):
for j in range(m):
if i > 0 and j < m - 1:
diag2[i][j] = harta[i][j] + diag2[i-1][j+1]
else:
diag2[i][j] = harta[i][j]

return diag1, diag2

def gaseste_punct_optim(n, m, harta, diag1, diag2):
max_nave = 0
coordonate_optime = (-1, -1)

for i in range(n):
for j in range(m):
if harta[i][j] == 0: # Poate ateriza doar într-o zonă fără bază marțiană
suma_nave = 0
if i > 0 and j > 0:
suma_nave += diag1[i-1][j-1]
if i > 0 and j < m - 1:
suma_nave += diag2[i-1][j+1]

if suma_nave > max_nave:
max_nave = suma_nave
coordonate_optime = (i + 1, j + 1)
elif suma_nave == max_nave:
if i + 1 > coordonate_optime[0] or (i + 1 == coordonate_optime[0] and j + 1 > coordonate_optime[1]):
coordonate_optime = (i + 1, j + 1)

return max_nave, coordonate_optime

def main():
n, m, harta = read_input()
diag1, diag2 = calculeaza_sume_diagonale(n, m, harta)
max_nave, coordonate_optime = gaseste_punct_optim(n, m, harta, diag1, diag2)

print(max_nave)
print(coordonate_optime[0], coordonate_optime[1])

# Apelare funcție principală
if __name__ == "__main__":
main()
</syntaxhighlight>

2607 - Pentagon

2024-07-28T08:52:55Z

RaulOtet: Pagină nouă: În urma bombardamentelor din 11 septembrie 2001, clădirea Pentagonului a suferit daune la unul din pereții clădirii. Imaginea codificată a peretelui avariat se reprezintă sub forma unei matrice cu <code>m</code> linii și <code>n</code> coloane, ca în figura de mai jos: <code>1110000111</code> <code>1100001111</code> <code>1000000011</code> <code>1111101111</code> <code>1110000111</code> unde <code>1</code> reprezintă zid intact, iar <code>0</code> zid avar...

În urma bombardamentelor din 11 septembrie 2001, clădirea Pentagonului a suferit daune la unul din pereții clădirii. Imaginea codificată a peretelui avariat se reprezintă sub forma unei matrice cu <code>m</code> linii și <code>n</code> coloane, ca în figura de mai jos:

<code>1110000111</code>

<code>1100001111</code>

<code>1000000011</code>

<code>1111101111</code>

<code>1110000111</code>

unde <code>1</code> reprezintă zid intact, iar <code>0</code> zid avariat. Sumele alocate pentru refacerea Pentagonului vor fi donate celor care vor ajuta americanii să refacă această clădire prin plasarea, pe verticală, a unor blocuri de înălțimi <code>k</code>, <code>k=1</code>, …, <code>m</code>, și lățime <code>1</code>, în locurile avariate.

= Cerința =
Pentru o structură dată a unui perete din clădirea Pentagonului, determinaţi numărul minim al blocurilor, de înălţimi <code>k=1</code>, <code>k=2</code>, …, <code>k=m</code>, necesare refacerii clădirii.

= Date de intrare =
Fișierul de intrare <code>pentagon.in</code> conține pe prima linie dimensiunile <code>m</code> şi <code>n</code> ale peretelui clădirii, iar pe următoarele <code>m</code> linii câte o secvență de caractere <code>1</code> sau <code>0</code> de lungime <code>n</code>.

= Date de ieșire =
Fișierul de ieșire <code>pentagon.out</code> va conține pe câte o linie, ordonate crescător după <code>k</code>, perechi de forma <code>k nr</code>, unde <code>k</code> este înălțimea blocului, iar <code>nr</code> este numărul de blocuri de înălțime <code>k</code>, separate prin câte un spaţiu.

= Restricții și precizări =

* <code>1 ≤ m, n ≤ 200</code>
* nu se vor afișa blocurile de înălțime <code>k</code>, a căror număr este zero (<code>0</code>).

= Exemplu: =
<code>pentagon.in</code>
5 10
1110000111
1100001111
1000000011
1111101111
1110000111
<code>pentagon.out</code>
1 7
2 1
3 2
5 1
<syntaxhighlight lang="python" line="1">
def min_blocks_to_repair(matrix):
m = len(matrix)
n = len(matrix[0])
min_blocks = 0

for col in range(n):
row = 0
while row < m:
if matrix[row][col] == 0:
height = 1
while row + height < m and matrix[row + height][col] == 0:
height += 1
min_blocks += 1
row += height
else:
row += 1

return min_blocks

# Testare
matrix = [
[1, 1, 1, 0, 0, 0, 1, 1, 1],
[1, 1, 0, 0, 0, 0, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 1, 1],
[1, 1, 1, 1, 1, 0, 1, 1, 1],
[1, 1, 1, 0, 0, 0, 1, 1, 1]
]

print(min_blocks_to_repair(matrix)) # Output: 8
</syntaxhighlight>

2432 - Cruce

2024-07-26T08:17:41Z

RaulOtet: Pagină nouă: Se consideră o matrice pătratică de dimensiune <code>N</code>, conţinând numere naturale. Numim '''cruce de lăţime''' <code>K</code> reuniunea mulțimii tuturor elementelor aflate pe <code>K</code> linii consecutive ale matricei și a mulțimii tuturor elementelor aflate pe <code>K</code> coloane consecutive ale matricei. Două elemente ale matricei se consideră distincte dacă sunt situate pe poziții distincte în matrice. Se acceptă şi forma degenerată a unei cr...

Se consideră o matrice pătratică de dimensiune <code>N</code>, conţinând numere naturale. Numim '''cruce de lăţime''' <code>K</code> reuniunea mulțimii tuturor elementelor aflate pe <code>K</code> linii consecutive ale matricei și a mulțimii tuturor elementelor aflate pe <code>K</code> coloane consecutive ale matricei. Două elemente ale matricei se consideră distincte dacă sunt situate pe poziții distincte în matrice. Se acceptă şi forma degenerată a unei cruci, în formă de <code>T</code> sau <code>L</code>, când una dintre liniile sau coloanele care formează crucea sunt chiar la marginea matricei. Vom defini '''valoarea''' unei cruci ca fiind suma elementelor din care aceasta este formată.

= Cerința =
Scrieți un program care, pentru o valoare <code>K</code> dată, determină o cruce de lățime <code>K</code> a cărei valoare este maximă și poziția ei în matrice. Această poziție va fi exprimată prin perechea de indici reprezentând prima linie din cele <code>K</code> consecutive și prima coloană din cele <code>K</code> consecutive din care este formată crucea.

= Date de intrare =
Fişierul <code>cruce.in</code> conţine pe prima linie numerele <code>N</code> şi <code>K</code>, iar pe următoarele <code>N</code> linii câte <code>N</code> numere întregi reprezentând în ordine, pe linii, elementele matricei. Numerele de pe aceeaşi linie sunt separate prin câte un spaţiu.

= Date de ieșire =
Fişierul <code>cruce.out</code> va conţine trei numere <code>Vmax L C</code>, separate prin câte un spaţiu, reprezentând valoarea maximă determinată pentru o cruce de lățime <code>K</code>, respectiv linia și coloana care exprimă poziția acesteia în matrice.

= Restricții și precizări =

* <code>1 ≤ N ≤ 500</code>
* <code>1 ≤ K < N</code>
* Numerele din matrice sunt din intervalul <code>[-5000, 5000]</code>
* Liniile şi coloanele se indexează începând cu <code>1</code>.
* Dacă există mai multe cruci de lățime <code>K</code> de valoare maximă, se va lua în considerare poziția cu indicele '''liniei''' mai mic, iar în caz de egalitate a liniilor poziția celei cu indicele '''coloanei''' mai mic.
* La olimpiadă s-au oferit 10 puncte din oficiu, aici vor fi date pe exemple.

= Exemplu: =
<code>cruce.in</code>
5 2
1 -2 3 -1 4
-3 2 2 -2 -1
1 2 3 4 5
1 0 -7 1 1
3 2 1 2 3
<code>cruce.out</code>
23 2 4

=== Explicație ===
Elementele ce formează crucea de valoare maxima sunt:

1 -2 3 <code>-1 4</code>

<code>-3 2 2 -2 -1</code>

<code>1 2 3 4 5</code>

1 0 -7 <code>1 1</code>

3 2 1 <code>2 3</code>

<syntaxhighlight lang="python" line="1">
def calculeaza_prefix_sum(matrice, N):
prefix_sum = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
for j in range(1, N + 1):
prefix_sum[i][j] = matrice[i - 1][j - 1] \
+ prefix_sum[i - 1][j] \
+ prefix_sum[i][j - 1] \
- prefix_sum[i - 1][j - 1]
return prefix_sum

def suma_submatrice(prefix_sum, x1, y1, x2, y2):
return (prefix_sum[x2][y2]
- prefix_sum[x1 - 1][y2]
- prefix_sum[x2][y1 - 1]
+ prefix_sum[x1 - 1][y1 - 1])

def cruce_maxima(matrice, N, K):
prefix_sum = calculeaza_prefix_sum(matrice, N)
max_valoare = -1
max_pos = (0, 0)

for i in range(1, N - K + 2):
for j in range(1, N - K + 2):
# Suma liniilor K consecutive
suma_linii = 0
for r in range(K):
suma_linii += suma_submatrice(prefix_sum, i + r, j, i + r, j + K - 1)

# Suma coloanelor K consecutive
suma_coloane = 0
for c in range(K):
suma_coloane += suma_submatrice(prefix_sum, i, j + c, i + K - 1, j + c)

# Calculul valorii crucii
suma_cruce = suma_linii + suma_coloane - suma_submatrice(prefix_sum, i, j, i + K - 1, j + K - 1)

if suma_cruce > max_valoare:
max_valoare = suma_cruce
max_pos = (i, j)

return max_valoare, max_pos

def main():
import sys
input = sys.stdin.read
data = input().split()

N = int(data[0])
K = int(data[1])
matrice = []

index = 2
for _ in range(N):
matrice.append([int(x) for x in data[index:index + N]])
index += N

max_valoare, max_pos = cruce_maxima(matrice, N, K)
print(max_valoare)
print(max_pos[0], max_pos[1])

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

2359 - Cifre 13

2024-07-26T08:16:00Z

RaulOtet: Pagină nouă: Pe o foaie de matematică cu <code>N x M</code> pătrăţele, Maria desenează <code>C</code> cifre. Fiecare cifră este desenată într-o zonă formată din <code>7 x 4</code> pătrăţele albe şi negre denumite pixeli, aşa cum este ilustrat mai jos : Fiecare pixel ocupă exact un pătrăţel pe foaia de matematică. Evident, pe foaie Maria va desena doar pixelii negri. = Cerința = Determinaţi numărul de pătrăţele negre de pe foaia de matematică după ce au fost d...

Pe o foaie de matematică cu <code>N x M</code> pătrăţele, Maria desenează <code>C</code> cifre. Fiecare cifră este desenată într-o zonă formată din <code>7 x 4</code> pătrăţele albe şi negre denumite pixeli, aşa cum este ilustrat mai jos :

Fiecare pixel ocupă exact un pătrăţel pe foaia de matematică. Evident, pe foaie Maria va desena doar pixelii negri.

= Cerința =
Determinaţi numărul de pătrăţele negre de pe foaia de matematică după ce au fost desenate cele <code>C</code> cifre.

= Date de intrare =
Fișierul de intrare <code>cifre13.in</code> conţine pe prima linie numerele naturale <code>N M C</code> cu semnificaţia din enunţ. Pe fiecare dintre următoarele <code>C</code> linii se găseşte câte un triplet de numere naturale <code>t lin col</code> ce descrie cifrele scrise de Maria şi poziţiile acestora pe foaia de matematică. Mai exact, <code>t</code> este cifra ce va fi scrisă pe foaie, iar <code>lin col</code> reprezintă linia, respectiv coloana pe care este plasat colţul stânga-sus al zonei care reprezintă cifra în cadrul foii de matematică.

= Date de ieșire =
Fișierul de ieșire <code>cifre13.out</code> va conţine o singură linie pe care va fi scris numărul de pătrăţele negre existente pe foaia de matematică, după desenarea celor <code>C</code> cifre.

= Restricții și precizări =

* <code>1 ≤ N, M ≤ 1000</code>
* <code>1 ≤ C ≤ 100000</code>
* Liniile de pe foaia de matematică sunt numerotate de la <code>1</code> la <code>N</code>, iar coloanele de la <code>1</code> la <code>M</code>.
* <code>0 < lin , col ≤ 1000</code>
* <code>0 ≤ t ≤ 9</code>
* Zonele pe care sunt desenate cifrele se pot suprapune.
* Cifrele pot să încapă parţial pe foaie.

= Exemplu: =
<code>cifre13.in</code>
10 10 2
4 2 3
6 4 6
<code>cifre13.out</code>
23
<syntaxhighlight lang="python" line="1">
# Modelele pentru cifrele 0-9
cifre = {
'0': [
"1111",
"1001",
"1001",
"1001",
"1001",
"1001",
"1111"
],
'1': [
"0010",
"0110",
"0010",
"0010",
"0010",
"0010",
"1111"
],
'2': [
"1111",
"0001",
"0001",
"1111",
"1000",
"1000",
"1111"
],
'3': [
"1111",
"0001",
"0001",
"1111",
"0001",
"0001",
"1111"
],
'4': [
"1001",
"1001",
"1001",
"1111",
"0001",
"0001",
"0001"
],
'5': [
"1111",
"1000",
"1000",
"1111",
"0001",
"0001",
"1111"
],
'6': [
"1111",
"1000",
"1000",
"1111",
"1001",
"1001",
"1111"
],
'7': [
"1111",
"0001",
"0001",
"0001",
"0001",
"0001",
"0001"
],
'8': [
"1111",
"1001",
"1001",
"1111",
"1001",
"1001",
"1111"
],
'9': [
"1111",
"1001",
"1001",
"1111",
"0001",
"0001",
"1111"
]
}

def numar_patratele_negre(cifre, cifra):
"""Numără pătrățelele negre dintr-o cifră specifică"""
model = cifre[cifra]
return sum(row.count('1') for row in model)

def total_patratele_negre(cifre, lista_cifre):
"""Calculează numărul total de pătrățele negre pentru toate cifrele date"""
total = 0
for cifra in lista_cifre:
total += numar_patratele_negre(cifre, cifra)
return total

# Exemplu de utilizare
def main():
import sys
input = sys.stdin.read

# Citim datele
data = input().strip()
lista_cifre = data.split()

# Calculăm numărul total de pătrățele negre
total_negre = total_patratele_negre(cifre, lista_cifre)

# Afișăm rezultatul
print(total_negre)

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

2140 - Poartas

2024-07-26T08:14:12Z

RaulOtet: Pagină nouă: Se consideră harta universului ca fiind o matrice cu <code>250</code> de linii și <code>250</code> de coloane. În fiecare celulă se găsește o așa numită poartă stelară, iar în anumite celule se găsesc echipaje ale porții stelare. La o deplasare, un echipaj se poate deplasa din locul în care se află în oricare alt loc în care se găsește o a doua poartă, în cazul nostru în orice altă poziție din matrice. Nu se permite situarea simultană a mai mult de un...

Se consideră harta universului ca fiind o matrice cu <code>250</code> de linii și <code>250</code> de coloane. În fiecare celulă se găsește o așa numită poartă stelară, iar în anumite celule se găsesc echipaje ale porții stelare. La o deplasare, un echipaj se poate deplasa din locul în care se află în oricare alt loc în care se găsește o a doua poartă, în cazul nostru în orice altă poziție din matrice. Nu se permite situarea simultană a mai mult de un echipaj într o celulă. La un moment dat un singur echipaj se poate deplasa de la o poartă stelară la alta.

= Cerința =
Dându-se un număr <code>p</code> de echipaje, pentru fiecare echipaj fiind precizate poziția inițială și poziția finală, determinați numărul minim de deplasări necesare pentru ca toate echipajele să ajungă din poziția inițială în cea finală.

= Date de intrare =
Fișierul de intrare <code>poartas.in</code> conține pe prima linie numărul <code>p</code> reprezentând numărul echipaje, iar pe următoarele <code>p</code> linii câte <code>4</code> numere naturale, primele două reprezentând coordonatele poziției inițiale a unui echipaj (linie coloană), următoarele două reprezentând coordonatele poziției finale a aceluiași echipaj (linie coloană).

= Date de ieșire =
Fișierul de ieșire <code>poartas.out</code> va conține un singur număr reprezentând numărul minim de deplasări necesar.

= Restricții și precizări =

* coordonatele pozițiilor inițiale și finale ale echipajelor sunt numere naturale din intervalul <code>[1, 250]</code>
* <code>1 
* pozițiile inițiale ale celor <code>p</code> echipaje sunt distincte două câte două
* pozițiile finale ale celor <code>p</code> echipaje sunt distincte două câte două

= Exemplu: =
<code>poartas.in</code>
3
1 2 3 4
6 5 3 9
3 4 1 2
<code>poartas.out</code>
4
<syntaxhighlight lang="python" line="1">
def citire_date(nume_fisier):
import sys
input = sys.stdin.read
data = input().strip().split()

# Parcurgem datele
index = 0
p = int(data[index])
index += 1
echipaje = []
for _ in range(p):
x1, y1, x2, y2 = map(int, data[index:index+4])
echipaje.append(((x1, y1), (x2, y2)))
index += 4

return p, echipaje

def floyd_warshall(dist, noduri):
# Aplicam algoritmul lui Floyd-Warshall pentru toate perechile de noduri
for k in range(noduri):
for i in range(noduri):
for j in range(noduri):
if dist[i][j] > dist[i][k] + dist[k][j]:
dist[i][j] = dist[i][k] + dist[k][j]

def numar_minim_deplasari(p, echipaje):
# Initializare matrice de distante mari (infinite)
INF = float('inf')
# Creem un dictionar pentru a stoca distantele intre porțile stelare
noduri = {}
index_nod = 0
for ((x1, y1), (x2, y2)) in echipaje:
if (x1, y1) not in noduri:
noduri[(x1, y1)] = index_nod
index_nod += 1
if (x2, y2) not in noduri:
noduri[(x2, y2)] = index_nod
index_nod += 1

num_noduri = len(noduri)
dist = [[INF] * num_noduri for _ in range(num_noduri)]

# Setam distanta de la un nod la sine insusi la 0
for i in range(num_noduri):
dist[i][i] = 0

# Setam distantele initiale (doar distanta directa dintre noduri)
for ((x1, y1), (x2, y2)) in echipaje:
nod1 = noduri[(x1, y1)]
nod2 = noduri[(x2, y2)]
dist[nod1][nod2] = 1
dist[nod2][nod1] = 1

floyd_warshall(dist, num_noduri)

total_deplasari = 0
for ((x1, y1), (x2, y2)) in echipaje:
nod1 = noduri[(x1, y1)]
nod2 = noduri[(x2, y2)]
total_deplasari += dist[nod1][nod2]

return total_deplasari

def scrie_rezultate(nume_fisier, total_deplasari):
with open(nume_fisier, 'w') as f:
f.write(f"{total_deplasari}\n")

# Main function
def main():
p, echipaje = citire_date('date.in')
total_deplasari = numar_minim_deplasari(p, echipaje)
scrie_rezultate('date.out', total_deplasari)

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

3299 - Mostenire 2

2024-07-26T08:12:49Z

RaulOtet: Pagină nouă: Fibocel tocmai a moștenit o pădure gigantică de formă dreptunghiulară pe care vrea să o transforme într-un parc de distracții pentru copii. Cum își dă seama că este foarte mult de lucru și nu știe de unde să înceapă, s-a decis ca mai întâi să numere câte pădurici se află în pădurea moștenită. O pădurice este o suprafață dreptunghiulară înconjurată în totalitate de copaci, cu cel puțin o poieniță oriunde în interior. O poieniță este o su...

Fibocel tocmai a moștenit o pădure gigantică de formă dreptunghiulară pe care vrea să o transforme într-un parc de distracții pentru copii. Cum își dă seama că este foarte mult de lucru și nu știe de unde să înceapă, s-a decis ca mai întâi să numere câte pădurici se află în pădurea moștenită. O pădurice este o suprafață dreptunghiulară înconjurată în totalitate de copaci, cu cel puțin o poieniță oriunde în interior. O poieniță este o suprafață fără copaci. Cum Fibocel și-a dat seama că și acest lucru este dificil de realizat, s-a decis să vă ceară vouă ajutorul!

= Cerința =
Dându-se pădurea moștenită de Fibocel sub forma unui dreptunghi cu <code>N</code> linii și <code>M</code> coloane având doar valori de <code>0</code> și <code>1</code>, unde <code>0</code> înseamnă suprafață fără copac iar <code>1</code> înseamnă suprafață cu copac, spuneți câte pădurici se regăsesc în interiorul pădurii moștenite.

= Date de intrare =
Fișierul de intrare <code>mostenire.in</code> conține pe prima linie două numere naturale <code>N</code> și <code>M</code> separate prin exact un spațiu reprezentând dimensiunea pădurii. Pe fiecare dintre următoarele <code>N</code> linii se găsesc exact <code>M</code> caractere fără spațiu între ele, având doar valori de <code>0</code> și de <code>1</code>.

= Date de ieșire =
Fișierul de ieșire <code>mostenire.out</code> va conține un număr reprezentând răspunsul cerut de Fibocel.

= Restricții și precizări =

* <code>1 ≤ N ≤ 100</code>
* <code>1 ≤ M ≤ 1000</code>
* Păduricile se pot intersecta între ele.
* Pentru 15% dintre teste <code>N, M ≤ 30</code>.
* Pentru alte 35% dintre teste, <code>M ≤ 100</code>.

= Exemplu: =
<code>mostenire.in</code>
5 4
1111
1010
1111
1010
1110
<code>mostenire.out</code>
3
<syntaxhighlight lang="python" line="1">
def citire_date(nume_fisier):
with open(nume_fisier, 'r') as f:
N, M = map(int, f.readline().split())
matrice = [list(map(int, f.readline().split())) for _ in range(N)]
return N, M, matrice

def verifica_dreptunghi(matrice, x1, y1, x2, y2):
# Verificam marginile dreptunghiului
for i in range(x1, x2 + 1):
if matrice[i][y1] != 1 or matrice[i][y2] != 1:
return False
for j in range(y1, y2 + 1):
if matrice[x1][j] != 1 or matrice[x2][j] != 1:
return False

# Verificam daca exista cel putin un 0 in interior
for i in range(x1 + 1, x2):
for j in range(y1 + 1, y2):
if matrice[i][j] == 0:
return True

return False

def numara_padurici(N, M, matrice):
numar_padurici = 0

for x1 in range(N):
for y1 in range(M):
for x2 in range(x1 + 1, N):
for y2 in range(y1 + 1, M):
if verifica_dreptunghi(matrice, x1, y1, x2, y2):
numar_padurici += 1

return numar_padurici

def scrie_rezultate(nume_fisier, numar_padurici):
with open(nume_fisier, 'w') as f:
f.write(f"{numar_padurici}\n")

# Main function
def main():
N, M, matrice = citire_date('date.in')
numar_padurici = numara_padurici(N, M, matrice)
scrie_rezultate('date.out', numar_padurici)

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

1033 - Elicop

2024-07-26T08:11:44Z

RaulOtet: Pagină nouă: Un teren de fotbal este folosit pentru aterizarea elicopterelor. Gazonul de pe stadion este parcelat în pătrăţele de aceeaşi dimensiune, cu laturile paralele cu marginile terenului. Liniile cu pătrăţele de gazon sunt numerotate de sus în jos cu numerele <code>1</code>, <code>2</code>, …, <code>m</code>, iar coloanele cu pătrăţele de gazon sunt numerotate de la stânga la dreapta cu numerele <code>1</code>, <code>2</code>, …, <code>n</code>. Din cauza tipului d...

Un teren de fotbal este folosit pentru aterizarea elicopterelor. Gazonul de pe stadion este parcelat în pătrăţele de aceeaşi dimensiune, cu laturile paralele cu marginile terenului. Liniile cu pătrăţele de gazon sunt numerotate de sus în jos cu numerele <code>1</code>, <code>2</code>, …, <code>m</code>, iar coloanele cu pătrăţele de gazon sunt numerotate de la stânga la dreapta cu numerele <code>1</code>, <code>2</code>, …, <code>n</code>. Din cauza tipului diferit de iarbă se ştie care dintre pătrăţele de gazon sunt afectate sau nu de umbră. Acest lucru este precizat printr-un tablou bidimensional a cu <code>m</code> linii şi <code>n</code> coloane, cu elemente <code>0</code> şi <code>1</code> (<code>aij</code> <code>= 0</code> înseamnă că pătrăţelul aflat pe linia <code>i</code> şi coloana <code>j</code> este afectat de umbră, iar <code>aij</code> <code>= 1</code> înseamnă că pătrăţelul aflat pe linia <code>i</code> şi coloana <code>j</code> nu este afectat de umbră). Fiecare elicopter are <code>3</code> roţi pe care se sprijină. Roţile fiecărui elicopter determină un triunghi dreptunghic isoscel. Elicopterele aterizează, astfel încât triunghiurile formate să fie cu catetele paralele cu marginile terenului. În exemplul următor avem patru elicoptere.

Pentru a preciza poziţia unui elicopter pe teren este suficient să cunoaştem linia şi coloana vărfurilor ipotenuzei şi poziţia vârfului deasupra (codificată prin <code>1</code>) sau dedesubtul ipotenuzei (codificată prin <code>-1</code>). Pentru exemplu, elicopterul din stânga sus este dat prin <code>(1,1)</code>, <code>(3,3)</code> şi <code>-1</code>, cel din dreapta sus prin <code>(1,9)</code>, <code>(5,5)</code> şi <code>1</code>, cel din stânga jos prin <code>(5,1)</code>, <code>(6,2)</code> şi <code>1</code>, iar cel din dreapta jos prin <code>(5,9)</code>, <code>(6,8)</code> şi <code>1</code>.

Un elicopter se consideră că a aterizat ''greşit'', dacă triunghiul format sub el (definit mai sus) are mai mult de jumătate din pătrăţele afectate de umbră.

Administratorul terenului de fotbal doreşte să determine numărul <code>N1</code> de elicoptere, care nu afectează nici un pătrăţel din teren şi numerele de ordine al elicopterelor, care au aterizat ''greşit'' în ordine crescătoare: <code>e1</code>, <code>e2</code>, …, <code>eN2</code>, ştiind că există <code>k</code> elicoptere codificate prin numerele <code>1</code>, <code>2</code>, …, <code>k</code>.

= Cerința =
Scrieţi un program care să determine, pentru fişierul cu datele din enunţ: numărul de elicoptere <code>N1</code>, care nu afectează nici un pătrăţel din teren şi numerele de ordine al elicopterelor, care au aterizat ''greşit'' în ordine crescătoare, precedate de numărul lor <code>N2</code>.

= Date de intrare =
Fișierul de intrare <code>elicop.in</code> conține pe prima linie două numere naturale <code>m</code> şi <code>n</code>, separate printr-un spaţiu, cu semnificaţia din enunţ. Următoarele <code>m</code> linii conţin câte <code>n</code> numere <code>0</code> sau <code>1</code>, separate prin câte un spaţiu cu semnificaţia <code>0</code> – pătrăţel de gazon care este afectat de umbră, respectiv <code>1</code>- pătrăţel care nu este afectat de umbră. Pe linia <code>m+2</code> se află numărul de elicoptere <code>k</code>, iar pe următoarele <code>k</code> linii (în ordinea codificării lor <code>1</code>, <code>2</code>, …, <code>k</code>) câte cinci numere separate prin cate un spaţiu, pentru liniile şi coloanele ipotenuzelor şi poziţia vârfului (<code>1</code> sau <code>-1</code>), triunghiurilor dreptunghice asociate elicopterelor:

<code>L1 C1 L2 C2 p</code>.

= Date de ieșire =
Fișierul de ieșire <code>elicop.out</code> va conține două linii: prima linie numărul <code>N1</code> de elicoptere, care nu afectează nici un pătrăţel din teren, a doua linie cu numerele naturale <code>N2</code>, <code>e1</code>, <code>e2</code>, …, <code>eN2</code> separate prin câte un spaţiu, în ordine crescătoare.

= Restricții și precizări =

* <code>2 ≤ m,n ≤ 100</code>; <code>1 ≤ k ≤ 40</code>
* Nu există suprapuneri de triunghiuri asociate la două elicoptere. Triunghiurile asociate elicopterelor conţin cel puţin trei pătrăţele.

= Exemplu: =
<code>elicop.in</code>
7 9
1 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0
0 0 1 0 1 1 1 0 0
1 1 1 0 1 1 0 1 1
0 0 1 1 1 1 0 1 1
1 1 1 1 1 1 0 1 1
1 1 1 1 1 1 0 0 1
4
1 1 3 3 -1
1 9 5 5 1
5 1 6 2 1
5 9 6 8 1
<code>elicop.out</code>
2
2 1 3

= Explicație =
Elicopterele <code>2</code> şi <code>4</code> nu afectează niciun pătrăţel de gazon.

Elicopterele <code>1</code> şi <code>3</code> afectează fiecare mai mult de jumătate din numărul pătrăţelelor asociate triunghiurilor dreptunghice şi deci aterizează greşit. Elicopterul <code>1</code> face umbră la <code>6</code> pătrăţele, din care afectate sunt <code>4</code>.

Elicopterul <code>3</code> face umbră la <code>3</code> pătrăţele, din care afectate sunt două.

<syntaxhighlight lang="python" line="1">
def citire_date(nume_fisier):
with open(nume_fisier, 'r') as f:
m, n = map(int, f.readline().split())
a = [list(map(int, f.readline().split())) for _ in range(m)]
k = int(f.readline())
elicoptere = []
for _ in range(k):
lin1, col1, lin2, col2, poz = map(int, f.readline().split())
elicoptere.append((lin1, col1, lin2, col2, poz))
return m, n, a, k, elicoptere

def triunghi_umbre(m, n, a, lin1, col1, lin2, col2, poz):
umbite = 0
total = 0
if poz == 1:
for i in range(lin1, lin2+1):
for j in range(col1, col2+1):
total += 1
if a[i-1][j-1] == 0:
umbite += 1
else:
for i in range(lin2, lin1+1):
for j in range(col1, col2+1):
total += 1
if a[i-1][j-1] == 0:
umbite += 1
return umbite, total

def verifica_aterizari(m, n, a, k, elicoptere):
n1 = 0
elicoptere_gresite = []
for idx, (lin1, col1, lin2, col2, poz) in enumerate(elicoptere, start=1):
umbite, total = triunghi_umbre(m, n, a, lin1, col1, lin2, col2, poz)
if umbite == 0:
n1 += 1
elif umbite > total / 2:
elicoptere_gresite.append(idx)
return n1, elicoptere_gresite

def scrie_rezultate(nume_fisier, n1, elicoptere_gresite):
with open(nume_fisier, 'w') as f:
f.write(f"{n1}\n")
f.write(f"{len(elicoptere_gresite)} {' '.join(map(str, elicoptere_gresite))}\n")

# Main function
def main():
m, n, a, k, elicoptere = citire_date('date.in')
n1, elicoptere_gresite = verifica_aterizari(m, n, a, k, elicoptere)
scrie_rezultate('date.out', n1, elicoptere_gresite)

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

3007 - Tort 1

2024-07-26T06:19:24Z

RaulOtet: Pagină nouă: De ziua lui, Gigel a primit un tort de formă dreptunghiulară, ornat cu un caroiaj ce împarte tortul în <code>m x n</code> pătrate, în fiecare pătrat aflându-se câte o cireașă sau o căpșună. Caroiajul cu fructe este reprezentat printr-o matrice cu <code>0</code> şi <code>1</code>, <code>0</code> însemnând cireaşă şi <code>1</code> căpşună. Sărbătoritul are dreptul să taie <code>k</code> felii de tort. O felie se poate obține prin tăierea după linii...

De ziua lui, Gigel a primit un tort de formă dreptunghiulară, ornat cu un caroiaj ce împarte tortul în <code>m x n</code> pătrate, în fiecare pătrat aflându-se câte o cireașă sau o căpșună. Caroiajul cu fructe este reprezentat printr-o matrice cu <code>0</code> şi <code>1</code>, <code>0</code> însemnând cireaşă şi <code>1</code> căpşună. Sărbătoritul are dreptul să taie <code>k</code> felii de tort. O felie se poate obține prin tăierea după liniile caroiajului, dintr-un capăt în celălalt, având lățimea egală cu <code>1</code>, de pe oricare latură a tortului, codificate cu <code>N</code>, <code>E</code>, <code>S</code>, <code>V</code>. Gigel fiind mare amator de căpşuni vrea să taie cele <code>k</code> felii astfel încât numărul căpşunilor din aceste felii să fie cât mai mare. Spre exemplu, dacă tortul iniţial este reprezentat ca o matrice având <code>6 x 6</code> linii şi coloane, după <code>3</code> tăieturi <code>N</code>, <code>E</code>, <code>V</code> bucata rămasă şi feliile obţinute vor fi conform figurii alăturate.

= Cerința =
Să se scrie un program care să determine numărul de posibilităţi de tăiere a <code>k</code> felii de tort, pentru a obţine un număr maxim de căpşuni. Două variante în care diferă doar ordinea de tăiere, dar rămâne aceeaşi bucată de tort, nu sunt considerate distincte. De exemplu, dacă numărul maxim de căpşuni se poate obţine prin una din variantele : <code>VSNNV</code> sau <code>VVNSN</code>, acestea nu sunt considerate distincte.

= Date de intrare =
Pe prima linie a fişierului de intrare <code>tort.in</code> sunt scrise dimensiunile tortului, <code>m</code> şi <code>n</code> şi numărul <code>k</code> al feliilor de tort tăiate de Gigel, separate prin câte un spaţiu. Pe următoarele <code>m</code> linii e descris caroiajul cu fructe printr-o matrice cu valori de <code>0</code> şi <code>1</code>.

= Date de ieșire =
Prima linie a fişierului <code>tort.out</code> va conţine numărul maxim de căpşuni care poate fi obţinut din cele <code>k</code> felii de tort. Pe linia a doua se va găsi numărul de posibilităţi distincte de a obţine numărul maxim de căpşuni.

= Restricții și precizări =

* <code>2 ≤ m, n ≤ 500</code>
* <code>1 ≤ k < min(m, n)</code>

= Exemplu: =
<code>tort.in</code>
6 6 3
0 1 1 1 0 1
1 0 0 0 0 1
0 0 0 1 0 0
0 1 0 1 0 1
1 0 0 0 0 0
1 1 1 0 0 1
<code>tort.out</code>
10
5

=== Explicație ===
Tortul este format dintr-un caroiaj cu <code>m = 6</code> linii şi <code>n = 6</code> coloane şi se pot tăia <code>k = 3</code> felii. Se pot obţine maximum <code>10</code> căpşuni. Cele <code>5</code> posibilităţi de a tăia cele trei felii sunt: <code>NNS</code>, <code>NSE</code>, <code>NSV</code>, <code>VEV</code> şi <code>NEV</code>.

<syntaxhighlight lang="python" line="1">
def count_strawberries(matrix):
return sum(sum(row) for row in matrix)

def cut_slice(matrix, direction):
if direction == 'N':
return matrix[0], matrix[1:]
elif direction == 'S':
return matrix[-1], matrix[:-1]
elif direction == 'E':
return [row[-1] for row in matrix], [row[:-1] for row in matrix]
elif direction == 'V':
return [row[0] for row in matrix], [row[1:] for row in matrix]

def max_strawberries(matrix, k):
from itertools import combinations_with_replacement

m = len(matrix)
n = len(matrix[0])
directions = ['N', 'E', 'S', 'V']

max_straws = 0
for cuts in combinations_with_replacement(directions, k):
temp_matrix = [row[:] for row in matrix]
total_straws = 0
for cut in cuts:
slice_straws, temp_matrix = cut_slice(temp_matrix, cut)
total_straws += sum(slice_straws)
max_straws = max(max_straws, total_straws)

return max_straws

# Exemplu de utilizare
matrix = [
[0, 1, 0, 1, 0, 1],
[1, 1, 0, 0, 1, 0],
[0, 0, 1, 1, 0, 1],
[1, 0, 0, 1, 1, 0],
[0, 1, 1, 0, 0, 1],
[1, 0, 1, 0, 1, 0]
]
k = 3
print(max_strawberries(matrix, k)) # Afișează numărul maxim de căpșuni care pot fi obținute
</syntaxhighlight>

2558 - Shootings

2024-07-26T06:17:41Z

RaulOtet: Pagină nouă: De când a început serviciul militar, Mihai nu și-a găsit vocația și a decis să-și încerce norocul încă o dată, mergând la superiorul său, Căpitanul Dan. De data aceasta, Dan a fost mai amabil, dar i-a cerut lui Mihai să demonstreze talentul său de trăgător. Vom considera țintele din zona de tragere ca fiind dreptunghiuri în plan. Căpitanul îi indică lui Mihai câteva puncta pe axa <code>OX</code> și direcțiile de tragere. Fiecare tragere este o se...

De când a început serviciul militar, Mihai nu și-a găsit vocația și a decis să-și încerce norocul încă o dată, mergând la superiorul său, Căpitanul Dan. De data aceasta, Dan a fost mai amabil, dar i-a cerut lui Mihai să demonstreze talentul său de trăgător.

Vom considera țintele din zona de tragere ca fiind dreptunghiuri în plan. Căpitanul îi indică lui Mihai câteva puncta pe axa <code>OX</code> și direcțiile de tragere. Fiecare tragere este o semidreaptă care poate fi orientată fie diagonal spre stânga la <code>45o</code>, fie diagonal spre dreapta la <code>45o</code>, fie pe verticală în sus.

Definim costul atingerii unei ținte ca fiind lungimea intersecției semidreptei de tragere cu dreptunghiul care reprezintă ținta. Dacă intersecția este vidă, sau constă dintr-un singur punct, atunci costul este <code>0</code>. Definim costul unei trageri ca suma costurilor atingerilor tuturor țintelor.

= Cerința =
Determinați costul fiecărei trageri.

= Date de intrare =
Fișierul de intrare <code>shootings.in</code> conține pe prima linie numărul natural <code>N</code>, reprezentând numărul de dreptunghiuri-ținte. Fiecare din următoarele <code>N</code> linii, conține descrierea unui dreptunghi–țintă: patru numere naturale, <code>X1</code>, <code>Y1</code>, <code>X2</code>, <code>Y2</code>, care reprezintă coordonatele colțului din stânga-jos și dreapta-sus, respectiv. Cele partu numere sunt separate prin câte un spațiu. Urmează o linie care conține numărul natural <code>T</code>, reprezentând numărul de împușcături. Fiecare din următoarele <code>T</code> linii, conține două numere întregi <code>P</code> și <code>D</code>, separate prin spațiu. Primul număr reprezintă coordonata <code>X</code> a punctului de tragere, cel de al doilea – direcția de tragere (<code>D = 1</code> corespunde unei trageri verticale, <code>D = 2</code> corespunde unei trageri diagonale spre stânga și <code>D = 3</code> corespunde unei trageri diagonale spre dreapta).

= Date de ieșire =
Fișierul de ieșire <code>shootings.out</code> are <code>T</code> linii. Fiecare linie conține un număr întreg non-negativ, care reprezintă pătratul costului unei trageri. Pătratele costurilor apar în fișierul de ieșire în aceeași ordine în care tragerile apar în fișierul de intrare. Reamintim că pentru fiecare din costurile determinate, se va scrie pătratul valorii sale.

= Restricții și precizări =

* <code>1 ≤ N ≤ 50000</code>
* <code>1 ≤ T ≤ 100000</code>
* <code>1 ≤ X1 < X2 ≤ 100000</code>, <code>1 ≤ Y1 < Y2 ≤ 100000</code>
* <code>-100000 ≤ P ≤ 200000</code>
* toate laturile dreptunghiurilor sunt paralele axei <code>OX</code> sau <code>OY</code>
* oricare două dreptunghiuri nu se intersectează (nu au nici un punct comun) și nu există dreptunghiuri incluse unul în celălalt.
* dreptunghiurile pot fi pătrate
* dreptunghiurile au arie diferită de <code>0</code>
* pot exista trageri identice
* de remarcat că numerele din fișierul de ieșire sunt întregi, non-negative

= Exemplu: =
<code>shootings.in</code>
4
1 1 4 3
2 4 5 7
6 3 10 5
8 1 9 2
2
0 3
9 1
<code>shootings.out</code>
18
9
<syntaxhighlight lang="python" line="1">
def calculate_intersection_length(rect, ray_origin, direction):
x1, y1, x2, y2 = rect
x0, y0 = ray_origin

if direction == "left":
# Equation of the line: y = -(x - x0) + y0 (negative slope)
intersections = []
# Check intersection with left side of the rectangle
y = -(x1 - x0) + y0
if y1 <= y <= y2:
intersections.append((x1, y))
# Check intersection with bottom side of the rectangle
x = -(y1 - y0) + x0
if x1 <= x <= x2:
intersections.append((x, y1))
# Check intersection with top side of the rectangle
x = -(y2 - y0) + x0
if x1 <= x <= x2:
intersections.append((x, y2))

elif direction == "right":
# Equation of the line: y = (x - x0) + y0 (positive slope)
intersections = []
# Check intersection with right side of the rectangle
y = (x2 - x0) + y0
if y1 <= y <= y2:
intersections.append((x2, y))
# Check intersection with bottom side of the rectangle
x = (y1 - y0) + x0
if x1 <= x <= x2:
intersections.append((x, y1))
# Check intersection with top side of the rectangle
x = (y2 - y0) + x0
if x1 <= x <= x2:
intersections.append((x, y2))

elif direction == "up":
# Vertical line upwards
intersections = []
# Check intersection with top side of the rectangle
if x1 <= x0 <= x2:
intersections.append((x0, y2))
# Check intersection with bottom side of the rectangle
if x1 <= x0 <= x2:
intersections.append((x0, y1))

# Calculate length of intersection segment
if len(intersections) == 2:
(xA, yA), (xB, yB) = intersections
return ((xB - xA)**2 + (yB - yA)**2)**0.5
else:
return 0

def calculate_shooting_cost(rectangles, shots):
costs = []
for shot in shots:
origin, direction = shot
total_cost = 0
for rect in rectangles:
total_cost += calculate_intersection_length(rect, origin, direction)
costs.append(total_cost)
return costs

# Exemplu de utilizare
rectangles = [
(1, 1, 4, 4), # dreptunghi definit prin (x1, y1, x2, y2)
(5, 3, 7, 5)
]

shots = [
((2, 0), "left"), # tragere de la (2, 0) în direcția diagonală stânga
((6, 0), "right"), # tragere de la (6, 0) în direcția diagonală dreapta
((3, 0), "up") # tragere de la (3, 0) în direcția verticală în sus
]

costs = calculate_shooting_cost(rectangles, shots)
for i, cost in enumerate(costs):
print(f"Costul tragerii {i+1}: {cost}")
</syntaxhighlight>

2439 - T Bile

2024-07-26T06:15:48Z

RaulOtet: Pagină nouă: Roboțelul Nino a primit cadou un dispozitiv care inscripționează bile. Dispozitivul poate fi încărcat cu n bile, ce vor fi inscripționate în ordine, cu numerele <code>1</code>, <code>2</code>, …, <code>n</code>. Nino trebuie să împartă bilele inscripționate în două șiruri, <code>X</code> și <code>Y</code>, astfel: - La primul pas Nino va pune în primul șir bila cu numărul <code>1</code> (<code>X[1] = 1</code>), iar în al doilea șir bila cu numărul <co...

Roboțelul Nino a primit cadou un dispozitiv care inscripționează bile. Dispozitivul poate fi încărcat cu n bile, ce vor fi inscripționate în ordine, cu numerele <code>1</code>, <code>2</code>, …, <code>n</code>.

Nino trebuie să împartă bilele inscripționate în două șiruri, <code>X</code> și <code>Y</code>, astfel:

- La primul pas Nino va pune în primul șir bila cu numărul <code>1</code> (<code>X[1] = 1</code>), iar în al doilea șir bila cu numărul <code>2</code> (<code>Y[1] = 2</code>).

- La al doilea pas Nino va pune în primul șir bila cu numărul <code>3</code> (<code>X[2] = 3</code>), iar în al doilea șir bila cu numărul <code>4</code> (<code>Y[2] = 4</code>).

- La fiecare pas <code>i ≥ 3</code> Nino va pune în șirul <code>X</code> bila <code>X[i] = X[i-1] + Y[i-1]</code>, iar în șirul <code>Y</code>, în ordine crescătoare, bilele numerotate cu <code>X[i-1]+1</code>, <code>X[i-1]+2</code>, …, <code>X[i]-1</code>, cu excepția bilei <code>4</code> care a fost pusă deja.

Dacă la un pas <code>k</code>, <code>X[k] > n</code>, bilele rămase vor fi inscripționate cu valorile <code>X[k-1]+1</code>, <code>X[k-1]+2</code>, …, <code>n</code> și vor fi puse în șirul <code>Y</code>.

Pentru că bilele se rostogolesc, Nino împachetează în tuburi verticale de culoare galbenă, bilele din primul șir, iar în tuburi verticale de culoare roșie, bilele din al doilea șir. În fiecare tub încap cel mult <code>m</code> bile, dispuse pe o singură coloană. Tuburile sunt așezate vertical, întâi cele galbene, în ordinea umplerii, apoi cele roșii în ordinea umplerii lor. Bilele de la baza fiecărui tub formează nivelul <code>1</code>, cele situate imediat deasupra lor formează nivelul <code>2</code> etc., nivelul maxim putând fi <code>m</code>.

= Cerința =
Se dau numerele naturale <code>n</code> și <code>m</code> și se cere să se determine:

1. Numărul de tuburi de culoare roșie necesare pentru a împacheta bilele din șirul <code>Y</code> și numărul total de bile conținute de acestea.

2. Pentru un nivel <code>v</code> dat, suma numerelor inscripționate pe bilele de pe nivelul <code>v</code>.

= Date de intrare =
Fișierul de intrare <code>tbile.in</code> conţine pe prima linie un număr natural <code>c</code> reprezentând cerința care trebuie să fie rezolvată (<code>1</code> sau <code>2</code>), pe a doua linie un număr natural <code>n</code>, reprezentând numărul de bile ce se inscripționează, iar pe cea de a treia linie un număr natural <code>m</code>, reprezentând numărul de bile care încap într-un tub. Dacă cerința este <code>c = 2</code>, fișierul de intrare conține, în plus, pe a patra linie, un număr natural <code>v</code> reprezentând numărul unui nivel.

= Date de ieșire =
Dacă cerința este <code>c = 1</code>, atunci, pe prima linie a fișierului <code>tbile.out</code>, vor fi scrise două numere naturale, separate printr-un spațiu, reprezentând, în această ordine, numărul de tuburi de culoare roșie necesare pentru a împacheta bilele din șirul <code>Y</code>, respectiv, numărul total de bile conținute de acestea.

Dacă cerința este <code>c = 2</code>, atunci, pe prima linie a fișierului <code>tbile.out</code> va fi scris un număr natural reprezentând suma numerelor inscripționate pe bilele de pe nivelul <code>v</code>.

= Restricții și precizări =

* <code>5 ≤ n ≤ 2 000 000 000</code>
* <code>1 ≤ c ≤ m ≤ 311445015</code>
* Se acordă <code>30</code> de puncte pentru rezolvarea corectă a cerinței 1 și <code>60</code> de puncte pentru rezolvarea corectă a cerinței 2.
* În concurs s-au acordat <code>10</code> puncte din oficiu. Aici se acordă punctele pentru exemplele din enunț.

= Exemplul 1: =
<code>tbile.in</code>
1
36
5
<code>tbile.out</code>
6 29

=== Explicație ===
Primul șir va conține <code>7</code> bile (<code>1</code>, <code>3</code>, <code>7</code>, <code>12</code>, <code>18</code>, <code>26</code>, <code>35</code>), iar cel de al doilea <code>36-7=29</code> de bile (ca în figura de mai sus). Sunt necesare <code>6</code> tuburi de capacitate <code>5</code>.

= Exemplul 2: =
<code>tbile.in</code>
2
36
5
3
<code>tbile.out</code>
126

=== Explicație ===
Pe nivelul <code>3</code> se găsesc bilele inscripționate cu numerele <code>7</code>, <code>5</code>, <code>11</code>, <code>17</code>, <code>23</code>, <code>29</code> și <code>34</code>. Suma acestor valori este <code>126</code>.

<syntaxhighlight lang="python" line="1">
def calculate_balls_and_tubes(n, m, v):
# Initialize X and Y
X = [1]
Y = [2]
current_num = 3

# Build X and Y sequences
while True:
if len(X) < 2:
X.append(current_num)
current_num += 1
else:
next_x = X[-1] + Y[-1]
if next_x > n:
break
X.append(next_x)
for i in range(X[-2] + 1, next_x):
if i != 4:
Y.append(i)
current_num = next_x + 1

# Add remaining balls to Y
for i in range(X[-1] + 1, n + 1):
if i != 4:
Y.append(i)

# Number of red tubes and total balls in Y
red_tubes = (len(Y) + m - 1) // m
total_balls_in_red_tubes = len(Y)

# Calculate the sum of the numbers on level v
sum_on_level_v = 0

# Yellow tubes (X balls)
for i in range(len(X)):
if (i // m) + 1 == v:
sum_on_level_v += X[i]

# Red tubes (Y balls)
for i in range(len(Y)):
if (i // m) + 1 == v:
sum_on_level_v += Y[i]

return red_tubes, total_balls_in_red_tubes, sum_on_level_v

# Exemplu de utilizare
n = 10 # numărul total de bile
m = 3 # capacitatea unui tub
v = 2 # nivelul dorit

red_tubes, total_balls_in_red_tubes, sum_on_level_v = calculate_balls_and_tubes(n, m, v)
print(f"Numărul de tuburi roșii necesare: {red_tubes}")
print(f"Numărul total de bile din tuburile roșii: {total_balls_in_red_tubes}")
print(f"Suma numerelor inscripționate pe bilele de pe nivelul {v}: {sum_on_level_v}")
</syntaxhighlight>

2010 - Fermier

2024-07-26T06:14:04Z

RaulOtet: Pagină nouă: Dorel și-a achiziționat o fermă cu <code>n</code> plantații și o mașină de transport cu o capacitate <code>c</code>, pentru transportul de îngrășăminte la toate plantațiile. Îngrășămintele se află într-un depozit, în cantitate suficientă pentru scopul propus. Plantațiile și depozitul sunt dispuse sub forma unui cerc. Există drumuri doar între plantația <code>i</code> și plantația <code>i+1</code> (<code>1≤i≤n-1</code>), precum și între depozit...

Dorel și-a achiziționat o fermă cu <code>n</code> plantații și o mașină de transport cu o capacitate <code>c</code>, pentru transportul de îngrășăminte la toate plantațiile. Îngrășămintele se află într-un depozit, în cantitate suficientă pentru scopul propus. Plantațiile și depozitul sunt dispuse sub forma unui cerc. Există drumuri doar între plantația <code>i</code> și plantația <code>i+1</code> (<code>1≤i≤n-1</code>), precum și între depozit și plantația <code>1</code> și depozit și plantația <code>n</code>, ca în figură.

La o plantație <code>i</code> se poate ajunge de la depozit trecând prin plantațiile <code>1</code>, <code>2</code>,…, <code>i-1</code> sau prin plantațiile <code>n</code>, <code>n-1</code>, …, <code>i+1</code>, alegerea făcându-se în funcție de traseul cel mai scurt. Se cunosc aceste distanțe, precum și cantitatea de îngrășăminte necesară pentru fiecare plantație. La fiecare încărcare, Dorel ia din depozit exact cantitatea <code>c</code>. Dorel vrea să-și organizeze bine munca la fermă și să consume cât mai puțină benzină prin alegerea celor mai scurte trasee de parcurs. Plantațiile trebuie să fie aprovizionate obligatoriu în ordinea următoare: mai întâi plantația <code>1</code>, apoi plantația <code>2</code>, plantația <code>3</code>,…, plantația <code>n</code>. În plus, și-a propus să încarce o nouă cantitate de îngrășământ doar după ce a folosit toată cantitatea încărcată anterior. Transportarea îngrășămintelor pe plantații se face deci, începând cu plantația <code>1</code>. După ce se transportă toată cantitatea necesară pentru această plantație, se trece la plantația <code>2</code>, și tot așa în ordine la <code>3</code>, <code>4</code> etc. până se deservește ultima plantație. Dacă după ce s-au transportat îngrășămintele necesare pentru plantația <code>i</code> în mașină au mai rămas încă îngrășăminte, acestea trebuie utilizate în continuare pentru alte plantații, alese în ordinea impusă (începând cu plantația <code>i+1</code>, apoi <code>i+2</code> etc.), până se epuizează toată cantitatea transportată de mașină. Astfel, dacă de la plantația <code>i</code> trebuie să ajungă la plantația <code>i+1</code>, va alege cel mai scurt traseu dintre traseul direct de la plantația <code>i</code> la <code>i+1</code> și traseul care trece prin plantațiile <code>i-1</code>, <code>i-2</code>, …, <code>1</code>, depozit, <code>n</code>, <code>n-1</code>, …, <code>i+1</code>. La final, mașina trebuie să se întoarcă la depozit, goală sau cu cantitatea rămasă după aprovizionarea cu îngrășăminte a plantației <code>n</code>.

= Cerința =
Ajutați-l pe Dorel să calculeze distanța parcursă pentru a transporta îngrășăminte la toate cele <code>n</code> plantații, conform cerințelor.

= Date de intrare =
Fișierul de intrare <code>fermier.in</code> conține pe prima linie numerele naturale <code>n</code> și <code>c</code>, separate printr-un spațiu. A doua linie conține numerele naturale <code>d[0]</code>, <code>d[1]</code>, <code>d[2]</code>, …, <code>d[n-1]</code>, <code>d[n]</code> separate două câte două prin câte un spaţiu, unde <code>d[0]</code> este distanța dintre prima plantație și depozit, <code>d[i]</code> (<code>1≤i≤n-1</code>) este distanța între plantația <code>i</code> și plantația <code>i+1</code>, iar <code>d[n]</code> este distanța dintre plantația <code>n</code> și depozit. Pe linia a treia se găsesc numerele naturale <code>q[1]</code>, <code>q[2]</code>,…, <code>q[n-1]</code>, <code>q[n]</code> separate două câte două prin câte un spaţiu, <code>q[i]</code> reprezentând cantitatea de îngrășăminte necesară pentru plantația <code>i</code> (<code>1≤i≤n</code>).

= Date de ieșire =
Fișierul de ieșire <code>fermier.out</code> va conține pe prima linie un număr natural conform cerinţei.

= Restricții și precizări =

* <code>1 ≤ n ≤ 100</code>
* <code>1 ≤ n ≤ 2</code>, pentru teste în valoare de 20 de puncte;
* <code>1 ≤ d[i] ≤ 1000</code>, <code>1 ≤ i ≤ n</code>;
* <code>1 ≤ q[i] ≤ 1000</code>, <code>1 ≤ i ≤ n</code>;
* <code>1 ≤ c ≤ 1000</code>;
* În concurs s-au acordat 10 puncte din oficiu. Pe site se acordă 10 puncte pentru exemplu.

= Exemplu: =
<code>fermier.in</code>
3 6
1 10 2 3
13 2 7
<code>fermier.out</code>
22

=== Explicație ===
La plantația <code>1</code> trebuie transportată o cantitate egală cu <code>13</code>, valoarea maximă pe care o poate transporta mașina fiind de <code>6</code>. La plantația <code>1</code> se ajunge pe drumul cel mai scurt direct de la depozit. Astfel se va merge mai întâi cu cantitatea <code>6</code>, ne întoarcem la depozit, încărcam iar mașina, ducem <code>6</code>, ne întoarcem, încărcăm și lăsăm doar <code>1</code> (atât mai este necesar). Pentru aceasta, s-a parcurs distanța de <code>1+1+1+1+1=5</code>. În mașină a mai rămas acum o cantitate egală cu <code>5</code>. Trebuie să mergem acum la plantația <code>2</code> pe drumul cel mai scurt. Pe drumul direct distanța este <code>10</code>, iar pe drumul invers care trece iar prin depozit este <code>6</code> (<code>1+3+2</code>). Vom alege drumul cu distanța <code>6</code>. Lăsăm cantitatea <code>2</code> (atât e necesar plantației <code>2</code>), ne mai rămân <code>3</code> și pentru plantația <code>3</code>. De la plantația <code>2</code> se ajunge direct la plantația <code>3</code> pe o distanță egală cu <code>2</code> sau invers, trecând prin depozit pe o distanță de <code>14</code> (<code>10+1+3</code>). Alegem drumul cu distanța <code>2</code>. Lăsăm îngrășămintele rămase și mai mergem iar la depozit, încărcăm și lăsăm <code>4</code> la plantația <code>3</code>. Pentru aceasta mai parcurgem distanța <code>3+3</code>. La final mașina trebuie să se întoarcă la depozit, deci încă un drum cu distanța <code>3</code>. În total: <code>5+6+2+6+3=22</code>.

<syntaxhighlight lang="python" line="1">
def shortest_distance(depot_to_1, depot_to_n, distances, c, requirements):
n = len(requirements)
total_distance = 0
current_fertilizer = 0

# Helper function to calculate shortest path between two plantations
def calculate_shortest_path(i, j):
if i < j:
direct_path = sum(distances[i:j])
else:
direct_path = sum(distances[j:i])
through_depot = depot_to_1 + depot_to_n
return min(direct_path, through_depot)

# Start from depot to the first plantation
total_distance += depot_to_1
current_index = 0

while current_index < n:
# If not enough fertilizer, go back to depot
if current_fertilizer < requirements[current_index]:
total_distance += depot_to_1 # Return to depot
current_fertilizer = c
total_distance += depot_to_1 # Go back to the current plantation

# Fulfill the current plantation's requirement
while current_index < n and current_fertilizer >= requirements[current_index]:
current_fertilizer -= requirements[current_index]
current_index += 1
if current_index < n:
total_distance += calculate_shortest_path(current_index - 1, current_index)

# Return to depot after the last plantation
total_distance += depot_to_1

return total_distance

# Example of usage:
depot_to_1 = 10
depot_to_n = 15
distances = [5, 8, 10, 12, 6] # Distances between consecutive plantations
c = 20 # Capacity of the truck
requirements = [5, 10, 8, 12, 6] # Fertilizer requirements for each plantation

result = shortest_distance(depot_to_1, depot_to_n, distances, c, requirements)
print(result)
</syntaxhighlight>

1492 - Bunicul

2024-07-26T06:12:12Z

RaulOtet: Pagină nouă: _”Se scutură din salcâmi o ploaie de miresme. Bunicul stă pe prispă. Se gândește. La ce se gândește? La nimic. Înnumără florile care cad. Se uită-n fundul grădinii. Se scarpină-n cap. Iar înnumără florile scuturate de adiere. Pletele lui albe și crețe parcă sunt niște ciorchini de flori albe; sprâncenele, mustățile, barba… peste toate au nins anii mulți și grei. Numai ochii bunicului au rămas ca odinioară: blânzi și mângâietori. Cine tr...

_”Se scutură din salcâmi o ploaie de miresme.

Bunicul stă pe prispă. Se gândește. La ce se gândește? La nimic. Înnumără florile care cad. Se uită-n fundul grădinii. Se scarpină-n cap. Iar înnumără florile scuturate de adiere. Pletele lui albe și crețe parcă sunt niște ciorchini de flori albe; sprâncenele, mustățile, barba… peste toate au nins anii mulți și grei.

Numai ochii bunicului au rămas ca odinioară: blânzi și mângâietori. Cine trânti poarta?

– O, voinicii moșului!…

Un băietan ș-o fetiță, roșii și bucălai, sărutară mânele lui „tata-moșu”. Bătrânul coprinse într-o mână pe fată și în cealaltă pe băiat.

– La ce te gândești bunicule?” (Barbu Ștefănescu Delavrancea – '''”Bunicul”''')_

Numărând florile, mă gândeam la execuția unui program care calculează formula fericirii. Am o problemă cu alocarea memoriei. În unele cazuri programul poate rula, iar în altele nu. Programul funcționează corect dacă se alocă memorie în primul spațiu liber din zona de date, în ordinea în care variabilele sunt declarate. De asemenea, adresa de memorie a unei variabile succede adresa de memorie a oricărei variabile declarate înaintea ei.

= Cerința =
Cunoscând dimensiunea memoriei <code>M</code>, numărul de zone ocupate <code>N</code>, numărul <code>R</code> de variabile declarate, cele <code>N</code> intervalele de memorie ocupate, precum și spațiul ocupat de fiecare din cele <code>R</code> variabile, să se determine:

a) Dimensiunea totală disponibilă pentru variabilele folosite.

b) Adresele de memorie pentru fiecare variabilă în parte în cazul în care alocarea memoriei este posibilă, respectând cerința problemei, sau numărul de variabile ce au putut fi alocate și adresa maximă la care este salvată o variabilă de memorie.

= Date de intrare =
Fișierul de intrare <code>bunicul.in</code> conține pe prima linie , despărțite printr-un spațiu, trei numere naturale <code>M</code>, <code>N</code> și <code>R</code>. Pe următoarele <code>N</code> linii câte două numere reprezentând intervalele de memorie ocupată. Pe linia <code>N+2</code> sunt cele <code>R</code> numere reprezentând spațiul ocupat de fiecare variabilă în parte în ordinea în care vor fi alocate.

= Date de ieșire =
Fișierul de ieșire <code>bunicul.out</code> va conține dimensiunea totală disponibilă pentru variabilele folosite, iar pe a doua linie <code>2*R</code> numere reprezentând intervalul de memorie pentru fiecare variabilă în parte sau două numere reprezentând numărul de variabile pentru care s-a putut aloca memorie și ultima locație de memorie ocupată de variabilele pentru care s-a alocat memorie.

= Restricții și precizări =

* <code>1 ≤ M ≤ 2.000.000.000</code>, <code>1 ≤ N ≤ 10.000</code>, <code>1 ≤ R ≤ 10.000</code>
* Variabilele ocupă cel mult <code>1000</code> bytes.
* Prima adresă la care pot fi încărcate datele este <code>0</code>.
* Toate variabilele sunt declarate în așa fel încât să nu depășească memoria disponibilă.
* Intervalele de memorie ocupată nu sunt date obligatoriu în ordinea adreselor lor.
* Intervalele ale memorie ocupată nu se suprapun.
* Dimensiunea <code>M</code> a memoriei este exprimată în bytes. Dimensiunile variabilelor sunt exprimate de asemenea în bytes. Toate aceste valori sunt numere naturale.
* Pentru rezolvarea corectă a primei cerințe, se acordă 20% din punctaj, iar pentru rezolvarea corectă a celei de-a doua cerințe, se acordă 80% din punctaj.

= Exemplul 1 =
<code>bunicul.in</code>
1300 9 7
46 100
130 180
200 300
349 450
501 607
670 750
800 802
900 902
1010 1050
30 20 50 35 60 100 100
<code>bunicul.out</code>
757
0 29 101 120 451 500 608 642 803 862 903 1002 1051 1150

=== Explicație ===
Spațiul total liber este de <code>757</code> bytes.

* Prima zonă liberă este cuprinsă între adresele <code>0 45</code>. Prima variabilă ocupă <code>30</code> bytes, spațiul alocat este intervalul <code>0,29</code>.
* A doua variabilă are <code>20</code> bytes. Prima zonă liberă de dimensiunea dorită este cuprinsă în intervalul <code>101,120</code>.
* Pentru a treia variabilă, care are <code>50</code> bytes, se va aloca memoria cuprinsă între <code>451,500</code>.
* Pentru a patra variabilă se vor aloca <code>35</code> bytes între adresele <code>608,642</code>.
* Pentru a cincea variabilă se alocă memorie în intervalul <code>803,862</code> (60 byes).
* Pentru a șasea variabilă se alocă spațiul de memorie cuprins între <code>903,1002</code> (<code>100</code> bytes).
* Pentru ultima variabilă se alocă spațiul de memorie de <code>100</code> bytes, cuprins între <code>1051,1150</code>.
<syntaxhighlight lang="python" line="1">
def calculate_memory_allocation(M, N, occupied_intervals, R, variable_sizes):
# Sort occupied intervals by starting address
occupied_intervals.sort()

# Calculate total available memory
total_available = 0
free_intervals = []

# Find free intervals
if occupied_intervals[0][0] > 0:
free_intervals.append((0, occupied_intervals[0][0] - 1))

for i in range(N - 1):
if occupied_intervals[i][1] + 1 < occupied_intervals[i + 1][0]:
free_intervals.append((occupied_intervals[i][1] + 1, occupied_intervals[i + 1][0] - 1))

if occupied_intervals[-1][1] < M - 1:
free_intervals.append((occupied_intervals[-1][1] + 1, M - 1))

for interval in free_intervals:
total_available += interval[1] - interval[0] + 1

# Allocate memory for variables
addresses = []
current_var_index = 0

for interval in free_intervals:
start = interval[0]
end = interval[1]

while start <= end and current_var_index < R:
var_size = variable_sizes[current_var_index]

if start + var_size - 1 <= end:
addresses.append((current_var_index, start))
start += var_size
current_var_index += 1
else:
break

# If we allocated all variables
if current_var_index == R:
return total_available, addresses

# If not all variables could be allocated
max_address = addresses[-1][1] + variable_sizes[addresses[-1][0]] - 1 if addresses else -1
return total_available, len(addresses), max_address

# Exemplu de utilizare:
M = 1000 # Dimensiunea memoriei
N = 3 # Numărul de zone ocupate
occupied_intervals = [(100, 199), (300, 399), (500, 599)] # Intervalele ocupate
R = 5 # Numărul de variabile declarate
variable_sizes = [50, 150, 60, 80, 200] # Dimensiunea fiecărei variabile

result = calculate_memory_allocation(M, N, occupied_intervals, R, variable_sizes)
print(result)
</syntaxhighlight>

1642 - Culegere

2024-07-25T12:40:44Z

RaulOtet: Pagină nouă: Pădurea magică din Povestea lui Negrimon este situată pe un teren dreptunghiular care poate fi privit ca o matrice cu <code>N</code> linii, numerotate de la <code>1</code> la <code>N</code> şi <code>M</code> coloane, numerotate de la <code>1</code> la <code>M</code>. Putem spune că terenul este împărţit în <code>N * M</code> parcele pătrate de latură <code>1</code>. În pădure trăieşte şarpele Snake care, iniţial, este lung cât <code>K</code> parcele şi lat...

Pădurea magică din Povestea lui Negrimon este situată pe un teren dreptunghiular care poate fi privit ca o matrice cu <code>N</code> linii, numerotate de la <code>1</code> la <code>N</code> şi <code>M</code> coloane, numerotate de la <code>1</code> la <code>M</code>. Putem spune că terenul este împărţit în <code>N * M</code>

parcele pătrate de latură <code>1</code>. În pădure trăieşte şarpele Snake care, iniţial, este lung cât <code>K</code> parcele şi lat cât una singură. La începutul poveştii şarpele se află pe prima linie, pe parcelele de la <code>1</code> la <code>K</code>, capul fiind pe poziţia <code>K</code> şi orientat spre est.

Snake se deplasează cu o parcelă pe secundă. Astfel, după prima secundă, şarpele se va afla tot pe linia <code>1</code>, deplasat cu o poziţie spre dreapta, mai exact capul va fi în parcela <code>K + 1</code>. Deplasarea se face simultan cu întreg corpul.

În pădure au loc <code>E</code> evenimente ce pot fi de tipurile următoare:

# Apariţia unui măr la secunda <code>st</code> pe linia <code>x</code> şi coloana <code>y</code>, care va dispărea la secunda <code>en</code>, dacă nu este mâncat până atunci de şarpe. Snake înghite mărul când capul său ajunge în parcela care îl conţine. Mărul dispare, desigur, iar corpul şarpelui creşte instantaneu cu o unitate care îi va fi adăugată la coadă şi va ocupa aceeaşi parcelă pe care s-a aflat coada (ultima porţiune din corp) la secunda anterioară înghiţirii mărului.

# Apariţia unui schimbător la secunda <code>st</code> pe linia <code>x</code> şi coloana <code>y</code>, care va dispărea la secunda <code>en</code> şi care are valoarea <code>v</code>. Când capul şarpelui ajunge în parcela schimbătorului, direcţia ulterioară de deplasare va fi dată de valoarea <code>v ∈ {1, 2, 3, 4}</code> cu semnificaţia: <code>1</code> Nord (sus); <code>2</code> Est (dreapta); <code>3</code> Sud (jos); <code>4</code> Vest (stânga).

Schimbătorul funcţionează astfel: de exemplu, dacă Snake se deplasează spre Est şi la o anumită secundă capul acestuia ajunge într-o parcelă unde se află un schimbător cu valoarea <code>1</code>, la următoarea secundă capul se va afla în parcela situată deasupra schimbătorului şi în parcela schimbătorului se află prima porţiune din corpul şarpelui.

Schimbătorul dispare exact în secunda <code>en</code> iar până atunci rămâne în matrice indiferent de câte ori Snake trece prin parcela acestuia. Schimbătorul va acţiona doar când capul lui Snake ajunge în parcela lui şi nu va exista nicio situaţie în care să se schimbe direcţia în sens opus celei din care vine. De exemplu, dacă direcţia lui Snake este spre Est, nu va întâlni un schimbător cu valoarea <code>4</code>, care l-ar întoarce spre Vest.

În fiecare secundă <code>s</code>, evenimentele se petrec în acestă ordine: dispar obiectele programate să dispară în secunda <code>s</code>, apar obiectele ce trebuie să apară în secunda <code>s</code>, Snake se deplasează cu o parcelă. Dacă printr-o combinaţie nefericită de mişcări, Snake se loveşte de propriul corp, el se blochează şi aşteptă serviciul de asistenţă a pădurii.

Deoarece Snake se află într-o pădure magică, deplasarea lui respectă reguli speciale: când capul este pe ultima coloană din matrice şi se mişcă spre Est, el reapare pe aceeaşi linie, dar pe prima coloană, trăgând corpul simultan. Analog şi pentru prima coloană, când se deplasează spre Vest, capul reapare pe aceeaşi linie dar pe ultima coloană. Dacă şarpele se află pe prima linie şi se deplasează spre Nord, mişcarea va continua pe ultima linie şi aceeaşi coloană din matrice. Analog pentru ultima linie, când Snake se deplasează spre Sud, capul reapare pe prima linie şi aceeaşi

coloană. Aceste mişcări au loc doar dacă Snake nu se blochează în propriul corp.

Povestea se termină în secunda în care apare oricare dintre situaţiile: Snake se loveşte de propriul corp, caz în care el rămâne BLOCAT; toate cele <code>E</code> evenimente s-au produs şi nu mai există niciun obiect în matrice pentru că toate au

dispărut, caz în care rămâne un şarpe LIBER.

= Cerința =
În funcţie de finalul poveştii, afişaţi starea lui Snake şi harta pădurii în secunda respectivă. Pe hartă trebuie să fie marcate parcelele ocupate de corpul lui Snake, inclusiv capul.

= Date de intrare =
Fișierul de intrare <code>culegere.in</code> conține pe prima linie valorile: <code>N</code> – numărul de linii, <code>M</code> – numărul de coloane în care este împărţită pădurea, K- lungimea şarpelui şi <code>E</code> – numărul de evenimente din pădure, separate prin câte un spaţiu.

Următoarele <code>E</code> linii respectă unul dintre formatele:

* <code>1 x y st en</code> – Apare un măr la secunda <code>st</code>, pe linia <code>x</code>, coloana <code>y</code> şi dispare la secunda <code>en</code>
* <code>2 x y st en v</code> – Apare un schimbător la secunda <code>st</code>, pe linia <code>x</code>, coloana <code>y</code>, dispare la secunda <code>en</code> şi are valoarea <code>v</code>. Evenimentele sunt sortate crescător în funcţie de <code>st</code>.

= Date de ieșire =
Fișierul de ieșire <code>culegere.out</code> va conține pe prima linie cuvântul <code>BLOCAT</code> sau <code>LIBER</code>, în funcţie de starea lui Snake la sfârşitul poveştii. Pe fiecare dintre următoarele <code>N</code> linii, se vor afla <code>M</code> caractere din mulţimea <code>{'.', 'O', '#'}</code>, cu

următoarea semnificaţie : <code>'.'</code> – parcelă liberă, majuscula <code>'O'</code> – parcelă în care se află o porţiune din corpul şarpelui, <code>'#'</code> – parcela în care se află capul lui Snake. Caracterul <code>'#'</code> va apărea o singură dată în matrice.

= Restricții și precizări =

* <code>2 ≤ N, M ≤ 2000; 2 ≤ K < M; 1 ≤ E ≤ 500.000;</code>
* <code>1 ≤ x ≤ N; 1 ≤ y ≤ M; 1 ≤ st < en ≤ 500.000; v ∈ {1,2,3,4}</code>
* Obiectele apar doar în parcele libere.
* Povestea începe la secunda <code>0</code>.

= Exemplul 1 =
<code>culegere.in</code>
4 5 3 4
1 1 5 1 5
2 1 1 2 6 3
2 2 1 2 5 2
2 4 4 3 5 4
<code>culegere.out</code>
LIBER
O....
OO#..
.....
.....

=== Explicație ===
'''Secunda 0:'''
OO#..
.....
.....
.....
'''Secunda 1:''' apare 1 măr, deplasare spre Est
.OO#M
.....
.....
.....
'''Secunda 2:''' apar <code>2</code> schimbătoare, deplasare spre Est, înghite măr, creşte coada
3OOO#
2....
.....
.....
'''Secunda 3:''' apare un schimbător pe <code>(4, 4)</code>, deplasare spre Est şi capul apare pe prima coloană peste schimbătorul <code>3</code> din poziţia <code>(1, 1)</code>
#.OOO
2....
.....
....4
'''Secunda 4:''' Nu apar şi nu dispar obiecte, deplasare spre Sud, corpul urmează acelaşi traseu ca şi capul care a fost influenţat la secunda <code>3</code> de schimbătorul cu valoarea <code>3</code>; capul ajunge peste schimbătorul <code>2</code> de la poziţia <code>(2,1)</code>
O..OO
#....
.....
....4
'''Secunda 5:''' dispare schimbătorul de la <code>(4, 4)</code>, deplasare spre Est deoarece capul a fost influenţat de schimbătorul cu valoarea <code>2</code> la secunda <code>4</code>; dacă mărul nu ar fi fost mâncat, acum ar fi dispărut
O...O
O#...
.....
.....
'''Secunda 6:''' dispare primul schimbător chiar dacă acesta a fost acoperit de corpul lui

Snake, deplasare spre Est
O....
OO#..
.....
.....
Aceasta este configuraţia finală deoarece acum a dispărut şi ultimul obiect. Snake nu s-a blocat în propriul corp, deci este LIBER.<syntaxhighlight lang="python" line="1">
from collections import deque

# Citire date de intrare
N, M = map(int, input().split())
K = int(input())
E = int(input())

events = []
for _ in range(E):
st, x, y, t, en = input().split()
st, x, y, en = int(st), int(x), int(y), int(en)
if t.isdigit():
t = int(t)
events.append((st, x-1, y-1, t, en))

# Direcții: Nord (1), Est (2), Sud (3), Vest (4)
directions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # E, S, W, N

# Inițializare șarpe
snake = deque([(0, i) for i in range(K)])
head = (0, K-1)
direction = 0 # Inițial est (E)
occupied = set(snake)

# Evenimente active
active_apples = {}
active_switchers = {}

# Stare șarpe
snake_alive = True
time = 0

def move_snake():
global head, direction
new_head = ((head[0] + directions[direction][0]) % N, (head[1] + directions[direction][1]) % M)
if new_head in occupied:
return False
occupied.add(new_head)
snake.append(new_head)
if new_head in active_apples:
occupied.add(snake[-1])
active_apples.pop(new_head)
else:
tail = snake.popleft()
occupied.remove(tail)
head = new_head
if new_head in active_switchers:
direction = active_switchers[new_head]
return True

# Simulare
while snake_alive and events:
# Elimina evenimentele care expira la timpul actual
for pos in list(active_apples.keys()):
if active_apples[pos] == time:
active_apples.pop(pos)
for pos in list(active_switchers.keys()):
if active_switchers[pos][1] == time:
active_switchers.pop(pos)

# Adaugă evenimente noi
while events and events[0][0] == time:
st, x, y, t, en = events.pop(0)
if isinstance(t, int):
active_switchers[(x, y)] = (t-1, en)
else:
active_apples[(x, y)] = en

# Deplasare șarpe
snake_alive = move_snake()
time += 1

# Rezultate
if snake_alive:
print("LIBER")
else:
print("BLOCAT")

# Harta finală
forest = [['.' for _ in range(M)] for _ in range(N)]
for x, y in snake:
forest[x][y] = 'S'
forest[head[0]][head[1]] = 'H'

for line in forest:
print(''.join(line))
</syntaxhighlight>

0750 - S Min

2024-07-25T12:38:29Z

RaulOtet: Pagină nouă: Ana are un joc nou. Pe o tablă pătrată este trasat un grid format din celule pătratice de dimensiune <code>1</code>. În oricare dintre colţurile oricărei celule, Ana poate înfige câte un beţişor perpendicular pe tablă. După ce a plasat <code>n</code> beţişoare, Ana ia dintr-o cutie (cu un număr suficient de mare de corzi elastice circulare) câte o coardă cu care înconjoară trei sau mai multe beţişoare. Fiecare coardă este bine întinsă şi formează pe...

Ana are un joc nou. Pe o tablă pătrată este trasat un grid format din celule pătratice de dimensiune <code>1</code>. În oricare dintre colţurile oricărei celule, Ana poate înfige câte un beţişor perpendicular pe tablă. După ce a plasat <code>n</code> beţişoare, Ana ia dintr-o cutie (cu un număr suficient de mare de corzi elastice circulare) câte o coardă cu care înconjoară trei sau mai multe beţişoare. Fiecare coardă este bine întinsă şi formează pe tablă un contur poligonal.

În figura alăturată este folosită o coardă ce formează un contur poligonal cu <code>4</code> laturi cu care sunt înconjurate <code>5</code> dintre cele <code>8</code> beţişoare de pe tablă.

Jocul se încheie când au fost plasate atâtea coarde încât toate beţişoarele de pe tablă să se afle pe marginea sau în interiorul a cel puţin unul dintre contururile poligonale formate. Scopul jocului este ca amplasarea corzilor să fie făcută convenabil astfel încât totalul ariilor contururilor poligonale formate să fie minim.

= Cerința =
Cunoscând coordonatele celor <code>n</code> beţişoare <code>(x[1], y[1])</code>, <code>(x[2], y[2])</code>, …, <code>(x[n], y[n])</code> măsurate faţă de unul dintre colţurile gridului, Ana doreşte să găsească suma minimă a ariilor poligonale obţinute prin amplasarea convenabilă a coardelor, astfel încât fiecare beţişor să se găsească în interiorul sau pe conturul a cel puţin un astfel de poligon.

= Date de intrare =
Fișierul de intrare <code>smin.in</code> conține pe prima linie numărul natural <code>n</code>. Pe fiecare dintre următoarele <code>n</code> linii, se află câte două numere naturale: <code>x y</code>.

= Date de ieșire =
Fișierul de ieșire <code>smin.out</code> va conține pe prima linie numărul real <code>s</code>, reprezentând suma minimă a ariilor poligoanelor convexe care acoperă toate punctele date.

= Restricții și precizări =

* <code>3 ≤ n ≤ 17</code>
* <code>0 ≤ x, y ≤ 100</code>
* Datele de intrare nu vor conţine trei beţişoare plasate în puncte coliniare din planul tablei.
* Suma cerută se obţine însumând ariile tuturor poligoanelor, indiferent dacă unele poligoane se suprapun sau nu.
* Modulul diferenţei dintre valoarea reală a lui <code>s</code> şi cea afişată este mai mic decât <code>0.001</code>.

= Exemplu: =
<code>smin.in</code>
4
0 2
0 4
4 4
4 2
<code>smin.out</code>
8.000

= Explicație =
Aria minimă este dreptunghiul din prima figură, cu cele patru beţişoare în vârfuri. Se foloseşte o singură coardă elastică.<syntaxhighlight lang="python" line="1">
import math

def orientation(p, q, r):
val = (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1])
if val == 0:
return 0
elif val > 0:
return 1
else:
return 2

def convex_hull(points):
n = len(points)
if n < 3:
return points

l = min(range(n), key=lambda i: (points[i][0], points[i][1]))
hull = []

p = l
while True:
hull.append(points[p])
q = (p + 1) % n
for i in range(n):
if orientation(points[p], points[i], points[q]) == 2:
q = i
p = q
if p == l:
break

return hull

def polygon_area(points):
n = len(points)
area = 0.0
for i in range(n):
j = (i + 1) % n
area += points[i][0] * points[j][1]
area -= points[j][0] * points[i][1]
return abs(area) / 2.0

def remaining_points(points, hull):
hull_set = set(hull)
return [p for p in points if p not in hull_set]

def minimum_total_area(points):
total_area = 0.0
while points:
hull = convex_hull(points)
total_area += polygon_area(hull)
points = remaining_points(points, hull)
return total_area

# Citirea datelor de intrare
n = int(input("Introduceți numărul de bețișoare: "))
points = []

for _ in range(n):
x, y = map(int, input().split())
points.append((x, y))

# Calcularea ariei minime totale
result = minimum_total_area(points)
print(f"Suma minimă a ariilor contururilor poligonale este: {result}")
</syntaxhighlight>

0749 - Cerc 2

2024-07-25T12:35:47Z

RaulOtet: Pagină nouă: <code>N</code> puncte numerotate de la <code>1</code> la <code>N</code> sunt aşezate pe cerc, în sensul acelor de ceasornic, în ordine strict crescătoare. Există <code>M</code> segmente de dreaptă diferite care unesc <code>M</code> perechi de puncte dintre cele <code>N</code> date. Cele două puncte care formează orice pereche sunt distincte. Distanţele dintre două puncte succesive sunt alese astfel încât să nu existe <code>3</code> sau mai multe segmente care t...

<code>N</code> puncte numerotate de la <code>1</code> la <code>N</code> sunt aşezate pe cerc, în sensul acelor de ceasornic, în ordine strict crescătoare.

Există <code>M</code> segmente de dreaptă diferite care unesc <code>M</code> perechi de puncte dintre cele <code>N</code> date. Cele două puncte care formează orice pereche sunt distincte.

Distanţele dintre două puncte succesive sunt alese astfel încât să nu existe <code>3</code> sau mai multe segmente care trec printr-un acelaşi punct interior cercului.

= Cerința =
Cunoscându-se numărul de puncte, numărul de perechi şi perechile de puncte care vor fi unite, se cere să se determine numărul <code>P</code> de puncte de intersecţie formate de acestea în interiorul cercului (punctele de intersecţie aflate chiar pe cerc nefiind luate în considerare).

= Date de intrare =
Fișierul de intrare <code>cerc2.in</code> conţine:

* pe prima linie două numere <code>N</code> şi <code>M</code> despărţite printr-un spaţiu, numere reprezentând numărul de puncte şi respectiv numărul de segmente;
* pe următoarele <code>M</code> linii, câte o pereche de numere distincte <code>p1[1]</code>, <code>p2[i]</code> despărţite prin câte un spaţiu, numere reprezentând capetele câte unui segment.

= Date de ieșire =
Fișierul de ieșire <code>cerc2.out</code> va conține un singur număr <code>P</code> reprezentând numărul total de puncte de intersecţie formate în interiorul cercului. Dacă acest număr depăşeşte <code>999999</code>, atunci se va scrie numărul format numai din ultimele sale <code>6</code> cifre.

= Restricții și precizări =

* <code>1 ≤ N ≤ 5000</code>
* <code>0 ≤ M < 125000</code>
* <code>1 ≤ p1[i] < p2[i] ≤ N</code>, numere naturale, oricare <code>i</code> din <code>{1,…, M}</code>
* NU există perechi <code>p1[i] p2[i]</code> identice.

= Exemplu: =
<code>cerc2.in</code>
5 6
1 2
1 3
1 4
2 4
3 5
4 5
<code>cerc2.out</code>
3

= Explicație =
S-au format în interiorul cercului <code>3</code> puncte de intersecţie (marcate prin cerculeţe pe figura de mai jos).

<syntaxhighlight lang="python" line="1">
def count_intersections(n, m, pairs):
def intersects(a, b, c, d):
return (a < c < b < d) or (c < a < d < b)

intersections = 0

# Iterate over all pairs of segments
for i in range(m):
for j in range(i + 1, m):
a, b = pairs[i]
c, d = pairs[j]
# Ensure that for each segment (x, y), we have x < y
if a > b:
a, b = b, a
if c > d:
c, d = d, c
if intersects(a, b, c, d):
intersections += 1

return intersections

# Citirea datelor de intrare
n = int(input("Introduceti numarul de puncte (N): "))
m = int(input("Introduceti numarul de perechi (M): "))
pairs = []

for _ in range(m):
x, y = map(int, input().split())
pairs.append((x, y))

# Calcularea numarului de puncte de intersectie
result = count_intersections(n, m, pairs)
print(f"Numarul de puncte de intersectie este: {result}")
</syntaxhighlight>

1040 - Clepsidru

2024-07-25T12:33:50Z

RaulOtet: Pagină nouă: O '''clepsidră''' este un dispozitiv folosit pentru a măsura timpul. Clepsidra este alcătuită din două incinte de sticlă, conectate printr-un tub fin. Una dintre incinte este umplută cu nisip, acesta scurgându-se în cea de-a doua incintă, cu o viteză constantă. Clepsidra poate fi întoarsă, pentru a măsura o altă perioadă de timp. Arheologii au descoperit un dispozitiv, pe care l-au denumit '''clepsidru''', format din <code>n</code> clepsidre identice, suprap...

O '''clepsidră''' este un dispozitiv folosit pentru a măsura timpul. Clepsidra este alcătuită din două incinte de sticlă, conectate printr-un tub fin. Una dintre incinte este umplută cu nisip, acesta scurgându-se în cea de-a doua incintă, cu o viteză constantă. Clepsidra poate fi întoarsă, pentru a măsura o altă perioadă de timp.

Arheologii au descoperit un dispozitiv, pe care l-au denumit '''clepsidru''', format din <code>n</code> clepsidre identice, suprapuse, numerotate de la <code>1</code> la <code>n</code>, prin care nisipul poate circula de la o clepsidră la alta datorită forţei gravitaţionale.

Studiind acest obiect, arheologii au constatat că :

* dispozitivul poate fi utilizat atât în poziţia <code>1</code>, când clepsidrele sunt în ordinea <code>1</code>, <code>2</code> ,…, <code>n</code> cu clepsidra <code>n</code> aşezată pe sol, cât şi în poziţia <code>2</code>, când clepsidrele sunt în ordinea <code>n</code>, <code>n-1</code>,…, <code>1</code> cu clepsidra <code>1</code> aşezată pe sol;
* viteza de trecere a nisipului de la o incintă la alta, a aceleiaşi clepsidre, este de <code>1</code> bob de nisip/secundă, pentru toate clepsidrele, indiferent de poziţie;
* trecerea clepsidrului dintr-o poziţie în alta presupune răsturnarea acestuia şi reaşezarea boabelor de nisip;
* timpul de trecere a boabelor de nisip de la o clepsidră la alta este 0.

Arheologii studiază comportarea clepsidrului realizând două experimente diferite, după cum urmează:

a) Se aşează clepsidrul în poziţia <code>1</code>, se introduc în incinta de sus a clepsidrei <code>1</code> un număr <code>b</code> de boabe de nisip şi se determină după câte secunde vor ajunge toate boabele de nisip în incinta de jos a ultimei clepsidre;

b) Se aşează clepsidrul în poziţia <code>1</code>, se introduc în incinta de sus a clepsidrei <code>1</code> un număr <code>b</code> de boabe de nisip, apoi se aşează clepsidrul în <code>k</code> stări consecutive, o stare fiind caracterizată de valorile <code>si</code> şi <code>pi</code> , <code>1 ≤ i ≤ k</code>, ce reprezintă numărul de secunde, respectiv poziţia, în care este menţinut nemişcat clepsidrul, iar la final se determină numărul de boabe de nisip din incintele fiecărei clepsidre.

Spre exemplu, dacă clepsidrul este format din <code>n=2</code> clepsidre, iar în incinta de sus a primei clepsidre se introduc <code>b=3</code> boabe de nisip, la primul experiment se va obţine valoarea <code>4</code>.

La al doilea experiment se aşează clepsidrul în <code>k=2</code> stări, caracterizate prin <code>s1=3</code>, <code>p1=1</code>; <code>s2=1</code>, <code>p2=2</code>.

Numărul de boabe de nisip din clepsidre va evolua ca în figura alăturată.

= Cerința =
Să se scrie un program care citeşte valorile <code>n</code> şi <code>b</code>, precum şi valorile <code>k</code>, <code>si</code>, <code>pi</code> , <code>1 ≤ i ≤ k</code>, şi calculează valorile obţinute de arheologi la realizarea celor două experimente.

= Date de intrare =
Fișierul de intrare <code>clepsidru.in</code> conține pe prima linie două numere naturale nenule <code>n</code> şi <code>b</code>, separate printr-un singur spaţiu, cu semnificaţia din enunţ; a doua linie conţine numărul natural nenul <code>k</code> având semnificaţia din enunţ, iar următoarele <code>k</code> linii conţin fiecare câte o pereche de valori <code>si</code> şi <code>pi</code>, <code>1 ≤ i ≤ k</code>, separate printr-un singur spaţiu, cu semnificaţia din enunţ.

= Date de ieșire =
Fișierul de ieșire <code>clepsidru.out</code> va conține pe prima linie un număr natural ce reprezintă valoarea obţinută la primul experiment, iar pe următoarele <code>n</code> linii va conţine câte o pereche de numere naturale, separate printr-un singur spaţiu, ce reprezintă cantităţile de boabe de nisip din incintele de sus şi de jos ale celor <code>n</code> clepsidre, scrise în ordinea de la <code>1</code> la <code>n</code> a clepsidrelor, după realizarea celui de-al doilea experiment.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1 000</code>;
* <code>1 ≤ b ≤ 1 000 000 000</code>;
* <code>1 ≤ k ≤ 1 000</code>;
* <code>1 ≤ si ≤ 1 000</code>, <code>1 ≤ i ≤ k</code>;
* <code>pi</code> aparține <code>{1, 2}</code>, <code>1 ≤ i ≤ k</code>;
* pentru rezolvarea corectă a primei cerinţe se acordă <code>25%</code> din punctaj, iar pentru rezolvarea corectă a celei de-a doua cerinţe se acordă <code>75%</code> din punctaj.

= Exemplu: =
<code>clepsidru.in</code>
2 3
2
3 1
1 2
<code>clepsidru.out</code>
4
1 1
0 1

= Explicație =

* Clepsidrul este format din <code>n=2</code> clepsidre şi în incinta de sus a primei clepsidre se introduc <code>b=3</code> boabe de nisip.
* Toate boabele de nisip vor ajunge în incinta de jos a ultimei clepsidre după <code>4</code> secunde.
* După ce clepsidrul este aşezat <code>3</code> secunde în poziţia <code>1</code> şi <code>1</code> secundă în poziţia <code>2</code>, în clepsidre se vor găsi câte <code>(1,1)</code>, <code>(0,1)</code> boabe de nisip
* <syntaxhighlight lang="python" line="1">
def experiment1(n, b):
return b + (n - 1)

def experiment2(n, b, k, states):
# Initializare
clepsidre = [0] * n
clepsidre[0] = b

for si, pi in states:
if pi == 1: # poziția inițială
for _ in range(si):
for i in range(n-1, 0, -1):
transfer = min(clepsidre[i-1], 1)
clepsidre[i] += transfer
clepsidre[i-1] -= transfer
elif pi == 2: # poziția inversată
for _ in range(si):
for i in range(1, n):
transfer = min(clepsidre[i], 1)
clepsidre[i-1] += transfer
clepsidre[i] -= transfer

return clepsidre

# Citirea input-ului
n = int(input("Introduceti numarul de clepsidre: "))
b = int(input("Introduceti numarul de boabe de nisip: "))
k = int(input("Introduceti numarul de stari: "))
states = []

for _ in range(k):
si = int(input("Introduceti numarul de secunde pentru starea curenta: "))
pi = int(input("Introduceti pozitia pentru starea curenta: "))
states.append((si, pi))

# Rezultatele experimentelor
timp_experiment1 = experiment1(n, b)
rezultat_experiment2 = experiment2(n, b, k, states)

print(f"Timpul pentru experimentul 1: {timp_experiment1}")
print("Numarul de boabe de nisip in fiecare clepsidra dupa experimentul 2:")
for i, boabe in enumerate(rezultat_experiment2, 1):
print(f"Clepsidra {i}: {boabe} boabe")
</syntaxhighlight>

2176 - Ruleta

2024-07-25T12:30:49Z

RaulOtet: Pagină nouă: Nicuşor este elev în clasa <code>a VI-a</code> şi s-a gândit că este suficient de mare ca să inventeze un joc nou. Are doar o foaie de hârtie şi un pix. Scrie mai întâi <code>n</code> numere naturale în cerc. Acestea formează Ruleta numerelor. Jocul se desfăşoară după următoarele reguli: - se parcurge şirul numerelor în sensul deplasării acelor de ceasornic; - se porneşte de fiecare dată de la acelaşi element; - se execută de fiecare dată o rota...

Nicuşor este elev în clasa <code>a VI-a</code> şi s-a gândit că este suficient de mare ca să inventeze un joc nou. Are doar o foaie de hârtie şi un pix. Scrie mai întâi <code>n</code> numere naturale în cerc. Acestea formează Ruleta numerelor. Jocul se desfăşoară după următoarele reguli:

- se parcurge şirul numerelor în sensul deplasării acelor de ceasornic;

- se porneşte de fiecare dată de la acelaşi element;

- se execută de fiecare dată o rotaţie completă;

- fiecare element nenul se scade din elementul imediat următor doar dacă este mai mic sau egal cu acesta şi nenul;

Exemplu. Dacă notăm cu <code>R1, R2, R3, R4, R5, R6, R7, R8</code> şirul numerelor ce formează ruleta din <code>figura 1</code>, atunci, o rotaţie completă realizează următoarele modificări asupra numerelor din listă:

- ruleta se opreşte atunci când execută o rotaţie completă şi nu se modifică nici o valoare din şirul elementelor.

<code>Exemplu</code>. Pentru ruleta din <code>figura 1</code> se execută <code>4</code> rotaţii (dintre care <code>3</code> în care se fac modificări):

= Cerința =
Scrieţi un program care să determine, pentru un şir de <code>n</code> numere naturale care indică starea iniţială a ruletei, numărul <code>r</code> de rotaţii complete efectuate respectând regulile jocului până la încheierea acestuia şi numărul <code>t</code> al elementelor nenule aflate în şir la încheierea jocului.

= Date de intrare =
Fişierul de intrare <code>ruleta.in</code> conţine pe prima linie numărul <code>n</code> de numere naturale aşezate în cerc iar pe linia a doua, separate prin câte un spaţiu, cele <code>n</code> valori , în ordinea deplasării, începând cu elementul de la care porneşte ruleta.

= Date de ieșire =
Fişierul de ieşire <code>ruleta.out</code> conţine pe prima linie, separate printr-un spaţiu, valorile <code>r</code> şi <code>t</code> (în această ordine).

= Restricții și precizări =

* <code>2 ≤ n ≤ 10000</code>;
* numerele de pe ruletă sunt numere naturale mai mici sau cel mult egale cu <code>30000</code>;

= Exemplu: =
<code>ruleta.in</code>
8
1 2 3 4 3 2 3 1
<code>ruleta.out</code>
4 3
<syntaxhighlight lang="python" line="1">
def roulette_game(numbers):
n = len(numbers)
rotations = 0
modified = True

while modified:
modified = False
rotations += 1
new_numbers = numbers[:]
for i in range(n):
if numbers[i] != 0 and numbers[i] <= numbers[(i + 1) % n]:
new_numbers[(i + 1) % n] -= numbers[i]
modified = True
numbers = new_numbers

non_zero_count = sum(1 for x in numbers if x != 0)
return rotations, non_zero_count

# Exemplu de utilizare
initial_numbers = [3, 4, 5, 6, 7, 8, 9, 10]
rotations, non_zero_count = roulette_game(initial_numbers)
print(f"Numărul de rotații: {rotations}")
print(f"Numărul de elemente nenule rămase: {non_zero_count}")
</syntaxhighlight>

1224 - Restaurare

2024-07-23T11:37:51Z

RaulOtet: Pagină nouă: <code>restaurare.in</code> 5 4 3 2 4 2 3 1 4 3 <code>restaurare.out</code> 0 4 2 După descoperirea ruinelor unei cetăți medievale, arheologii au hotărât restaurarea acesteia, începând cu zidul principal. Acesta este format din <code>N</code> piloni, fiecare cu lățimea de <code>1</code> metru, așezați unul lângă altul (lipiți). Se cunoaște înălțimea, în metri, a fiecărui pilon dar, din păcate, nu toți mai sunt acum la același nivel. Pentru restau...

<code>restaurare.in</code>
5
4 3 2 4 2
3
1 4 3
<code>restaurare.out</code>
0
4
2
După descoperirea ruinelor unei cetăți medievale, arheologii au hotărât restaurarea acesteia, începând cu zidul principal. Acesta este format din <code>N</code> piloni, fiecare cu lățimea de <code>1</code> metru, așezați unul lângă altul (lipiți). Se cunoaște înălțimea, în metri, a fiecărui pilon dar, din păcate, nu toți mai sunt acum la același nivel.

Pentru restaurarea zidului, arheologii dispun de cărămizi care au lățimea de câte <code>1</code> metru și lungimi variabile, exprimate în metri. Sunt disponibile oricâte cărămizi, de oricare lungime. Considerăm că toate cărămizile disponibile și toți pilonii care alcătuiesc zidul au aceeași grosime, de <code>1</code> metru.

Restaurarea constă în două etape:

* în prima etapă, toți pilonii cu înălțimea mai mare sau egală cu <code>H</code> se retează, aducându-se astfel la înălțimea <code>H</code>, ceilalți, mai scunzi, păstrându-și înălțimea inițială;
* în a doua etapă se aduc toți pilonii la aceeași înălțime, umplându-se golurile dintre ei cu cărămizi, astfel încât zidul să devină compact; din motive neînțelese, arheologii vor așeza cărămizile “culcate”, fiecare dintre acestea ocupând, eventual, spațiul aflat deasupra mai multor piloni.

Arheologii au analizat situația, independent, pentru <code>Q</code> valori posibile ale lui <code>H</code>.

= Cerința =
Pentru fiecare dintre cele <code>Q</code> valori alese pentru înălțimea <code>H</code>, se cere să se determine numărul minim de cărămizi necesare restaurării zidului, independent, pornind de la înălțimile inițiale ale pilonilor.

= Date de intrare =
Fișierul de intrare <code>restaurare.in</code> conține:

* pe prima linie, numărul <code>N</code> de piloni;
* pe a doua linie, <code>N</code> numere naturale, separate prin câte un spațiu, reprezentând înălțimile inițiale ale pilonilor, în ordine, de la stânga la dreapta;
* pe linia a treia, numărul natural <code>Q</code>, reprezentând numărul de valori posibile pentru înălțimea <code>H</code>;
* pe a patra linie, <code>Q</code> numere naturale, separate prin câte un spațiu, reprezentând valorile posibile ale lui <code>H</code>.

= Date de ieșire =
Fișierul de ieșire <code>restaurare.out</code> va conține <code>Q</code> numere, câte unul pe linie, reprezentând numărul minim de cărămizi necesare restaurării pentru fiecare dintre înălțimile <code>H</code>, în ordinea în care acestea apar în fișierul de intrare.

= Restricții și precizări =

* <code>1 ≤ N ≤ 100000</code>;
* înălțimea fiecărui pilon este un număr natural din intervalul <code>[1 , 100000]</code>;
* <code>1 ≤ Q ≤ 100000</code>;
* <code>1 ≤ H ≤</code> valoarea maximă dintre înălțimile inițiale ale pilonilor;
* pentru 35% dintre teste <code>N ≤ 1000</code>, iar pentru alte 40% dintre teste <code>Q = 1</code>.

= Exemplu: =
<code>restaurare.in</code>
5
4 3 2 4 2
3
1 4 3
<code>restaurare.out</code>
0
4
2

= Explicație =
Forma inițială a zidului este:

Pentru <code>H=1</code> toți pilonii au aceeași înălțime, deci nu mai este necesară nicio cărămidă, pentru <code>H=4</code>, sunt necesare <code>4</code> cărămizi, zidul având, după restaurare structura din fig. a, iar pentru <code>H=3</code>, sunt necesare <code>2</code> cărămizi, zidul având, după restaurare structura din fig. b.

<syntaxhighlight lang="python" line="1">
def min_bricks_for_heights(piloni, H):
total_bricks = 0
current_height = 0

for height in piloni:
if height > H:
height = H

if height > current_height:
total_bricks += 1
current_height = height
elif height < current_height:
current_height = height

return total_bricks

def bricks_needed_for_restoration(piloni, H_values):
results = []
for H in H_values:
results.append(min_bricks_for_heights(piloni, H))
return results

# Exemplu de utilizare
N = 5
piloni = [3, 1, 4, 1, 5]
Q = 3
H_values = [2, 3, 5]

print(bricks_needed_for_restoration(piloni, H_values))
</syntaxhighlight>

1208 - Solitar

2024-07-23T11:35:37Z

RaulOtet: Pagină nouă: Se consideră un joc de cărţi cu un număr nelimitat de coloane. Iniţial, pe prima coloană există, într‑o ordine oarecare, <code>N</code> cărţi cu numere distincte din mulţimea <code>{1,2,…,N}</code>, următoarele coloane fiind vide (fără cărţi). Numim secvenţă de la sfârşitul coloanei ultima sau ultimele două sau ultimele trei etc. cărţi din coloană care au scrise pe ele numere consecutive în ordine crescătoare, considerate de jos în sus. De exemp...

Se consideră un joc de cărţi cu un număr nelimitat de coloane. Iniţial, pe prima coloană există, într‑o ordine oarecare, <code>N</code> cărţi cu numere distincte din mulţimea <code>{1,2,…,N}</code>, următoarele coloane fiind vide (fără cărţi). Numim secvenţă de la sfârşitul coloanei ultima sau ultimele două sau ultimele trei etc. cărţi din coloană care au scrise pe ele numere consecutive în ordine crescătoare, considerate de jos în sus. De exemplu, în figurile 1 şi 2 sunt reprezentate două astfel de coloane cu câte <code>6</code> cărţi având numere între <code>1</code> şi <code>6</code>. În figura 1, secvenţa de la sfârşitul coloanei este formată doar din cartea <code>1</code>. În figura 2, secvenţa de la sfârşitul coloanei este formată din cărţile <code>3</code>, <code>4</code> şi <code>5</code>. Se observă că în coloana din figura 1 mai există o secvenţă formată din cărţile <code>2</code>, <code>3</code> şi <code>4</code>, dar aceasta nu este la sfârşitul coloanei.

Operaţiile permise ale jocului sunt:

A. mutarea secvenţei de cărţi de la sfârşitul unei coloane pe o coloană nouă, dacă acea coloană este vidă (nu conţine nicio carte);

B. mutarea secvenţei de cărţi de la sfârşitul unei coloane la sfârşitul altei coloane cu cărţi, doar dacă secvenţa mutată formează o secvenţă de numere consecutive cu cele de pe cartea sau cărţile aflate la sfârşitul coloanei respective.

Se doreşte ca, printr-un număr minim de operaţii permise, să se obţină pe una dintre coloane toate numerele de la <code>1</code> la <code>N</code>, în ordine crescătoare, considerate de jos în sus.

De exemplu, de la configuraţia iniţială din figura 2 se va obţine, printr-o operaţie <code>A</code>, configuraţia 1 de mai jos. Apoi, printr-o operaţie <code>B</code>, se obţine configuraţia 2, printr-o nouă operaţie <code>B</code> se obţine configuraţia 3, apoi se mută secvenţa <code>2,3,4,5,6</code> pe o coloană vidă (operaţia <code>A</code>), apoi se mută secvenţa <code>1</code> peste secvenţa <code>2,3,4,5,6</code> (operaţia <code>B</code>) şi se obţine, pe coloana a doua, configuraţia finală cerută.
{| class="wikitable"
|Configurația 1
|Configurația 2
|Configurația 3
|Configurația 4
|Configurația 5
|-
|
|
|
|}

= Cerința =
Cunoscând valoarea lui <code>N</code>, precum şi valorile cărţilor de pe prima coloană, să se determine numărul minim de operaţii prin care se poate obţine secvenţa <code>1, 2, …, N</code> pe una dintre coloane.

= Date de intrare =
Fişierul <code>solitar.in</code> conţine pe prima linie numărul natural <code>N</code> şi pe linia următoare <code>N</code> numere naturale distincte din mulţimea <code>{1,2,…,N}</code>, separate prin câte un spaţiu, date în ordinea de pe coloană, de sus în jos.

= Date de ieșire =
Fişierul <code>solitar.out</code> va conţine o singură linie pe care va fi scris un număr natural <code>M</code> reprezentând numărul minim de operaţii prin care se poate obţine secvenţa cerută.

= Restricții și precizări =

* <code>2 ≤ n ≤ 100 000</code>

= Exemplu: =
<code>solitar.in</code>
6
1 6 2 5 4 3
<code>solitar.out</code>
5

= Explicație =
Cele <code>5</code> mutări sunt descrise în enunţul problemei.

<syntaxhighlight lang="python" line="1">
from collections import deque

def min_operations_to_sort_cards(N, cards):
# Initialize columns with the initial column
columns = [deque(cards)]

def find_sequences(column):
sequences = []
start = len(column) - 1
while start >= 0:
end = start
while start > 0 and column[start] - 1 == column[start - 1]:
start -= 1
sequences.append((start, end))
start -= 1
return sequences

def move_sequence(src, dst):
if not columns[dst] or columns[dst][-1] + 1 == columns[src][sequences[0][0]]:
for _ in range(sequences[0][1] - sequences[0][0] + 1):
columns[dst].append(columns[src].popleft())
else:
for _ in range(sequences[0][1] - sequences[0][0] + 1):
columns.append(deque())
columns[-1].append(columns[src].popleft())

operations = 0
while len(columns) > 1 or len(columns[0]) != N:
for idx, col in enumerate(columns):
sequences = find_sequences(col)
if sequences[0][0] == 0:
if idx == 0 and len(sequences) == 1 and sequences[0][1] == N - 1:
return operations
continue
move_sequence(idx, (idx + 1) % len(columns))
operations += 1

return operations

# Exemplu de utilizare
N = 6
cards = [5, 4, 3, 2, 1, 6]
print("Numărul minim de operații:", min_operations_to_sort_cards(N, cards))
</syntaxhighlight>

1706 - Stele

2024-07-23T11:32:42Z

RaulOtet: Pagină nouă: Pasionată de astronomie, Teodora dorește să țină evidența numărului de stele din galaxii. Pentru a face lucrurile mai interesante, ea codifică aceste numere într-un sistem propriu, transformându-le într-o înșiruire de litere și cifre după algoritmul următor: * notează fiecare putere a lui <code>2</code>, strict mai mică decât <code>226</code>, cu o literă a alfabetului, astfel: {| class="wikitable" |<code>20</code> |<code>21</s...

Pasionată de astronomie, Teodora dorește să țină evidența numărului de stele din galaxii. Pentru a face lucrurile mai interesante, ea codifică aceste numere într-un sistem propriu, transformându-le într-o înșiruire de litere și cifre după algoritmul următor:

* notează fiecare putere a lui <code>2</code>, strict mai mică decât <code>226</code>, cu o literă a alfabetului, astfel:

{| class="wikitable"
|<code>20</code>
|<code>21</code>
|<code>22</code>
|<code>23</code>
|<code>24</code>
|<code>25</code>
|<code>26</code>
|<code>27</code>
|<code>28</code>
|<code>29</code>
|<code>210</code>
|<code>211</code>
|<code>212</code>
|-
|a
|b
|c
|d
|e
|f
|g
|h
|i
|j
|k
|l
|m
|-
|<code>213</code>
|<code>214</code>
|<code>215</code>
|<code>216</code>
|<code>217</code>
|<code>218</code>
|<code>219</code>
|<code>220</code>
|<code>221</code>
|<code>222</code>
|<code>223</code>
|<code>224</code>
|<code>225</code>
|-
|n
|o
|p
|q
|r
|s
|t
|u
|v
|w
|x
|y
|z
|}

* reprezintă fiecare număr ca un șir de cifre și litere obținut din scrierea acelui număr ca sumă de puteri ale lui <code>2</code>; dacă o putere este folosită de mai multe ori în descompunerea numărului atunci ea va fi precedată în șir de numărul de utilizări.

Un număr poate fi reprezentat astfel în mai multe moduri. De exemplu, pentru numărul <code>100</code> printre variantele de reprezentare avem:

* <code>100 = cfg = 22+25+26 = 4+32+64 = 100</code>
* <code>100 = 2ab2cde2f = 2*20+21+2*22+23+24+2*25 = 2*1+2+2*4+8+16+2*32 = 100</code>
* <code>100 = 16bcg = 16*21+22+26 = 16*2+4+64 = 100</code>

= Cerința =
Scrieți un program care rezolvă următoarele cerinţe:

# cunoscând <code>s</code> numărul de stele dintr-o galaxie, determină o reprezentare codificată a acestui număr formată doar din litere mici distincte ordonate alfabetic;
# cunoscând <code>g</code>, reprezentând numărul de galaxii și <code>g</code> numere în scriere codificată, reprezentând numărul de stele din fiecare galaxie, determină scrierea zecimală a numărului total de stele din cele <code>g</code> galaxii.

= Date de intrare =
Fișierul de intrare <code>stele.in</code> conține pe prima linie un număr natural <code>c</code>, reprezentând cerinţa care trebuie rezolvată (1 sau 2). Dacă cerinţa este 1, pe a doua linie se află un număr natural <code>s</code>, ce reprezintă numărul care trebuie codificat.

Dacă cerinţa este 2, pe a doua linie se află un număr natural <code>g</code> reprezentând numărul de galaxii, iar pe următoarele <code>g</code> linii câte un șir de caractere reprezentând numărul de stele dintr-o galaxie, codificat folosind algoritmul descris mai sus.

= Date de ieșire =
Fișierul de ieșire <code>stele.out</code> va conţine o singură linie pe care va fi scris un șir de litere mici distincte, ordonate alfabetic, reprezentând scrierea codificată a numărului <code>s</code> (dacă cerinţa este 1) sau un număr natural în scriere zecimală ce reprezintă numărul total de stele din cele <code>g</code> galaxii (dacă cerinţa este 2).

= Restricții și precizări =

* <code>1 ≤ s ≤ 226-1</code>
* <code>1 ≤ g ≤ 1000</code>
* Reprezentările codificate din fişierul de intrare pot avea maximum <code>420</code> caractere.
* Numărul care poate apărea în fața unei litere poate avea maximum <code>15</code> cifre.
* Pentru teste valorând 30% din punctaj cerinţa este 1.
* Pentru teste corespunzătoare cerinţei 2 valorând 20% din punctaj valoarea obținută nu depășește <code>1018</code>

= Exemplul 1 =
<code>stele.in</code>
1
100
<code>stele.out</code>
cfg

=== Explicație ===
Cerința este 1. Reprezentarea numărului <code>100</code> care respectă cerinţa este: <code>cfg = 22+25+26 = 4+32+64 = 100</code>

<syntaxhighlight lang="python" line="1">
def num_to_code(s):
powers_of_2 = [
1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192,
16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432
]
letters = "abcdefghijklmnopqrstuvwxyz"

result = []
i = len(powers_of_2) - 1
while s > 0:
if s >= powers_of_2[i]:
result.append(letters[i])
s -= powers_of_2[i]
i -= 1

return ''.join(sorted(result))

def code_to_num(code):
letters = "abcdefghijklmnopqrstuvwxyz"
powers_of_2 = {
letter: 2 ** i for i, letter in enumerate(letters)
}

total = 0
for char in code:
total += powers_of_2[char]

return total

def total_stars_in_galaxies(galaxies):
total_stars = 0
for galaxy in galaxies:
total_stars += code_to_num(galaxy)
return total_stars

# Exemple de utilizare
s = 100
code_representation = num_to_code(s)
print(f"Reprezentarea codificată a numărului {s}: {code_representation}")

g = 3
galaxies = ["cfg", "bcd", "ace"]
total_stars = total_stars_in_galaxies(galaxies)
print(f"Numărul total de stele din {g} galaxii: {total_stars}")
</syntaxhighlight>

4137 - rgb

2024-07-23T11:29:48Z

RaulOtet: Pagină nouă: Ionuţ, tânăr programator, se lansează pe piaţa producătorilor de jocuri pe calculator. Jocul pe care l-a proiectat se numeşte RGB. În joc există <code>N</code> personaje extraterestre. Fiindcă Ionuţ nu este de acord cu teoria omuleţilor verzi, personajele lui sunt de trei culori: * <code>R</code> extratereştri de culoare roşie; * <code>G</code> extratereştri de culoare verde; * <code>B</code> extratereştri de culoare albastră. Fiecare extraterestru are o an...

Ionuţ, tânăr programator, se lansează pe piaţa producătorilor de jocuri pe calculator. Jocul pe care l-a proiectat se numeşte RGB. În joc există <code>N</code> personaje extraterestre. Fiindcă Ionuţ nu este de acord cu teoria omuleţilor verzi, personajele lui sunt de trei culori:

* <code>R</code> extratereştri de culoare roşie;
* <code>G</code> extratereştri de culoare verde;
* <code>B</code> extratereştri de culoare albastră.

Fiecare extraterestru are o anumită putere, exprimată printr-un număr natural impar, puterile oricăror doi extratereştri fiind diferite. Pe parcursul jocului fiecare extraterestru va lupta cu fiecare dintre ceilalţi extratereştri. Rezultatul unei lupte între doi extratereştri depinde de puterea acestora, dar şi de culoarea lor. Într-o luptă dintre doi extratereştri de aceeaşi culoare, va câştiga cel cu puterea cea mai mare. Într-o luptă între doi extratereştri de culori diferite, puterile lor se modifică după cum urmează, iar după modificare lupta o va câştiga extraterestrul cu puterea mai mare:

* Puterea unui extraterestru roșu este dublată dacă adversarul este un extraterestru verde.
* Puterea unui extraterestru verde este dublată dacă adversarul este un extraterestru albastru.
* Puterea unui extraterestru albastru este dublată dacă adversarul este un extraterestru roșu.

După fiecare luptă, puterile extratereștrilor revin la valorile inițiale, în caz că s-au modificat.

= Cerința =
Scrieţi un program care, cunoscând culorile şi puterile extratereştrilor, rezolvă următoarele două cerinţe:

1) determină puterea extraterestrului care câştigă cele mai multe lupte; dacă există mai mulţi astfel de extratereştri, se va afişa puterea minimă;

2) determină pentru fiecare extraterestru numărul de lupte câştigate de acesta.

= Date de intrare =
Fișierul de intrare <code>rgb.in</code> conține pe prima linie numerele naturale <code>C</code> <code>R</code> <code>G</code> și <code>B</code>, unde <code>C</code> este cerinţa care trebuie să fie rezolvată (1 sau 2), <code>R</code> reprezintă numărul de extratereștri roșii, <code>G</code> numărul de extratereștri verzi, iar <code>B</code> numărul de extratereștri albaştri. Pe cea de a doua linie se află <code>R</code> numere naturale impare în ordine strict crescătoare, reprezentând puterile celor R extratereștri roșii. Pe cea de a treia linie se află <code>G</code> numere naturale impare în ordine strict crescătoare, reprezentând puterile celor G extratereștri verzi.

Pe cea de a patra linie se află <code>B</code> numere naturale impare în ordine strict crescătoare, reprezentând puterile celor B extratereștri albaştri. Valorile scrise pe aceeaşi linie sunt separate prin câte un spaţiu.

= Date de ieșire =
Pentru <code>C = 1</code>, fişierul de ieşire <code>rgb.out</code> va conţine o singură linie pe care va fi scrisă puterea extraterestrului care câştigă cele mai multe lupte; dacă există mai mulţi extratereştri care câştigă un număr maxim de lupte, se va afişa puterea minimă.Pentru <code>C = 2</code>, fişierul de ieşire <code>rgb.out</code> va conţine trei linii. Pe prima linie se va scrie numărul de lupte câştigate de fiecare extraterestru roșu. Pe a doua linie, se va scrie numărul de lupte câştigate de fiecare extraterestru verde. Pe a treia linie, se va scrie numărul de lupte câştigate de fiecare extraterestru albastru. Pentru fiecare culoare, valorile vor fi afişate considerând ordinea extratereştrilor din fişierul de intrare. Valorile scrise pe aceeaşi linie vor fi separate prin câte un spaţiu.

= Restricții și precizări =

* <code>N = R + G + B</code>, <code>N ≤ 500.000</code>
* <code>1 ≤ R, G, B ≤ N-2</code>
* <code>1 ≤ puterea oricărui extraterestru ≤ 2 • N - 1</code>
* Datorită dimensiunilor mari, unele teste nu au fost adăugate

= Exemplul 1: =
<code>rgb.in</code>
1 1 2 2
3
1 7
5 9
<code>rgb.out</code>
7

=== Explicație ===
<code>C = 1</code>, deci se va rezolva prima cerinţă. Există un extraterestru roşu, care are puterea <code>3</code>, doi extratereştri verzi, având puterile <code>1</code>, respectiv <code>7</code> şi doi extratereştri albaștri cu puterile <code>5</code>, respectiv <code>9</code>. Extraterestrul cu puterea <code>7</code> este singurul care va câştiga cele mai multe lupte (în cazul acesta, chiar toate):

* când luptă cu extraterestrul verde cu puterea <code>1</code> câştigă, pentru că are puterea mai mare;
* când luptă cu extraterestrul roşu cu puterea <code>3</code>, acesta îşi va dubla puterea (va avea puterea <code>6</code>), dar va fi insuficient pentru a câștiga lupta;
* când luptă contra extraterestrului albastru cu puterea <code>9</code>, va avea puterea dublată (<code>14</code>), prin urmare va câştiga şi această luptă.
<syntaxhighlight lang="python" line="1">
def determine_winner_and_counts(N, colors, powers):
# Initialize the win counts
win_counts = [0] * N

for i in range(N):
for j in range(i + 1, N):
power_i = powers[i]
power_j = powers[j]

# Adjust powers based on the colors
if colors[i] == 'R' and colors[j] == 'G':
power_i *= 2
elif colors[i] == 'G' and colors[j] == 'R':
power_j *= 2
elif colors[i] == 'G' and colors[j] == 'B':
power_i *= 2
elif colors[i] == 'B' and colors[j] == 'G':
power_j *= 2
elif colors[i] == 'B' and colors[j] == 'R':
power_i *= 2
elif colors[i] == 'R' and colors[j] == 'B':
power_j *= 2

# Determine winner
if power_i > power_j:
win_counts[i] += 1
else:
win_counts[j] += 1

# Determine the extraterrestrial with the most wins
max_wins = max(win_counts)
winners = [powers[i] for i in range(N) if win_counts[i] == max_wins]
min_power_winner = min(winners)

return min_power_winner, win_counts

# Exemplu de utilizare
N = 5
colors = ['R', 'G', 'B', 'R', 'G']
powers = [5, 3, 7, 9, 1]

min_power_winner, win_counts = determine_winner_and_counts(N, colors, powers)
print("Puterea extraterestrului cu cele mai multe lupte câștigate:", min_power_winner)
print("Numărul de lupte câștigate de fiecare extraterestru:", win_counts)
</syntaxhighlight>