Bitnami MediaWiki - User contributions [en]

3641 - Xorstanta

2024-01-15T10:19:35Z

VanceaGabriel: sc

= Cerința =
''Totuși, combatanții au și ei regretele lor, regrete pe care vor să le depășească''

În anul <code>2018</code>, Olimpiada Națională de Informatică s-a ținut în Constanța, iar concurenții au fost triști că nicio problemă nu s-a numit Xorstanța.

Se dă un număr <code>n</code>. De asemenea, ai două variabile <code>a</code> și <code>b</code>, inițial egale cu <code>0</code>. Apoi, pentru fiecare număr <code>i</code> de la <code>1</code> la <code>n</code>, trebuie să alegem între <code>a = a ^ i</code> și <code>b = b ^ i</code>, unde cu <code>^</code> notăm operația <code>XOR</code>.

Calculați suma maximă ce se poate obține între <code>a</code> și <code>b</code>.

= Date de intrare =
Programul citește de la tastatură numărul <code>t</code>, reprezentând numărul de teste ce trebuie rezolvate.

Pe fiecare dintre următoarele <code>t</code> linii se va afla numărul <code>n</code>.

= Date de ieșire =
Programul va afișa pe fiecare dintre cele <code>t</code> linii răspunsul pentru inputul de pe linia <code>i+1</code>.

= Restricții și precizări =

* <code>1 ≤ t ≤ 100000</code>
* <code>1 ≤ n ≤ 1.000.000.000</code>
* Pentru <code>10</code> puncte, <code>1 ≤ n ≤ 20</code> și <code>t = 1</code>
* Pentru <code>30</code> de puncte, <code>1 ≤ n ≤ 100000</code> și <code>t = 1</code>

= Exemplu: =
Intrare
4
6
30
15
18
Ieșire
7
31
30
43
<syntaxhighlight lang="python3">
def calculeaza_suma_maxima_xor(n):
# Setăm suma_max la 29, valoare constantă folosită în bucla for.
suma_max = 29
numar_a, numar_b = 0, 0

# Calculăm valoarea lui a în funcție de restul împărțirii lui n la 4.
if n % 4 == 1:
numar_a = 1
elif n % 4 == 2:
numar_a = n + 1
elif n % 4 == 3:
numar_a = 0
else:
numar_a = n

# Calculăm valoarea numarului b în funcție de puterile lui 2 până la 2^29 care sunt mai mici sau egale cu n.
for j in range(suma_max, -1, -1):
if (1 << j) <= n:
numar_b += (1 << j)

# Efectuăm operația XOR între a și b și returnăm suma rezultată.
numar_a = numar_a ^ numar_b
return numar_a + numar_b

def main():
# Citim numărul de teste.
numarul_t = int(input("T: "))

# Parcurgem fiecare test.
for _ in range(numarul_t):
# Citim valoarea n pentru testul curent.
numarul_n = int(input("n: "))

# Calculăm și afișăm suma maximă XOR pentru valoarea n dată.
suma_maxima_xor = calculeaza_suma_maxima_xor(numarul_n)
print(suma_maxima_xor)

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

2102 - Robot 3

2024-01-13T20:39:38Z

VanceaGabriel: Pagină nouă: Paul dorește să învețe cum să programeze un robot. Pentru început s-a gândit să construiască un robot format dintr-un mâner, <code>10</code> butoane aranjate circular şi un ecran. Pe butoane sunt scrise, în ordine crescătoare, cifrele de la <code>0</code> la <code>9</code>, ca în figură. miniatura Un roboprogram va fi format dintr-o secvenţă de instrucţiuni. Instrucțiunile pot fi: Iniţial mânerul robotului este plasat în dre...

Paul dorește să învețe cum să programeze un robot. Pentru început s-a gândit să construiască un robot format dintr-un mâner, <code>10</code> butoane aranjate circular şi un ecran. Pe butoane sunt scrise, în ordine crescătoare, cifrele de la <code>0</code> la <code>9</code>, ca în figură.
[[Fișier:Image.png|stanga|miniatura]]
Un roboprogram va fi format dintr-o secvenţă de instrucţiuni. Instrucțiunile pot fi:

Iniţial mânerul robotului este plasat în dreptul butonului <code>0</code>, iar ecranul este gol.

De exemplu, în urma executării roboprogramului <code>D4AS1AAD6AT</code> robotul apasă butoanele pe care sunt scrise cifrele <code>4, 3, 3, 9,</code> iar pe ecran va apărea <code>4339</code>.

=== Cerințe ===
Să se scrie un program care rezolvă următoarele cerinţe:

=== Date de intrare ===
Fişierul de intrare <code>robot3.in</code> conţine pe prima linie un număr natural <code>C</code>, reprezentând cerinţa care urmează să fie rezolvată <code>(1, 2 sau 3)</code>. Dacă <code>C=1</code> sau <code>C=2</code>, pe a doua linie a fişierului se află un roboprogram. Dacă <code>C=3</code>, pe a doua linie a fişierului de intrare se află numărul natural <code>N</code>.

=== Date de ieșire ===
Fişierul de ieşire <code>robot3.out</code> va conţine o singură linie. Dacă <code>C=1</code>, pe prima linie se va scrie un număr natural reprezentând numărul de cifre afişate pe ecran după executarea roboprogramului din fişierul de intrare.

Dacă <code>C=2</code>, pe prima linie vor fi scrise cifrele afișate pe ecran în urma executării roboprogramului din fişierul de intrare. Dacă <code>C=3</code>, pe prima linie va fi scris roboprogramul solicitat de cerinţa <code>3</code>.

=== Restricții și precizări ===
• <code>0 ≤ N ≤ 1000000000</code>

• Lungimea roboprogramului citit din fişierul de intrare sau scris în fişierul de ieşire este <code>cel mult 1000</code> de caractere.

• Dacă mânerul este plasat în dreptul butonului <code>0</code> şi se deplasează spre dreapta, se va îndrepta către butonul <code>1</code>; dacă deplasarea este spre stânga, se va îndrepta către butonul <code>9</code>.

• Pentru rezolvarea corectă a primei cerinţe se acordă 10 puncte, pentru rezolvarea corectă a celei de a doua cerințe se acordă 30 de puncte, iar pentru rezolvarea corectă a celei de a treia cerințe se acordă 50 de puncte. 10 puncte se acordă din oficiu.

=== Exemplul 1: ===
<code>robot3.in</code>
1
D1AD2AS1AT
<code>robot3.out</code>
3
<code>C=1</code>, pentru acest test se rezolvă <code>cerința 1</code>.

Se afişează pe ecran <code>3 cifre (132)</code>

=== Exemplul 2: ===
<code>robot3.in</code>
2
S0AD2AS1AT
<code>robot3.out</code>
021
<code>C=2</code>, pentru acest test se rezolvă <code>cerința 2</code>.

Mânerul robotului se deplasează cu <code>0</code> unități la stânga, deci rămâne în dreptul butonului <code>0</code> și apasă, apoi se deplasează <code>2</code> unități spre dreapta şi ajunge în dreptul butonului <code>2</code>, apasă, apoi se deplasează <code>1</code> unitate la stânga și ajunge în dreptul butonului <code>1</code> și apasă acest buton → <code>021</code>.

=== Exemplul 3: ===
<code>robot3.in</code>
3
19332
<code>robot3.out</code>
D1AS2AD4AAS1AT
<code>C=3</code>, pentru acest test se rezolvă <code>cerința 3</code>. Pentru a afișa cifra <code>1</code>, mânerul robotului se deplasează <code>1</code> unitate la dreapta după care apasă <code>(D1A)</code>. Pentru a afișa cifra <code>9</code>, din poziția curentă mânerul robotului se deplasează <code>2</code> unități la stânga şi apasă <code>(S2A)</code>. Pentru a afișa cifra <code>3</code>, din poziția curentă mânerul robotului se deplasează <code>4</code> unități la dreapta după care apasă <code>(D4A)</code>. Pentru a afișa a doua cifra <code>3</code>, mânerul robotului rămâne în poziția curentă și apasă butonul. Pentru a afișa cifra <code>2</code>, din poziția curentă mânerul robotului se deplasează <code>1</code> unitate la stânga după care apasă <code>(S1A)</code>. Programul se termină cu instrucțiunea <code>T → D1AS2AD4AAS1AT</code><syntaxhighlight lang="python3">
def main():
# Deschidem fisierul de intrare si iesire
with open("robot.in", "r") as fin, open("robot.out", "w") as fout:
# Citim numarul de cazuri de test 'numar_c'.
numar_c = int(fin.readline().strip())

# Citim sirul 'numar_a' de caractere A, S, D.
numar_a = fin.readline().strip()

# Definim functia 'rezultat' care va scriem rezultatul in fisier in functie de diferenta dintre doua caractere.
def rezultat(a, b):
if a == b:
fout.write('A')
elif a < b:
if b - a <= (a + 10 - b) % 10:
fout.write(f'D{b - a}A')
elif b - a > (a + 10 - b) % 10:
fout.write(f'S{(a + 10 - b) % 10}A')
else:
if a - b < (b + 10 - a) % 10:
fout.write(f'S{a - b}A')
else:
fout.write(f'D{(b + 10 - a) % 10}A')

# Verificam tipul de operatie specificat de 'numar_c'.
if numar_c == 1:
# Calculam numarul de A-uri si il scriem in fisier.
numar = numar_a.count('A')
fout.write(str(numar))
elif numar_c == 2:
# Calculam pozitia finala in functie de operatiile S si D si o scriem in fisier.
pozitie = 0
for i in range(len(numar_a)):
if numar_a[i] == 'S':
variabila = int(numar_a[i + 1])
pozitie = (pozitie + 10 - variabila) % 10
elif numar_a[i] == 'D':
variabila = int(numar_a[i + 1])
pozitie = (pozitie + variabila) % 10
elif numar_a[i] == 'A':
fout.write(str(pozitie))
elif numar_c == 3:
# Calculam rezultatul pentru fiecare pereche de caractere si scriem 'T' la final.
rezultat(0, int(numar_a[0]))
for i in range(1, len(numar_a)):
rezultat(int(numar_a[i - 1]), int(numar_a[i]))
fout.write('T')

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

File:Image.png

2024-01-13T20:38:39Z

VanceaGabriel:

figura

3641 - Xorstanta

2024-01-13T20:18:59Z

VanceaGabriel: Pagină nouă: = Cerința = ''Totuși, combatanții au și ei regretele lor, regrete pe care vor să le depășească'' În anul <code>2018</code>, Olimpiada Națională de Informatică s-a ținut în Constanța, iar concurenții au fost triști că nicio problemă nu s-a numit Xorstanța. Se dă un număr <code>n</code>. De asemenea, ai două variabile <code>a</code> și <code>b</code>, inițial egale cu <code>0</code>. Apoi, pentru fiecare număr <code>i</code> de la <code>1</code> la <...

= Cerința =
''Totuși, combatanții au și ei regretele lor, regrete pe care vor să le depășească''

În anul <code>2018</code>, Olimpiada Națională de Informatică s-a ținut în Constanța, iar concurenții au fost triști că nicio problemă nu s-a numit Xorstanța.

Se dă un număr <code>n</code>. De asemenea, ai două variabile <code>a</code> și <code>b</code>, inițial egale cu <code>0</code>. Apoi, pentru fiecare număr <code>i</code> de la <code>1</code> la <code>n</code>, trebuie să alegem între <code>a = a ^ i</code> și <code>b = b ^ i</code>, unde cu <code>^</code> notăm operația <code>XOR</code>.

Calculați suma maximă ce se poate obține între <code>a</code> și <code>b</code>.

= Date de intrare =
Programul citește de la tastatură numărul <code>t</code>, reprezentând numărul de teste ce trebuie rezolvate.

Pe fiecare dintre următoarele <code>t</code> linii se va afla numărul <code>n</code>.

= Date de ieșire =
Programul va afișa pe fiecare dintre cele <code>t</code> linii răspunsul pentru inputul de pe linia <code>i+1</code>.

= Restricții și precizări =

* <code>1 ≤ t ≤ 100000</code>
* <code>1 ≤ n ≤ 1.000.000.000</code>
* Pentru <code>10</code> puncte, <code>1 ≤ n ≤ 20</code> și <code>t = 1</code>
* Pentru <code>30</code> de puncte, <code>1 ≤ n ≤ 100000</code> și <code>t = 1</code>

= Exemplu: =
Intrare
4
6
30
15
18
Ieșire
7
31
30
43
<syntaxhighlight lang="python3">
def main():
suma_max = 29
numar_t = int(input("T: "))
while numar_t > 0:
n = int(input(""))
numar_a, numar_b = 0, 0

# Calculează a în funcție de restul împărțirii lui n la 4.
if n % 4 == 1:
numar_a = 1
elif n % 4 == 2:
numar_a = n + 1
elif n % 4 == 3:
numar_a = 0
else:
numar_a = n

# Calculează b în funcție de puterile lui 2 până la 2^29 care sunt mai mici sau egale cu n.
for j in range(suma_max, 0, -1):4
if (1 << j) <= n:
numar_b += (1 << j)

# Efectuam operația XOR între a și b și afișam rezultatul.
numar_a = numar_a ^ numar_b
print(str(numar_a + numar_b) + "\n")
numar_t -= 1

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

4143 - Ghicitoare

2024-01-13T19:39:00Z

VanceaGabriel: Pagină nouă: = Cerința = Fie un număr natural nenul <code>n</code>, cunoscut. RAU-Gigel alege un număr oarecare din intervalul închis <code>[1,n]</code>, fie acesta <code>x</code>. Apoi calculează “suma XOR” <code>S = 1 ^ 2 ^ ... ^ (x-2) ^ (x-1) ^ (x+1) ^ (x+2) ^ ... ^ n</code> pe care v-o comunică. Puteți să-l ghiciți pe <code>x</code> ? RAU-Gigel nu prea are răbdare, el vrea repede un răspuns de la voi. Am notat cu <code>^</code> operația <code>XOR</code> (operatorul d...

= Cerința =
Fie un număr natural nenul <code>n</code>, cunoscut. RAU-Gigel alege un număr oarecare din intervalul închis <code>[1,n]</code>, fie acesta <code>x</code>. Apoi calculează “suma XOR” <code>S = 1 ^ 2 ^ ... ^ (x-2) ^ (x-1) ^ (x+1) ^ (x+2) ^ ... ^ n</code> pe care v-o comunică. Puteți să-l ghiciți pe <code>x</code> ? RAU-Gigel nu prea are răbdare, el vrea repede un răspuns de la voi.

Am notat cu <code>^</code> operația <code>XOR</code> (operatorul de disjuncție exclusivă).

Ca să fie sigur că nu nimeriți din întâmplare răspunsul, RAU-Gigel vă testează de mai multe ori.

= Date de intrare =
Fișierul de intrare <code>ghicitoare.in</code> conține pe prima linie un număr natural <code>T</code> reprezentând numărul de teste / ghicitori pe care RAU-Gigel vi le propune, apoi <code>T</code> linii care conțin perechi de forma <code>n S</code>, separate printr-un spațiu, cu semnificația de mai sus.

= Date de ieșire =
Fișierul de ieșire <code>ghicitoare.out</code> va conține <code>T</code> rânduri, cu răspunsurile <code>x</code>, în ordinea solicitării, câte unul pe linie, la ghicitorile lui RAU-Gigel.

= Restricții și precizări =

* <code>1 ≤ T ≤ 10</code>, <code>1 ≤ n ≤ 1.000.000.000</code>, <code>0 ≤ S ≤ 1.000.000.000</code>, <code>1 ≤ x ≤ n</code>
* Pentru teste în valoare de <code>10</code> de puncte: <code>T = 2</code>, <code>n ≤ 100</code>
* Pentru teste în valoare de alte <code>30</code> de puncte: <code>n ≤ 1.000.000</code>

= Exemplu: =
<code>ghicitoare.in</code>
2
5 2
10 14
<code>ghicitoare.out</code>
3
5

=== Explicație ===
RAU-Gigel vă propune <code>2</code> ghicitori.

La prima ghicitoare avem: <code>n = 5, S = 2</code>. Numărul căutat este <code>3</code>. Intr-adevăr,

<code>S = 1 ^ 2 ^ 4 ^ 5 = |001| ^ |010| ^ |100| ^ |101| = |010| = 2</code> (am notat cu <code>|a|</code> reprezentarea binară a lui <code>a</code>)

La a doua ghicitoare avem: <code>n = 10, S = 14</code>. Numărul căutat este <code>5</code>. Intr-adevăr,

<code>S = 1 ^ 2 ^ 3 ^ 4 ^ 6 ^ 7 ^ 8 ^ 9 ^ 10</code> are valoarea <code>14</code>.<syntaxhighlight lang="python3">
def main():
# Deschide fisierul de intrare si iesire
fin = open("ghicitoare.in", "r")
fout = open("ghicitoare.out", "w")

# Citim numarul de teste 'numar_t' din prima linie a fisierului de intrare.
numar_t = int(fin.readline())

# Parcurge fiecare test.
for i in range(numar_t):
# Citim linia de input și extragem cele două valori 'numar_n' și 'numar_s'.
line = fin.readline().split()
numar_n, numar_s = int(line[0]), int(line[1])

# Calculam xorrange pentru numar_n și adaugă rezultatul la numar_s.
# Scriem rezultatul în fisierul de iesire.
fout.write(str(xorrange(numar_n) ^ numar_s) + "\n")

# Inchidem fisierele de intrare si iesire.
fin.close()
fout.close()

def xorrange(numar_n):
# Folosim // pentru impartire la intreg in Python.
if (numar_n + 1) // 2 % 2 == 0:
rezultat = 0
else:
rezultat = 1

# Initializam i la 4 pentru a evita bucla infinita.
i = 4

# Parcurgem elementele în șir până la numar_n.
while (i >> 1) <= numar_n:
rest_impartire = numar_n % i

# Verificam daca restul impartirii este mai mic decat i / 2 si aplicam operatii.
if rest_impartire < (i >> 1):
pass
elif rest_impartire == 1 or rest_impartire % 2 == 0:
rezultat |= (i >> 1)

# Dublam valoarea lui i pentru a continua iteratia.
i <<= 1

return rezultat

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

2110 - Vot

2024-01-13T19:05:48Z

VanceaGabriel: Pagină nouă: În clasa lui Andrei sunt <code>n</code> elevi, codificaţi cu numerele <code>1, 2, …, n</code>. Ei au fost rugaţi de către diriginta lor să propună un coleg de clasă care să devină liderul lor. Fiecare elev şi-a exprimat opţiunea scriind pe un bileţel codul său şi codul elevului ales de el pentru funcţia de şef de clasă. În acest fel diriginta a putut afla pe cine a votat fiecare elev. După studierea propunerilor venite din partea elevilor săi, diriginta...

În clasa lui Andrei sunt <code>n</code> elevi, codificaţi cu numerele <code>1, 2, …, n</code>. Ei au fost rugaţi de către diriginta lor să propună un coleg de clasă care să devină liderul lor. Fiecare elev şi-a exprimat opţiunea scriind pe un bileţel codul său şi codul elevului ales de el pentru funcţia de şef de clasă. În acest fel diriginta a putut afla pe cine a votat fiecare elev. După studierea propunerilor venite din partea elevilor săi, diriginta lui Andrei a dorit să determine un grup cât mai numeros de elevi care s-au votat unii pe alţii. Cu alte cuvinte, pentru fiecare elev din grup să existe un membru al grupului care să-l fi votat. Dacă de exemplu, sunt <code>5</code> elevi şi elevul <code>1</code> îl votează pe <code>3</code>, <code>2</code> îl votează pe <code>4</code>, votul lui <code>3</code> merge spre <code>2</code>, al lui <code>4</code>, spre <code>2</code> iar <code>5</code> se votează pe sine, grupul determinat va fi format din elevii <code>2, 4 şi 5</code>. Să observăm că şi elevii din grupurile <code>{2, 4} şi {5}</code> îşi exercită votul în cadrul grupului dar aceste grupuri nu sunt maximale.

= Cerința =
Scrieţi un program care, pe baza voturilor elevilor clasei, să determine un grup cu un număr maxim de elevi pentru care voturile primite de ei provin de la elevi aparţinând aceluiaşi grup.

= Date de intrare =
Pe prima linie a fişierului <code>vot.in</code> se găseşte un număr natural <code>n</code>, reprezentând numărul de elevi din clasa lui Andrei. Pe linia a doua se dau <code>n</code> numere naturale din mulţimea <code>{1, 2, …, n}</code>, separate prin câte un spaţiu, reprezentând voturile elevilor, astfel: numărul de pe pozitia <code>i</code> indică pe cine a votat elevul <code>i</code>.

= Date de ieșire =
Pe prima linie din fişierul <code>vot.out</code> se găseşte un număr natural <code>m</code> reprezentând numărul de elevi din grupul determinat. Pe linia a doua se găsesc, în ordine crescătoare, cele <code>m</code> coduri ale elevilor din grup.

= Restricții și precizări =
• <code>1< n ≤ 1000</code>

• Este posibil ca un elev să se voteze pe sine.

= Exemplu: =
<code>vot.in</code>
10
10 3 3 1 1 5 1 1 7 9
<code>vot.out</code>
5
1 3 7 9 10

=== Explicație ===
Se observă că <code>1</code> îl votează pe <code>10</code>, <code>3</code> se votează pe el însuşi, votul lui <code>7</code> merge spre <code>1</code>, al lui <code>9</code> – spre <code>7</code> iar <code>10</code> îl votează pe <code>9</code>, deci toti elevii din acest grup primesc voturi din partea unor elevi ai grupului şi acesta este maximal cu proprietatea cerută.<syntaxhighlight lang="python3">
import numpy as np

def main():
# Deschidem fisierul de intrare "vot.in" pentru citire si fisierul de iesire "vot.out" pentru scriere.
fin = open("vot.in", "r")
fout = open("vot.out", "w")

# Initializam array-uri pentru stocarea datelor
numar_a = np.zeros(1001, dtype=int)
numar_b = np.zeros(1001, dtype=int)
numar_c = np.zeros(1001, dtype=int)

# Citim numarul 'n' din prima linie a fisierului de intrare.
numar_n = int(fin.readline())

# Citim o linie de numere intregi separate prin spatiu si le stocheaza in array-ul 'a'.
line = fin.readline().split()
for i in range(1, numar_n + 1):
# Converteste valorile citite din fisier in intregi si le stocheaza in 'a'.
numar_a[i] = int(line[i - 1])
# Incrementam contor pentru fiecare valoare din 'a' in array-ul 'b'.
numar_b[numar_a[i]] += 1

# Initializam pointeri si array suplimentar pentru a retine anumite valori.
numar_p, numar_u = 1, 0

# Identificam valorile care nu apar in 'a'.
for i in range(1, numar_n + 1):
if numar_b[i] == 0:
numar_u += 1
numar_c[numar_u] = i

# Eliminam anumitor elemente din 'a' bazat pe contorul din 'b'.
while numar_p <= numar_u:
j = numar_c[numar_p]
if numar_a[j] > 0 and numar_b[j] == 0:
numar_b[numar_a[j]] -= 1
if numar_b[numar_a[j]] == 0:
numar_u += 1
numar_c[numar_u] = numar_a[j]
numar_a[j] = 0
numar_p += 1

# Scriem rezultatul in fisierul de iesire
fout.write(str(numar_n - numar_u) + "\n")
for i in range(1, numar_n + 1):
if numar_a[i] > 0:
fout.write(str(i) + " ")

# Inchidem fisierele de intrare si iesire.
fin.close()
fout.close()

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

4260 - Nr X Div Imp

2024-01-13T01:22:37Z

VanceaGabriel: Pagină nouă: = Cerința = Folosind metoda Divide et Impera, scrieți funcția recursivă cu antetul int NrXDivImp(int a[], int st, int dr, int x) care primind ca parametri un vector <code>a</code> de numere întregi și trei numere întregi <code>st</code>, <code>dr</code> și <code>x</code>, returnează numărul de apariții ale numărului <code>x</code> în vectorul secvența <code>a[st], a[st+1], ..., a[dr]</code>. = Restricții și precizări = * <code>st ≤ dr</code> * Numele fun...

= Cerința =
Folosind metoda Divide et Impera, scrieți funcția recursivă cu antetul
int NrXDivImp(int a[], int st, int dr, int x)
care primind ca parametri un vector <code>a</code> de numere întregi și trei numere întregi <code>st</code>, <code>dr</code> și <code>x</code>, returnează numărul de apariții ale numărului <code>x</code> în vectorul secvența <code>a[st], a[st+1], ..., a[dr]</code>.

= Restricții și precizări =

* <code>st ≤ dr</code>
* Numele funcției este <code>NrXDivImp</code>.
* Vectorul <code>a</code> este indexat de la <code>1</code>
* Se recomandă utilizarea metodei Divide et Impera în rezolvarea problemei.

= Exemplu: =
Dacă <code>a = (2,5,1,5,3,5,5,5,7,6)</code>, atunci <code>NrXDivImp(a, 1, 6, 5) = 3</code>, deoarece în secvența <code>2,5,1,5,3,5</code> numărul <code>5</code> apare de <code>3</code> ori. De asemenea, <code>NrXDivImp(a, 9, 10, 5) = 0</code>.

= Important =
Soluția propusă va conține doar funcția cerută. Introducerea în soluție a altor instrucțiuni poate duce la erori de compilare sau de execuție, care vor duce la depunctarea soluției.<syntaxhighlight lang="python3">
def NrXDivImp(numar_a, stanga, dreapta, numar_x):
# Caz de bază: intervalul are un singur element
if stanga == dreapta:
return int(numar_a[stanga] == numar_x)

# Împărțim intervalul în două jumătăți
mijloc = (stanga + dreapta) // 2

# Apelăm funcția pentru fiecare jumătate și adunăm rezultatele
return (NrXDivImp(numar_a, stanga, mijloc, numar_x) +
NrXDivImp(numar_a, mijloc + 1, dreapta, numar_x))

# Punct de intrare în program
if __name__ == "__main__":
# Vectorul de numere
numar_a = [0, 2, 5, 1, 5, 3, 5, 5, 5, 7, 6]

# Apelăm funcția pentru intervalul [1, 6] și [9, 10]
rezultat1 = NrXDivImp(numar_a, 1, 6, 5)
rezultat2 = NrXDivImp(numar_a, 9, 10, 5)

# Afișăm rezultatele
print(f'NrXDivImp(a, 1, 6, 5) = {rezultat1}')
print(f'NrXDivImp(a, 9, 10, 5) = {rezultat2}')
</syntaxhighlight>

2979 - Cartele 1

2024-01-12T23:14:08Z

VanceaGabriel: nume variabile

Într-o școală există un sistem de acces cu ajutorul cartelelor, conectat la un calculator și o imprimantă. Fiecare elev al școlii are câte o cartelă. Într-o zi, la utilizarea fiecărei cartele, sistemul imprimă următoarele informații pe hârtie, pe câte o linie, după regula următoare:

- Caracterul <code>b</code> dacă elevul este băiat sau caracterul <code>f</code> dacă este fată. Caracterul va fi urmat de un spațiu;

- Caracterul <code>i</code> dacă elevul a intrat în școală sau caracterul <code>e</code> dacă a ieșit din școală. De asemenea, acest caracter va fi urmat de un spațiu;

- Momentul utilizării cartelei, exprimat prin oră, minute și secunde. Acestea vor fi reprezentate în cadrul liniei, exact în această ordine, prin trei numere naturale, separate între ele prin câte un spațiu.

= Cerința =
Cunoscându-se toate cele <code>N</code> linii imprimate într-o zi determinați:

1. Câți băieți și câte fete sunt la școală după cele <code>N</code> acțiuni imprimate de sistem.

2. Care este numărul total de secunde în care, în școală, s-au aflat un număr egal, nenul, de fete și băieți, până în momentul utilizării ultimei cartele. Dacă nu există această situație se afișează <code>0</code>.

3. Care este numărul maxim de secunde în care, în școală, până în momentul utilizării ultimei cartele, s-au aflat neîntrerupt un număr impar de băieți. Dacă nu există o astfel de situație se afișează <code>0</code>.

= Date de intrare =
Fișierul de intrare <code>cartele.in</code> conține pe prima linie un număr natural <code>C</code> reprezentând numărul cerinței care poate avea valorile <code>1</code>, <code>2</code> sau <code>3</code>, pe a doua linie numărul natural <code>N</code>, iar pe următoarele <code>N</code> linii informațiile imprimate de sistem sub forma descrisă în enunț, în ordinea strict crescătoare a momentului folosirii cartelei.

= Date de ieșire =
Dacă <code>C = 1</code>, atunci fișierul de ieșire <code>cartele.out</code> va conține, în această ordine, separate printr-un spațiu, numărul de băieți și numărul de fete determinat conform cerinței 1.

Dacă <code>C = 2</code> sau <code>C = 3</code>, atunci fișierul de ieșire <code>cartele.out</code> va conține pe prima linie un singur număr natural ce reprezintă rezultatul determinat conform cerinței.

= Restricții și precizări =

* <code>1 ≤ N ≤ 10.000</code>
* La momentul utilizării primei cartele, în școală nu se află niciun elev
* Sistemul de acces nu permite folosirea simultană a două cartele
* Pentru orice linie imprimată de sistem <code>0 ≤ ora ≤ 23</code>, <code>0 ≤ minute ≤ 59</code> și <code>0 ≤ secunde ≤ 59</code>
* Pe fiecare linie a fișierului de intrare, după ultimul număr, reprezentând secundele, nu există spațiu.
* Pentru rezolvarea corectă a primei cerințe se acordă <code>20</code> de puncte, pentru rezolvarea corectă a celei de-a doua cerințe se acordă <code>30</code> de puncte iar pentru rezolvarea corectă a celei de-a treia cerințe se acordă <code>40</code> de puncte.
* În concurs s-au acordat <code>10</code> puncte din oficiu. Aici se acordă pentru exemplele din enunț.

= Exemplul 1: =
<code>cartele.in</code>
1
3
b i 0 0 24
f i 0 0 26
b e 0 0 29
<code>cartele.out</code>
0 1

=== Explicație ===
Un băiat a intrat la momentul <code>0 0 24</code> (adică ora <code>0</code>, minutul <code>0</code> și secunda <code>24</code>) și ieșit la momentul <code>0 0 29</code>. O fată a intrat la momentul <code>0 0 26</code>. După cele <code>3</code> acțiuni, în școală a rămas o fată.

= Exemplul 2: =
<code>cartele.in</code>
2
3
b i 0 0 24
f i 0 0 26
b e 0 0 29
<code>cartele.out</code>
3

=== Explicație ===
Între momentul <code>0 0 24</code> și <code>0 0 26</code> în școală este doar un băiat. Între momentul <code>0 0 26</code> și <code>0 0 29</code> în școală se află un băiat și o fată adică un număr nenul egal de fete și băieți. Deci, numărul de secunde determinat este <code>3</code>.

= Exemplul 3: =
<code>cartele.in</code>
2
8
f i 8 19 10
b i 8 19 12
b e 8 19 15
b i 8 20 0
b e 8 20 4
b i 8 20 10
b i 8 20 50
b i 8 20 51
<code>cartele.out</code>
47

=== Explicație ===
Între momentele <code>8 19 12</code> și <code>8 19 15</code> în școală se află <code>1</code> băiat și <code>1</code> fată, deci durata este <code>3</code> secunde.

Între momentele <code>8 20 0</code> și <code>8 20 4</code> în școală se află <code>1</code> băiat și <code>1</code> fată, deci durata este <code>4</code> secunde.

Între momentele <code>8 20 10</code> și <code>8 20 50</code> în școală se află <code>1</code> băiat și <code>1</code> fată, deci durata este <code>40</code> de secunde.

Durata totală este <code>3 + 4 + 40 = 47</code> de secunde.

= Exemplul 4: =
<code>cartele.in</code>
3
9
f i 8 19 10
b i 8 19 12
f e 8 19 13
b e 8 19 15
b i 8 20 0
b i 8 20 1
b i 8 20 10
b i 8 20 12
b i 8 20 13
<code>cartele.out</code>
3

=== Explicație ===
Între momentele <code>8 19 12</code> și <code>8 19 15</code> în școală se află <code>1</code> băiat, deci durata este <code>3</code> secunde.

Între momentele <code>8 20 0</code> și <code>8 20 1</code> în școală se află <code>1</code> băiat, deci durata este <code>1</code> secundă.

Între momentele <code>8 20 10</code> și <code>8 20 12</code> în școală se află <code>3</code> băieți, deci durata este <code>2</code> secunde.

Durata maximă cerută este de <code>3</code> secunde.<syntaxhighlight lang="python3">
def main():
fin = open("cartele.in", "r")
fout = open("cartele.out", "w")

# Citim valorile numerelor C și N din fișierul de intrare
numar_C = int(fin.readline().strip())
numar_N = int(fin.readline().strip())

baieti_in_scoala = 0
fete_in_scoala = 0
timp_egal_fete_baieti = 0
timp_maxim_baieti = 0
ultimul_timp_inregistrat = 0

for i in range(numar_N):
# Citim o linie și extragem informațiile relevante
line = fin.readline().split()
gen, actiune, ora, minut, secunde = line[0], line[1], int(line[2]), int(line[3]), int(line[4])

timp_initial = ora * 3600 + minut * 60 + secunde

# Actualizăm numărul de băieți și fete în școală în funcție de acțiunea curentă
if gen == 'b':
baieti_in_scoala += 1 if actiune == 'i' else -1
else:
fete_in_scoala += 1 if actiune == 'i' else -1

# Verificăm dacă numărul de băieți și fete este egal și calculăm timpul
# Verificăm timpul maxim cu un număr impar de băieți în școală
if baieti_in_scoala == fete_in_scoala and fete_in_scoala > 0:
timp_egal_fete_baieti += timp_initial - ultimul_timp_inregistrat

if baieti_in_scoala % 2 == 1:
timp_maxim_baieti = max(timp_maxim_baieti, timp_initial - ultimul_timp_inregistrat)

# Actualizăm ultimul timp înregistrat
ultimul_timp_inregistrat = timp_initial

# Scrie rezultatele în funcție de tipul cerinței
if numar_C == 1:
fout.write(f"{baieti_in_scoala} {fete_in_scoala}")
elif numar_C == 2:
fout.write(str(timp_egal_fete_baieti))
elif numar_C == 3:
fout.write(str(timp_maxim_baieti))

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

4287 - Veverita 4

2024-01-12T22:28:09Z

VanceaGabriel:

În parcul orașului există <code>4</code> rânduri de câte <code>n</code> copaci perfect aliniați. Rândurile sunt notate A, B, C și D, iar copacii de pe fiecare rând sunt numerotați de la <code>1</code> la <code>n</code>, ca în imaginea de mai jos:

O veveriță jucăușă sare prin copaci astfel:

* pornește dintr-un copac numerotat cu <code>1</code>;
* la fiecare pas sare dintr-un copac numerotat cu <code>i</code> într-un copac numerotat cu <code>i+1</code>. Dacă se află într-un copac de pe rândul A, va sări în copacul de pe rândul B, dacă se află într-un copac de pe rândul D, va sări în copacul de pe rândul C, dacă se află în copacul de pe rândul B, va sări în copacul de pe rândul A sau în copacul de pe rândul C, iar dacă se află în copacul de pe rândul C, va sări în copacul de pe rândul B sau în copacul de pe rândul D;
* se oprește într-unul dintre copacii numerotați cu <code>n</code>.

= Cerința =
<syntaxhighlight lang="python3">
Constanta_mod = 666013
# Constanta pentru operatia modulo

numar_n = 0

# Definim functie pentru inmultirea matricei
def inmultire_matrice(numar_a, numar_b):
raspuns = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
for i in range(4):
for j in range(4):
for k in range(4):
raspuns[i][j] += numar_a[i][k] * numar_b[k][j]
if numar_n > 1000:
# Aplicam operatia modulo daca n > 1000
raspuns[i][j] %= Constanta_mod
return raspuns

def main():
# Deschidem fisierele input si output
fin = open("veverita4.in", "r")
fout = open("veverita4.out", "w")

# Citim valoarea numarului "n" din fisierul input
numar_n = int(fin.readline())

# Definim matricea initiala "matrice"
matrice = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]

# Initializam rezultatul matricei "matrice_rezultata" ca matrice de identitate
matrice_rezultata = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]

# Efectuam exponentierea matricei folosind metoda exponentierei binare
exponent = numar_n - 1
while exponent:
if exponent % 2 == 1:
# Inmultim matricea_rezultata cu matricea
matrice_rezultata = inmultire_matrice(matrice_rezultata, matrice)
# Ridicam matricea la puterea 2
matrice = inmultire_matrice(matrice, matrice)
exponent = int(exponent / 2)

# Calculam rezultatul final apeland elementele din "matrice_rezultata"
raspuns = 0
for i in range(4):
for j in range(4):
raspuns += matrice_rezultata[i][j]

# Aplicam operatia modulo daca n > 1000
if numar_n > 1000:
raspuns %= Constanta_mod

# Scriem rezultatul final in fisierul output si inchidem fisierele
fout.write(str(raspuns))

fin.close()
fout.close()

# Verificam daca scriptul este rulat direct

if __name__ == "__main__":
# Apelam functia main()
main()
</syntaxhighlight>Aflați numărul <code>M</code> de modalități în care se poate deplasa veverița, respectând regulile de mai sus. Dacă <code>n</code> este mai mic sau egal cu <code>1000</code>, atunci veți afișa chiar numărul <code>M</code>, iar dacă <code>n</code> este mai mare decât <code>1000</code>, veți afișa restul împărțirii lui <code>M</code> la <code>666013</code>.

= Date de intrare =
Fișierul de intrare <code>veverita4.in</code> conține pe prima linie numărul <code>n</code>.

= Date de ieșire =
Fișierul de ieșire <code>veverita4.out</code> va conține pe prima linie valoarea cerută.

= Restricții și precizări =

* <code>1 ≤ n ≤ 109</code>
* pentru 60% din teste, <code>n ≤ 1000</code>;
* pentru alte 40% din teste, <code>n ≤ 109</code>;

= Exemplu =
<code>veverita4.in</code>
3
<code>veverita4.out</code>
10

3646 - Zoom poza

2024-01-12T22:01:13Z

VanceaGabriel: nume variabile

= Cerința =
În orașul Detroit s-a produs o spargere la un magazin de bijuterii. Infractorii au fugit de la locul faptei, iar polițiștii au reusit să facă rost doar de o poză neclară cu infractorii.

Cu ajutorul inteligenței artificiale reușesc să mărească acea imagine pentru a găsi niște detalii pentru a-i ajuta la rezolvarea cazului. Fii de partea binelui și ajută-i pe polițiști să rezolve acest caz!

Poza este reprezentată printr-o matrice cu <code>n</code> linii și <code>m</code> coloane, alcătuită din numere naturale. Polițiștii te roagă să-i ajuți, răspunzând la următoarele întrebări:

1) Dându-se o matrice reprezentând poza și un coeficient de mărire <code>z</code>, construiește o altă matrice care să reprezinte poza mărită de <code>z</code> ori.

2) Dându-se o matrice reprezentând poza, coeficientul de mărire <code>z</code> și un șir perechi de coordonate din poza mărită, determină pentru fiecare pereche de coordonate valoarea din poza mărită.

== Date de intrare ==
Fișierul de intrare <code>zoom_poza.in</code> conține pe prima linie numărul <code>c</code>, reprezentând întrebarea la care trebuie să răspunzi.

Pentru <code>c=1</code> pe a doua linie se află numărul de linii <code>n</code> și numărul de coloane <code>m</code>, pe a treia linie factorul de al imaginii <code>z</code>, iar pe următoarele <code>n</code> linii și <code>m</code> coloane poza sub forma unei matrici.

Pentru <code>c=2</code> pe a doua linie se află numărul de linii <code>n</code> și numărul de coloane <code>m</code>, pe a treia linie factorul de al imaginii <code>z</code>, iar pe următoarele <code>n</code> linii și <code>m</code> coloane poza sub forma unei matrici. Pe a patra linie se află <code>k</code> – numărul de perchi de coordonate, iar pe următoarele <code>k</code> linii câte două numere <code>l1 c1</code>, reprezentând numărul de ordine al liniei, respectiv al coloanei pentru elementul cerut din matricea finală.

== Date de ieșire ==
Fișierul de ieșire <code>zoom_poza.out</code> va conține:

* pentru <code>c=1</code> imaginea mărită de către program, în dimensiune de <code>n*z</code> linii și <code>m*z</code> coloane.
* pentru <code>c=2</code> se vor afișa numerele aflate pe pozițiile date în poza mărită, separate printr-un spațiu.

=== Restricții și precizări ===

* Pentru <code>c=1</code>:
** <code>1 ≤ n ≤ m ≤ 70</code>
** <code>1 ≤ a[i][j] ≤ 100.000</code>
** <code>1 ≤ z ≤ 10</code>
** Pentru teste în valoare de 40 de puncte, <code>c=1</code>.
* Pentru <code>c=2</code>:
** Pentru 20 de puncte:
*** <code>1 ≤ n ≤ m ≤ 70</code>
*** <code>1 ≤ a[i][j] ≤ 100.000</code>
*** <code>1 ≤ z ≤ 10</code>
*** <code>1 ≤ k ≤ 1000</code>
*** <code>1 ≤ l1 ≤ c1 ≤ 2500</code>
** Pentru 60 de puncte:
*** <code>1 ≤ n ≤ m ≤ 50</code>
*** <code>1 ≤ a[i][j] ≤ 9•1018</code>
*** <code>1 ≤ z ≤ 9•1014</code>
*** <code>1 ≤ k ≤ 1.000</code>
*** <code>1 ≤ l1 ≤ c1 ≤ 9•1018</code>

* Se recomandă evitarea rezolvării din afișare!

<syntaxhighlight lang="python3">
import numpy as np

def main():
fin = open("zoom_poza.in", "r")
fout = open("zoom_poza.out", "w")

numar_c = int(fin.readline())

if numar_c == 1:
caz_1(fin, fout)
elif numar_c == 2:
caz_2(fin, fout)

def caz_1(fin, fout):
numar_n, numar_m = map(int, fin.readline().split()) # citim numerele n, m
numar_z = int(fin.readline()) # citim numar z
numar_a = np.zeros((numar_n, numar_m), dtype=int)
for i in range(numar_n):
line = fin.readline().split()
for j in range(numar_m):
numar_a[i][j] = int(line[j]) # citim matricea initiala
numar_b = np.zeros((numar_n * numar_z, numar_m * numar_z), dtype=int)
for i in range(numar_n):
constanta = 0
for j in range(numar_m):
for numar_x in range(numar_z):
for numar_y in range(numar_z):
numar_b[i * numar_z + numar_y][
constanta * numar_z + numar_x
] = numar_a[i][j]
# se creeaza matricea marita de z ori
constanta += 1
for i in range(0, numar_z * numar_n):
for j in range(0, numar_z * numar_m):
fout.write(str(numar_b[i][j]) + " ") # scriem in fisier matricea rezultata
fout.write("\n")

def caz_2(fin, fout):
numar_n, numar_m = map(int, fin.readline().split()) # citim numerele n, m
numar_z = int(fin.readline()) # citim z
numar_a = np.zeros((numar_n, numar_m), dtype=int)
for i in range(numar_n):
line = fin.readline().split()
for j in range(numar_m):
numar_a[i][j] = int(line[j]) # citim matricea initiala
numar_k = int(fin.readline()) # citim numarul k
for i in range(numar_k):
linia1, coloana1 = map(int, fin.readline().split()) # citim linia 1, coloana 1
line = linia1 / numar_z
if linia1 % numar_z != 0:
line += 1
column = coloana1 / numar_z
if coloana1 % numar_z != 0:
column += 1
fout.write(
str(numar_a[int(line - 1)][int(column - 1)]) + " "
) # scriem in fisier valoarea de
# pe pozitia ceruta

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

2979 - Cartele 1

2024-01-12T20:47:15Z

VanceaGabriel: Pagină nouă: Într-o școală există un sistem de acces cu ajutorul cartelelor, conectat la un calculator și o imprimantă. Fiecare elev al școlii are câte o cartelă. Într-o zi, la utilizarea fiecărei cartele, sistemul imprimă următoarele informații pe hârtie, pe câte o linie, după regula următoare: - Caracterul <code>b</code> dacă elevul este băiat sau caracterul <code>f</code> dacă este fată. Caracterul va fi urmat de un spațiu; - Caracterul <code>i</code> dacă ele...

Într-o școală există un sistem de acces cu ajutorul cartelelor, conectat la un calculator și o imprimantă. Fiecare elev al școlii are câte o cartelă. Într-o zi, la utilizarea fiecărei cartele, sistemul imprimă următoarele informații pe hârtie, pe câte o linie, după regula următoare:

- Caracterul <code>b</code> dacă elevul este băiat sau caracterul <code>f</code> dacă este fată. Caracterul va fi urmat de un spațiu;

- Caracterul <code>i</code> dacă elevul a intrat în școală sau caracterul <code>e</code> dacă a ieșit din școală. De asemenea, acest caracter va fi urmat de un spațiu;

- Momentul utilizării cartelei, exprimat prin oră, minute și secunde. Acestea vor fi reprezentate în cadrul liniei, exact în această ordine, prin trei numere naturale, separate între ele prin câte un spațiu.

= Cerința =
Cunoscându-se toate cele <code>N</code> linii imprimate într-o zi determinați:

1. Câți băieți și câte fete sunt la școală după cele <code>N</code> acțiuni imprimate de sistem.

2. Care este numărul total de secunde în care, în școală, s-au aflat un număr egal, nenul, de fete și băieți, până în momentul utilizării ultimei cartele. Dacă nu există această situație se afișează <code>0</code>.

3. Care este numărul maxim de secunde în care, în școală, până în momentul utilizării ultimei cartele, s-au aflat neîntrerupt un număr impar de băieți. Dacă nu există o astfel de situație se afișează <code>0</code>.

= Date de intrare =
Fișierul de intrare <code>cartele.in</code> conține pe prima linie un număr natural <code>C</code> reprezentând numărul cerinței care poate avea valorile <code>1</code>, <code>2</code> sau <code>3</code>, pe a doua linie numărul natural <code>N</code>, iar pe următoarele <code>N</code> linii informațiile imprimate de sistem sub forma descrisă în enunț, în ordinea strict crescătoare a momentului folosirii cartelei.

= Date de ieșire =
Dacă <code>C = 1</code>, atunci fișierul de ieșire <code>cartele.out</code> va conține, în această ordine, separate printr-un spațiu, numărul de băieți și numărul de fete determinat conform cerinței 1.

Dacă <code>C = 2</code> sau <code>C = 3</code>, atunci fișierul de ieșire <code>cartele.out</code> va conține pe prima linie un singur număr natural ce reprezintă rezultatul determinat conform cerinței.

= Restricții și precizări =

* <code>1 ≤ N ≤ 10.000</code>
* La momentul utilizării primei cartele, în școală nu se află niciun elev
* Sistemul de acces nu permite folosirea simultană a două cartele
* Pentru orice linie imprimată de sistem <code>0 ≤ ora ≤ 23</code>, <code>0 ≤ minute ≤ 59</code> și <code>0 ≤ secunde ≤ 59</code>
* Pe fiecare linie a fișierului de intrare, după ultimul număr, reprezentând secundele, nu există spațiu.
* Pentru rezolvarea corectă a primei cerințe se acordă <code>20</code> de puncte, pentru rezolvarea corectă a celei de-a doua cerințe se acordă <code>30</code> de puncte iar pentru rezolvarea corectă a celei de-a treia cerințe se acordă <code>40</code> de puncte.
* În concurs s-au acordat <code>10</code> puncte din oficiu. Aici se acordă pentru exemplele din enunț.

= Exemplul 1: =
<code>cartele.in</code>
1
3
b i 0 0 24
f i 0 0 26
b e 0 0 29
<code>cartele.out</code>
0 1

=== Explicație ===
Un băiat a intrat la momentul <code>0 0 24</code> (adică ora <code>0</code>, minutul <code>0</code> și secunda <code>24</code>) și ieșit la momentul <code>0 0 29</code>. O fată a intrat la momentul <code>0 0 26</code>. După cele <code>3</code> acțiuni, în școală a rămas o fată.

= Exemplul 2: =
<code>cartele.in</code>
2
3
b i 0 0 24
f i 0 0 26
b e 0 0 29
<code>cartele.out</code>
3

=== Explicație ===
Între momentul <code>0 0 24</code> și <code>0 0 26</code> în școală este doar un băiat. Între momentul <code>0 0 26</code> și <code>0 0 29</code> în școală se află un băiat și o fată adică un număr nenul egal de fete și băieți. Deci, numărul de secunde determinat este <code>3</code>.

= Exemplul 3: =
<code>cartele.in</code>
2
8
f i 8 19 10
b i 8 19 12
b e 8 19 15
b i 8 20 0
b e 8 20 4
b i 8 20 10
b i 8 20 50
b i 8 20 51
<code>cartele.out</code>
47

=== Explicație ===
Între momentele <code>8 19 12</code> și <code>8 19 15</code> în școală se află <code>1</code> băiat și <code>1</code> fată, deci durata este <code>3</code> secunde.

Între momentele <code>8 20 0</code> și <code>8 20 4</code> în școală se află <code>1</code> băiat și <code>1</code> fată, deci durata este <code>4</code> secunde.

Între momentele <code>8 20 10</code> și <code>8 20 50</code> în școală se află <code>1</code> băiat și <code>1</code> fată, deci durata este <code>40</code> de secunde.

Durata totală este <code>3 + 4 + 40 = 47</code> de secunde.

= Exemplul 4: =
<code>cartele.in</code>
3
9
f i 8 19 10
b i 8 19 12
f e 8 19 13
b e 8 19 15
b i 8 20 0
b i 8 20 1
b i 8 20 10
b i 8 20 12
b i 8 20 13
<code>cartele.out</code>
3

=== Explicație ===
Între momentele <code>8 19 12</code> și <code>8 19 15</code> în școală se află <code>1</code> băiat, deci durata este <code>3</code> secunde.

Între momentele <code>8 20 0</code> și <code>8 20 1</code> în școală se află <code>1</code> băiat, deci durata este <code>1</code> secundă.

Între momentele <code>8 20 10</code> și <code>8 20 12</code> în școală se află <code>3</code> băieți, deci durata este <code>2</code> secunde.

Durata maximă cerută este de <code>3</code> secunde.<syntaxhighlight lang="python3">
def main():
fin = open("cartele1.in", "r")
fout = open("cartele1.out", "w")

# Citim valorile C și N din fișierul de intrare
C = int(fin.readline().strip())
N = int(fin.readline().strip())

baieti_in_scoala = 0
fete_in_scoala = 0
timp_egal_fete_baieti = 0
timp_maxim_baieti = 0
ultimul_timp_inregistrat = 0

for i in range(N):
line = fin.readline().split()

gen, actiune, h, m, s = line[0], line[1], int(line[2]), int(line[3]), int(line[4])

timp_initial = h * 3600 + m * 60 + s

# Actualizăm numărul de băieți și fete în școală în funcție de acțiunea curentă
if gen == 'b':
baieti_in_scoala += 1 if actiune == 'i' else -1
else:
fete_in_scoala += 1 if actiune == 'i' else -1

# Verificăm dacă numărul de băieți și fete este egal și calculăm timpul
# Verificăm timpul maxim cu un număr impar de băieți în școală
if baieti_in_scoala == fete_in_scoala and fete_in_scoala > 0:
timp_egal_fete_baieti += timp_initial - ultimul_timp_inregistrat

if baieti_in_scoala % 2 == 1:
timp_maxim_baieti = max(timp_maxim_baieti, timp_initial - ultimul_timp_inregistrat)

# Actualizăm ultimul timp înregistrat
ultimul_timp_inregistrat = timp_initial

# Scrie rezultatele în funcție de tipul cerinței
if C == 1:
fout.write(f"{baieti_in_scoala} {fete_in_scoala}")
elif C == 2:
fout.write(str(timp_egal_fete_baieti))
elif C == 3:
fout.write(str(timp_maxim_baieti))

if __name__ == "__main__":
# Apelăm funcția main
main()
</syntaxhighlight>

4287 - Veverita 4

2024-01-11T22:59:41Z

VanceaGabriel: Pagină nouă: În parcul orașului există <code>4</code> rânduri de câte <code>n</code> copaci perfect aliniați. Rândurile sunt notate A, B, C și D, iar copacii de pe fiecare rând sunt numerotați de la <code>1</code> la <code>n</code>, ca în imaginea de mai jos: O veveriță jucăușă sare prin copaci astfel: * pornește dintr-un copac numerotat cu <code>1</code>; * la fiecare pas sare dintr-un copac numerotat cu <code>i</code> într-un copac numerotat cu <code>i+1</code>. Da...

În parcul orașului există <code>4</code> rânduri de câte <code>n</code> copaci perfect aliniați. Rândurile sunt notate A, B, C și D, iar copacii de pe fiecare rând sunt numerotați de la <code>1</code> la <code>n</code>, ca în imaginea de mai jos:

O veveriță jucăușă sare prin copaci astfel:

* pornește dintr-un copac numerotat cu <code>1</code>;
* la fiecare pas sare dintr-un copac numerotat cu <code>i</code> într-un copac numerotat cu <code>i+1</code>. Dacă se află într-un copac de pe rândul A, va sări în copacul de pe rândul B, dacă se află într-un copac de pe rândul D, va sări în copacul de pe rândul C, dacă se află în copacul de pe rândul B, va sări în copacul de pe rândul A sau în copacul de pe rândul C, iar dacă se află în copacul de pe rândul C, va sări în copacul de pe rândul B sau în copacul de pe rândul D;
* se oprește într-unul dintre copacii numerotați cu <code>n</code>.

= Cerința =
<syntaxhighlight lang="python3">
MOD = 666013 #definim constanta pentru operatia modulo

fin = open("veverita4.in", "r") #deschidem fisierele input si output
fout = open("veverita4.out", "w")

n = int(fin.readline()) #citim valoarea lui "n" din fisierul input

#definim functie pentru inmultirea matricei
def mat_multiply(a, b)
ans = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
for i in range(4):
for j in range(4):
for k in range(4):
ans[i][j] += a[i][k] * b[k][j]
if n > 1000:#aplicam operatia modulo daca n>1000
ans[i][j] %= MOD
return ans # ridicam matricea la puterea n-1

#definim matricea initiala "mat"
mat = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]
#initializam rezultatul matricel "ansmat" ca matrice de identitate
ansmat = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
#efectuam exponentierea matricei folosind metoda exponentierei binare
exp = n - 1
while exp:
if exp % 2 == 1:
ansmat = mat_multiply(ansmat, mat)
mat = mat_multiply(mat, mat)
exp = int(exp / 2)
#calculam rezultatul final apeland elementele din "ansmat"
ans = 0
for i in range(4):
for j in range(4):
ans += ansmat[i][j]
#aplicam operatia modulo daca n>1000
if n > 1000:
ans %= MOD
#scriem rezultatul final in fisierul output si inchidem fisierul
fout.write(str(ans))
fin.close()
fout.close()
</syntaxhighlight>Aflați numărul <code>M</code> de modalități în care se poate deplasa veverița, respectând regulile de mai sus. Dacă <code>n</code> este mai mic sau egal cu <code>1000</code>, atunci veți afișa chiar numărul <code>M</code>, iar dacă <code>n</code> este mai mare decât <code>1000</code>, veți afișa restul împărțirii lui <code>M</code> la <code>666013</code>.

= Date de intrare =
Fișierul de intrare <code>veverita4.in</code> conține pe prima linie numărul <code>n</code>.

= Date de ieșire =
Fișierul de ieșire <code>veverita4.out</code> va conține pe prima linie valoarea cerută.

= Restricții și precizări =

* <code>1 ≤ n ≤ 109</code>
* pentru 60% din teste, <code>n ≤ 1000</code>;
* pentru alte 40% din teste, <code>n ≤ 109</code>;

= Exemplu =
<code>veverita4.in</code>
3
<code>veverita4.out</code>
10

3646 - Zoom poza

2024-01-11T20:14:02Z

VanceaGabriel:

= Cerința =
În orașul Detroit s-a produs o spargere la un magazin de bijuterii. Infractorii au fugit de la locul faptei, iar polițiștii au reusit să facă rost doar de o poză neclară cu infractorii.

Cu ajutorul inteligenței artificiale reușesc să mărească acea imagine pentru a găsi niște detalii pentru a-i ajuta la rezolvarea cazului. Fii de partea binelui și ajută-i pe polițiști să rezolve acest caz!

Poza este reprezentată printr-o matrice cu <code>n</code> linii și <code>m</code> coloane, alcătuită din numere naturale. Polițiștii te roagă să-i ajuți, răspunzând la următoarele întrebări:

1) Dându-se o matrice reprezentând poza și un coeficient de mărire <code>z</code>, construiește o altă matrice care să reprezinte poza mărită de <code>z</code> ori.

2) Dându-se o matrice reprezentând poza, coeficientul de mărire <code>z</code> și un șir perechi de coordonate din poza mărită, determină pentru fiecare pereche de coordonate valoarea din poza mărită.

== Date de intrare ==
Fișierul de intrare <code>zoom_poza.in</code> conține pe prima linie numărul <code>c</code>, reprezentând întrebarea la care trebuie să răspunzi.

Pentru <code>c=1</code> pe a doua linie se află numărul de linii <code>n</code> și numărul de coloane <code>m</code>, pe a treia linie factorul de al imaginii <code>z</code>, iar pe următoarele <code>n</code> linii și <code>m</code> coloane poza sub forma unei matrici.

Pentru <code>c=2</code> pe a doua linie se află numărul de linii <code>n</code> și numărul de coloane <code>m</code>, pe a treia linie factorul de al imaginii <code>z</code>, iar pe următoarele <code>n</code> linii și <code>m</code> coloane poza sub forma unei matrici. Pe a patra linie se află <code>k</code> – numărul de perchi de coordonate, iar pe următoarele <code>k</code> linii câte două numere <code>l1 c1</code>, reprezentând numărul de ordine al liniei, respectiv al coloanei pentru elementul cerut din matricea finală.

== Date de ieșire ==
Fișierul de ieșire <code>zoom_poza.out</code> va conține:

* pentru <code>c=1</code> imaginea mărită de către program, în dimensiune de <code>n*z</code> linii și <code>m*z</code> coloane.
* pentru <code>c=2</code> se vor afișa numerele aflate pe pozițiile date în poza mărită, separate printr-un spațiu.

=== Restricții și precizări ===

* Pentru <code>c=1</code>:
** <code>1 ≤ n ≤ m ≤ 70</code>
** <code>1 ≤ a[i][j] ≤ 100.000</code>
** <code>1 ≤ z ≤ 10</code>
** Pentru teste în valoare de 40 de puncte, <code>c=1</code>.
* Pentru <code>c=2</code>:
** Pentru 20 de puncte:
*** <code>1 ≤ n ≤ m ≤ 70</code>
*** <code>1 ≤ a[i][j] ≤ 100.000</code>
*** <code>1 ≤ z ≤ 10</code>
*** <code>1 ≤ k ≤ 1000</code>
*** <code>1 ≤ l1 ≤ c1 ≤ 2500</code>
** Pentru 60 de puncte:
*** <code>1 ≤ n ≤ m ≤ 50</code>
*** <code>1 ≤ a[i][j] ≤ 9•1018</code>
*** <code>1 ≤ z ≤ 9•1014</code>
*** <code>1 ≤ k ≤ 1.000</code>
*** <code>1 ≤ l1 ≤ c1 ≤ 9•1018</code>

* Se recomandă evitarea rezolvării din afișare!

<syntaxhighlight lang="python3">
import numpy as np
def main():
fin = open("zoom_poza.in", "r")
fout = open("zoom_poza.out", "w")

c = int(fin.readline())

if c == 1:
process_case_1(fin, fout)
elif c == 2:
process_case_2(fin, fout)
def process_case_1(fin, fout):
n, m = map(int, fin.readline().split()) # citim n, m
z = int(fin.readline()) # citim z
a = np.zeros((n, m), dtype=int)
for i in range(n):
line = fin.readline().split()
for j in range(m):
a[i][j] = int(line[j]) # citim matricea initiala
b = np.zeros((n * z, m * z), dtype=int)
for i in range(n):
constanta = 0
for j in range(m):
for x in range(z):
for y in range(z):
b[i * z + y][constanta * z + x] = a[i][
j
] # se creeaza matricea marita de z ori
constanta += 1
for i in range(0, z * n):
for j in range(0, z * m):
fout.write(str(b[i][j]) + " ") # scriem in fisier matricea rezultata
fout.write("\n")
def process_case_2(fin, fout):
n, m = map(int, fin.readline().split()) # citim n, m
z = int(fin.readline()) # citim z
a = np.zeros((n, m), dtype=int)
for i in range(n):
line = fin.readline().split()
for j in range(m):
a[i][j] = int(line[j]) # citim matricea initiala
k = int(fin.readline()) # citim k
for i in range(k):
l1, c1 = map(int, fin.readline().split()) # citim l1, c1
line = l1 / z
if l1 % z != 0:
line += 1
column = c1 / z
if c1 % z != 0:
column += 1
fout.write(str(a[int(line - 1)][int(column - 1)]) + " ")#scriem in fisier valoarea de
# pe pozitia ceruta

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

3646 - Zoom poza

2024-01-11T16:17:56Z

VanceaGabriel: Cerinta + rezolvare

= Cerința =
În orașul Detroit s-a produs o spargere la un magazin de bijuterii. Infractorii au fugit de la locul faptei, iar polițiștii au reusit să facă rost doar de o poză neclară cu infractorii.

Cu ajutorul inteligenței artificiale reușesc să mărească acea imagine pentru a găsi niște detalii pentru a-i ajuta la rezolvarea cazului. Fii de partea binelui și ajută-i pe polițiști să rezolve acest caz!

Poza este reprezentată printr-o matrice cu <code>n</code> linii și <code>m</code> coloane, alcătuită din numere naturale. Polițiștii te roagă să-i ajuți, răspunzând la următoarele întrebări:

1) Dându-se o matrice reprezentând poza și un coeficient de mărire <code>z</code>, construiește o altă matrice care să reprezinte poza mărită de <code>z</code> ori.

2) Dându-se o matrice reprezentând poza, coeficientul de mărire <code>z</code> și un șir perechi de coordonate din poza mărită, determină pentru fiecare pereche de coordonate valoarea din poza mărită.

== Date de intrare ==
Fișierul de intrare <code>zoom_poza.in</code> conține pe prima linie numărul <code>c</code>, reprezentând întrebarea la care trebuie să răspunzi.

Pentru <code>c=1</code> pe a doua linie se află numărul de linii <code>n</code> și numărul de coloane <code>m</code>, pe a treia linie factorul de al imaginii <code>z</code>, iar pe următoarele <code>n</code> linii și <code>m</code> coloane poza sub forma unei matrici.

Pentru <code>c=2</code> pe a doua linie se află numărul de linii <code>n</code> și numărul de coloane <code>m</code>, pe a treia linie factorul de al imaginii <code>z</code>, iar pe următoarele <code>n</code> linii și <code>m</code> coloane poza sub forma unei matrici. Pe a patra linie se află <code>k</code> – numărul de perchi de coordonate, iar pe următoarele <code>k</code> linii câte două numere <code>l1 c1</code>, reprezentând numărul de ordine al liniei, respectiv al coloanei pentru elementul cerut din matricea finală.

== Date de ieșire ==
Fișierul de ieșire <code>zoom_poza.out</code> va conține:

* pentru <code>c=1</code> imaginea mărită de către program, în dimensiune de <code>n*z</code> linii și <code>m*z</code> coloane.
* pentru <code>c=2</code> se vor afișa numerele aflate pe pozițiile date în poza mărită, separate printr-un spațiu.

=== Restricții și precizări ===

* Pentru <code>c=1</code>:
** <code>1 ≤ n ≤ m ≤ 70</code>
** <code>1 ≤ a[i][j] ≤ 100.000</code>
** <code>1 ≤ z ≤ 10</code>
** Pentru teste în valoare de 40 de puncte, <code>c=1</code>.
* Pentru <code>c=2</code>:
** Pentru 20 de puncte:
*** <code>1 ≤ n ≤ m ≤ 70</code>
*** <code>1 ≤ a[i][j] ≤ 100.000</code>
*** <code>1 ≤ z ≤ 10</code>
*** <code>1 ≤ k ≤ 1000</code>
*** <code>1 ≤ l1 ≤ c1 ≤ 2500</code>
** Pentru 60 de puncte:
*** <code>1 ≤ n ≤ m ≤ 50</code>
*** <code>1 ≤ a[i][j] ≤ 9•1018</code>
*** <code>1 ≤ z ≤ 9•1014</code>
*** <code>1 ≤ k ≤ 1.000</code>
*** <code>1 ≤ l1 ≤ c1 ≤ 9•1018</code>

* Se recomandă evitarea rezolvării din afișare!

<syntaxhighlight lang="python3">
import numpy as np

def main():
fin = open("zoom_poza.in", "r")
fout = open("zoom_poza.out", "w") # deschidem fisierele input si output

c = int(fin.readline())
fout.write(str(c))

if c == 1:
process_case_1(fin, fout)
elif c == 2:
process_case_2(fin, fout)

fin.close()
fout.close()

def process_case_1(fin, fout):
a = np.zeros((71, 71), dtype=int)
n, m, z = map(int, fin.readline().split())
for i in range(1, m+1):
a[i][j] = int(fin.readline()) # inlocuim j cu i
b = np.zeros((701, 701), dtype=int)
for i in range(1, n+1):
constanta = 0 # Initializam constanta
for j in range(1, m+1):
for x in range(1, z+1):
for x1 in range(1, z+1):
b[(i - 1) * z + x1][constanta * z + x] = a[i][j]
constanta += 1
for i in range(1, z * m + 1):
for j in range(1, z * m + 1):
fout.write(str(b[i][j]) + " ")
fout.write("\n")

def process_case_2(fin, fout):
n, m, z = map(int, fin.readline().split())
b = np.zeros((701, 701), dtype=int)
for i in range(1, n+1):
for j in range(1, m+1):
b[i][j] = int(fin.readline())
k = int(fin.readline())
for _ in range(k):
l1, c1 = map(int, fin.readline().split())
linie = l1 // z
if l1 % z != 0:
linie += 1
coloana = c1 // z
if c1 % z != 0:
coloana += 1
fout.write(str(b[linie][coloana]) + " ")

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