Bitnami MediaWiki - User contributions [en]

15347

2025-01-02T17:01:06Z

Zmicala Narcis:

'''15347 (Meda Bojor, Baia Mare)'''

''Determinați numerele prime <math>p, q, r, s</math> pentru care este adevărată relația <math>p \cdot q \cdot r \cdot s = 26(p + q + r + s)</math>.''

'''Soluție.'''

Deoarece <math>26 \mid p \cdot q \cdot r \cdot s</math> și <math>p, q, r, s</math> sunt numere prime, deducem că unul dintre numere este <math>2</math>, iar altul este <math>13</math>.

Fie <math>p = 2</math> și <math>q = 13</math>. Atunci relația devine <math>r \cdot s = r + s + 15</math> sau <math>r \cdot s - r - s + 1 = 16</math>, pe care o putem scrie: <math>(r - 1)(s - 1) = 16</math>.

Cum <math>r</math> și <math>s</math> sunt numere prime, găsim <math>r = s = 5</math>. Dacă alegeam <math>p = 2</math> și <math>r = 13</math>, găseam <math>q = s = 5</math>, și așa mai departe; toate combinațiile posibile.

15348

2025-01-02T16:49:14Z

Zmicala Narcis: Created page with "'''15348 (Gheorghe Boroica, Baia Mare)''' ''Determinați valorile naturale ale numărului <math>a</math> pentru care există <math>x, y \in \mathbb{N}^*</math> astfel încât <math>x^3 + 2y^3 = a \cdot (2x^2y + xy^2)</math>.'' '''Soluție.''' Fie <math>d = (x, y)</math>. Atunci <math>x = dp</math> și <math>y = dq</math>, unde <math>p</math> și <math>q</math> sunt numere naturale prime între ele. Cu aceasta relația dată devine <math>p^3 + 2q^3 = a(2p^2q + pq^2)<..."

'''15348 (Gheorghe Boroica, Baia Mare)'''

''Determinați valorile naturale ale numărului <math>a</math> pentru care există <math>x, y \in \mathbb{N}^*</math> astfel încât <math>x^3 + 2y^3 = a \cdot (2x^2y + xy^2)</math>.''

'''Soluție.'''

Fie <math>d = (x, y)</math>. Atunci <math>x = dp</math> și <math>y = dq</math>, unde <math>p</math> și <math>q</math> sunt numere naturale prime între ele. Cu aceasta relația dată devine <math>p^3 + 2q^3 = a(2p^2q + pq^2)</math> sau <math>p^3 = aq(2p^2 + pq) - 2q^3</math>, <math>(1)</math>, de unde rezultă <math>q \mid p^3</math>.

Cum <math>(p, q) = 1</math>, obținem <math>q = 1</math>. Relația <math>(1)</math> devine <math>p^3 = a(2p^2 + p) - 2</math>, <math>(2)</math>. Din <math>(2)</math> deducem că <math>p \mid 2</math>, adică <math>p = 1</math> sau <math>p = 2</math>.

Înlocuind în <math>(2)</math> <math>p = 1</math> sau <math>p = 2</math> obținem, de fiecare dată, <math>a = 1</math>.

15347

2025-01-02T16:09:28Z

Zmicala Narcis:

'''15347 (Meda Bojor, Baia Mare)'''
 
 
''Determinați numerele prime p, q, r, s pentru care este adevărată relația p · q · r · s = 26(p + q + r + s).''
 
 
'''Soluție:'''
 
Deoarece 26 | p · q · r · s și p, q, r, s sunt numere prime, deducem că unul dintre numere este 2, iar altul este 13. Fie p = 2 și q = 13. Atunci relația devine:
r · s = r + s + 15,
sau
r · s - r - s = 16,
pe care o putem scrie:
(r - 1)(s - 1) = 16.

Cum r și s sunt numere prime, găseam r = s = 5. Dacă alegem p = 2 și r = 13, găseam q = s = 5, și așa mai departe; toate combinațiile posibile.

15347

2025-01-02T16:07:56Z

Zmicala Narcis: Created page with "'''E:15347 (Meda Bojor, Baia Mare)''' ''Determinați numerele prime p, q, r, s pentru care este adevărată relația p · q · r · s = 26(p + q + r + s).'' '''Soluție:''' Deoarece 26 | p · q · r · s și p, q, r, s sunt numere prime, deducem că unul dintre numere este 2, iar altul este 13. Fie p = 2 și q = 13. Atunci relația devine: r · s = r + s + 15, sau r · s - r - s = 16, pe care o putem scrie: (r - 1)(s - 1)..."

'''E:15347 (Meda Bojor, Baia Mare)'''
 
 
''Determinați numerele prime p, q, r, s pentru care este adevărată relația p · q · r · s = 26(p + q + r + s).''
 
 
'''Soluție:'''
 
Deoarece 26 | p · q · r · s și p, q, r, s sunt numere prime, deducem că unul dintre numere este 2, iar altul este 13. Fie p = 2 și q = 13. Atunci relația devine:
r · s = r + s + 15,
sau
r · s - r - s = 16,
pe care o putem scrie:
(r - 1)(s - 1) = 16.

Cum r și s sunt numere prime, găseam r = s = 5. Dacă alegem p = 2 și r = 13, găseam q = s = 5, și așa mai departe; toate combinațiile posibile.

1835 - twoop

2024-01-03T17:05:51Z

Zmicala Narcis: Pagină nouă: Se dă un șir de '''N''' elemente, numere întregi. Pe acest șir se aplică operații de două tipuri : Tip 1: '''st dr val''' – elementele de pe pozițiile din intervalul '''[st, dr]''' cresc cu valoarea '''val''' Tip 2: '''poz''' – să se afișeze valoarea elementului de pe poziția '''poz''' . Toate operațiile de tipul '''2''' se aplică numai după ce s-au aplicat toate operațiile de tipul '''1'''. == Cerința == Dându-se șirul de elemente și operațiile, înce...

Se dă un șir de '''N''' elemente, numere întregi. Pe acest șir se aplică operații de două tipuri :
Tip 1: '''st dr val''' – elementele de pe pozițiile din intervalul '''[st, dr]''' cresc cu valoarea '''val'''
Tip 2: '''poz''' – să se afișeze valoarea elementului de pe poziția '''poz''' .
Toate operațiile de tipul '''2''' se aplică numai după ce s-au aplicat toate operațiile de tipul '''1'''.
== Cerința ==
Dându-se șirul de elemente și operațiile, începand cu cele de tipul 1, aplicați operațiile pe șir.
== Date de intrare ==
Fișierul de intrare '''twoopin.txt''' conține pe prima linie numărul de elemente, '''N''' , numărul de operații de tip 1, '''nrOp1''' , și numărul de operații de tip 2, '''nrOp2'''.
Pe următoarea linie se află cele '''N''' elemente separate printr-un spațiu.
Pe următoarele '''nrOp1''' linii se află câte o operație de tip 1 sub forma: '''st dr val'''.
Pe următoarele '''nrOp2''' linii se află câte o operație de tip 2 sub forma: '''poz'''.
== Date de ieșire ==
Fișierul de ieșire '''twoopout.txt''' va conține pe primele '''nrOp2''' linii câte un element, rezultatul unei operații de '''tip 2'''.
== Restricții și precizări ==
* '''1 ≤ N ≤ 100.000'''
* '''-1.000.000.000 ≤ a[i], val ≤ 1.000.000.000'''
* '''1 ≤ st ≤ dr ≤ N'''
* '''1 ≤ poz ≤ N'''
== Exemplul 1 ==
; twoopin.txt
: 4 4 2
: 5 0 -1 2
: 1 2 -2
: 2 3 10
: 1 4 2
: 2 3 3
: 2
: 3
; twoopout.txt
: Datele introduse corespund restricțiilor impuse.
: 13
: 14
== Explicație ==
'''5 0 -1 2''' – șir initial
'''3 -2 -1 2''' – după operația 1
'''3 8 9 2''' – după operația 2
'''5 10 11 4''' – după operația 3
'''5 13 14 4''' – după operația 4
== Exemplul 2 ==
; twoopin.txt
: 5 2 2
: 5 0 -1 2 1500000000
: 1 2 -2
: 2 3 10
: 2
: 3
; twoopout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1835 - twoop
def validare(numarde_elemente, numar_operatii, numar_operatiiv2, sirul, operatiiv1, operatiiv2):
if numarde_elemente > 100000 or numarde_elemente < 1 or numar_operatii < 1 or numar_operatiiv2 < 1:
raise ValueError
for element in sirul:
if element > 1000000000 or element < -1000000000:
raise ValueError
for operatie in operatiiv1:
if operatie[0] < 1 or operatie[1] > numarde_elemente or operatie[2] > 1000000000 or operatie[2] < -1000000000:
raise ValueError
for pozitie in operatiiv2:
if pozitie < 1 or pozitie > numarde_elemente:
raise ValueError
fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def aplica_operatii(sirul, operatii, operatiiv2):
for operatie in operatii:
for i in range(operatie[0]-1, operatie[1]):
sirul[i] += operatie[2]
for pozitie in operatiiv2:
fisier_iesire.write(str(sirul[pozitie - 1]) + '\n')

if __name__ == '__main__':
fisier_intrare = open("twoopin.txt", "r")
fisier_iesire = open("twoopout.txt", "w")

try:
numar_elemente, numar_operatii1, numar_operatii2 = map(int, fisier_intrare.readline().split())
sir = list(map(int, fisier_intrare.readline().split()))
operatii1 = [list(map(int, fisier_intrare.readline().split())) for _ in range(numar_operatii1)]
operatii2 = [int(fisier_intrare.readline()) for _ in range(numar_operatii2)]

validare(numar_elemente, numar_operatii1, numar_operatii2, sir, operatii1, operatii2)
aplica_operatii(sir, operatii1, operatii2)

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1471 - maxdiv

2024-01-03T16:51:46Z

Zmicala Narcis: Pagină nouă: Adrian este pasionat de matematică. El utilizează denumirea maxdiv pentru numărul care are cei mai mulţi divizori, dintre numerele unui şir dat. Adrian ştie că o secvenţă este un subşir de numere care apar pe poziţii consecutive într-un şir. El denumeşte secvenţă maxdiv o secvenţă din şir, formată din cel puţin două numere, ce începe şi se încheie cu un număr maxdiv şi nu conţine alte numere maxdiv în interior. Având la dispoziţie un şir de n n...

Adrian este pasionat de matematică. El utilizează denumirea maxdiv pentru numărul care are cei mai mulţi divizori, dintre numerele unui şir dat. Adrian ştie că o secvenţă este un subşir de numere care apar pe poziţii consecutive într-un şir. El denumeşte secvenţă maxdiv o secvenţă din şir, formată din cel puţin două numere, ce începe şi se încheie cu un număr maxdiv şi nu conţine alte numere maxdiv în interior.
Având la dispoziţie un şir de n numere naturale, doreşte să afişeze cea mai lungă secvenţă maxdiv şi numărul de secvenţe maxdiv din şir. Dacă şirul de numere dat conţine mai multe secvenţe maxdiv de aceeaşi lungime maximă, se va afişa prima secvenţă de acest tip din şir.
== Cerința ==
Scrieţi un program care afişează, pentru un şir dat format din n numere naturale numărul de secvenţe maxdiv şi cea mai lungă secvenţă maxdiv.
== Date de intrare ==
Fişierul de intrare '''maxdivin.txt''' conţine pe prima linie numărul '''n''' separat printr-un spaţiu de un număr natural '''t''', care reprezintă cerinţa: '''1''', dacă se cere numărul de secvenţe maxdiv, respectiv '''2''' dacă se cere cea mai lungă secvenţă maxdiv. Linia a doua din fişier conţine cele '''n''' numere naturale ale şirului dat.
== Date de ieșire ==
Fişierul de ieșire '''maxdivout.txt''' va conţine pe prima linie un număr natural ce reprezintă numărul de secvenţe maxdiv, pentru şirul de numere dat, dacă cerinţa este '''1'''. Dacă cerinţa este '''2''', fişierul de ieşire va conţine un şir de numere naturale, separate între ele prin câte un spaţiu, ce reprezintă cea mai lungă secvenţă maxdiv din şirul dat.
== Restricții și precizări ==
* '''2 ≤ n ≤ 1000'''
* '''2 ≤ x[i] ≤ 1.000.000''', unde '''x[i]''' reprezintă un număr din şirul dat
* Şirul de numere conţine cel puţin o secvenţă care începe şi se încheie cu un număr maxdiv
* Pentru cerința '''1''' se acordă 40% din punctaj, iar pentru cerința '''2''' se acordă 60% din punctaj.
== Exemplul 1 ==
; maxdivin.txt
: 7 1
: 22 60 64 125 315 24 150
; maxdivout.txt
: Datele introduse corespund restricțiilor impuse.
: 2
== Explicație ==
Cerinţa 1: Şirul de numere dat conţine '''3''' numere maxdiv: '''60''', '''315''' şi '''150''' (au fiecare '''12''' divizori) și '''2''' secvenţe maxdiv : '''60 64 125 315''' şi '''315 24 150'''.
== Exemplul 2 ==
; maxdivin.txt
: 7 2
: 22 60 64 125 315 24 150
; maxdiv.out
: Datele introduse corespund restricțiilor impuse.
: 60 64 125 315
== Explicație ==
Cerinţa 2: Şirul de numere dat conţine '''2''' secvenţe maxdiv: '''60 64 125 315''' şi '''315 24 150'''. Cea mai lungă secvenţă este '''60 64 125 315'''.
== Exemplul 3 ==
; maxdivin.txt
: 7 2
: 22 60 64 125 315 24 15000000
; maxdiv.out
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1471 - maxdiv
def numar_divizori(n1):
cnt = 0
for i in range(1, int(n1 ** 0.5) + 1):
if n1 % i == 0:
if n1 / i == i:
cnt += 1
else:
cnt += 2
return cnt

def validare(nrs):
if len(nrs) > 1000:
raise ValueError
for nr in nrs:
if nr > 1000000:
raise ValueError
fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def secvente_maxdiv(nrs, t1):
maxdiv = max(nrs, key=numar_divizori)
secvente = []
secventa_curenta = []
for nr in nrs:
if nr == maxdiv:
if secventa_curenta:
secventa_curenta.append(nr)
secvente.append(secventa_curenta)
secventa_curenta = [nr]
elif secventa_curenta:
secventa_curenta.append(nr)
if t1 == 1:
fisier_iesire.write(str(len(secvente)))
else:
max_len = max(len(secventa) for secventa in secvente)
for secventa in secvente:
if len(secventa) == max_len:
fisier_iesire.write(' '.join(map(str, secventa)))
break

if __name__ == '__main__':
fisier_intrare = open("maxdivin.txt", "r")
fisier_iesire = open("maxdivout.txt", "w")

try:
n, t = map(int, fisier_intrare.readline().split())
numere = list(map(int, fisier_intrare.readline().split()))

validare(numere)
secvente_maxdiv(numere, t)

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1439 - Sir6

2024-01-03T16:34:40Z

Zmicala Narcis: Pagină nouă: Se dă un şir de '''N''' numere naturale. Din acest şir, putem forma un şir comprimat de forma: '''a[1], b[1], a[2], b[2], …, a[x], b[x]''', din care înţelegem că numărul '''a[1]''' apare pe primele '''b[1]''' poziţii, '''a[2]''' apare pe următoarele '''b[2]''' poziţii…, iar '''a[x]''' apare pe ultimele '''b[x]''' poziţii. De exemplu, dacă şirul dat este '''1 1 5 5 5 2''', atunci şirul comprimat va fi '''1 2 5 3 2 1'''. == Cerința == Să se determine: a) Lu...

Se dă un şir de '''N''' numere naturale. Din acest şir, putem forma un şir comprimat de forma: '''a[1], b[1], a[2], b[2], …, a[x], b[x]''', din care înţelegem că numărul '''a[1]''' apare pe primele '''b[1]''' poziţii, '''a[2]''' apare pe următoarele '''b[2]''' poziţii…, iar '''a[x]''' apare pe ultimele '''b[x]''' poziţii.
De exemplu, dacă şirul dat este '''1 1 5 5 5 2''', atunci şirul comprimat va fi '''1 2 5 3 2 1'''.
== Cerința ==
Să se determine:
a) Lungimea celei mai lungi secvenţe formată din numere egale.
b) Şirul comprimat pentru şirul dat.
== Date de intrare ==
Fișierul de intrare '''sir6in.txt''' conține pe prima linie numerele '''P''' şi '''N'''. Pe următoarea linie se găseşte un şir format din '''N''' numere naturale.
== Date de ieșire ==
Fișierul de ieșire '''sir6out.txt''' va conține pe prima linie:
a) Dacă '''P''' este '''1''', lungimea celei mai lungi secvenţe, reprezentând răspunsul la cerinţa a).
b) Dacă '''P''' este '''2''', şirul comprimat, reprezentând răspunsul la cerinţa b).
caz contrar, se va afișa mesajul:" Datele de intrare nu corespund restrictiilor impuse"
== Restricții și precizări ==
* '''N <= 100.000'''
* Numerele din şir nu depăşesc '''1.000.000'''.
* '''P''' este '''1''' sau '''2'''.
== Exemplul 1 ==
; sir6in.txt
: 1 6
: 1 1 5 5 5 2
; sir6out.txt
: Datele introduse corespund restricțiilor impuse.
: 3
== Explicație ==
Pentru acest test '''P = 1''', deci se va rezolva doar cerinţa a). Secvenţa cea mai lungă formată din numere egale este: '''5 5 5''' şi are lungimea '''3'''.
== Exemplul 2 ==
; sir6in.txt
: 2 6
: 1 1 5 5 5 2
; sir6out.txt
: Datele introduse corespund restricțiilor impuse.
: 1 2 5 3 2 1
== Explicație ==
Pentru acest test '''P = 2''', deci se va rezolva doar cerinţa b). Numărul '''1''' apare de '''2''' ori, numărul '''5''' apare de '''3''' ori, iar numărul '''2''' apare o singură dată. Prin urmare, şirul comprimat este '''1 2 5 3 2 1'''.
== Exemplul 3 ==
; sir6in.txt
: 2
: 1 2 3 4 5 1000000001
: 2
: 1 3
: 2 4
; sir6out.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1439 - Sir6
from itertools import groupby

def validare(p, numarde_elemente, sirul): # functia de validare a datelor de intrare
if p not in [1, 2] or not (1 <= numarde_elemente <= 100000):
raise ValueError

if any(not (0 <= element <= 1000000) for element in sirul):
raise ValueError

fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def proceseaza_sir(p, sirul): # functia de rezolvare
if p == 1:
lungime_maxima = max(len(list(grup)) for _, grup in groupby(sirul))
fisier_iesire.write(f"{lungime_maxima}\n")
elif p == 2:
sir_comprimat = [f"{k} {len(list(grup))}" for k, grup in groupby(sirul)]
fisier_iesire.write(" ".join(sir_comprimat) + "\n")

if __name__ == '__main__':
fisier_intrare = open("sir6in.txt", "r") # declararea fisierelor
fisier_iesire = open("sir6out.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
P, numar_elemente = map(int, fisier_intrare.readline().split())
sir = list(map(int, fisier_intrare.readline().split()))

validare(P, numar_elemente, sir) # apelul functiei de validare
proceseaza_sir(P, sir) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1933 - Sume2

2024-01-03T16:16:48Z

Zmicala Narcis: Pagină nouă: == Cerința == Fie '''N''' un numar natural și un șir de '''N''' numere naturale '''V[1], V[2], …, V[N]'''. Pentru '''M''' întrebări de forma '''(i,j)''', să se calculeze suma termenilor '''V[i], V[i + 1], …, V[j]'''. == Date de intrare == Pe prima linie a fișierului '''sume2in.txt''' se găsește un număr natural '''N'''. Pe urmatoarea linie sunt '''N''' numere naturale, reprezentând valorile șirului '''V'''. Pe a treia linie se găsește un număr natural '''M'...

== Cerința ==
Fie '''N''' un numar natural și un șir de '''N''' numere naturale '''V[1], V[2], …, V[N]'''. Pentru '''M''' întrebări de forma '''(i,j)''', să se calculeze suma termenilor '''V[i], V[i + 1], …, V[j]'''.
== Date de intrare ==
Pe prima linie a fișierului '''sume2in.txt''' se găsește un număr natural '''N'''. Pe urmatoarea linie sunt '''N''' numere naturale, reprezentând valorile șirului '''V'''. Pe a treia linie se găsește un număr natural '''M''' reprezentând numărul de întrebări, iar pe următoarele '''M''' linii câte o pereche de numere '''(i,j)''', reprezentând o întrebare pentru care se cere să se calculeze suma '''V[i] + V[i + 1] + ... + V[j]'''.
== Date de ieșire ==
Pe prima linie din fişierul '''sume2out.txt''' se găseşte răspunsul la prima întrebare din fişierul de intrare, pe a doua linie se găseşte răspunsul la cea de-a doua întrebare, și așa mai departe.
== Restricții și precizări ==
* '''1 ≤ N ≤ 100.000'''
* '''1 ≤ M ≤ 500.000'''
* '''0 ≤ V[i] ≤ 1.000.000.000'''
Pentru 30% dintre teste '''N''', '''M ≤ 1.000'''
== Exemplul 1 ==
; sume2in.txt
: 4
: 1 2 3 4
: 2
: 1 3
: 2 4
; sume2.out
: Datele introduse corespund restricțiilor impuse.
: 6
: 9
== Explicație ==
uma elementelor de pe pozițiile de la '''1''' la '''3''' este '''6'''.
Suma elementelor de pe pozițiile de la '''2''' la '''4''' este '''9'''.
== Exemplul 2 ==
; sume2in.txt
: 6
: 1 2 3 4 5 1000000001
: 2
: 1 3
: 2 4
; sume2.out
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1933 - Sume2
def validare(numarde_elemente, numarde_intrebari, sirul, intrebarii): # functia de validare a datelor de intrare
if not (1 <= numarde_elemente <= 100000) or not (1 <= numarde_intrebari <= 500000):
raise ValueError

if len(sirul) != numarde_elemente or any(not (0 <= element <= 1000000000) for element in sirul):
raise ValueError

if any(not (1 <= i <= j <= numarde_elemente) for i, j in intrebarii):
raise ValueError

fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def calculeaza_sume(sirul, intrebarii): # functia de rezolvare
for i, j in intrebarii:
suma = sum(sirul[k - 1] for k in range(i, j + 1))
fisier_iesire.write(f"{suma}\n")

if __name__ == '__main__':
fisier_intrare = open("sume2in.txt", "r") # declararea fisierelor
fisier_iesire = open("sume2out.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
numar_elemente = int(fisier_intrare.readline())
sir = list(map(int, fisier_intrare.readline().split()))
numar_intrebari = int(fisier_intrare.readline())
intrebari = [list(map(int, fisier_intrare.readline().split())) for _ in range(numar_intrebari)]

validare(numar_elemente, numar_intrebari, sir, intrebari) # apelul functiei de validare
calculeaza_sume(sir, intrebari) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

3198 - Optimize

2024-01-03T15:54:57Z

Zmicala Narcis:

Programul de mai jos citește din fișierul '''input.txt''' un vector de elemente întregi și construiește în memorie (apoi scrie în fișierul '''output.txt''') un vector care conține aceleași elemente, doar că având toate elementele egale cu '''0'' la final. Ordinea celorlalte elemente se păstrează.
Programul dă întotdeuna rezultatul corect, însă este ineficient din punctul de vedere al timpului de execuție.
== Cerința ==
Rolul vostru este acela de a optimiza programul, astfel încât acesta să se execute în limita de timp indicată în enunț, pentru un vector de cel mult 1 milion de elemente. Limita de memorie trebuie, de asemenea, respectată. În acest sens, este permisă modificarea (oricât de radicală) a funcției '''nule'''. Orice modificare în afara corpului acestei funcții va conduce la respingerea soluței.
== Date de intrare ==
Fișierul de intrare '''input.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''output.txt''' va conține pe prima linie numărul '''n''', iar pe a doua linie elementele vectorului generat.
== Restricții și precizări ==
* '''1 ≤ n ≤ 1.000.000'''
== Important ==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce la erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.
== Exemplul 1 ==
; input.txt
: 10
: 0 3 8 0 0 3 8 7 0 10
; output.txt
: Datele introduse corespund restricțiilor impuse.
: 10
: 3 8 3 8 7 10 0 0 0 0
== Exemplul 2 ==
; input.txt
: 1000001
: 0 1 2 3 4 5 6 7 8 9 10
; output.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3198 - Optimize
def validare(n, v):
if n < 1 or n > 1000000:
raise ValueError("Datele introduse nu corespund restricțiilor impuse.")
if len(v) != n:
raise IndexError("Datele introduse nu corespund restricțiilor impuse.")
print("Datele introduse corespund restricțiilor impuse.")

def nule(v):
size = len(v)
for i in range(size - 1):
swaped = False
for j in range(size - i - 1):
if v[j] == 0:
v[j], v[j+1] = v[j+1], v[j]
swaped = True
if not swaped:
break

def main():
input_filename = "input.txt"
output_filename = "output.txt"
# Read vector from input file
try:
with open(input_filename, 'r') as input_file:
size = int(input_file.readline())
v = list(map(int, input_file.readline().split()))
validare(size, v)
except IOError:
print(f"Failed to open {input_filename}")
exit(-1)
except (ValueError, IndexError) as e:
print(e)
exit(-1)
# Call nule() function
nule(v)
# Print vector to output file
try:
with open(output_filename, 'w') as output_file:
output_file.write(str(size) + '\n')
output_file.write(' '.join(map(str, v)) + '\n')
except IOError:
print(f"Failed to open {output_filename}")
exit(-1)

if __name__ == "__main__":
main()

</syntaxhighlight>

3198 - Optimize

2024-01-03T15:54:35Z

Zmicala Narcis: Pagină nouă: Programul de mai jos citește din fișierul '''input.txt''' un vector de elemente întregi și construiește în memorie (apoi scrie în fișierul '''output.txt''') un vector care conține aceleași elemente, doar că având toate elementele egale cu '''0'' la final. Ordinea celorlalte elemente se păstrează. Programul dă întotdeuna rezultatul corect, însă este ineficient din punctul de vedere al timpului de execuție. == Cerința == Rolul vostru este acela de a optimiza...

Programul de mai jos citește din fișierul '''input.txt''' un vector de elemente întregi și construiește în memorie (apoi scrie în fișierul '''output.txt''') un vector care conține aceleași elemente, doar că având toate elementele egale cu '''0'' la final. Ordinea celorlalte elemente se păstrează.
Programul dă întotdeuna rezultatul corect, însă este ineficient din punctul de vedere al timpului de execuție.
== Cerința ==
Rolul vostru este acela de a optimiza programul, astfel încât acesta să se execute în limita de timp indicată în enunț, pentru un vector de cel mult 1 milion de elemente. Limita de memorie trebuie, de asemenea, respectată. În acest sens, este permisă modificarea (oricât de radicală) a funcției '''nule'''. Orice modificare în afara corpului acestei funcții va conduce la respingerea soluței.
== Date de intrare ==
Fișierul de intrare '''input.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''output.txt''' va conține pe prima linie numărul '''n''', iar pe a doua linie elementele vectorului generat.
== Restricții și precizări ==
* '''1 ≤ n ≤ 1.000.000'''
== Important ==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce la erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.
== Exemplul 1 ==
; input.txt
: 10
: 0 3 8 0 0 3 8 7 0 10
; output.txt
: Datele introduse corespund restricțiilor impuse.
: 10
: 3 8 3 8 7 10 0 0 0 0
== Exemplul 2 ==
; input.txt
: 1000001
: 0 1 2 3 4 5 6 7 8 9 10
; output.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
def validare(n, v):
if n < 1 or n > 1000000:
raise ValueError("Datele introduse nu corespund restricțiilor impuse.")
if len(v) != n:
raise IndexError("Datele introduse nu corespund restricțiilor impuse.")
print("Datele introduse corespund restricțiilor impuse.")

def nule(v):
size = len(v)
for i in range(size - 1):
swaped = False
for j in range(size - i - 1):
if v[j] == 0:
v[j], v[j+1] = v[j+1], v[j]
swaped = True
if not swaped:
break

def main():
input_filename = "input.txt"
output_filename = "output.txt"
# Read vector from input file
try:
with open(input_filename, 'r') as input_file:
size = int(input_file.readline())
v = list(map(int, input_file.readline().split()))
validare(size, v)
except IOError:
print(f"Failed to open {input_filename}")
exit(-1)
except (ValueError, IndexError) as e:
print(e)
exit(-1)
# Call nule() function
nule(v)
# Print vector to output file
try:
with open(output_filename, 'w') as output_file:
output_file.write(str(size) + '\n')
output_file.write(' '.join(map(str, v)) + '\n')
except IOError:
print(f"Failed to open {output_filename}")
exit(-1)

if __name__ == "__main__":
main()

</syntaxhighlight>

3652 - secvcost

2024-01-03T15:15:54Z

Zmicala Narcis: Pagină nouă: Se dă un șir '''V''' de '''N''' numere naturale distincte. O secvență '''[X, Y]''' este formată din toate pozițiile consecutive dintre '''X''' și '''Y''' din șir. Se definește costul unei poziții '''P''' ca fiind valoarea din șir de pe poziția '''P''' înmulțită cu lungimea maximă a unei secvențe care conține poziția '''P''' și a cărei valoare maximă se află tot pe poziția '''P'''. == Cerința == Se dau '''M''' întrebări de forma: '''X Y''' – să se...

Se dă un șir '''V''' de '''N''' numere naturale distincte. O secvență '''[X, Y]''' este formată din toate pozițiile consecutive dintre '''X''' și '''Y''' din șir. Se definește costul unei poziții '''P''' ca fiind valoarea din șir de pe poziția '''P''' înmulțită cu lungimea maximă a unei secvențe care conține poziția '''P''' și a cărei valoare maximă se află tot pe poziția '''P'''.
== Cerința ==
Se dau '''M''' întrebări de forma: '''X Y''' – să se calculeze suma tuturor costurilor pozițiilor din secvența '''[X, Y]'''.
Atenție! Când se calculează costul unei poziții P din '''[X, Y]''', secvența de lungime maximă pe care valoarea '''V[P]''' este maximă se calculează în funcție de tot șirul, NU în funcție de secvența '''[X, Y]''' (pentru clarificare urmăriți exemplul).
== Date de intrare ==
Fișierul de intrare '''secvcostin.txt''' conține pe prima linie cele două numere '''N''' și '''M''', separate prin spațiu. Pe a doua linie se află '''N''' numere naturale distincte reprezentând elementele șirului '''V'''. Pe următoarele '''M''' linii se află perechi de valori '''X''', '''Y''' reprezentând întrebările la care trebuie să se răspundă.
== Date de ieșire ==
Fișierul de ieșire '''secvcostout.txt''' va conține '''M''' linii cu câte un număr pe fiecare linie reprezentând răspunsul la cele '''M''' întrebări, în ordine.
== Restricții și precizări ==
* Toate valorile din șir sunt mai mici sau egale decât 5.000.000
* Pentru 25% din teste '''N, M ≤ 500'''
* Pentru alte 25% din teste '''N, M ≤ 10.000'''
* Pentru restul de 50% din teste '''N, M ≤ 200.000'''
== Exemplul 1 ==
; secvcostin.txt
: 5 2
: 2 3 1 5 4
: 3 3
: 2 2
; secvcostout.txt
: Datele introduse corespund restricțiilor impuse.
: 1
: 9
== Explicație ==
Pentru prima întrebare avem '''V[3] = 1''' care este maxim pe secvența '''[3, 3]'''. Costul este '''1 * 1 = 1'''. Pentru a doua întrebare avem '''V[2] = 3''' care este maxim pe secvența '''[1, 3]'''. Costul este '''3 * 3 = 9'''.
== Exemplul 2 ==
; secvcostin.txt
: 5 3
: 2 3 1 5 4
: 1 3
: 5 5
: 4 4
; secvcostout.txt
: Datele introduse corespund restricțiilor impuse.
: 12
: 4
: 25
== Explicație ==
'''2*1 + 3*3 + 1*1 = 12'''
'''4*1 = 4'''
'''5*5 = 25'''
== Exemplul 3 ==
; secvcostin.txt
: 10 10
: 10 30 29 39 34 32 3 6 7 9
: 6 7
: 1 7
: 6 10
: 1 5
: 7 9
: 4 7
: 3 7
: 5 6
: 3 7
: 6 10
; secvcostout.txt
: Datele introduse corespund restricțiilor impuse.
: 163
: 886
: 232
: 723
: 36
: 757
: 786
: 364
: 786
: 232
== Exemplul 4 ==
; secvcostin.txt
: 5 2
: 2 3 1 5 6000000
: 3 3
: 2 2
; secvcostout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3652 - secvcost
def validare(date1): # functia de validare a datelor de intrare
numar_elemente, numar_intrebari = map(int, date1[0].split())
if not (1 <= numar_elemente <= 200000) or not (1 <= numar_intrebari <= 200000):
raise ValueError

sir = list(map(int, date1[1].split()))
if len(sir) != numar_elemente or any(element > 5000000 for element in sir):
raise ValueError

intrebari = [list(map(int, date1[i].split())) for i in range(2, 2 + numar_intrebari)]
if any(not (1 <= X <= Y <= numar_elemente) for X, Y in intrebari):
raise ValueError

fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def cost_secventa(date1): # functia de rezolvare
numar_elemente, numar_intrebari = map(int, date1[0].split())
sir = list(map(int, date1[1].split()))
intrebari = [list(map(int, date1[i].split())) for i in range(2, 2 + numar_intrebari)]
for X, Y in intrebari:
cost = sum([sir[i] * max(len(sir[:i+1]), len(sir[i:])) for i in range(X-1, Y)])
fisier_iesire.write(f"{cost}\n")

if __name__ == '__main__':
fisier_intrare = open("secvcostin.txt", "r") # declararea fisierelor
fisier_iesire = open("secvcostout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

# din cauza datelor de intrare pot aparea 2 tipuri de erori, valueError sau IndexError pe care le tratam
try:
date = fisier_intrare.readlines() # citirea numerelor se face ca sir de caractere

validare(date) # apelul functiei de validare
cost_secventa(date) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

2464 - anagrame3

2024-01-03T14:58:02Z

Zmicala Narcis: Pagină nouă: Se dau două șiruri '''S1''' si '''S2''' formate doar cu litere mici. Numim subșir de lungime '''K''' al unui șir a un șir '''a' = ai1, ai2,…, aiK''' astfel încât să avem: '''i1''' == Cerința == Să se determine lungimea maximă a unui subșir din '''S1''', format prin concatenarea unor anagrame ale șirului '''S2'''. Dintre toate subșirurile cu lungime maximă se va determina cel care este cel mai mic lexicografic. Un șir de lungime na se consideră mai mic lexi...

Se dau două șiruri '''S1''' si '''S2''' formate doar cu litere mici. Numim subșir de lungime '''K''' al unui șir a un șir '''a' = ai1, ai2,…, aiK''' astfel încât să avem: '''i1'''
== Cerința ==
Să se determine lungimea maximă a unui subșir din '''S1''', format prin concatenarea unor anagrame ale șirului '''S2'''. Dintre toate subșirurile cu lungime maximă se va determina cel care este cel mai mic lexicografic. Un șir de lungime na se consideră mai mic lexicografic decât un șir de lungime nb dacă există un indice i, astfel încât '''a1=b1, a2=b1, …, ai-1=bi-1''' și '''ai<bi'''. Un șir '''a''' este anagrama unui șir '''b''' dacă sortându-le crescător pe fiecare se obțin două șiruri identice.
== Date de intrare ==
Fișierul de intrare '''anagrame3in.txt''' conține pe prima linie se află un număr natural '''P'''. Pe linia a doua se află șirul '''S1''', iar pe a treia linie se află șirul '''S2'''.
== Date de ieșire ==
În fișierul '''anagrame3out.txt''', dacă '''P = 1''', atunci pe prima linie se va scrie un număr natural reprezentând lungimea maximă a unui șir cu proprietatea cerută, iar dacă '''P = 2''', atunci pe prima linie se va scrie subșirul de lungime maximă cu proprietatea cerută și minim lexicografic.
== Restricții și precizări ==
* '''1 ≤ Lungime(S2) ≤ Lungime(S1) ≤ 100 000'''
* Se garantează că cel puțin o anagramă a lui '''S2''' apare în '''S1'''
== Exemplul 1 ==
; anagrame3in.txt
: 1
: abbaaabababbaabaabba
: aba
; anagrame3out.txt
: Datele introduse corespund restricțiilor impuse.
: 15
== Explicație ==
Deoarece a apare de '''11''' ori, '''S2''' poate să apară de cel mult '''5''' ori. Se observă subșirul format cu litere îngroșate și subliniate '''abbaaabababbaabaabba''' deci '''abaaabababaabaa''' este un subșir de lungime maximă, egală cu '''15''', cu proprietatea cerută.
== Exemplul 2 ==
; anagrame3in.txt
: 2
: abbaaabababbaabaabba
: aba
: anagrame3.out
: Datele de intrare corespund restricțiilor impuse.
: abaaabaabaabaab
== Explicație ==
Se observă că subșirul verifică proprietatea cerută.
== Exemplul 3 ==
; anagrame3in.txt
: 2
: abbaaabababbaabaabba
: abababababababababab
; anagrame3.out
: Datele de intrare nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2464 - anagrame3
from collections import Counter

def validare(sirul1, sirul2): # functia de validare a datelor de intrare
if not (1 <= len(sirul2) <= len(sirul1) <= 100000):
raise ValueError("Datele introduse nu corespund restrictiilor impuse.")

def gaseste_subsir(sirul1, sirul2, p1): # functia de rezolvare
count_sir2 = Counter(sirul2)
subsiruri = []
for i in range(len(sirul1) - len(sirul2) + 1):
if Counter(sirul1[i:i + len(sirul2)]) == count_sir2:
subsiruri.append(sirul1[i:i + len(sirul2)])
subsiruri.sort()
if p1 == 1:
return len(subsiruri[-1])
elif p1 == 2:
return subsiruri[0]

if __name__ == '__main__':
fisier_intrare = open("anagrame3in.txt", "r") # declararea fisierelor
fisier_iesire = open("anagrame3out.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
p = int(fisier_intrare.readline())
sir1 = fisier_intrare.readline().strip()
sir2 = fisier_intrare.readline().strip()

validare(sir1, sir2) # apelul functiei de validare
rezultat = gaseste_subsir(sir1, sir2, p) # apelul functiei de rezolvare
fisier_iesire.write(str(rezultat))

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

1971 - Plus

2024-01-03T14:28:53Z

Zmicala Narcis: Pagină nouă: Locuitorii planetei Aritmo au hotărât ca în celebrul an 2012 să le explice pământenilor metoda plus de adunare a numerelor naturale pe planeta lor. La fel ca și planetele, înainte de adunare, numerele se aliniază astfel încât să se obțină cât mai multe cifre egale pe aceleași poziții. Cifrele egale, astfel obținute, se elimină din cele două numere. Pentru a obține rezultatul final, se adună cele două numerele deplasate, obținute după eliminare, ca în...

Locuitorii planetei Aritmo au hotărât ca în celebrul an 2012 să le explice pământenilor metoda plus de adunare a numerelor naturale pe planeta lor. La fel ca și planetele, înainte de adunare, numerele se aliniază astfel încât să se obțină cât mai multe cifre egale pe aceleași poziții. Cifrele egale, astfel obținute, se elimină din cele două numere. Pentru a obține rezultatul final, se adună cele două numerele deplasate, obținute după eliminare, ca în exemplu.

Exemplu: Numerele 18935 și 85352 se aliniază ca în figura de mai jos. După eliminare se obțin numerele 19 și 52 care se adună deplasate, pentru a obține rezultatul final. Așadar 18935 plus 85352=242.

: 18935 plus 19 +
: 85352 52
: ---
: 242
Dacă există mai multe posibilități de a alinia numerele astfel încât să se elimine același număr maxim de cifre, atunci numerele sunt aliniate astfel încât, după eliminare şi adunarea numerelor după metoda descrisă, să se obțină o valoare cât mai mare.

Exemplu: '''22331 plus 3322 = 33331''' (există două moduri în care cele două numere pot fi aliniate astfel încât să se elimine un număr maxim de cifre, valoarea maximă obținându-se atunci când se elimină cele două cifre 2)

: 22331 221 + 22331 331+
: 3322 22 3322 33
: ---- -----
: 2232 33331
Dacă două numere a și b sunt identice sau nu au cifre comune atunci a plus b=0. Dacă se elimină toate cifrele unui număr atunci rezultatul este dat de cifrele rămase în celălalt număr. Exemple: '''23 plus 523=5, 562 plus 56=2'''.

Adunarea mai multor numere se face de la stânga la dreapta: se adună primele două numere conform metodei descrise mai sus, apoi rezultatul se adună cu al treilea, și așa mai departe.

Într-o expresie în care se adună mai multe numere pot să apară paranteze rotunde. În evaluarea unei asemenea expresii, numită expresie parantezată, se efectuează mai întâi adunările din paranteze conform metodei descrise mai sus, parantezele fiind apoi înlocuite cu rezultatul adunărilor din paranteze.

Se definește adâncimea Ad(E) corespunzătoare unei expresii parantezate E astfel:

* dacă expresia '''E''' nu conține paranteze, atunci adâncimea acesteia este '''0''';
* dacă expresia '''E''' este de forma '''(F)''', atunci '''Ad(E)=1+Ad(F)''';
* dacă expresia '''E''' este de forma '''E1 plus E2…plus Ek''', atunci '''Ad(E)=max(Ad(E1)''', '''Ad(E2),…, Ad(Ek))'''.
== Cerința ==
Pentru a-i ajuta pe pământenii care doresc să învețe acest nou mod de adunare, scrieți un program care citește o expresie parantezată și determină:
a) adâncimea expresiei date;
b) valoarea acestei expresii.
== Date de intrare ==
Fișierul de intrare '''plusin.txt''' conține pe prima linie un număr natural '''n'''. Pe următoarele '''n''' linii se află descrierea expresiei parantezate. Pe fiecare dintre aceste linii se află un număr natural sau una dintre valorile '''-1''' sau '''-2'''. Valoarea '''-1''' reprezintă o paranteză rotundă deschisă iar valoarea '''-2''' reprezintă o paranteză rotundă închisă.
== Date de ieșire ==
Fișierul de ieșire '''plusout.txt''' va conține:
a) pe prima linie numărul natural ce reprezintă adâncimea expresiei date;
b) pe a doua linie se va scrie numărul natural ce reprezintă rezultatul evaluării expresiei date, adunarea numerelor făcându-se conform metodei descrise.
== Restricții și precizări ==
* '''1<n≤2000''';
* fiecare dintre celelalte numere naturale din fișier are cel mult 9 cifre;
* în fiecare paranteză se află cel puțin un număr natural;
* dacă într-o paranteză se află un singur număr natural, atunci valoarea expresiei este egală cu valoarea numărului din paranteză;
* pentru rezolvarea corectă a cerinței a) se acordă 20% din punctaj, iar pentru rezolvarea corectă a ambelor cerinţe se acordă punctajul integral.
== Exemplul 1 ==
; plusin.txt
: 12
: -1
: 1343
: -1
: 234
: 4532
: -2
: -2
: 14091
: -1
: 21
: 2
: -2
; plusout.txt
: Datele introduse corespund restricțiilor impuse.
: 2
: 4639
== Explicație ==
Expresia parantezată care trebuie evaluată este:
'''(1343 plus (234 plus 4532)) plus 14091 plus (21 plus 2)='''
'''(1343 plus 45334)plus 14091 plus (21 plus 2) ='''
'''4543 plus 14091 plus (21 plus 2)='''
'''4543 plus 14091 plus 1='''
'''46391 plus 1=4639'''
Valoarea expresei este '''4639'''. Adâncimea expresiei este '''2'''.
== Exemplul 2 ==
; plusin.txt
: 13
: -1
: 1343
: -1
: 234
: 4532
: -2
: -2
: 14091
: -1
: 21
: 2
: -2
: 1000000000
; plusout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1971 - Plus
def validare(op): # functia de validare a datelor de intrare
if len(op) > 2000:
raise ValueError
for operatie in op:
if operatie != -1 and operatie != -2 and (operatie < 1 or operatie > 999999999):
raise ValueError
fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def plus(op): # functia de rezolvare
if len(op) == 0:
fisier_iesire.write("0\n")
return
stiva = []
adancime = 0
for operatie in op:
if operatie == -1:
stiva.append([])
adancime = max(adancime, len(stiva))
elif operatie == -2:
if len(stiva[-1]) == 1:
if len(stiva) > 1:
stiva[-2].append(stiva[-1][0])
stiva.pop()
else:
numere = stiva.pop()
while len(numere) > 1:
a = numere.pop()
b = numere.pop()
numere.append(a + b - int(str(a) + str(b)))
if len(stiva) > 0:
stiva[-1].append(numere[0])
else:
stiva[-1].append(operatie)
fisier_iesire.write(str(adancime) + "\n")
fisier_iesire.write(str(stiva[0][0]) + "\n")

if __name__ == '__main__':
fisier_intrare = open("plusin.txt", "r") # declararea fisierelor
fisier_iesire = open("plusout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
N = int(fisier_intrare.readline())
operatii = [int(linie) for linie in fisier_intrare.readlines()]

validare(operatii) # apelul functiei de validare
plus(operatii) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

4242 - perle

2024-01-03T14:14:09Z

Zmicala Narcis: Pagină nouă: Graniţa nu se trece uşor. Asta pentru că Balaurul Arhirel (mare pasionat de informatică) nu lasă pe nimeni să treacă decât după ce răspunde la nişte întrebări. În acea ţară există trei tipuri de perle normale (le vom nota cu 1, 2 şi 3) şi trei tipuri de perle magice (le vom nota cu A, B şi C). Perlele magice sunt deosebite prin faptul că se pot transforma în alte perle (una sau mai multe, normale sau magice). Perla magică de tipul A se poate transforma...

Graniţa nu se trece uşor. Asta pentru că Balaurul Arhirel (mare pasionat de informatică) nu lasă pe nimeni să treacă decât după ce răspunde la nişte întrebări.
În acea ţară există trei tipuri de perle normale (le vom nota cu 1, 2 şi 3) şi trei tipuri de perle magice (le vom nota cu A, B şi C). Perlele magice sunt deosebite prin faptul că se pot transforma în alte perle (una sau mai multe, normale sau magice).
Perla magică de tipul A se poate transforma în orice perlă normală (una singură).
Perla magică de tipul B se poate transforma într-o perlă normală de tipul 2 şi una magică de tipul B, sau într-o perlă normală de tipul 1, una magică de tipul A, una normală de tipul 3, una magică de tipul A şi una magică de tipul C.
Perla magică de tipul C se poate transforma într-o perlă normală de tipul 2 sau într-o perlă normală de tipul 3, una magică de tipul B şi una magică de tipul C sau într-o perlă normală de tipul 1, una normală de tipul 2 şi una magică de tipul A.
Ca să rezumăm cele de mai sus putem scrie:
'''A -> 1 | 2 | 3'''
'''B -> 2B | 1A3AC'''
'''C -> 2 | 3BC | 12A'''
Balaurul Arhirel ne lasă la început să ne alegem o perlă magică (una singură), iar apoi folosind numai transformările de mai sus trebuie să obţinem un anumit şir de perle normale. Când o perlă magică se transformă, perlele din stânga şi din dreapta ei rămân la fel (şi în aceeaşi ordine). De asemenea ordinea perlelor rezultate din transformare este chiar cea prezentată mai sus.
De exemplu, dacă balaurul ne cere să facem şirul de perle '''21132123''', putem alege o perlă magică de tipul B şi următorul şir de transformări: B '''-> 2B -> 21A3AC -> 21A3A12A -> 21132123'''.
Întrucât Balaurul nu are prea multă răbdare, el nu ne cere decât să spunem dacă se poate sau nu obţine şirul respectiv de perle.
== Cerința ==
Să se determine pentru fiecare şir de intrare dacă se poate obţine prin transformările de mai sus sau nu (alegând orice primă perlă magică, la fiecare şir).
== Date de intrare ==
Fișierul de intrare '''perlein.txt''' are următoarea structură:
pe prima linie numărul '''N''', reprezentând numărul de şiruri din fişierul de intrare
urmează '''N''' linii; a i-a linie dintre cele N descrie şirul i, printr-o succesiune de numere naturale despărţite de câte un spaţiu. Primul număr reprezintă lungimea şirului '''L[i]''', iar următoarele '''L[i]''' numere sunt tipurile de perle normale, în ordine, de la stânga la dreapta.
== Date de ieșire ==
Fișierul de ieșire '''perleout.txt''' va conţine '''N''' linii. Pe linia i se va scrie un singur număr '''1''' sau '''0''' ('''1''' dacă se poate obţine şirul respectiv – al i-lea – şi '''0''' dacă nu se poate).
== Restricții și precizări ==
* '''0 < N < 11'''
* '''0 < L[i] < 10001''', pentru orice '''i'''
== Exemplul 1 ==
; perlein.txt
: 3
: 8 2 1 1 3 2 1 2 3
: 2 2 2
: 1 3
; perleout.txt
: Datele introduse corespund restricțiilor impuse.
: 1
: 0
: 1
== Exemplul 2 ==
; perlein.txt
: 4
: 8 2 1 1 3 2 1 2 3
: 2 2 2
: 1 3
: 12 1 2 3 4 5 6 7 8 9 10 11 12
; perleout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 4242 - perle
def validare(op): # functia de validare a datelor de intrare
if len(op) > 11:
raise ValueError
for operatie in op:
if operatie[0] < 1 or operatie[0] > 10001:
raise ValueError
fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def perle(op): # functia de rezolvare
for sir in op:
if len(sir) % 2 == 0 or sir[0] != 1:
fisier_iesire.write("0\n")
else:
fisier_iesire.write("1\n")

if __name__ == '__main__':
fisier_intrare = open("perlein.txt", "r") # declararea fisierelor
fisier_iesire = open("perleout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
N = int(fisier_intrare.readline())
operatii = [list(map(int, linie.split()))[1:] for linie in fisier_intrare.readlines()]

validare(operatii) # apelul functiei de validare
perle(operatii) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1690 - Undo

2024-01-03T14:02:32Z

Zmicala Narcis: Pagină nouă: == Cerința == XORin este nemulțumit de problemele primite în prima zi de concurs de la Olimpiada Națională de Informatică și decide astfel să se implice în comisie. În scurt timp devine specialistul comisiei în generarea de teste formate din șiruri de numere. Din când în când el trebuie să adauge sau să șteargă elemente din șir. Câteodată el decide să readauge dintre elemente șterse anterior. Fie șirul de numere '''a=(a[1], a[2], … ,a[N])''' și '''...

== Cerința ==
XORin este nemulțumit de problemele primite în prima zi de concurs de la Olimpiada Națională de Informatică și decide astfel să se implice în comisie. În scurt timp devine specialistul comisiei în generarea de teste formate din șiruri de numere. Din când în când el trebuie să adauge sau să șteargă elemente din șir. Câteodată el decide să readauge dintre elemente șterse anterior. Fie șirul de numere '''a=(a[1], a[2], … ,a[N])''' și '''N''' numărul de elemente din șir după fiecare operație.
Astfel el are de realizat următoarele operații pornind de la un șir vid:
* Inserează la sfârșitul șirului o valoare '''x''';
* Șterge ultimele '''x''' elemente din șir;
* Readaugă la sfârșitul șirului primele '''x''' elemente șterse. Dacă, de exemplu, în operația anterioară de ștergere a unui număr '''y''' de elemente, am șters elementele '''a[N-y+1], a[N-y+2],…, a[N]''', iar acum urmează o operație de readăugare a '''x''' elemente, vor fi adăugate în ordine elementele '''a[N-y+1], a[N-y+2],…, a[N-y+x]''' la sfârșitul șirului.
Din când în când XORin își pune următoarea întrebare: de câte ori există valoarea '''x''' în șir?
== Date de intrare ==
Fișierul de intrare '''undoin.txt''' conține pe prima linie numărul '''M''' ce reprezintă numărul de operații.
Pe următoarele '''M''' linii se vor afla operațiile codificate astfel:
* '''1 x''' – se inserează elementul '''x''' la sfârșitul șirului
* '''2 y''' – se șterg ultimele '''y''' elemente adăugate în șir
* '''3 z''' – se adaugă înapoi la sfârșitul șirului primele '''z''' elemente șterse
* '''4 t''' – se afișează numărul de elemente cu valoarea '''t''' din șir
== Date de ieșire ==
Pe fiecare linie a fișierului '''undoout.txt''' se scriu răspunsurile la întrebările lui XORin, fiecare răspuns pe câte o linie.
== Restricții și precizări ==
* Toate numerele din fișierul de intrare sunt cuprinse între '''1''' și '''200000''';
* Pentru 20% din teste se garantează '''M ≤ 1000''', pentru alte 40% din teste, se garantează că numerele inserate vor fi distincte;
* Între o operație de ștergere și una de readăugare sau între două de readăugare nu se vor afla alte operații de inserare
* Numărul de elemente readăugate nu va fi mai mare decât numărul de elemente șterse la ultima operație.
* Între două operații de readăugare va exista cel puțin o operație de ștergere.
== Exemplul 1 ==
; undoin.txt
: 16
: 1 1
: 1 2
: 1 3
: 1 4
: 4 4
: 2 2
: 4 3
: 3 1
: 4 4
: 4 3
: 1 7
: 1 7
: 1 7
: 4 7
: 2 2
: 4 7
; undoout.txt
: Datele introduse corespund restricțiilor impuse.
: 1
: 0
: 0
: 1
: 3
: 1
== Explicație ==
Inițial șirul este vid.
După primele '''4''' operații de inserare șirul este '''1, 2, 3, 4'''.
Operația '''4 4''' va afișa '''1'''.
Operația '''2 2''' va șterge ultimele două elemente șirul devenind '''1, 2'''.
Din cauză că elementul '''3''' a fost șters, a șaptea operație va afișa '''0'''.
Operația '''3 1''' va readăuga la sfârșitul șirului elementul '''3'''.
În urma acestei operații șirul devine '''1, 2, 3'''.
Operația '''4 4''' va afișa '''0''', iar operația '''4 3''' va afișa '''1'''.
ș.a.m.d.
== Exemplul 2 ==
; undoin.txt
: 17
: 1 1
: 1 2
: 1 3
: 1 4
: 4 4
: 2 2
: 4 3
: 3 1
: 4 4
: 4 3
: 1 7
: 1 7
: 1 7
: 4 7
: 2 2
: 4 7
: 1 200001
; undoout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1690 - Undo
def validare(op): # functia de validare a datelor de intrare
if len(op) > 200000:
raise ValueError
for operatie in op:
if operatie[0] < 1 or operatie[0] > 4 or operatie[1] < 1 or operatie[1] > 200000:
raise ValueError
fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def undo(op): # functia de rezolvare
sir = []
sters = []
for operatie in op:
if operatie[0] == 1:
sir.append(operatie[1])
elif operatie[0] == 2:
for _ in range(operatie[1]):
sters.insert(0, sir.pop())
elif operatie[0] == 3:
for _ in range(operatie[1]):
sir.append(sters.pop(0))
elif operatie[0] == 4:
fisier_iesire.write(str(sir.count(operatie[1])) + "\n")

if __name__ == '__main__':
fisier_intrare = open("undoin.txt", "r") # declararea fisierelor
fisier_iesire = open("undoout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
M = int(fisier_intrare.readline())
operatii = [list(map(int, linie.split())) for linie in fisier_intrare.readlines()]

validare(operatii) # apelul functiei de validare
undo(operatii) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

3437 - Datorii 1

2024-01-03T13:37:07Z

Zmicala Narcis: Pagină nouă: Într-o țară îndepărtată, economia este în criză. Cea mai mare problemă este lipsa de capital care creează blocaje financiare. De exemplu, o firmă '''X''' poate avea datorii către o firmă '''Y''' pe care nu le poate plăti, deoarece o altă firmă '''Z''' are datorii către firma '''X''' pe care nu le-a plătit, ş.a.m.d. Există o listă cu toate datoriile firmelor sub forma următoare: '''X > Y S''' cu semnificaţia “firma '''X'' datorează firmei '''Y''' suma...

Într-o țară îndepărtată, economia este în criză. Cea mai mare problemă este lipsa de capital care creează blocaje financiare. De exemplu, o firmă '''X''' poate avea datorii către o firmă '''Y''' pe care nu le poate plăti, deoarece o altă firmă '''Z''' are datorii către firma '''X''' pe care nu le-a plătit, ş.a.m.d.
Există o listă cu toate datoriile firmelor sub forma următoare:
'''X > Y S'''
cu semnificaţia “firma '''X'' datorează firmei '''Y''' suma '''S'''”. Este posibil ca '''X''' să aibă mai multe datorii la firma '''Y''' (în funcţie de contractele derulate împreună) sau chiar ca '''X''' să aibă datorii la '''Y''' și '''Y''' să aibă datorii la '''X'''.
== Cerințe ==
Cunoscând lista cu datoriile firmelor, scrieți un program care să rezolve următoarele cerințe:
1. determină numărul de firme distincte care apar în această listă;
2. realizează o situație financiară a firmelor distincte din această listă, scrise în ordine lexicografică; pentru fiecare firmă se vor determina două valori '''SD SP''', unde '''SD''' reprezintă suma totală a datoriilor pe care firma le are către alte firme, iar '''SP''' este totalul sumelor pe care firma trebuie să le primească de la alte firme.
== Date de intrare ==
Fișierul de intrare '''datorii1in.txt''' conține pe prima linie un număr natural '''C''' reprezentând cerința care
trebuie să fie rezolvată ('''1''' sau '''2'''). Pe a doua linie se află un număr natural '''D''' care reprezintă numărul de înregistrări existente în lista datoriilor firmelor. Pe următoarele '''D''' linii sunt descrise datoriile firmelor, în forma specificată în enunț, câte o datorie pe o linie.
== Date de ieșire ==
Fișierul de ieșire '''datoriiout.txt''' va conține răspunsul la cerinţa '''C''' specificată în fișierul de intrare. Dacă '''C=1''' fișierul va conține un număr natural, reprezentând numărul de firme distincte care apar în lista menționată. Dacă '''C=2''' fișierul va conține pentru fiecare dintre firmele distincte din lista menționată câte un singur triplet de forma '''X SD SP''', unde '''X''' este numele firmei, iar '''SD''' și '''SP''' au semnificația din enunț pentru firma '''X'''; tripletele vor fi scrise astfel încât numele firmelor să apară în ordine lexicografică, fiecare triplet pe câte o linie a fișierului, iar '''X''', '''SD''' și '''SP''' vor fi separate prin câte un singur spațiu.
== Restricții și precizări ==
* Există în total cel mult '''6000''' de firme distincte în lista menționată de datorii.
* Numele unei firme este format din maximum '''20''' de caractere (litere mari şi mici ale alfabetului englez, cifre, spaţii); se face distincţie între literele mari şi literele mici în numele firmelor; nu există alte restricţii referitoare la numele firmelor.
* Două firme distincte au nume distincte. O firmă nu poate avea datorii la ea însăși.
* În descrierea unei datorii '''(X > Y S)''' există un singur spaţiu între '''X''' și '''>''', un singur spațiu între '''>''' și '''Y''', respectiv un singur spațiu între '''Y''' și '''S'''.
* '''1 ≤ D ≤ 80000'''
* Sumele datorate de firme sunt numere naturale nenule ≤106.
* Dacă '''X''' și '''Y''' sunt numele a două firme distincte, iar '''k (k≥0)''' este valoarea maximă cu proprietatea că secvența formată din primele '''k''' caractere din '''X''' este identică cu secvența formată din primele caractere din '''Y''', spunem că '''X''' precedă din punct de vedere lexicografic pe '''Y''' dacă '''X''' are doar '''k''' caractere sau dacă al k+1-lea caracter din '''X''' este mai mic decât al k+1-lea caracter din '''Y'''.
* Pentru teste valorând '''30''' de puncte cerinţa este '''1'''. Pentru teste valorând '''60''' de puncte cerinţa este '''2'''.
* Pentru teste valorând '''40''' de puncte D≤1000. Pentru teste valorând '''45''' de puncte numele firmelor nu
conțin spaţii.
* În concurs s-au acordat '''10''' puncte din oficiu. Pe site se acordă '''10''' puncte pentru exemple.
== Exemplul 1 ==
; datoriiin.txt
: 1
: 4
: Vasile Inc > Anatolia 100
: ana > Anatolia 10
: ana > Vasilescu Inc 5
: Popa25 PF > Anatolia 30
; datoriiout.txt
: Datele introduse corespund restricțiilor impuse.
: 5
== Exemplul 2 ==
; datoriiin.txt
: 2
: 5
: Vasile Inc > Anatolia 100
: ana > Anatolia 10
: ana > Vasilescu Inc 5
: Popa25 PF > Anatolia 30
: Popa25 PF > ana 50
; datoriiout.txt
: Datele introduse corespund restricțiilor impuse.
: Anatolia 0 140
: Popa25 PF 80 0
: Vasile Inc 100 0
: Vasilescu Inc 0 5
: ana 15 50
== Exemplul 3 ==
; datoriiin.txt
: 2
: 6
: Vasile Inc > Anatolia 100
: ana > Anatolia 10
: ana > Vasilescu Inc 5
: Popa25 PF > Anatolia 30
: Popa25 PF > ana 50
: Vasile Inc > Vasile Inc 20
; datoriiout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3437 - Datorii 1
from collections import defaultdict

def validare(datorii_val1): # functia de validare a datelor de intrare
if len(datorii_val1) > 6000:
raise ValueError

for X_val1, Y_val1, S_val1 in datorii_val1:
if len(X_val1) > 20 or len(Y_val1) > 20 or S_val1 <= 0 or S_val1 > 10**6:
raise ValueError

file_out.write("Datele de intrare corespund restrictiilor impuse\n")

def rezolvare(datorii_val1): # functia de rezolvare
firme = defaultdict(lambda: [0, 0]) # dictionar cu valori default [0, 0]
for X_val1, Y_val1, S_val1 in datorii_val1:
firme[X_val1][0] += S_val1 # adaugam la suma datoriilor firmei X
firme[Y_val1][1] += S_val1 # adaugam la suma pe care firma Y trebuie sa o primeasca

for firma in sorted(firme.keys()): # sortam firmele lexicografic
file_out.write(f"{firma} {firme[firma][0]} {firme[firma][1]}\n")

if __name__ == '__main__':
file_in = open("datoriiin.txt", "r") # declararea fisierelor
file_out = open("datoriiout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

# din cauza datelor de intrare pot aparea 2 tipuri de erori, valueError sau IndexError pe care le tratam
try:
C = int(file_in.readline()) # citirea cerintei
D = int(file_in.readline()) # citirea numarului de datorii
datorii_val = []
for _ in range(D):
X_val, _, Y_val, S_val = file_in.readline().split()
S_val = int(S_val)
datorii_val.append((X_val, Y_val, S_val))

validare(datorii_val) # apelul functiei de validare
if C == 2:
rezolvare(datorii_val) # apelul functiei de rezolvare

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1323 - Matrice Rara

2024-01-03T13:04:47Z

Zmicala Narcis: Pagină nouă: == Cerința == Se citesc două matrice rare și se cere să se calculeze suma lor. O matrice '''A(n,m)''' se numește rară dacă majoritatea elementelor sale sunt egale cu zero (cel puţin jumătate). Datorită numărului mic de numere nenule, o matrice rară '''A(n,m)''', având '''k''' elemente nenule, poate fi memorată folosind un șir '''X''' conţinând '''k''' triplete de forma '''(linie, coloană , valoare)''', corespunzătoare valorilor nenule ale matricei. Elemente...

== Cerința ==
Se citesc două matrice rare și se cere să se calculeze suma lor.
O matrice '''A(n,m)''' se numește rară dacă majoritatea elementelor sale sunt egale cu zero (cel puţin jumătate). Datorită numărului mic de numere nenule, o matrice rară '''A(n,m)''', având '''k''' elemente nenule, poate fi memorată folosind un șir '''X''' conţinând '''k''' triplete de forma '''(linie, coloană , valoare)''', corespunzătoare valorilor nenule ale matricei. Elementele șirului '''X''' se memorează în ordine lexicografică după '''(linie,coloana)'''.
De exemplu matricea cu '''n = m = 3'''
: 1 0 2
: 0 0 5
: 0 2 0
se va memora sub forma sirului '''X''' continand '''4''' triplete : '''{(1,1,1) , (1,3,2) , (2,3,5) , (3,2,2)}'''.
== Date de intrare ==
Fișierul de intrare '''matrice_rarain.txt''' conține pe prima linie , dimensiunile celor două matrice '''n m''' – reprezentând numărul de linii şi coloane, şi '''N1 N2''', numărul de elemente nenule ale matricei '''A''', respectiv matricei '''B'''. Apoi următoarele '''N1''' linii vor conține triplete – elementele nenule ale matricei A în ordine lexicografică, iar ultimele N2 linii vor conține triplete reprezentând elementele nenule ale matricei '''B''', tot în ordine lexicografică .
== Date de ieșire ==
Fișierul de ieșire '''matrice_raraout.txt''' va conține pe prima linie numărul de elemente diferite de '''0''' din matricea sumă '''C''' şi apoi matricea în sine sub forma tripletelor în ordine lexicografică, câte unul pe o linie .
== Restricții și precizări ==
* '''1 ≤ n , m ≤ 1.000.000'''
* '''1 ≤ N1 , N2 ≤ 300.000'''
* '''-1.000.000.000 ≤ A[i][j], B[i][j] ≤ 1.000.000.000'''
== Exemplul 1 ==
; matrice_rarain.txt
: 5 6 3 3
: 1 1 2
: 3 4 3
: 4 6 1
: 1 2 3
: 3 4 -2
: 4 6 2
; matrice_raraout.txt
: Datele introduse corespund restricțiilor impuse.
: 4
: 1 1 2
: 1 2 3
: 3 4 1
: 4 6 3
== Exemplul 2 ==
; matrice_rarain.txt
: 1000001 6 3 3
: 1 1 2
: 3 4 3
: 4 6 1
: 1 2 3
: 3 4 -2
: 4 6 2
; matrice_raraout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1323 - Matrice Rara
def validare(matrice_a1, matrice_b1): # functia de validare a datelor de intrare
for matrice in [matrice_a1, matrice_b1]:
if len(matrice) > 1000000:
raise ValueError

for element in matrice:
if element[2] < -1000000000 or element[2] > 1000000000:
raise ValueError

fisier_iesire.write("Datele introduse corespund restrictiilor impuse.\n")

def suma_matrici(matrice_a1, matrice_b1): # functia de rezolvare
suma = {}
for element in matrice_a1 + matrice_b1:
if (element[0], element[1]) not in suma:
suma[(element[0], element[1])] = 0
suma[(element[0], element[1])] += element[2]

matrice_suma1 = [(k[0], k[1], v) for k, v in suma.items() if v != 0]
matrice_suma1.sort()

return matrice_suma1

if __name__ == '__main__':
fisier_intrare = open("matrice_rarain.txt", "r") # declararea fisierelor
fisier_iesire = open("matrice_raraout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
n, m, N1, N2 = map(int, fisier_intrare.readline().split())
matrice_a = [list(map(int, fisier_intrare.readline().split())) for _ in range(N1)]
matrice_b = [list(map(int, fisier_intrare.readline().split())) for _ in range(N2)]

validare(matrice_a, matrice_b) # apelul functiei de validare

matrice_suma = suma_matrici(matrice_a, matrice_b) # apelul functiei de rezolvare
fisier_iesire.write(f"{len(matrice_suma)}\n")
for elem in matrice_suma:
fisier_iesire.write(f"{elem[0]} {elem[1]} {elem[2]}\n")

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")
except IndexError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

3856 - Scytale

2024-01-03T12:31:40Z

Zmicala Narcis: Pagină nouă: == Scytale == Cifrul '''Scytale''' functioneaza asa: se da un mesaj cu '''n''' litere si un numar '''m'''; mesajul trebuie asezat intr-o matrice cu '''m''' linii si n coloane; pentru mesajul '''WEAREDISCOVEREDFLEEATONCE''' cu '''25''' de litere si numarul '''m=3''', mesajul va fi pozitionat in matrice asa: '''W . . E . . A . . R . . E . . D . . I . . S . . C''' '''. O . . V . . E . . R . . E . . D . . F . . L . .''' '''. . E . . E . . A . . T . . O . . N . . C . . E .'''...

== Scytale ==
Cifrul '''Scytale''' functioneaza asa:
se da un mesaj cu '''n''' litere si un numar '''m''';
mesajul trebuie asezat intr-o matrice cu '''m''' linii si n coloane;
pentru mesajul '''WEAREDISCOVEREDFLEEATONCE''' cu '''25''' de litere si numarul '''m=3''', mesajul va fi pozitionat in matrice asa:

'''W . . E . . A . . R . . E . . D . . I . . S . . C'''

'''. O . . V . . E . . R . . E . . D . . F . . L . .'''

'''. . E . . E . . A . . T . . O . . N . . C . . E .'''

== Cerința ==
Dandu-se un numar c, mesajul si numarul m:
* pentru '''c=1''', sa se afiseze mesajul criptat
* pentru '''c=2''', sa se afiseze mesajul decriptat
== Date de intrare ==
Fișierul de intrare '''scytalein.txt''' conține pe prima linie numărul '''c''', mesajul si numarul '''m'''.
== Date de ieșire ==
Fișierul de ieșire '''scytaleout.txt''' va conține pe prima linie mesajul criptat sau decriptat, in functie de '''c'''.
== Restricții și precizări ==
* '''1 ≤ n*m ≤ 1000000'''
* mesajul va contine numai litere mari
== Exemplul 1 ==
; scytalein.txt
: 1 WEAREDISCOVEREDFLEEATONCE 3
; scytaleout.txt
: Datele introduse corespund restricțiilor impuse.
: WOEEVEAEARRTEEODDNIFCSLEC
== Exemplul 2 ==
; scytalein.txt
: 2 WOEEVEAEARRTEEODDNIFCSLEC 3
; scytaleout.txt
: Datele introduse corespund restricțiilor impuse.
: WEAREDISCOVEREDFLEEATONCE
== Exemplul 3 ==
; scytalein.txt
: 2 WOEEVEAEARRTEEODDNIFCSLEC 300000
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3856 - Scytale
def validare(mesaj_validare, m_validare): # functia de validare a datelor de intrare
if len(mesaj_validare) * m_validare > 1000000:
raise ValueError

fisier_iesire.write("Datele introduse corespund restrictiilor impuse.\n")

def criptare(mesaj_criptare, m_criptare): # functia de criptare
criptat = ""
for i in range(m_criptare):
for j in range(i, len(mesaj_criptare), m_criptare):
criptat += mesaj_criptare[j]
return criptat

def decriptare(mesaj_decriptare, m_decriptare): # functia de decriptare
n = len(mesaj_decriptare) // m_decriptare
decriptat = ""
for i in range(n):
for j in range(i, len(mesaj_decriptare), n):
decriptat += mesaj_decriptare[j]
return decriptat

if __name__ == '__main__':
fisier_intrare = open("scytalein.txt", "r") # declararea fisierelor
fisier_iesire = open("scytaleout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
cerinta = int(fisier_intrare.readline())
mesaj = fisier_intrare.readline().strip()
m = int(fisier_intrare.readline())

validare(mesaj, m) # apelul functiei de validare
if cerinta == 1:
fisier_iesire.write(criptare(mesaj, m)) # apelul functiei de criptare
elif cerinta == 2:
fisier_iesire.write(decriptare(mesaj, m)) # apelul functiei de decriptare

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")
except IndexError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

3808 - ADFGVX

2024-01-03T12:15:15Z

Zmicala Narcis: Pagină nouă: == ADFGVX == Cifrul ADFGVX este un cifru ce folosește o matrice '''6x6''' care conţine literele alfabetului englez si cifre. Cifrul functioneaza asa: se citeste matricea, un mesajul si o cheie. In matrice, linia '''1''' si coloana '''1''' au codul '''A''', linia '''2''' si coloana '''2''' au codul '''D''', linia '''3''' si coloana '''3''' au codul '''F''', linia '''4''' si coloana '''4''' au codul '''G''', linia '''5''' si coloana '''5''' au codul '''V''', iar linia '''6'''...

== ADFGVX ==
Cifrul ADFGVX este un cifru ce folosește o matrice '''6x6''' care conţine literele alfabetului englez si cifre. Cifrul functioneaza asa:
se citeste matricea, un mesajul si o cheie.
In matrice, linia '''1''' si coloana '''1''' au codul '''A''', linia '''2''' si coloana '''2''' au codul '''D''', linia '''3''' si coloana '''3''' au codul '''F''', linia '''4''' si coloana '''4''' au codul '''G''', linia '''5''' si coloana '''5''' au codul '''V''', iar linia '''6''' si coloana '''6''' au codul '''X'''.
Fiecare litera din mesaj este inlocuita cu un codul liniei si coloanei pe care se afla in matrice.
literele codurilor obtinute sunt puse intr-o matrice care are atatea coloane cate caractere are cheia(ultima linie a noii matrici poate fi incompleta).
coloanele noii matrici au codul literei din cheie de pe pozitia egala cu numarul de ordine al coloanei.
coloanele sunt sortate in functie de ordinea alfabetica al literei pe care o au asociata.
In final se afiseaza matricea noua parcursa pe coloane (pentru a fi mai clar, literele se afiseaza fara spatii intre ele, iar cand se trece pe o noua coloana, se va pune un spatiu).
== Cerința ==
Vi se ofera un numar '''c''' si matricea pentru criptare.Pentru '''c=1''', vi se ofera un mesaj si o cheie si trebuie sa criptati mesajul. Pentru '''c=2''', vi se ofera mesajul criptat si o cheie si trebuie sa decriptati mesajul.h1.
== Date de intrare ==
Fișierul de intrare '''adfgvxin.txt''' conține pe prima linie numărul '''c''', iar pe urmatoarele linii matricea, mesajul si cheia.
== Date de ieșire ==
Fișierul de ieșire '''adfgvxout.txt''' va conține pe prima linie mesajul criptat sau decriptat, in functie de '''c'''.
== Restricții și precizări ==
* '''1 ≤ lungimea mesajului necriptat ≤ 1000000'''
* '''1≤c≤2'''
* cheia va avea numai litere distincte h1.
== Exemplul 1 ==
; adfgvxin.txt
: 1
: NA1C3H
: 8TB2OM
: E5WRPD
: 4F6G7I
: 9J0KLQ
: SUVXYZ
: ATTACKAT1200AM PRIVACY
; adfgvx.out
: Datele introduse corespund restricțiilor impuse.
: DGDD DAGD DGAF ADDF DADV DVFA ADVX
== Exemplul 2 ==
; adfgvxin.txt
: 2
: NA1C3H
: 8TB2OM
: E5WRPD
: 4F6G7I
: 9J0KLQ
: SUVXYZ
: DGDD DAGD DGAF ADDF DADV DVFA ADVX PRIVACY
; adfgvx.out
: Datele introduse corespund restricțiilor impuse.
: ATTACKAT1200AM
== Explicatie ==
codul literelor va fi: AD,DD,DD,AD,AG,VG,AD,DD,AF,DG,VF,VF,AD,DX.
Matricea noua va arata astfel:

'''P R I V A C Y'''

A D D D D D A

D A G V G A D

D D A F D G V

F V F A D D X

Dupa ce sortam coloanele, matricea va arata astfel:

'''A C I P R V Y'''

D D D A D D A

G A G D A V D

D G A D D F V

D D F F V A X
== Exemplul 3 ==
; adfgvxin.txt
: 2
: NA1C3H
: 8TB2OM
: E5WRPD
: 4F6G7I
: 9J0KLQ
: PRIVACY
: DGDD DAGD DGAF ADDF DADV DVFA ADVX
; adfgvx.out
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3808 - ADFGVX
def validare(matrice_validare, mesaj_validare): # functia de validare a datelor de intrare
if len(mesaj_validare) > 1000000:
raise ValueError

for linie in matrice_validare:
if len(linie) != 6: # fiecare linie trebuie sa aiba 6 caractere
raise ValueError

fisier_iesire.write("Datele introduse corespund restrictiilor impuse.\n")

def codificare(matrice_codificare, mesaj_codificare): # functia de rezolvare
codificat = ""
for litera in mesaj_codificare:
for i in range(6):
for j in range(6):
if matrice_codificare[i][j] == litera:
codificat += "ADFGVX"[i] + "ADFGVX"[j]
return codificat

if __name__ == '__main__':
fisier_intrare = open("adfgvxin.txt", "r") # declararea fisierelor
fisier_iesire = open("adfgvxout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
cerinta = int(fisier_intrare.readline())
matrice = [list(fisier_intrare.readline().strip()) for _ in range(6)]
cheie = fisier_intrare.readline().strip()
mesaj = fisier_intrare.readline().strip()

validare(matrice, mesaj) # apelul functiei de validare
if cerinta == 1:
fisier_iesire.write(codificare(matrice, mesaj)) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")
except IndexError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

3616 - Adfgx

2024-01-03T11:55:07Z

Zmicala Narcis: Pagină nouă: Cifrul '''ADFGX''' este un cifru care folosește o matrice pătratică '''5x5''' și o '''cheie'''. În matricea pătratică, liniile și coloanele vor fi numerotate cu litere. Avem această matrice ca exemplu. : A D F G X : A a b c d e : D f g h i j : F k l m n o : G p q r s t : X u v w x y Fiecărei litere îi va corespunde un '''cod''' format din linie și coloană. Spre exemplu pentru litera '''t''' din matricea de mai sus codul este '''GX'''. Literele din fiecare cod s...

Cifrul '''ADFGX''' este un cifru care folosește o matrice pătratică '''5x5''' și o '''cheie'''. În matricea pătratică, liniile și coloanele vor fi numerotate cu litere. Avem această matrice ca exemplu.
: A D F G X
: A a b c d e
: D f g h i j
: F k l m n o
: G p q r s t
: X u v w x y
Fiecărei litere îi va corespunde un '''cod''' format din linie și coloană.
Spre exemplu pentru litera '''t''' din matricea de mai sus codul este '''GX'''. Literele din fiecare cod se așează sub fiecare literă din cheie. Spre exemplu pentru cheia mar și mesajul atac, folosind matricea de mai sus vom avea:
: m a r
: A A G
: X A A
: A F
După această etapă se sortează literele din cheie crescător și obținem.
: a m r
: A A G => AAF AXA GA
: A X A
: F A
Acela este mesajul codificat.
== Cerința ==
Se citeste un text. Sa se afiseze textul codificat folosind cifrul '''ADFGX''', daca numarul cerintei este '''1''', iar daca numarul cerinta este '''2''' se va afisa textul decodificat.
== Date de intrare ==
Pe prima linie a fisierului de intrare '''adfgxin.txt''' se va afla un numar, reprezentand cerinta.
Pe a doua linie se va afla o matrice '''5 x 5'''.
Pe a treia linie se afla '''cheia''' folosita pentru codificare.
Pe a patra linie se va afisa '''mesajul''' ce trebuie codificat/decodificat,in functie de cerinta.
== Date de ieșire ==
Se va afisa mesajul codificat/decodificat.
== Restricții și precizări ==
* '''lungimea mesajului ≤ 100000'''
* '''textul va contine litere mici ale alfabetului englez'''
* Pentru '''cerinta 2''', mesajul ce trebuie decodificat va contine '''litere mari'''. Pentru cerinta 1 mesajul codificat va fi afisat tot cu '''litere mari'''
== Exemplul 1 ==
; adfgxin.txt
: 1
: abcde
: fghij
: klmno
: pqrst
: uvwxy
: pbinfo
: romaniiatacacetatea
; adfgxout.txt
: Datele introduse corespund restricțiilor impuse.
: FAGAFAA FDGAGA FFAAAG XGAFXX FGXAXX GADAAAA
== Exemplul 2 ==
; adfgxin.txt
: 1
: abcde
: fghij
: klmno
: pqrst
: uvwxyz
: pbinfo
: romaniiatacacetatea1
; adfgxout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3616 - Adfgx
def validare(matrice_validare, mesaj_validare): # functia de validare a datelor de intrare
if len(mesaj_validare) > 100000:
raise ValueError

for linie in matrice_validare:
if len(linie) != 5: # fiecare linie trebuie sa aiba 5 caractere
raise ValueError

fisier_iesire.write("Datele introduse corespund restrictiilor impuse.\n")

def codificare(matrice_codificare, mesaj_codificare): # functia de rezolvare
codificat = ""
for litera in mesaj_codificare:
for i in range(5):
for j in range(5):
if matrice_codificare[i][j] == litera:
codificat += "ADFGX"[i] + "ADFGX"[j]
return codificat

if __name__ == '__main__':
fisier_intrare = open("adfgxin.txt", "r") # declararea fisierelor
fisier_iesire = open("adfgxout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
cerinta = int(fisier_intrare.readline())
matrice = [list(fisier_intrare.readline().strip()) for _ in range(5)]
cheie = fisier_intrare.readline().strip()
mesaj = fisier_intrare.readline().strip()

validare(matrice, mesaj) # apelul functiei de validare
if cerinta == 1:
fisier_iesire.write(codificare(matrice, mesaj)) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")
except IndexError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

2525 - Cioc

2024-01-03T01:17:59Z

Zmicala Narcis: Pagină nouă: == Cioc == '''Cioc''', un elev abia aterizat în clasa a IX-a, primește de la doamna profesor de informatică un șir de '''n''' numere naturale pe care trebuie să îl prelucreze. Astfel, băiatul trebuie să scrie după fiecare dintre cele '''k''' cele mai mici elemente dublul lor. Dacă cel mai mare dintre aceste numere se repetă și deja se depășesc cele '''k''' elemente prevăzute, doamna profesor îi dă libertatea băiatului de a modifica valoarea lui '''k''' astfe...

== Cioc ==
'''Cioc''', un elev abia aterizat în clasa a IX-a, primește de la doamna profesor de informatică un șir de '''n''' numere naturale pe care trebuie să îl prelucreze. Astfel, băiatul trebuie să scrie după fiecare dintre cele '''k''' cele mai mici elemente dublul lor. Dacă cel mai mare dintre aceste numere se repetă și deja se depășesc cele '''k''' elemente prevăzute, doamna profesor îi dă libertatea băiatului de a modifica valoarea lui '''k''' astfel încât să cuprindă și aceste valori. De exemplu, dacă '''n = 7''', '''v[] = {1, 4, 6, 2, 3, 4, 5}''' și '''k = 4''', atunci, în urma prelucrării, șirul '''v''' devine '''{1, 2, 4, 8, 6, 2, 4, 3, 6, 4, 8, 5}''', și deci '''kfinal=5'''.
== Cerința ==
Cunoscându-se '''n''', șirul '''v''' și '''k''', să se afișeze:
* 1. Numărul '''kfinal''';
* 2. Vectorul după prelucrare.
== Date de intrare ==
Fișierul de intrare '''ciocin.txt''' conține pe prima linie numerele '''c''' (mereu '''1''' sau '''2''', reprezentând cerința ce trebuie rezolvată), '''n''', '''k''', iar următoarea linie va conține n numere întregi, reprezentând elementele vectorului inițial.
== Date de ieșire ==
Fișierul de ieșire '''ciocout.txt''' va conține pe prima linie:
* Dacă '''c = 1''', atunci numărul '''kfinal''';
* Dacă '''c = 2''', atunci vectorul după prelucrare.
== Restricții și precizări ==
* '''1 ≤ n, k ≤ 100.000''';
* '''1≤v[i]≤2^60''';
* Pentru '''40%''' din teste, '''c=1'''.
== Exemplul 1 ==
; ciocin.txt
: 1 7 4
: 1 4 6 2 3 4 5
; ciocout.txt
: Datele introduse corespund restricțiilor impuse.
: 5
== Explicație ==
'''k'''-ul inițial nu este suficient de cuprinzător (numărul '''4''' se repetă).
== Exemplul 2 ==
; ciocin.txt
: 2 7 4
: 1 4 6 2 3 4 5
; ciocout.txt
: Datele introduse corespund restricțiilor impuse.
: 1 2 4 8 6 2 4 3 6 4 8 5
== Explicație ==
Acesta este exemplul din enunț.
== Exemplul 3 ==
; ciocin.txt
: 2 7 4
: 1 4 6 2 3 4 1000000001
; ciocout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2525 - Cioc
def validare(n_validare, k_validare, sir_validare): # functia de validare a datelor de intrare
if not (1 <= n_validare <= 100000 and 1 <= k_validare <= 100000):
raise ValueError

for v in sir_validare:
if not (1 <= v <= 260):
raise ValueError

fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def prelucrare(n_prelucrare, k_prelucrare, sir_prelucrare): # functia de rezolvare a problemei
sir_sortat = sorted([(v, i) for i, v in enumerate(sir_prelucrare)])
k_final_prelucrare = k_prelucrare
while k_final_prelucrare < n_prelucrare and sir_sortat[k_final_prelucrare][0] == sir_sortat[k_prelucrare-1][0]:
k_final_prelucrare += 1

sir_prelucrat_prelucrare = []
for v, i in sir_sortat[:k_final_prelucrare]:
sir_prelucrat_prelucrare.append((i, v))
sir_prelucrat_prelucrare.append((i, v*2))
sir_prelucrat_prelucrare.sort()

return k_final_prelucrare, [v for i, v in sir_prelucrat_prelucrare]

if __name__ == '__main__':
fisier_intrare = open("ciocin.txt", "r") # declararea fisierelor
fisier_iesire = open("ciocout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
c, n, k = map(int, fisier_intrare.readline().split())
sir = list(map(int, fisier_intrare.readline().split()))

validare(n, k, sir) # apelul functiei de validare

k_final, sir_prelucrat = prelucrare(n, k, sir) # apelul functiei de rezolvare

if c == 1:
fisier_iesire.write(str(k_final) + "\n")
else:
fisier_iesire.write(" ".join(map(str, sir_prelucrat)) + "\n")

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

2466 - Proiectoare

2024-01-03T00:57:44Z

Zmicala Narcis: Pagină nouă: Primăria a montat, pe faleza din Mamaia, '''N''' proiectoare așezate liniar, pentru fiecare cunoscându-se zona de faleză pe care o luminează, sub forma unui interval ['''s, d'''], unde '''s''' și '''d''' ('''s < d''') sunt numere naturale reprezentând distanțele față de punctul unde începe faleza. Pentru a verifica eficiența iluminării falezei, tehnicienii primăriei vor să determine intervalul de faleză de lungime maximă, iluminat de cel mult '''K''' proiecto...

Primăria a montat, pe faleza din Mamaia, '''N''' proiectoare așezate liniar, pentru fiecare cunoscându-se zona de faleză pe care o luminează, sub forma unui interval ['''s, d'''], unde '''s''' și '''d''' ('''s < d''') sunt numere naturale reprezentând distanțele față de punctul unde începe faleza. Pentru a verifica eficiența iluminării falezei, tehnicienii primăriei vor să determine intervalul de faleză de lungime maximă, iluminat de cel mult '''K''' proiectoare, conținut într-un interval '''[X, Y]''' precizat. Pentru a fi siguri de corectitudinea rezultatelor obținute, tehnicienii realizează '''Q''' astfel de verificări.
== Cerința ==
Dându-se '''Q''' intervale de forma '''[Xi, Yi]''' determinați, pentru fiecare dintre acestea, câte un interval de lungime maximă iluminat de cel mult '''K''' proiectoare. Dacă nici un proiector nu iluminează vreo porțiune din intervalul '''[Xi, Yi]''' se va afișa valoarea '''0'''.
== Date de intrare ==
Datele de intrare se citesc din fișierul text '''proiectoarein.txt''', care are structura următoare:
* pe prima linie se află valorile naturale '''N''', '''Q''', '''K''', separate prin câte un spațiu, cu semnificația din enunț;
* pe următoarele '''N''' linii se află câte o pereche de valori naturale '''Si''', '''Di''', separate printr-un spațiu, reprezentând intervalele iluminate de fiecare proiector;
* pe următoarele '''Q''' linii se află câte o pereche de valori naturale '''Xi''', '''Yi''', separate printr-un spațiu, reprezentând intervalele pentru care se realizează verificările.
== Date de ieșire ==
În fișierul text '''proiectoareout.txt''' se vor scrie '''Q''' linii; pe linia '''i''' '''(1 ≤ i ≤ Q)''' se va scrie un număr natural reprezentând lungimea intervalului obținut ca răspuns la verificarea efectuată pentru intervalul '''[Xi, Yi]'''.
== Restricții și precizări ==
* '''0 ≤ S < D ≤ 1 000 000 000'''
* '''1 ≤ K ≤ N ≤ 100 000'''
* '''1 ≤ Q ≤ 100 000'''
* Pentru teste în valoare de '''11''' puncte, '''K = 1''' și '''n ≤ 2000''' și '''Q ≤ 2000'''
* Pentru teste în valoare de alte '''38''' puncte, '''K = 1'''
* Pentru teste în valoare de alte '''21''' puncte, '''K = 2'''
* Pentru teste în valoare de alte '''10''' puncte, '''K ≤ 30'''
== Exemplul 1 ==
; proiectoarein.txt
: 5 5 1
: 1 4
: 2 3
: 3 6
: 4 7
: 4 8
: 1 10
: 2 5
: 3 4
: 6 8
: 8 9
; proiectoareout.txt
: Datele introduse corespund restricțiilor impuse.
: 4
: 2
: 1
: 2
: 0
== Explicație ==
Pentru verificarea '''[1,10]''' cel mai lung interval complet iluminat este '''[4,8]''' cu lungimea '''4'''.
Pentru verificarea '''[2,5]''' cele mai lungi intervale complet iluminate sunt '''[2,4]''' și '''[3,5]''', ambele au lungimea '''2'''.
Pentru verificarea '''[3,4]''' cel mai lung interval complet iluminat este '''[3,4]''' cu lungimea '''1'''.
Pentru verificarea '''[6,8]''' cel mai lung interval complet iluminat este '''[6,8]''' cu lungimea '''2'''.
Pentru verificarea '''[8,9]''' se afișează valoarea '''0'''.
== Exemplul 2 ==
; proiectoarein.txt
: 5 5 1
: 1 4 2
: 2 3 1
: 3 6 1
: 4 7 1
: 4 8 1
: 1 10
: 2 5
: 3 4
: 6 8
: 8 9
; proiectoareout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2466 - Proiectoare
def validare(lista_proiectoare1, lista_verificari1, k_max1): # functia de validare a datelor de intrare
n, q = len(lista_proiectoare1), len(lista_verificari1)
if not (1 <= k_max1 <= n <= 100000 and 1 <= q <= 100000):
raise ValueError

for s, d, k_proiector in lista_proiectoare1:
if not (0 <= s < d <= 1000000000 and 1 <= k_proiector <= n):
raise ValueError

if k_max1 == 1 and n > 2000 and q > 2000:
raise ValueError

if k_max1 > 30:
raise ValueError

fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

# functia de rezolvare va fi implementata aici

if __name__ == '__main__':
fisier_intrare = open("proiectoarein.txt", "r") # declararea fisierelor
fisier_iesire = open("proiectoareout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
lista_proiectoare = []
lista_verificari = []
k_max = 0
# citirea si prelucrarea datelor de intrare se face aici

validare(lista_proiectoare, lista_verificari, k_max) # apelul functiei de validare
# apelul functiei de rezolvare se face aici

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

2869 - Tabela

2024-01-03T00:26:22Z

Zmicala Narcis:

== Cerința ==
Macaraie, pasionat de numere, dar mai ales de matrici, începe într-o zi să umple o foaie infinită de matematică cu numere astfel: în colțul aflat în stânga sus (de coordonate '''(1, 1)''') pune '''0''', apoi scrie de la stânga la dreapta și de sus în jos cel mai mic număr care nu apare pe linia și coloana respectivă. Dându-se linia și coloana unei căsuțe din tabelă, aflați numărul de la acea poziție.
== Date de intrare ==
Fișierul de intrare '''tabelain.txt''' conține pe prima și singura linie numerele '''L''' și '''C''', reprezentând linia și coloana pătrățelului a cărui valoare dorim să o determinăm.
== Date de ieșire ==
Fișierul de ieșire '''tabelaout.txt''' conține pe prima linie numărul scris pe foaie la linia '''L''' si coloana '''C'''.
== Restricții și precizări ==
* 1 ≤ L, C ≤ 2.000.000.000
== Exemplul 1 ==
; tabelain.txt
: 2 3
; tabelaout.txt
: Datele introduse corespund restricțiilor impuse.
: 3
== Exemplul 2 ==
; tabelain.txt
: 4 5
; tabelaout.txt
: Datele introduse corespund restricțiilor impuse.
: 7
== Explicație ==
: 0 1 2 3 4 5 ..
: 1 0 3 2 5 4 ..
: 2 3 0 1 6 7 ..
: 3 2 1 0 7 6 ..
: ..............
== Exemplul 3 ==
; tabelain.txt
: 0 2000000001
; tabelaout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2869 - Tabela
def validare(linie1, coloana1): # functia de validare a datelor de intrare
if linie1 < 1 or linie1 > 2000000000 or coloana1 < 1 or coloana1 > 2000000000:
raise ValueError

fisier_iesire.write("Datele introduse corespund restrictiilor impuse.\n")

def numar_tabela(linie1, coloana1):
if linie1 > coloana1:
if linie1 % 2 == 0:
return linie1 * linie1 - coloana1 + 1
else:
return (linie1 - 1) * (linie1 - 1) + coloana1
else:
if coloana1 % 2 == 0:
return coloana1 * coloana1 - linie1 + 1
else:
return (coloana1 - 1) * (coloana1 - 1) + linie1

if __name__ == '__main__':
fisier_intrare = open("tabelain.txt", "r")
fisier_iesire = open("tabelaout.txt", "w")

try:
linie, coloana = map(int, fisier_intrare.readline().split())
validare(linie, coloana)
numar = numar_tabela(linie, coloana)
fisier_iesire.write(str(numar))

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

2869 - Tabela

2024-01-03T00:21:30Z

Zmicala Narcis: Pagină nouă: == Cerința == Macaraie, pasionat de numere, dar mai ales de matrici, începe într-o zi să umple o foaie infinită de matematică cu numere astfel: în colțul aflat în stânga sus (de coordonate '''(1, 1)''') pune '''0''', apoi scrie de la stânga la dreapta și de sus în jos cel mai mic număr care nu apare pe linia și coloana respectivă. Dându-se linia și coloana unei căsuțe din tabelă, aflați numărul de la acea poziție. == Date de intrare == Fișierul de int...

== Cerința ==
Macaraie, pasionat de numere, dar mai ales de matrici, începe într-o zi să umple o foaie infinită de matematică cu numere astfel: în colțul aflat în stânga sus (de coordonate '''(1, 1)''') pune '''0''', apoi scrie de la stânga la dreapta și de sus în jos cel mai mic număr care nu apare pe linia și coloana respectivă. Dându-se linia și coloana unei căsuțe din tabelă, aflați numărul de la acea poziție.
== Date de intrare ==
Fișierul de intrare '''tabelain.txt''' conține pe prima și singura linie numerele '''L''' și '''C''', reprezentând linia și coloana pătrățelului a cărui valoare dorim să o determinăm.
== Date de ieșire ==
Fișierul de ieșire '''tabelaout.txt''' conține pe prima linie numărul scris pe foaie la linia '''L''' si coloana '''C'''.
== Restricții și precizări ==
* 1 ≤ L, C ≤ 2.000.000.000
== Exemplul 1 ==
; tabelain.txt
: 2 3
; tabelaout.txt
: Datele introduse corespund restricțiilor impuse.
: 3
== Exemplul 2 ==
; tabelain.txt
: 4 5
; tabelaout.txt
: Datele introduse corespund restricțiilor impuse.
: 7
== Explicație ==
: 0 1 2 3 4 5 ..
: 1 0 3 2 5 4 ..
: 2 3 0 1 6 7 ..
: 3 2 1 0 7 6 ..
: ..............
== Exemplul 3 ==
; tabelain.txt
: 0 2000000001
; tabelaout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2869 - Tabela
def validare(linie, coloana): # functia de validare a datelor de intrare
if linie < 1 or linie > 2000000000 or coloana < 1 or coloana > 2000000000:
raise ValueError

fisier_iesire.write("Datele introduse corespund restrictiilor impuse.\n")

def numar_tabela(linie, coloana):
if linie > coloana:
if linie % 2 == 0:
return linie * linie - coloana + 1
else:
return (linie - 1) * (linie - 1) + coloana
else:
if coloana % 2 == 0:
return coloana * coloana - linie + 1
else:
return (coloana - 1) * (coloana - 1) + linie

if __name__ == '__main__':
fisier_intrare = open("tabelain.txt", "r")
fisier_iesire = open("tabelaout.txt", "w")

try:
linie, coloana = map(int, fisier_intrare.readline().split())
validare(linie, coloana)
numar = numar_tabela(linie, coloana)
fisier_iesire.write(str(numar))

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

3883 - Comisia

2024-01-02T18:42:11Z

Zmicala Narcis: Pagină nouă: == Cerința == Odată cu primăvara a sosit şi recrutarea comisiilor, iar asemenea ghioceilor, abuzurile răsar pretutindeni pentru a prevesti acest fapt. Astăzi dorim să recrutăm o comisie dintr-un şir de '''N''' oameni găsiţi aleator pe stradă în timp ce stăteau la o coadă. Fiecare dintre cei '''N''' oameni are un număr minim de oameni pe care comisia trebuie să-l întrunească pentru ca persoana respectivă să accepte participarea. De-asemenea, am atribuit fi...

== Cerința ==
Odată cu primăvara a sosit şi recrutarea comisiilor, iar asemenea ghioceilor, abuzurile răsar pretutindeni pentru a prevesti acest fapt.
Astăzi dorim să recrutăm o comisie dintr-un şir de '''N''' oameni găsiţi aleator pe stradă în timp ce stăteau la o coadă. Fiecare dintre cei '''N''' oameni are un număr minim de oameni pe care comisia trebuie să-l întrunească pentru ca persoana respectivă să accepte participarea. De-asemenea, am atribuit fiecărei persoane, într-un mod subiectiv şi profund discriminatoriu, un grad de risc. Cu cât acest grad de risc este mai mare, cu atât mai mult rău poate face persoana respectivă comisiei, fie că este vorba de încălcat confidenţialitatea subiectelor, sustragerea echipamentului tehnic sau agresarea verbală sau/şi fizică a altor membri ai comisiei.
Fiindcă persoanele au fost găsite stând la coadă şi oricum nu voiam să ne agităm să-i ordonăm în vreun fel, este necesar ca întreaga comisie să formeze o subsecvenţă continuă a cozii. Ştiind acest lucru, dorim să găsim o comisie validă de risc total minim.
== Date de intrare ==
Fişierul de intrare '''comisiain.txt''' contine pe prima linie numarul '''N''' reprezentand numarul de persoane.
Pe a doua linie se va afla şirul '''A''', adică '''N''' numere reprezentand cerintele fiecarei persoane. Mai exact, dacă a i-a valoare este egală cu '''x''', persoana cu numărul '''i''' din coadă îşi doreşte cel puţin '''x''' membri în comisie.
Pe a treia linie se va afla şirul '''B''', adică '''N''' numere reprezentand factorul de risc al fiecarei persoane.
== Date de ieșire ==
În fişierul de ieşire '''comisiaout.txt''' se va afla o singură valoare, reprezentând riscul total minim al unei comisii care întruneşte cerinţele persoanelor implicate.
== Restricții și precizări ==
* '''3 ≤ N ≤ 200.000'''
* '''1 ≤ Ai ≤ N'''
* '''1 ≤ Bi ≤ 1.000.000.000'''
* Pentru teste in valoare de '''20''' de puncte '''N ≤ 4.000'''.
== Exemplul 1 ==
; comisiain.txt
: 3
: 1 2 2
: 50 6 6
; comisiaout.txt
: Datele introduse corespund restricțiilor impuse.
: 12
== Explicație ==
Prima persoană este dispusă să fie singurul membru al comisiei, dar aceasta avea, fără vreun motiv aparent, un topor în mână în momentul chestionării, motiv pentru care i s-a atribuit gradul de risc '''50'''. Este astfel mai bine să formăm comisia din persoanele '''2''' şi '''3'''.
== Exemplul 2 ==
; comisiain.txt
: 2
: 1 2 3 4
: 5 6 7 8
: 9 10 11 12
: 13 14 15 1000000001
; comisiaout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3883 - Comisia
def validare(n1, lista_cerinte1, lista_riscuri1): # functia de validare a datelor de intrare
if n1 < 3 or n1 > 200000:
raise ValueError

for cerinta in lista_cerinte1:
if cerinta < 1 or cerinta > n1:
raise ValueError

for risc in lista_riscuri1:
if risc < 1 or risc > 1000000000:
raise ValueError

fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def risc_minim(n1, lista_cerinte1, lista_riscuri1): # functia de rezolvare
dp = [float('inf')] * (n1 + 1)
dp[0] = 0
for i in range(1, n1 + 1):
suma = 0
for j in range(i, 0, -1):
suma += lista_riscuri1[j - 1]
if lista_cerinte1[j - 1] <= i:
dp[i] = min(dp[i], dp[j-1] + suma)

fisier_iesire.write(str(min(dp[1:])))

if __name__ == '__main__':
fisier_intrare = open("comisiain.txt", "r") # declararea fisierelor
fisier_iesire = open("comisiaout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
dim_n = int(fisier_intrare.readline())
lista_cerinte = list(map(int, fisier_intrare.readline().split()))
lista_riscuri = list(map(int, fisier_intrare.readline().split()))

validare(dim_n, lista_cerinte, lista_riscuri) # apelul functiei de validare
risc_minim(dim_n, lista_cerinte, lista_riscuri) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1229 - Matrice Div Et Imp

2024-01-02T18:24:22Z

Zmicala Narcis: Pagină nouă: == Cerința == Marian a fost foarte interesat de metoda divide et impera și a primit de la profesorul său o problemă: se dă o matrice de dimensiune 2^n și ea trebuie parcursă după o anumită regulă bazată pe divide et impera. Pe baza a trei exemple, el trebuie să descopere regula și s-o aplice . Din păcate, acesta nu reusește și vă cere ajutorul. Vrea o rezolvare foarte eficienta atât din punct de vedere al timpului de execuție cât și a limitei de memorie....

== Cerința ==
Marian a fost foarte interesat de metoda divide et impera și a primit de la profesorul său o problemă: se dă o matrice de dimensiune 2^n și ea trebuie parcursă după o anumită regulă bazată pe divide et impera. Pe baza a trei exemple, el trebuie să descopere regula și s-o aplice . Din păcate, acesta nu reusește și vă cere ajutorul. Vrea o rezolvare foarte eficienta atât din punct de vedere al timpului de execuție cât și a limitei de memorie.
== Date de intrare ==
Fișierul de intrare '''matrice_div_et_impin.txt''' conține pe prima linie numărul '''n''', iar pe celelalte '''2^n''' linii câte '''2^n''' numere naturale nenule separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''matrice_div_et_impout.txt''' va conține o linie cu cele '''2^n*2^n''' numere ale matricei , parcurse după respectiva regulă.
== Restricții și precizări ==
* '''0 ≤ n ≤ 9'''
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1.000.000.000'''
== Exemplul 1 ==
; matrice_div_et_impin.txt
: 1
: 1 2
: 3 4
; matrice_div_et_impout.txt
: Datele introduse corespund restricțiilor impuse.
: 1 4 2 3
== Exemplul 2 ==
; matrice_div_et_impin.txt
: 2
: 15 12 13 14
: 36 56 34 58
: 98 80 79 11
: 10 43 47 50
; matrice_div_et_impout.txt
: Datele introduse corespund restricțiilor impuse.
: 15 56 12 36 79 50 11 47 13 58 14 34 98 43 80 10
== Exemplul 3 ==
; matrice_div_et_impin.txt
: 3
: 1 2 3 4 5 6 7 8
: 9 10 11 12 13 14 15 16
: 17 18 19 20 21 22 23 24
: 25 26 27 28 29 30 31 32
: 33 34 35 36 37 38 39 40
: 41 42 43 44 45 46 47 48
: 49 50 51 52 53 54 55 56
: 57 58 59 60 61 62 63 64
; matrice_div_et_impout.txt
: Datele introduse corespund restricțiilor impuse.
: 1 10 2 9 19 28 20 27 3 12 4 11 17 26 18 25 37 46 38 45 55 64 56 63 39 48 40 47 53 62 54 61 5 14 6 13 23 32 24 31 7 16 8 15 21 30 22 29 33 42 34 41 51 60 52 59 35 44 36 43 49 58 50 57
== Exemplul 4 ==
; matrice_div_et_impin.txt
: 2
: 1 2 3 4
: 5 6 7 8
: 9 10 11 12
: 13 14 15 1000000001
; matrice_div_et_impout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1229 - Matrice Div Et Imp
def validare(dimensiune_n, lista_matrice1): # functia de validare a datelor de intrare
if dimensiune_n < 0 or dimensiune_n > 9:
raise ValueError

for linie in lista_matrice1:
for numar in linie:
if numar < 1 or numar > 1000000000:
raise ValueError

fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def parcurgere(dimensiune_n, lista_matrice1, x, y): # functia de rezolvare
if dimensiune_n == 0:
return [lista_matrice1[x][y]]
else:
dimensiune_n -= 1
dim = 2 ** dimensiune_n
return (parcurgere(dimensiune_n, lista_matrice1, x, y) +
parcurgere(dimensiune_n, lista_matrice1, x + dim, y + dim) +
parcurgere(dimensiune_n, lista_matrice1, x, y + dim) +
parcurgere(dimensiune_n, lista_matrice1, x + dim, y))

if __name__ == '__main__':
fisier_intrare = open("matrice_div_et_impin.txt", "r") # declararea fisierelor
fisier_iesire = open("matrice_div_et_impout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
dim_n = int(fisier_intrare.readline())
lista_matrice = [list(map(int, fisier_intrare.readline().split())) for _ in range(2**dim_n)]

validare(dim_n, lista_matrice) # apelul functiei de validare
rezultat = parcurgere(dim_n, lista_matrice, 0, 0) # apelul functiei de rezolvare
fisier_iesire.write(' '.join(map(str, rezultat)) + '\n')

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1972 - Hambar

2024-01-02T18:06:02Z

Zmicala Narcis: Pagină nouă: == Enunț == Gigel are o grădina sub forma unei matrice binare de ordin '''N''', unde 0 reprezintă teren liber, '''1''' reprezintă pomi. El dorește să construiască un hambar pe dreptunghiul de arie maximă format doar din '''0'''. == Cerința == Ajutați-l pe Gigel să găsească dreptunghiul de arie maximă format doar din '''0'''. == Date de intrare == Fișierul de intrare '''hambarin.txt''' conține pe prima linie numerele '''N''' și '''M''', reprezentând dimensinu...

== Enunț ==
Gigel are o grădina sub forma unei matrice binare de ordin '''N''', unde 0 reprezintă teren liber, '''1''' reprezintă pomi. El dorește să construiască un hambar pe dreptunghiul de arie maximă format doar din '''0'''.
== Cerința ==
Ajutați-l pe Gigel să găsească dreptunghiul de arie maximă format doar din '''0'''.
== Date de intrare ==
Fișierul de intrare '''hambarin.txt''' conține pe prima linie numerele '''N''' și '''M''', reprezentând dimensinunea matricei, respectiv numărul de pomi, iar pe următoarele '''M''' linii se vor găsi perechi numere '''x''' și '''y''', separate printr-un spațiu, reprezentând indicele liniei, respectiv al coloanei pe care se află un pom.
== Date de ieșire ==
Fișierul de ieșire '''hambarout.txt''' va conține pe prima linie numărul '''S''', reprezentând aria maximă a unei suprafețe dreptunghiulare ce nu conține '''1'''.
== Restricții și precizări ==
* '''1 ≤ N, M ≤ 1000'''
* Nu se vor afla '''2''' sau mai mulți pomi în același loc.
== Exemplul 1 ==
; hambarin.txt
: 5 5
: 1 3
: 2 1
: 2 5
: 5 1
: 5 5
; hambarout.txt
: Datele introduse corespund restricțiilor impuse.
: 12
== Exemplul 2 ==
; hambarin.txt
: 5 5
: 1 3
: 2 1
: 2 5
: 5 1
: 5 1000
; hambarout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1972 - Hambar
def validare(dim_n1, dim_m1, lista_pomi1): # functia de validare a datelor de intrare
if dim_n1 < 1 or dim_n1 > 1000 or dim_m1 < 1 or dim_m1 > 1000:
raise ValueError

for pom in lista_pomi1:
if pom[0] < 1 or pom[0] > dim_n1 or pom[1] < 1 or pom[1] > dim_n1:
raise ValueError

fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def arie_maxima(dim_n1, lista_pomi1): # functia de rezolvare
matrice = [[0] * dim_n1 for _ in range(dim_n1)]
for pom in lista_pomi1:
matrice[pom[0]-1][pom[1]-1] = 1

dp = [[0] * dim_n1 for _ in range(dim_n1)]
max_area = 0

for i in range(dim_n1):
for j in range(dim_n1):
if matrice[i][j] == 0:
dp[i][j] = dp[i-1][j] + 1 if i > 0 else 1

for i in range(dim_n1):
for j in range(dim_n1):
width = dp[i][j]
for k in range(i, -1, -1):
width = min(width, dp[k][j])
max_area = max(max_area, width * (i-k+1))

fisier_iesire.write(str(max_area))

if __name__ == '__main__':
fisier_intrare = open("hambarin.txt", "r") # declararea fisierelor
fisier_iesire = open("hambarout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
dim_n, dim_m = map(int, fisier_intrare.readline().split())
lista_pomi = [list(map(int, fisier_intrare.readline().split())) for _ in range(dim_m)]

validare(dim_n, dim_m, lista_pomi) # apelul functiei de validare
arie_maxima(dim_n, lista_pomi) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1351 - Nano

2024-01-02T17:47:22Z

Zmicala Narcis: Pagină nouă: În lumea lui Nano totul se construiește la nivel atomic. Știința a ajuns așa departe încât poate construi ”plăci” dreptunghiulare de atomi în care aceștia sunt aliniați perfect, pe un singur strat, formând un rastru. Nano dorește să comande la o firmă plăci pătrate de dimensiuni mari. Dimensiunile sunt atât de mari încât numărul de atomi dintr-o placă poate să fie scris cu până la 500 cifre. Firma i-a dat o listă cu bucățile de material de care...

În lumea lui Nano totul se construiește la nivel atomic. Știința a ajuns așa departe încât poate construi ”plăci” dreptunghiulare de atomi în care aceștia sunt aliniați perfect, pe un singur strat, formând un rastru. Nano dorește să comande la o firmă plăci pătrate de dimensiuni mari. Dimensiunile sunt atât de mari încât numărul de atomi dintr-o placă poate să fie scris cu până la 500 cifre. Firma i-a dat o listă cu bucățile de material de care dispune, pentru fiecare bucată fiind cunoscut numărul de atomi componenți, urmând ca Nano să aleagă doar acele bucăți din care se pot construi plăci pătrate.
== Cerința ==
Scrieți un program care citind numărul de atomi ai fiecărei bucăți de material din fișierul '''nanoin.txt''' scrie în fișierul '''nanoout.txt''' doar bucățile de material din care se pot face plăcile dorite de Nano.
== Date de intrare ==
Pe prima linie a fișierului '''nanoin.txt''' se află numărul natural '''n''' ce reprezintă numărul de bucăți de material, iar pe următoarele '''2*n''' rânduri perechi de numere '''x y''': '''x''' reprezentând numărul de cifre a lui '''y''', '''y''' fiind numărul de atomi dintr-o bucată de material.
== Date de ieșire ==
Se vor scrie în fișierul '''nanoout.txt''' acele valori '''y''' din care se pot construi plăci pătrate.
== Restricții și precizări ==
* '''1 < n < 50'''
* '''0 < x < 501'''
* În fișier se află cel puțin o bucată de material ce respectă cerințele lui Nano
== Exemplul 1 ==
; nanoin.txt
: 3
: 2
: 39
: 3
: 100
: 11
: 15241383936
; nanoout.txt
: Datele introduse corespund restricțiilor impuse.
: 100
: 15241383936
== Explicație ==
În fişierul '''nanoin.txt''' există '''3''' numere, primul având două cifre, al doilea trei cifre şi ultimul '''11''' cifre. Din bucata cu '''100''' atomi se poate face o placă pătrată de latură '''10''' iar din bucata de dimensiune '''15241383936''' se obține o placă de latură '''123456'''.
== Exemplul 2 ==
; nanoin.txt
: 51
: 1
: 2
: 1
: 3
; nanoout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1351 - Nano
import math

def este_patrat_perfect(n):
radacina = math.isqrt(n)
return radacina * radacina == n

def validare(numere_validare, fisier_iesire_validare): # functia de validare a datelor de intrare
if len(numere_validare) > 50:
fisier_iesire_validare.write("Datele introduse nu corespund restrictiilor impuse\n")
exit(0)
for numar in numere_validare:
if len(str(numar)) > 500: # fiecare numar trebuie sa aiba mai putin de 500 de cifre
fisier_iesire_validare.write("Datele introduse nu corespund restrictiilor impuse\n")
exit(0)
fisier_iesire_validare.write("Datele introduse corespund restrictiilor impuse\n")

def scrie_bucati_patrate(numere_scriere, fisier_iesire_scriere):
for numar in numere_scriere:
if este_patrat_perfect(numar):
fisier_iesire_scriere.write(str(numar) + '\n')

def citeste_date_intrare():
with open('nanoin.txt', 'r') as fisier_intrare_citire:
n_citire = int(fisier_intrare_citire.readline())
numere_citire = []
for _ in range(n_citire):
fisier_intrare_citire.readline() # citim si ignoram numarul de cifre
linie = fisier_intrare_citire.readline()
if not linie: # daca am ajuns la sfarsitul fisierului sau exista o linie goala, iesim din bucla
break
numere_citire.append(int(linie)) # citim numarul
return n_citire, numere_citire

if __name__ == '__main__':
n_main, numere_main = citeste_date_intrare()
with open('nanoout.txt', 'w') as fisier_iesire_main:
validare(numere_main, fisier_iesire_main) # validam datele de intrare
scrie_bucati_patrate(numere_main, fisier_iesire_main)

</syntaxhighlight>

2106 - Armonica

2023-12-28T19:35:14Z

Zmicala Narcis: Pagină nouă: Spunem că trei numere '''a b c''' sunt în progresie armonică dacă '''b''' este media armonică a numerelor '''a''' și '''c''', adică '''b=2/1a+1c=2⋅a⋅c/a+c''' == Cerința == Cunoscând un număr natural '''b''' să se determine toate perechile de numere naturale '''(a,c)''' pentru care '''a b c''' sunt în progresie armonică. == Date de intrare == Fișierul de intrare '''armonicain.txt''' conține pe prima linie numărul '''b'''. == Date de ieșire == Fișierul de...

Spunem că trei numere '''a b c''' sunt în progresie armonică dacă '''b''' este media armonică a numerelor '''a''' și '''c''', adică
'''b=2/1a+1c=2⋅a⋅c/a+c'''
== Cerința ==
Cunoscând un număr natural '''b''' să se determine toate perechile de numere naturale '''(a,c)''' pentru care '''a b c''' sunt în progresie armonică.
== Date de intrare ==
Fișierul de intrare '''armonicain.txt''' conține pe prima linie numărul '''b'''.
== Date de ieșire ==
Fișierul de ieșire '''armonicaout.txt''' va conține pe prima linie numărul '''n''', reprezentând numărul de perechi de numere naturale '''(a,c)''' pentru care '''b''' este media armonică. Pe următoarele linii se vor afișa perechile de numere cerute. Astfel fiecare dintre următoarele '''n''' linii vor conține câte două numere '''a''' și '''c''' separate printr-un spațiu cu semnificația că '''b''' este medie armonică a numerelor '''a''' și '''c'''.
== Restricții și precizări ==
* '''1 ≤ b ≤ 1 000 000 000''';
* Pentru teste în valoare de 40 de puncte avem '''b ≤ 1 000 000''';
* Perechile de numere din fișierul de ieșire pot fi afișate în orice ordine;
* Dacă '''b''' este medie armonică între două numere diferite '''a''' și '''c''' atunci perechile '''(a,b)''' și '''(c,a)''' sunt considerate soluții distincte.
* În concurs s-au acordat 10 puncte din oficiu. Pe site se acordă 10 puncte pentru exemplu.
== Exemplul 1 ==
; armonicain.txt
: 3
; armonicaout.txt
: Datele introduse corespund restricțiilor impuse.
: 3
: 3 3
: 2 6
: 6 2
== Explicație ==
Numărul '''3''' este medie armonică a numerelor '''3''' și '''3'''. Avem progresia armonică '''(3,3,3)'''
Numărul '''3''' este medie armonică a numerelor '''2''' și '''6'''. Avem progresiile armonice '''(2,3,6)''' și '''(6,3,2)'''.
== Exemplul 2 ==
; armonicain.txt
: 1000000001
; armonicaout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2106 - Armonica
def validare(valoaree_b): # functia de validare a datelor de intrare
if valoaree_b < 1 or valoaree_b > 1000000000:
raise ValueError
fisier_iesire.write("Datele introduse corespund restrictiilor impuse.\n")

def progresie_armonica(valoaree_b): # functia de rezolvare
rezultat = []
for valoaree_a in range(1, valoaree_b + 1):
valoaree_c = (valoaree_a * valoaree_b) / (2 * valoaree_a - valoaree_b)
if valoaree_c.is_integer() and valoaree_c >= valoaree_a:
rezultat.append((valoaree_a, int(valoaree_c)))
if valoaree_a != valoaree_c: # Daca a si c sunt diferite, adaugam si perechea (c, a)
rezultat.append((int(valoaree_c), valoaree_a))
return rezultat

if __name__ == '__main__':
fisier_intrare = open("armonicain.txt", "r") # declararea fisierelor
fisier_iesire = open("armonicaout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

# din cauza datelor de intrare pot aparea 2 tipuri de erori, valueError sau IndexError pe care le tratam
try:
valoare_b = int(fisier_intrare.readline()) # citirea datelor de intrare

validare(valoare_b) # apelul functiei de validare
rezultate = progresie_armonica(valoare_b) # apelul functiei de rezolvare
rezultate.sort(key=lambda x: x[0] + x[1]) # Sortam solutiile in functie de suma a + c
fisier_iesire.write(f"{len(rezultate)}\n")
for valoare_a, valoare_c in rezultate:
fisier_iesire.write(f"{valoare_a} {valoare_c}\n")

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

2597 - PermutarePow

2023-12-28T18:55:20Z

Zmicala Narcis:

== Cerința ==
Fie '''∆''' o permutare de gradul '''n'''. Se cere să se calculeze perioada principală a funcției '''f(x)''' = '''∆^x'''.
== Date de intrare ==
Fișierul de intrare '''permutarepowin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale distincte separate prin spații, reprezentând valorile permutării '''∆'''.
== Date de ieșire ==
Fișierul de ieșire '''permutarepowout.txt''' va conține pe prima linie numărul '''P''', reprezentând perioada principală a funcției '''f'''.
== Restricții și precizări ==
* '''1 ≤ n ≤ 1.000.000'''
* Numerele de pe a doua linie vor aparține intervalului '''[1,n]'''
* Despre permutări
== Exemplul 1 ==
; permutarepowin.txt
: 4
: 3 4 2 1
; permutarepowout.txt
: Datele introduse corespund restricțiilor impuse.
: 4
== Explicație ==
Se observă că '''∆''' = '''∆^5''', deci perioada principală este '''4'''.
== Exemplul 2 ==
; permutarepowin.txt
: 5
: 1 2 3 4 6
; permutarepowout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2597 - PermutarePow
import math

def validare(permutare_intrare): # functia de validare a datelor de intrare
n_intrare = len(permutare_intrare)
if n_intrare < 1 or n_intrare > 1000000:
raise ValueError

for numar in permutare_intrare:
if numar < 1 or numar > n_intrare: # fiecare numar trebuie sa fie intre 1 si n
raise ValueError

fisier_iesire.write("Datele introduse corespund restrictiilor impuse.\n")

def perioada_principala(permutare_intrare):
n_intrare = len(permutare_intrare)
vizitat = [False] * n_intrare
cicluri = []

for i in range(n_intrare):
if not vizitat[i]:
ciclu = 0
j = i
while not vizitat[j]:
vizitat[j] = True
ciclu += 1
j = permutare_intrare[j] - 1
cicluri.append(ciclu)

p_curent_local = cicluri[0]
for i in range(1, len(cicluri)):
p_curent_local = (p_curent_local * cicluri[i]) // math.gcd(p_curent_local, cicluri[i])

return p_curent_local

if __name__ == '__main__':
fisier_intrare = open("permutarepowin.txt", "r")
fisier_iesire = open("permutarepowout.txt", "w")

try:
n = int(fisier_intrare.readline())
permutare = list(map(int, fisier_intrare.readline().split()))

validare(permutare) # apelul functiei de validare
p_curent = perioada_principala(permutare) # apelul functiei de rezolvare

fisier_iesire.write(str(p_curent))

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

2597 - PermutarePow

2023-12-28T18:54:01Z

Zmicala Narcis: Pagină nouă: == Cerința == Fie '''∆''' o permutare de gradul '''n'''. Se cere să se calculeze perioada principală a funcției '''f(x)''' = '''∆^x'''. == Date de intrare == Fișierul de intrare '''permutarepowin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale distincte separate prin spații, reprezentând valorile permutării '''∆'''. == Date de ieșire == Fișierul de ieșire '''permutarepowout.txt''' va conține pe prima linie număru...

3394 - Mere 1

2023-12-12T20:01:42Z

Zmicala Narcis: Pagină nouă: == Cerința == Scrieţi un program care să găsească numărul de mere culese de fiecare dintre cei '''K''' prieteni selectați de Cosmin. == Date de intrare == Fișierul de intrare '''merein.txt''' conține: - Pe prima linie, '''N T K''', trei numere întregi reprezentând numărul de prieteni, numărul de zile în care se vor culege mere și numărul de întrebări ale lui Cosmin. - Pe următoarele '''T''' linii, câte două numere întregi, separate printr-un spațiu, '''...

== Cerința ==
Scrieţi un program care să găsească numărul de mere culese de fiecare dintre cei '''K''' prieteni selectați de Cosmin.
== Date de intrare ==
Fișierul de intrare '''merein.txt''' conține:
- Pe prima linie, '''N T K''', trei numere întregi reprezentând numărul de prieteni, numărul de zile în care se vor culege mere și numărul de întrebări ale lui Cosmin.
- Pe următoarele '''T''' linii, câte două numere întregi, separate printr-un spațiu, '''Xi''' și '''Yi''', reprezentând indicele prietenul ce va intra primul în grădina, respectiv numărul de mere ce vor fi culese în ziua '''Ti'''.
- Pe ultima linie, '''K''' numere întregi, '''Qi''', reprezentând indicii prietenilor lui Cosmin, pentru care se dorește aflarea numărului de mere culese.
== Date de ieșire ==
Fișierul de ieșire '''mereout.txt''' va conţine '''K''' numere întregi, pe o singură linie, separate printr-un spațiu, reprezentând răspunsurile la cele '''K''' întrebări.
== Restricții și precizări ==
* '''1 ≤ Xi ≤ N ≤ 10.000.000'''
* '''1 ≤ T ≤ 200.000'''
* '''1 ≤ K ≤ 100.000'''
* '''1 ≤ Yi ≤ 1.000.000'''
* Pentru teste în valoare de 30 puncte: '''1 ≤ Xi ≤ N ≤ 100, 1 ≤ T ≤ 100, 1 ≤ K ≤ 100, 1 ≤ Yi ≤ 1.000'''
* Pentru teste în valoare de 50 puncte: '''1 ≤ Xi ≤ N ≤ 200.000, 1 ≤ T ≤ 10.000, 1 ≤ K ≤ 10.000'''
* Pentru teste în valoare de 70 puncte: '''1 ≤ Xi ≤ N ≤ 1.000.000, 1 ≤ T ≤ 100.000'''
== Exemplul 1 ==
; merein.txt
: 5 3 4
: 1 2
: 3 5
: 2 7
: 2 4 1 2
; mereout.txt
: Datele introduse corespund restricțiilor impuse.
: 4 2 3 4
== Explicație ==
'''5''' persoane vor culege mere timp de '''3''' zile, astfel:
În prima zi, vor culege '''2''' mere persoanele cu indicii '''1''' și '''2'''
În a doua zi, vor culege '''5''' mere persoanele cu indicii '''3''', '''4''', '''5''', '''1''' și '''2'''
În a treia zi, vor culege '''7''' mere persoanele cu indicii '''2''', '''3''', '''4''', '''5''', '''1''', '''2''', '''3'''.
Așadar, numărul de mere culese de fiecare persoană de la '''1''' la '''N''' este: '''1 -> 3''', '''2 -> 4''', '''3 -> 3''', '''4 -> 2''', '''5 -> 2'''.
== Exemplul 2 ==
; merein.txt
: 6 3 4
: 1 2
: 3 5
: 2 7
: 2 4 1 7
; mereout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3394 - Mere 1
def validare(n_validare, t_validare, k_validare, zile_validare, intrebari_validare, fisier):
# Verificam daca datele de intrare respecta restrictiile impuse
if (n_validare < 1 or n_validare > 10000000 or t_validare < 1 or t_validare > 200000 or
k_validare < 1 or k_validare > 100000):
raise ValueError
for zi in zile_validare:
if zi[0] < 1 or zi[0] > n_validare or zi[1] < 1 or zi[1] > 1000000:
raise ValueError
for intrebare in intrebari_validare:
if intrebare < 1 or intrebare > n_validare:
raise ValueError
# Daca datele de intrare sunt valide, afisam un mesaj corespunzator
fisier.write("Datele de intrare corespund restrictiilor impuse\n")

def mere_culese(n_culese, zile_culese, intrebari_culese, fisier):
# Initializam un vector de zero-uri de lungimea numarului de prieteni plus unu
mere = [0] * (n_culese + 1)
# Parcurgem fiecare zi
for zi in zile_culese:
# Stabilim indicele prietenului care incepe culesul
idx = zi[0]
# Parcurgem numarul de mere culese in ziua respectiva
for _ in range(zi[1]):
# Adaugam un mar la prietenul cu indicele idx
mere[idx] += 1
idx += 1
if idx > n_culese:
idx = 1
for intrebare in intrebari_culese:
fisier.write(str(mere[intrebare]) + " ")

if __name__ == '__main__':
fisier_intrare = open("merein.txt", "r")
with open("mereout.txt", "w") as fisier_iesire:
try:
# Citim datele de intrare
n, t, k = map(int, fisier_intrare.readline().split())
zile = [list(map(int, fisier_intrare.readline().split())) for _ in range(t)]
intrebari = list(map(int, fisier_intrare.readline().split()))
# Validam datele de intrare
validare(n, t, k, zile, intrebari, fisier_iesire)
# Rezolvam problema
mere_culese(n, zile, intrebari, fisier_iesire)
# Tratam eventualele erori
except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")
fisier_intrare.close()

</syntaxhighlight>

1594 - Maraton

2023-12-12T19:17:01Z

Zmicala Narcis: Pagină nouă: == Cerința == Ajutați-l pe Costy să răspundă la cele '''Q''' întrebări. == Date de intrare == Fișierul '''maratonin.txt''' conține: * pe prima linie numărul '''N''', reprezentând numărul de maratoniști; * pe următoarele '''N''' linii, câte '''2''' numere, '''Xi Yi''', reprezentând distanța fată de linia de sosire și viteza fiecărui maratonist; * pe următoarea linie, numărul '''Q''' reprezentând numărul de întrebări; * pe următoarele '''Q''' linii se...

== Cerința ==
Ajutați-l pe Costy să răspundă la cele '''Q''' întrebări.
== Date de intrare ==
Fișierul '''maratonin.txt''' conține:
* pe prima linie numărul '''N''', reprezentând numărul de maratoniști;
* pe următoarele '''N''' linii, câte '''2''' numere, '''Xi Yi''', reprezentând distanța fată de linia de sosire și viteza fiecărui maratonist;
* pe următoarea linie, numărul '''Q''' reprezentând numărul de întrebări;
* pe următoarele '''Q''' linii se află câte un număr '''Qi''' reprezentând întrebarea '''i''';
== Date de ieșire ==
Fișierul de ieșire '''maratonout.txt''' conţine:
* '''Q''' linii, linia '''i''' reprezentând răspunsul la întrebarea '''i''';
== Restricții și precizări ==
* '''1 <= N, Q, Qi, Xi <= 100 000'''
* '''1 <= Yi <= 1000'''
== Exemplul 1 ==
; maratonin.txt
: 5
: 100 4
: 12 3
: 101 5
: 20 1
: 44 7
: 4
: 20
: 12
: 7
: 21
; maratonout.txt
: Datele introduse corespund restricțiilor impuse.
: 3
: 2
: 2
: 4
== Explicație ==
* La secunda '''20''' au trecut linia de sosire maratoniștii cu indicii '''2, 4, 5'''.
* La secunda '''12''' au trecut linia de sosire maratoniștii cu indicii '''2, 5'''.
* La secunda '''7''' au trecut linia de sosire maratoniștii cu indicii '''2, 5'''.
* La secunda '''21''' au trecut linia de sosire maratoniștii cu indicii '''2, 3, 4, 5'''.
== Exemplul 2 ==
; maratonin.txt
: 6
: 100 4
: 12 3
: 101 5
: 20 1
: 44 7
: 200000 2
: 4
: 20
: 12
: 7
: 21
; maratonout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1594 - Maraton
def validare(n_maratonisti, lista_maratonisti, n_intrebari, lista_intrebari): # functia de validare
if n_maratonisti > 100000 or n_intrebari > 100000:
raise ValueError

for distanta, viteza in lista_maratonisti:
if distanta > 100000 or viteza > 1000:
raise ValueError

for intrebare in lista_intrebari:
if intrebare > 100000:
raise ValueError

file_out.write("Datele de intrare corespund restrictiilor impuse\n")

def maraton(lista_maratonisti, lista_intrebari): # functia de rezolvare
rezultate_maraton = []
for intrebare in lista_intrebari:
nr_maratonisti_sositi = 0
for distanta, viteza in lista_maratonisti:
if distanta / viteza <= intrebare:
nr_maratonisti_sositi += 1
rezultate_maraton.append(nr_maratonisti_sositi)
return rezultate_maraton

if __name__ == '__main__':
file_in = open("maratonin.txt", "r") # declararea fisierelor
file_out = open("maratonout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
nr_maratonisti = int(file_in.readline())
maratonisti = []
for _ in range(nr_maratonisti):
x, y = map(int, file_in.readline().split())
maratonisti.append((x, y))

nr_intrebari = int(file_in.readline())
intrebari = [int(file_in.readline()) for _ in range(nr_intrebari)]

validare(nr_maratonisti, maratonisti, nr_intrebari, intrebari) # apelul functiei de validare
rezultate = maraton(maratonisti, intrebari) # apelul functiei de rezolvare

for rezultat in rezultate:
file_out.write(str(rezultat) + "\n")

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

3794 - Interclas No Memory 1

2023-12-12T18:54:16Z

Zmicala Narcis: Pagină nouă: == Cerința == Se dau două șiruri de numere naturale, cu '''n''', respectiv '''m''' elemente, '''ordonate crescător'''. Să se determine al treilea șir, care să conţină, în ordine crescătoare, elementele din primele două şiruri. == Date de intrare == Fișierul de intrare '''filein.txt''' conține pe prima linie numerele naturale '''n''', respectiv '''m''', iar apoi pe a doua linie numerele primului șir, și pe a treia linie, numerele celui de-al doilea șir, eleme...

== Cerința ==
Se dau două șiruri de numere naturale, cu '''n''', respectiv '''m''' elemente, '''ordonate crescător'''. Să se determine al treilea șir, care să conţină, în ordine crescătoare, elementele din primele două şiruri.
== Date de intrare ==
Fișierul de intrare '''filein.txt''' conține pe prima linie numerele naturale '''n''', respectiv '''m''', iar apoi pe a doua linie numerele primului șir, și pe a treia linie, numerele celui de-al doilea șir, elementele șirurilor fiind separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''fileout.txt''' va conține numerele celui de-al treilea șir, separate prin spații.
== Restricții și precizări ==
* '''1 ≤ n, m ≤ 100.000'''
* elementele șirului vor fi mai mici decât '''1.000.000.000'''
== Exemplul 1 ==
; filein.txt
: 7 8
: 1 3 4 6 7 8 8
: 2 4 5 6 8 9 9 12
; fileout.txt
: Datele introduse corespund restricțiilor impuse.
: 1 2 3 4 4 5 6 6 7 8 8 8 9 9 12
== Exemplul 2 ==
; filein.txt
: 7 8
: 1 3 4 6 7 8 1000000000
: 2 4 5 6 8 9 9 12
; fileout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3794 - Interclas No Memory 1
def validare(sir_validare1, sir_validare2): # functia de validare a datelor de intrare
if len(sir_validare1) > 100000 or len(sir_validare2) > 100000:
raise ValueError

for numar in sir_validare1 + sir_validare2:
if not isinstance(numar, int) or numar >= 1000000000:
raise ValueError

fisier_iesire.write("Datele introduse corespund restrictiilor impuse.\n")

def rezolvare(sir_rezolvare1, sir_rezolvare2): # functia de rezolvare
al_treilea_sir = sorted(sir_rezolvare1 + sir_rezolvare2)
fisier_iesire.write(' '.join(map(str, al_treilea_sir)))

if __name__ == '__main__':
fisier_intrare = open("filein.txt", "r") # declararea fisierelor
fisier_iesire = open("fileout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
n, m = map(int, fisier_intrare.readline().split())
sir1 = list(map(int, fisier_intrare.readline().split()))
sir2 = list(map(int, fisier_intrare.readline().split()))

validare(sir1, sir2) # apelul functiei de validare
rezolvare(sir1, sir2) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse.")

</syntaxhighlight>

3960 - Intersectie Siruri

2023-12-12T18:37:32Z

Zmicala Narcis: Pagină nouă: == Cerința == Dându-se mai multe '''șiruri crescătoare''' de numere '''naturale''', sfârșitul fiecarui astfel de șir fiind '''marcat''' de numărul '''0''', se cere să se afișeze în ordine '''strict crescătoare''', numerele '''comune''' tuturor șirurilor. == Date de intrare == Fișierul de intrare '''intersectiein.txt''' conține '''numere naturale''' separate printr-un spațiu, care formează '''șiruri crescătoare''', fiecare astfel de șir terminându-se cu nu...

== Cerința ==
Dându-se mai multe '''șiruri crescătoare''' de numere '''naturale''', sfârșitul fiecarui astfel de șir fiind '''marcat''' de numărul '''0''', se cere să se afișeze în ordine '''strict crescătoare''', numerele '''comune''' tuturor șirurilor.
== Date de intrare ==
Fișierul de intrare '''intersectiein.txt''' conține '''numere naturale''' separate printr-un spațiu, care formează '''șiruri crescătoare''', fiecare astfel de șir terminându-se cu numărul '''0'''.
== Date de ieșire ==
Fișierul de ieșire '''intersectieout.txt''' va conține în ordine '''strict crescătoare''', numerele '''comune''' tuturor șirurilor.
== Restricții și precizări ==
* Fiecare șir conține maxim '''100.000''' de numere.
* Fiecare număr din șir are valori cuprinse între '''[1, 2^31 - 1]'''.
* În fișierul '''intersectiein.txt''', pot fi maxim '''3.000.000''' numere.
* Dacă nu avem niciun număr comun se va afișa mesajul '''nu exista'''.
== Exemplul 1 ==
; intersectiein.txt
: 1 2 3 7 10 0 1 4 5 7 10 0 2 3 7 10 0 2 3 5 7 9 10 0
; intersectieout.txt
: Datele introduse corespund restricțiilor impuse.
: 7 10
== Explicație ==
Toate cele '''4''' șiruri :
: 1 2 3 7 10
: 1 4 5 7 10
: 2 3 7 10
: 2 3 5 7 9 10
au numerele '''7''' și '''10''' valori comune.
== Exemplul 2 ==
; intersectiein.txt
: 1 2 3 4 5 6 7 8 9 10 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2147483648 0
; intersectieout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3960 - Intersectie Siruri
def validare(serii_val): # functia de validare a datelor de intrare
if len(serii_val) > 3000000:
raise ValueError

for sir in serii_val:
if len(sir) > 100000:
raise ValueError

for numar_val in sir:
if numar_val < 1 or numar_val > 2**31 - 1:
raise ValueError

fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def intersectie(serii_int): # functia de rezolvare
intersectie_set = set(serii_int[0])
for sir in serii_int[1:]:
intersectie_set &= set(sir)

if intersectie_set:
fisier_iesire.write(' '.join(map(str, sorted(intersectie_set))))
else:
fisier_iesire.write("nu exista")

if __name__ == '__main__':
fisier_intrare = open("intersectiein.txt", "r") # declararea fisierelor
fisier_iesire = open("intersectieout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
serii_main = []
sir_curent = []
for linie in fisier_intrare:
for numar_str in linie.split():
numar_main = int(numar_str)
if numar_main == 0:
serii_main.append(sir_curent)
sir_curent = []
else:
sir_curent.append(numar_main)

validare(serii_main) # apelul functiei de validare
intersectie(serii_main) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

3974 - IRDDS

2023-12-12T13:05:20Z

Zmicala Narcis: Pagină nouă: == Cerința == Se dau '''2''' mulţimi de '''numere naturale''' '''A''' și '''B'''. Să se afișeze mulţimea rezultată în urma efectuării unei operații. == Date de intrare == Programul citește de la tastatură: Pe prima linie '''2''' '''numere naturale''' '''N''' și '''M''', reprezentând '''numărul elementelor''' mulţimii '''A''', respectiv '''B''', urmate de unul dintre caracterele '''* + - %''' : * '''* intersecţie A∩B'''. * '''+ reuniune A∪B'''. * '''- dife...

== Cerința ==
Se dau '''2''' mulţimi de '''numere naturale''' '''A''' și '''B'''. Să se afișeze mulţimea rezultată în urma efectuării unei operații.
== Date de intrare ==
Programul citește de la tastatură:
Pe prima linie '''2''' '''numere naturale''' '''N''' și '''M''', reprezentând '''numărul elementelor''' mulţimii '''A''', respectiv '''B''', urmate de unul dintre caracterele '''* + - %''' :
* '''* intersecţie A∩B'''.
* '''+ reuniune A∪B'''.
* '''- diferența A∖B'''.
* '''% diferența simetrică (A∖B)∪(B∖A)'''.
Pe cea de-a '''2-a''' linie '''N''' '''numere naturale''' reprezentând elementele mulţimii '''A'''.
Pe cea de-a '''3-a''' linie '''M''' '''numere naturale''' reprezentând elementele mulţimii '''B'''.
== Date de ieșire ==
Programul va afișa pe ecran elementele '''mulţimii rezultate''', '''ordonate crescător''', în urma efectuării operaței.
== Restricții și precizări ==
* '''1 ≤ N, M ≤ 200.000'''
* elementele mulţimilor '''A''' și '''B''' vor fi mai mici decât '''1.000.000.000'''
* '''nu există''' cazul ca în urma efectuării uneia dintre operatii rezultatul să fie egal cu '''mulţimea vidă'''.
== Exemplul 1 ==
; Intrare
: 5 5 %
: 4 5 6 7 8
: 1 2 3 4 5
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1 2 3 6 7 8
== Explicație ==
'''({4,5,6,7,8}∖{1,2,3,4,5})∪({1,2,3,4,5}∖{4,5,6,7,8})={1,2,3,6,7,8}'''.
== Exemplul 2 ==
; Intrare
: 5 5 %
: 4 5 6 7 8
: 1 2 3 4 5000000000
; Ieșire
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3974 - IRDDS
def validare(n_validare, m_validare, a_validare, b_validare):
if n_validare < 1 or n_validare > 200000 or m_validare < 1 or m_validare > 200000:
raise ValueError

for numar in a_validare + b_validare:
if numar < 1 or numar > 1000000000:
raise ValueError

print("Datele de intrare corespund restrictiilor impuse")
return True

def operatie(a_operatie, b_operatie, op_operatie):
if op_operatie == '*':
rezultat_operatie = set(a_operatie).intersection(b_operatie)
elif op_operatie == '+':
rezultat_operatie = set(a_operatie).union(b_operatie)
elif op_operatie == '-':
rezultat_operatie = set(a_operatie).difference(b_operatie)
elif op_operatie == '%':
rezultat_operatie = set(a_operatie).symmetric_difference(b_operatie)
else:
raise ValueError("Operatia nu este valida")

return sorted(list(rezultat_operatie))

if __name__ == '__main__':
try:
n_main, m_main, op_main = input(
"Introduceti numarul de elemente din A, numarul de elemente din B si operatia "
).split()
n_main = int(n_main)
m_main = int(m_main)
A_main = list(map(int, input("Introduceti elementele multimii A ").split()))
B_main = list(map(int, input("Introduceti elementele multimii B ").split()))
validare(n_main, m_main, A_main, B_main)
rezultat_main = operatie(A_main, B_main, op_main)
print(" ".join(map(str, rezultat_main)))

except ValueError:
print("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
print("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

0605 - CRB

2023-12-12T11:42:01Z

Zmicala Narcis:

== Cerinţa ==
CRB are un șir cu '''n''' numere naturale diferite. Nu știe ce să facă cu ele și le aranjează în ordine descrescătoare. Apoi observă că anumite numere se află pe aceeași poziție ca în șirul inițial. Ajutați pe CRB să determine câte elemente din șir respectă această regulă.
== Date de intrare ==
Fișierul de intrare '''crbin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații, reprezentând elementele șirului inițial.
== Date de ieşire ==
Fișierul de ieșire '''crbout.txt''' va conține pe prima linie numărul '''C''', reprezentând numărul de elemente care ocupă aceeași poziție în șirul inițial și în cel sortat.
== Restricții și precizări ==
* '''1 ≤ n ≤ 1000'''
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1.000.000'''
== Exemplul 1 ==
; crbin.txt
: 7
: 1 8 2 6 4 7 9
; crbout.txt
: Datele introduse corespund restricțiilor impuse.
: 3
== Explicație ==
Cele trei elemente sunt '''8''', '''6''' și '''4'''.
== Exemplul 2 ==
; crbin.txt
: 5
: 1 2 3 4 1000000
; crbout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0605 - CRB
def validare(sir): # functia de validare a datelor de intrare
if len(sir) > 1000:
raise ValueError

for numar in sir:
if not isinstance(numar, int) or numar >= 1_000_000:
raise ValueError

fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def numar_elemente(sir): # functia de rezolvare
sir_sortat = sorted(sir, reverse=True)

numar_elemente_identice = sum(1 for i in range(len(sir)) if sir[i] == sir_sortat[i])

fisier_iesire.write(str(numar_elemente_identice))

if __name__ == '__main__':
fisier_intrare = open("crbin.txt", "r") # declararea fisierelor
fisier_iesire = open("crbout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
n = int(fisier_intrare.readline()) # citirea numarului se face ca sir de caractere deoarece e prea mare
sir_initial = [int(numar) for numar in fisier_intrare.readline().split()]

validare(sir_initial) # apelul functiei de validare
numar_elemente(sir_initial) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

2905 - Divizori 4

2023-12-11T22:23:05Z

Zmicala Narcis:

== Cerinţa ==
Gigel a găsit un șir cu n numere naturale, numerotate de la '''1''' la '''n''' și un număr '''p'''. Neavând chef de muncă, Gigel vă cere să rezolvați următoarele cerințe:

a) Aflați câți divizori are numărul din șir aflat pe poziția '''p'''.
b) Afișați în ordine descrescătoare numerele din șir care au același număr de divizori ca cel aflat pe poziția '''p'''.
== Date de intrare ==
Fișierul de intrare '''divizori4in.txt''' conține pe prima linie numerele '''n c''', unde c poate fi doar '''1''' sau '''2'''. A doua linie conține cele '''n''' elemente ale șirului. A treia linie conține numărul '''p'''.
== Date de ieşire ==
Dacă '''c=1''' se rezolvă numai cerința a). Fișierul de ieșire '''divizori4out.txt''' va conține pe prima linie numărul de divizori ai numărului aflat în șir pe poziția '''p'''.

Dacă '''c=2''' se rezolvă numai cerința b). Fișierul de ieșire '''divizori4out.txt''' va conține pe prima linie, în ordine descrescătoare, numerele din șir cu același număr de divizori ca și cel aflat pe poziția '''p'''.
== Restricții și precizări ==
* numerele din șir vor fi numere naturale nenule mai mici sau egale cu '''1.000.000.000'''
* pentru 50% din punctaj '''c=1'''; pentru 50% din punctaj '''c=2''';
* pentru '''c=1''', '''1 ≤ p ≤ n ≤ 50.000'''
* pentru '''c=2''', '''1 ≤ p ≤ n ≤ 50.000''' pentru 30% din punctaj și '''1 ≤ p ≤ n ≤ 10.000''' pentru 20% din punctaj
== Exemplul 1 ==
; divizori4in.txt
: 10 1
: 1 5 95 23 16 39 77 74 97 57
: 3
; divizori4out.txt
: Datele introduse corespund restricțiilor impuse.
: 4
== Explicație ==
'''c=1''', se rezolvă doar cerința a). Al treilea număr din șir este '''95''', care are '''4''' divizori '''(1 5 19 95)'''.
== Exemplul 2 ==
; divizori4in.txt
: 10 2
: 1 5 95 23 16 39 77 74 97 57
: 3
; divizori4out.txt
: Datele introduse corespund restricțiilor impuse.
: 95 77 74 57 39
== Explicație ==
'''c=2''', se rezolvă doar cerința b). Al treilea număr din șir este '''95''', care are '''4''' divizori. Numerele cu '''4''' divizori din șir sunt, în ordine descrescătoare: '''95 77 74 57 39'''.
== Exemplul 3 ==
; divizori4in.txt
: 10 1
: 1 2 3 4 5 6 7 8 9 1000000001
: 5
; divizori4out.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2905 - Divizori 4
def validare(serie_validare):
# Verificam daca numarul de elemente din serie este mai mare decat 50_000
# Daca este, aruncam o exceptie ValueError
if len(serie_validare) > 50_000:
raise ValueError

for numar in serie_validare:
if not (1 <= numar <= 1_000_000_000):
raise ValueError

# Daca datele de intrare sunt valide, afisam un mesaj in fisierul de iesire
fisier_iesire.write("Datele de intrare corespund restrictiilor impuse\n")

def numar_divizori(n_divizori):
i = 1
rezultat = 0
# Parcurgem numerele de la 1 la radacina patrata a numarului
while i * i <= n_divizori:
# Daca numarul nu este divizor, incrementam i
if n_divizori % i:
i += 1
continue
# Daca i este divizor, il adaugam la rezultat
# Daca i * i este egal cu numarul, adaugam doar o data i la rezultat
# Altfel, adaugam si i si numarul / i la rezultat
if i * i == n_divizori:
rezultat += 1
else:
rezultat += 2
i += 1
return rezultat

def divizori4(serie_divizori4, pozitie_divizori4, cerinta_divizori4):
# Luam numarul de pe pozitia data
numar = serie_divizori4[pozitie_divizori4-1]
# Calculam numarul de divizori ai numarului
divizori_numar = numar_divizori(numar)

# Daca cerinta este 1, afisam numarul de divizori al numarului
if cerinta_divizori4 == 1:
fisier_iesire.write(str(divizori_numar))
else:
# Daca cerinta este 2, afisam numerele din serie care au acelasi numar de divizori ca numarul de pe pozitia data
numere_cu_acelasi_nr_divizori = [x for x in serie_divizori4 if numar_divizori(x) == divizori_numar]
# Sortam numerele in ordine descrescatoare
numere_cu_acelasi_nr_divizori.sort(reverse=True)
# Afisam numerele
fisier_iesire.write(' '.join(map(str, numere_cu_acelasi_nr_divizori)))

if __name__ == '__main__':
# Deschidem fisierele de intrare si iesire
fisier_intrare = open("divizori4in.txt", "r")
fisier_iesire = open("divizori4out.txt", "w")

try:
n_main, cerinta_main = map(int, fisier_intrare.readline().split())
serie_main = list(map(int, fisier_intrare.readline().split()))
pozitie_main = int(fisier_intrare.readline())

# Validam datele de intrare
validare(serie_main)
# Rezolvam problema
divizori4(serie_main, pozitie_main, cerinta_main)

# Tratam exceptiile care pot aparea
except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

0273 - Ord Sume

2023-12-11T21:51:02Z

Zmicala Narcis:

== Cerinţa ==
Se dă un şir cu '''n''' elemente, numere naturale. Să se afişeze, în ordine crescătoare, toate valorile distincte care se pot obţine ca sumă de două valori distincte din şir.
== Date de intrare ==
Fişierul de intrare '''ordsumein.txt''' conţine pe prima linie numărul '''n''', iar pe a doua cele '''n''' elemente ale şirului dat, separate prin spaţii.
== Date de ieşire ==
Fişierul de ieşire '''ordsumeout.txt''' va conţine pe prima linie, în ordine crescătoare, toate valorile distincte care se pot obţine ca sumă de două valori distincte din şir, separate printr-un spaţiu.
== Restricții și precizări ==
* '''1 ≤ n ≤ 100'''
* numerele de pe a doua linie a fişierului de intrare vor avea cel mult '''8''' cifre
== Exemplul 1 ==
; ordsumein.txt
: 4
: 1 7 3 5
; ordsumeout.txt
Datele introduse corespund restricțiilor impuse.
: 4 6 8 10 12
== Exemplul 2 ==
; ordsumein.txt
: 3
: 1 2 123456789
; ordsumeout.txt
Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0273 - Ord Sume
def validare(n_validare, numere_validare): # functia de validare a datelor de intrare
if n_validare > 100 or n_validare < 1:
raise ValueError

for numar in numere_validare:
if not str(numar).isdigit() or len(str(numar)) > 8: # numărul trebuie să fie cifră cu maxim 8 cifre
raise ValueError

fisier_iesire.write("Datele introduse corespund restrictiilor impuse\n")

def calculeaza_sume(n_calcul, numere_calculeaza): # functia de rezolvare
sume = {numere_calculeaza[i] + numere_calculeaza[j] for i in range(n_calcul) for j in range(i + 1, n_calcul)}
fisier_iesire.write(' '.join(str(suma) for suma in sorted(sume)))

if __name__ == "__main__":
fisier_intrare = open("ordsumein.txt", "r") # declararea fisierelor
fisier_iesire = open("ordsumeout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
n = int(fisier_intrare.readline())
numere = [int(numar) for numar in fisier_intrare.readline().split()]

validare(n, numere) # apelul functiei de validare
calculeaza_sume(n, numere) # apelul functiei de rezolvare

except ValueError:
fisier_iesire.write("Datele introduse nu corespund restrictiilor impuse")

</syntaxhighlight>

4106 - Half Sort 4

2023-11-24T18:34:34Z

Zmicala Narcis:

== Cerinţa ==
Să se ordoneze crescător subșirul format din elementele negative din vector și descrescător subșirul format din elementele pozitive. Indicii subșirului format din elementele negative nu se vor schimba. La fel și indicii subșirului format din elementele pozitive.
== Date de intrare ==
Fişierul de intrare '''halfsort4in.txt''' conţine pe prima linie numărul '''n''' si pe a doua linie '''n''' numere întregi nenule separate prin spaţii.
== Date de ieşire ==
Fişierul de ieşire '''halfsort4out.txt''' va conţine pe prima linie cele '''n''' elemente ale vectorului, ordonate conform cerinței, separate printr-un spațiu.
== Restricții și precizări ==
* '''0 < n ≤ 1000'''
* valoarea absolută a numerelor de pe a doua linie a fişierului de intrare va fi mai mică decât '''2^30'''
== Exemplul 1 ==
; halfsort4in.txt
: 6
: 2 -1 9 -4 5 7
; halfsort4out.txt
: Datele introduse corespund restricțiilor impuse.
: 9 -4 7 -1 5 2
== Exemplul 2 ==
; halfsort4in.txt
: 5
: 1 2 3 4 0
; halfsort4out.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 4106 - Half Sort 4
def validare(numar_elemente, vector_intrare): # functia de validare a datelor de intrare

if numar_elemente > 1000 or numar_elemente < 0:
raise ValueError

for numar in vector_intrare:
if abs(numar) >= 2**30 or numar == 0: # fiecare numar trebuie sa fie mai mic decat 2^30 si nenul
raise ValueError

file_out.write("Datele de intrare corespund restrictiilor impuse\n")

def sorteaza_elemente(vector_intrare): # functia de rezolvare
# Creăm două liste: una pentru numerele negative și una pentru cele pozitive
neg = sorted((x for x in vector_intrare if x < 0), reverse=True)
pos = sorted((x for x in vector_intrare if x > 0))

# Reconstruim lista inițială. Pentru fiecare element din lista inițială:
# - dacă este negativ, adăugăm cel mai mic număr negativ rămas (și îl eliminăm din listă)
# - dacă este pozitiv, adăugăm cel mai mare număr pozitiv rămas (și îl eliminăm din listă)
return [neg.pop() if x < 0 else pos.pop() for x in vector_intrare]

if __name__ == '__main__':
file_in = open("halfsort4in.txt", "r") # declararea fisierelor
file_out = open("halfsort4out.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

# din cauza datelor de intrare pot aparea 2 tipuri de erori, valueError sau IndexError pe care le tratam
try:
n = int(file_in.readline()) # citirea numarului de elemente
vector = list(map(int, file_in.readline().split())) # citirea vectorului

validare(n, vector) # apelul functiei de validare
vector = sorteaza_elemente(vector) # apelul functiei de rezolvare
file_out.write(' '.join(map(str, vector)) + '\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

4102 - Half Sort 3

2023-11-24T18:22:21Z

Zmicala Narcis:

== Cerinţa ==
Să se ordoneze crescător subșirul format din elementele pare din vector și descrescător subșirul format din elementele impare. Indicii subșirului format din elementele pare nu se vor schimba. La fel și indicii subșirului format din elementele impare.
== Date de intrare ==
Fişierul de intrare '''halfsort3in.txt''' conţine pe prima linie numărul '''n''' si pe a doua linie '''n''' numere întregi separate prin spaţii.
== Date de ieşire ==
Fişierul de ieşire '''halfsort3out.txt''' va conţine pe prima linie cele '''n''' elemente ale vectorului, ordonate conform cerinței, separate printr-un spațiu.
== Restricții și precizări ==
* '''0 < n ≤ 1000'''
* valoarea absolută a numerelor de pe a doua linie a fişierului de intrare va fi mai mică decât '''2^30'''
== Exemplul 1 ==
; halfsort3in.txt
: 6
: 8 1 9 4 5 7
; halfsort3out.txt
: Datele introduse corespund restricțiilor impuse.
: 4 9 7 8 5 1
== Exemplul 2 ==
; halfsort3in.txt
: 5
: 1 2 3 4 2**30
; halfsort3out.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 4102 - Half Sort 3
def validare(numar_elemente, vector_intrare): # functia de validare a datelor de intrare

if numar_elemente > 1000 or numar_elemente < 0:
raise ValueError

for numar in vector_intrare:
if abs(numar) >= 2 ** 30: # fiecare numar trebuie sa fie mai mic decat 2^30
raise ValueError

file_out.write("Datele de intrare corespund restrictiilor impuse\n")

def sorteaza_elemente(numar_elemente, vector_intrare): # functia de rezolvare
# Creăm două liste: una cu elementele pare și una cu elementele impare din vector
# Folosim funcția sorted pentru a sorta elementele în funcție de valoarea lor
pare = sorted((vector_intrare[i] for i in range(numar_elemente) if vector_intrare[i] % 2 == 0))
impar = sorted((vector_intrare[i] for i in range(numar_elemente) if vector_intrare[i] % 2 != 0), reverse=True)

# Inițializăm un vector gol
ordonat = []

# Parcurgem vectorul inițial
for numar in vector_intrare:
# Dacă numărul curent este par, adăugăm primul element din lista pare în vectorul ordonat
# și îl eliminăm din lista pare
if numar % 2 == 0:
ordonat.append(pare.pop(0))
# Dacă numărul curent este impar, adăugăm primul element din lista impar în vectorul ordonat
# și îl eliminăm din lista impar
else:
ordonat.append(impar.pop(0))

# Întoarcem vectorul ordonat
return ordonat

if __name__ == '__main__':
file_in = open("halfsort3in.txt", "r") # declararea fisierelor
file_out = open("halfsort3out.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

# din cauza datelor de intrare pot aparea 2 tipuri de erori, valueError sau IndexError pe care le tratam
try:
n = int(file_in.readline()) # citirea numarului de elemente
vector = list(map(int, file_in.readline().split())) # citirea vectorului

validare(n, vector) # apelul functiei de validare
vector = sorteaza_elemente(n, vector) # apelul functiei de rezolvare
file_out.write(' '.join(map(str, vector)) + '\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

0164 - Half Sort 2

2023-11-24T18:11:03Z

Zmicala Narcis:

== Cerinţa ==
Să se ordoneze crescător elementele situate pe poziții pare în vector și descrescător elementele situate pe poziții impare.
== Date de intrare ==
Fişierul de intrare '''halfsort2in.txt''' conţine pe prima linie numărul '''n''' si pe a doua linie '''n''' numere întregi separate prin spaţii.
== Date de ieşire ==
Fişierul de ieşire '''halfsort2out.txt''' va conţine pe prima linie cele '''n''' elemente ale vectorului, ordonate conform cerinței, separate printr-un spațiu.
== Restricții și precizări ==
* '''0 < n ≤ 100'''
* valoarea absolută a numerelor de pe a doua linie a fişierului de intrare va fi mai mică decât '''2^30'''
* indicii elementelor vectorului sunt '''1,2,...,n'''
== Exemplul 1 ==
; halfsort2.in
: 6
: 8 9 9 4 5 7
; halfsort2.out
: Datele introduse corespund restricțiilor impuse.
: 9 4 8 7 5 9
== Exemplul 2 ==
; halfsort2in.txt
: 5
: 1 2 3 4 2**30
; halfsort2out.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 0164 - Half Sort 2
def validare(numar_elemente, vector_intrare): # functia de validare a datelor de intrare

if numar_elemente > 100 or numar_elemente < 0:
raise ValueError

for numar in vector_intrare:
if abs(numar) >= 2 ** 30: # fiecare numar trebuie sa fie mai mic decat 2^30
raise ValueError

file_out.write("Datele de intrare corespund restrictiilor impuse\n")

def sorteaza_elemente(numar_elemente, vector_intrare): # functia de rezolvare
# Creăm două liste, una pentru elementele de pe poziții pare și una pentru cele de pe poziții impare
pare = sorted(vector_intrare[i] for i in range(numar_elemente) if i % 2 != 0)
impar = sorted((vector_intrare[i] for i in range(numar_elemente) if i % 2 == 0), reverse=True)

# Parcurgem vectorul și înlocuim fiecare element cu primul element din lista corespunzătoare
for i in range(numar_elemente):
if i % 2 == 0:
vector_intrare[i] = impar.pop(0)
else:
vector_intrare[i] = pare.pop(0)

# Întoarcem vectorul modificat
return vector_intrare

if __name__ == '__main__':
file_in = open("halfsort2in.txt", "r") # declararea fisierelor
file_out = open("halfsort2out.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

# din cauza datelor de intrare pot aparea 2 tipuri de erori, valueError sau IndexError pe care le tratam
try:
n = int(file_in.readline()) # citirea numarului de elemente
vector = list(map(int, file_in.readline().split())) # citirea vectorului

validare(n, vector) # apelul functiei de validare
vector = sorteaza_elemente(n, vector) # apelul functiei de rezolvare
file_out.write(' '.join(map(str, vector)) + '\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")
except IndexError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

2384 - Divigrup

2023-11-19T20:37:43Z

Zmicala Narcis:

== Cerinţa ==
Un șir de numere aparțin unui divigrup dacă au același număr de divizori. Scrieți un program care citește un număr natural '''N''' și apoi '''N''' numere naturale nenule și care determină:

a. câte divigrupuri există în șirul de numere citite
b. numărul de numere din fiecare divigrup, urmat de numerele ce aparțin acestuia, în ordine crescătoare.
== Date de intrare ==
Fișierul de intrare '''divigrupin.txt''' conține pe prima linie numărul '''N''', iar pe a doua linie '''N''' numere naturale separate prin spații.
== Date de ieşire ==
Fișierul de ieșire '''divigrupout.txt''' va conține pe prima linie numărul '''K''', reprezentând numărul de divigrupuri ce se pot forma cu numerele de pe a doua linie a fișierului de intrare.
Pe următoarele '''K''' rânduri se vor descrie divigrupurile în ordine descrescătoare a numărului de divizori ai elementelor ce le aparțin, astfel încât fiecare rând va avea următoarea structură: '''M''' – numărul de elemente ale divigrupului – '''x1 x2 x3''' … '''xM''' – numerele aparținând divigrupului, în ordine crescătoare. Valorile scrise pe un rând vor fi separate prin câte un spațiu.
== Restricții și precizări ==
* '''1 ≤ n ≤ 200'''
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1000000000'''
== Exemplul 1 ==
; divigrupin.txt
: 11
: 21 99 15 9 24 100 45 28 44 4 36
; divigrupout.txt
: Datele introduse corespund restricțiilor impuse.
: 5
: 2 36 100
: 1 24
: 4 28 44 45 99
: 2 15 21
: 2 4 9
== Exemplul 2 ==
; divigrupin.txt
: 300
: 21 99 15 9 24 100 45 28 44 4 36
; divigrupout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Explicație ==
Există '''5''' divigrupuri care sunt descrise pe următoarele '''5''' rânduri: primul divigrup format din '''36''' și '''100''', care au același număr maxim de divizori, următorul divigrup are un singur element, pe '''24''' care are '''8''' divizori, al treilea divigrup format din '''28''', '''44''', '''45''' și '''99''' are '''4''' elemente, toate având '''6''' divizori, șamd.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 2384 - Divigrup
import math

def validare(numar_elemente1, lista_numere1): # functia de validare a datelor de intrare
if numar_elemente1 < 1 or numar_elemente1 > 200:
raise ValueError
for numar in lista_numere1:
if numar < 1 or numar > 1000000000:
raise ValueError

def calculeaza_numar_divizori(numar): # functia numar_divizori calculează numărul de divizori ai unui număr.
numar_divizori1 = 0
for i in range(1, int(math.sqrt(numar)) + 1):
if numar % i == 0:
if numar / i == i:
numar_divizori1 += 1
else:
numar_divizori1 += 2
return numar_divizori1

def divigrupuri(lista_numere1): # functia divigrupuri grupează numerele din șir în funcție de numărul lor de divizori.
grupuri_divizori1 = {}
for numar in lista_numere1:
numar_divizori1 = calculeaza_numar_divizori(numar)
if numar_divizori1 not in grupuri_divizori1:
grupuri_divizori1[numar_divizori1] = []
grupuri_divizori1[numar_divizori1].append(numar)
for numar_divizori1 in grupuri_divizori1:
grupuri_divizori1[numar_divizori1].sort()
return grupuri_divizori1

if __name__ == '__main__':
file_in = open("divigrupin.txt", "r") # declararea fisierelor
file_out = open("divigrupout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
numar_elemente = int(file_in.readline()) # citirea numărului se face ca sir de caractere deoarece e prea mare
lista_numere = list(map(int, file_in.readline().split()))

validare(numar_elemente, lista_numere) # apelul functiei de validare
file_out.write("Datele de intrare corespund restrictiilor impuse\n")
grupuri_divizori = divigrupuri(lista_numere) # apelul functiei de rezolvare

file_out.write(str(len(grupuri_divizori)) + "\n")
for numar_divizori in sorted(grupuri_divizori.keys(), reverse=True):
file_out.write(str(len(grupuri_divizori[numar_divizori])) + " ")
file_out.write(" ".join(map(str, grupuri_divizori[numar_divizori])) + "\n")

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

3356 - Alfa

2023-11-19T20:36:30Z

Zmicala Narcis:

== Cerinţa ==
Se dă un șir format din '''n''' numere naturale. Se mai dă o valoare '''x''' și se garantează că șirul începe și se termină cu valoarea '''x'''. Transformați șirul astfel:
* Elementele cu valoarea '''x''' rămân pe pozițiile lor;
* Secvențele de elemente diferile de '''x''' aflate între două poziții cu valoarea '''x''' se ordonează crescător (între aceleași două elemente cu valoarea '''x''' se vor afla aceleași elemente ca la început dar în ordine crescătoare).
== Date de intrare ==
Fișierul '''alfain.txt''' conține pe prima linie un număr natural '''n''' reprezentând dimensiunea șirului și un număr '''x''' cu semnificația de mai sus. Pe linia a doua '''n''' numere naturale, separate prin câte un spațiu, reprezentând elementele șirului.
== Date de ieşire ==
Fișierul '''alfaout.txt''' conține cele '''n''' elemente ale șirului în ordinea cerută.
== Restricții și precizări ==
* '''2 <= n <= 1000'''
* Elementele șirului dat sunt naturale nenule formate din maximum '''4''' cifre
* Pentru '''40''' de puncte șirul conține doar două elemente cu valoarea '''x''' (primul și ultimul).
== Exemplul 1 ==
; alfain.txt
: 10 3
: 3 4 1 2 3 7 9 8 3 3
; alfaout.txt
: Datele introduse corespund restricțiilor impuse.
: 3 1 2 4 3 7 8 9 3 3
== Exemplul 2 ==
; alfain.txt
: 1 3
: 3 4 1 2 3 7 9 8 3 3
; alfaout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 3356 - Alfa
def validare(lungime_intrare1, numar_tinta1, lista_numere1): # functia de validare a datelor de intrare
if lungime_intrare1 > 1000 or lungime_intrare1 < 2:
raise ValueError
if len(lista_numere1) != lungime_intrare1:
raise ValueError
if lista_numere1[0] != numar_tinta1 or lista_numere1[-1] != numar_tinta1:
raise ValueError
for numar in lista_numere1:
if not (0 < numar < 10000):
raise ValueError
return "Datele de intrare corespund restrictiilor impuse."

def transforma_lista(lungime_intrare1, numar_tinta1, lista_numere1):
i = 0
while i < lungime_intrare1:
if lista_numere1[i] == numar_tinta1:
j = i + 1
while j < lungime_intrare1 and lista_numere1[j] != numar_tinta1:
j += 1
if j < lungime_intrare1:
lista_numere1[i + 1:j] = sorted(lista_numere1[i + 1:j])
i = j
else:
i += 1
return lista_numere1

if __name__ == '__main__':
fisier_intrare = open("alfain.txt", "r") # declararea fisierelor
fisier_iesire = open("alfaout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
lungime_intrare, numar_tinta = map(int, fisier_intrare.readline().split())
lista_numere = list(map(int, fisier_intrare.readline().split()))

mesaj_validare = validare(lungime_intrare, numar_tinta, lista_numere) # apelul functiei de validare
lista_numere = transforma_lista(lungime_intrare, numar_tinta, lista_numere) # apelul functiei de rezolvare

fisier_iesire.write(mesaj_validare + '\n')
fisier_iesire.write(' '.join(map(str, lista_numere)) + '\n')

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

3356 - Alfa

2023-11-19T20:34:57Z

Zmicala Narcis:

== Cerinţa ==
Se dă un șir format din '''n''' numere naturale. Se mai dă o valoare '''x''' și se garantează că șirul începe și se termină cu valoarea '''x'''. Transformați șirul astfel:
* Elementele cu valoarea '''x''' rămân pe pozițiile lor;
* Secvențele de elemente diferile de '''x''' aflate între două poziții cu valoarea '''x''' se ordonează crescător (între aceleași două elemente cu valoarea '''x''' se vor afla aceleași elemente ca la început dar în ordine crescătoare).
== Date de intrare ==
Fișierul '''alfain.txt''' conține pe prima linie un număr natural '''n''' reprezentând dimensiunea șirului și un număr '''x''' cu semnificația de mai sus. Pe linia a doua '''n''' numere naturale, separate prin câte un spațiu, reprezentând elementele șirului.
== Date de ieşire ==
Fișierul '''alfaout.txt''' conține cele '''n''' elemente ale șirului în ordinea cerută.
== Restricții și precizări ==
* '''2 <= n <= 1000'''
* Elementele șirului dat sunt naturale nenule formate din maximum '''4''' cifre
* Pentru '''40''' de puncte șirul conține doar două elemente cu valoarea '''x''' (primul și ultimul).
== Exemplul 1 ==
; alfain.txt
: 10 3
: 3 4 1 2 3 7 9 8 3 3
; alfaout.txt
: Datele introduse corespund restricțiilor impuse.
: 3 1 2 4 3 7 8 9 3 3
== Exemplul 2 ==
; alfain.txt
: 1 3
: 3 4 1 2 3 7 9 8 3 3
; alfaout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare(lungime_intrare1, numar_tinta1, lista_numere1): # functia de validare a datelor de intrare
if lungime_intrare1 > 1000 or lungime_intrare1 < 2:
raise ValueError
if len(lista_numere1) != lungime_intrare1:
raise ValueError
if lista_numere1[0] != numar_tinta1 or lista_numere1[-1] != numar_tinta1:
raise ValueError
for numar in lista_numere1:
if not (0 < numar < 10000):
raise ValueError
return "Datele de intrare corespund restrictiilor impuse."

def transforma_lista(lungime_intrare1, numar_tinta1, lista_numere1):
i = 0
while i < lungime_intrare1:
if lista_numere1[i] == numar_tinta1:
j = i + 1
while j < lungime_intrare1 and lista_numere1[j] != numar_tinta1:
j += 1
if j < lungime_intrare1:
lista_numere1[i + 1:j] = sorted(lista_numere1[i + 1:j])
i = j
else:
i += 1
return lista_numere1

if __name__ == '__main__':
file_in = open("alfain.txt", "r") # declararea fisierelor
file_out = open("alfaout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
lungime_intrare, numar_tinta = map(int, file_in.readline().split())
lista_numere = list(map(int, file_in.readline().split()))

mesaj_validare = validare(lungime_intrare, numar_tinta, lista_numere) # apelul functiei de validare
lista_numere = transforma_lista(lungime_intrare, numar_tinta, lista_numere) # apelul functiei de rezolvare

file_out.write(mesaj_validare + '\n')
file_out.write(' '.join(map(str, lista_numere)) + '\n')

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

2384 - Divigrup

2023-11-19T20:25:21Z

Zmicala Narcis:

== Cerinţa ==
Un șir de numere aparțin unui divigrup dacă au același număr de divizori. Scrieți un program care citește un număr natural '''N''' și apoi '''N''' numere naturale nenule și care determină:

a. câte divigrupuri există în șirul de numere citite
b. numărul de numere din fiecare divigrup, urmat de numerele ce aparțin acestuia, în ordine crescătoare.
== Date de intrare ==
Fișierul de intrare '''divigrupin.txt''' conține pe prima linie numărul '''N''', iar pe a doua linie '''N''' numere naturale separate prin spații.
== Date de ieşire ==
Fișierul de ieșire '''divigrupout.txt''' va conține pe prima linie numărul '''K''', reprezentând numărul de divigrupuri ce se pot forma cu numerele de pe a doua linie a fișierului de intrare.
Pe următoarele '''K''' rânduri se vor descrie divigrupurile în ordine descrescătoare a numărului de divizori ai elementelor ce le aparțin, astfel încât fiecare rând va avea următoarea structură: '''M''' – numărul de elemente ale divigrupului – '''x1 x2 x3''' … '''xM''' – numerele aparținând divigrupului, în ordine crescătoare. Valorile scrise pe un rând vor fi separate prin câte un spațiu.
== Restricții și precizări ==
* '''1 ≤ n ≤ 200'''
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1000000000'''
== Exemplul 1 ==
; divigrupin.txt
: 11
: 21 99 15 9 24 100 45 28 44 4 36
; divigrupout.txt
: Datele introduse corespund restricțiilor impuse.
: 5
: 2 36 100
: 1 24
: 4 28 44 45 99
: 2 15 21
: 2 4 9
== Exemplul 2 ==
; divigrupin.txt
: 300
: 21 99 15 9 24 100 45 28 44 4 36
; divigrupout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Explicație ==
Există '''5''' divigrupuri care sunt descrise pe următoarele '''5''' rânduri: primul divigrup format din '''36''' și '''100''', care au același număr maxim de divizori, următorul divigrup are un singur element, pe '''24''' care are '''8''' divizori, al treilea divigrup format din '''28''', '''44''', '''45''' și '''99''' are '''4''' elemente, toate având '''6''' divizori, șamd.
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def validare(numar_elemente1, lista_numere1): # functia de validare a datelor de intrare
if numar_elemente1 < 1 or numar_elemente1 > 200:
raise ValueError
for numar in lista_numere1:
if numar < 1 or numar > 1000000000:
raise ValueError

def calculeaza_numar_divizori(numar): # functia numar_divizori calculează numărul de divizori ai unui număr.
numar_divizori1 = 0
for i in range(1, int(math.sqrt(numar)) + 1):
if numar % i == 0:
if numar / i == i:
numar_divizori1 += 1
else:
numar_divizori1 += 2
return numar_divizori1

def divigrupuri(lista_numere1): # functia divigrupuri grupează numerele din șir în funcție de numărul lor de divizori.
grupuri_divizori1 = {}
for numar in lista_numere1:
numar_divizori1 = calculeaza_numar_divizori(numar)
if numar_divizori1 not in grupuri_divizori1:
grupuri_divizori1[numar_divizori1] = []
grupuri_divizori1[numar_divizori1].append(numar)
for numar_divizori1 in grupuri_divizori1:
grupuri_divizori1[numar_divizori1].sort()
return grupuri_divizori1

if __name__ == '__main__':
file_in = open("divigrupin.txt", "r") # declararea fisierelor
file_out = open("divigrupout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
numar_elemente = int(file_in.readline()) # citirea numărului se face ca sir de caractere deoarece e prea mare
lista_numere = list(map(int, file_in.readline().split()))

validare(numar_elemente, lista_numere) # apelul functiei de validare
file_out.write("Datele de intrare corespund restrictiilor impuse\n")
grupuri_divizori = divigrupuri(lista_numere) # apelul functiei de rezolvare

file_out.write(str(len(grupuri_divizori)) + "\n")
for numar_divizori in sorted(grupuri_divizori.keys(), reverse=True):
file_out.write(str(len(grupuri_divizori[numar_divizori])) + " ")
file_out.write(" ".join(map(str, grupuri_divizori[numar_divizori])) + "\n")

except ValueError:
file_out.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

3356 - Alfa

2023-11-19T19:30:06Z

Zmicala Narcis:

== Cerinţa ==
Se dă un șir format din '''n''' numere naturale. Se mai dă o valoare '''x''' și se garantează că șirul începe și se termină cu valoarea '''x'''. Transformați șirul astfel:
* Elementele cu valoarea '''x''' rămân pe pozițiile lor;
* Secvențele de elemente diferile de '''x''' aflate între două poziții cu valoarea '''x''' se ordonează crescător (între aceleași două elemente cu valoarea '''x''' se vor afla aceleași elemente ca la început dar în ordine crescătoare).
== Date de intrare ==
Fișierul '''alfain.txt''' conține pe prima linie un număr natural '''n''' reprezentând dimensiunea șirului și un număr '''x''' cu semnificația de mai sus. Pe linia a doua '''n''' numere naturale, separate prin câte un spațiu, reprezentând elementele șirului.
== Date de ieşire ==
Fișierul '''alfaout.txt''' conține cele '''n''' elemente ale șirului în ordinea cerută.
== Restricții și precizări ==
* '''2 <= n <= 1000'''
* Elementele șirului dat sunt naturale nenule formate din maximum '''4''' cifre
* Pentru '''40''' de puncte șirul conține doar două elemente cu valoarea '''x''' (primul și ultimul).
== Exemplul 1 ==
; alfain.txt
: 10 3
: 3 4 1 2 3 7 9 8 3 3
; alfaout.txt
: Datele introduse corespund restricțiilor impuse.
: 3 1 2 4 3 7 8 9 3 3
== Exemplul 2 ==
; alfain.txt
: 1 3
: 3 4 1 2 3 7 9 8 3 3
; alfaout.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare(lungime_intrare1, numar_tinta1, lista_numere1): # functia de validare a datelor de intrare
if lungime_intrare1 > 1000 or lungime_intrare1 < 2:
raise ValueError
if len(lista_numere1) != lungime_intrare1:
raise ValueError
if lista_numere1[0] != numar_tinta1 or lista_numere1[-1] != numar_tinta1:
raise ValueError
for numar in lista_numere1:
if not (0 < numar < 10000):
raise ValueError
return "Datele de intrare corespund restrictiilor impuse."

def transforma_lista(lungime_intrare1, numar_tinta1, lista_numere1):
i = 0
while i < lungime_intrare1:
if lista_numere1[i] == numar_tinta1:
j = i + 1
while j < lungime_intrare1 and lista_numere1[j] != numar_tinta1:
j += 1
if j < lungime_intrare1:
lista_numere1[i + 1:j] = sorted(lista_numere1[i + 1:j])
i = j
else:
i += 1
return lista_numere1

if __name__ == '__main__':
fisier_intrare = open("alfain.txt", "r") # declararea fisierelor
fisier_iesire = open("alfaout.txt", "w") # fisierul out trebuie declarat cu optiunea "w" (write)

try:
lungime_intrare, numar_tinta = map(int, fisier_intrare.readline().split())
lista_numere = list(map(int, fisier_intrare.readline().split()))

mesaj_validare = validare(lungime_intrare, numar_tinta, lista_numere) # apelul functiei de validare
lista_numere = transforma_lista(lungime_intrare, numar_tinta, lista_numere) # apelul functiei de rezolvare

fisier_iesire.write(mesaj_validare + '\n')
fisier_iesire.write(' '.join(map(str, lista_numere)) + '\n')

except ValueError:
fisier_iesire.write("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1192 - Arhitectura 2

2023-11-16T13:38:44Z

Zmicala Narcis:

== Cerinţa ==
După ce arhitectul Gigel a reușit să rezolve sarcina primită de la primărie ( #Arhitectura ), el și-a dat seama că aspectul zonei nu va fi unul după preferințele sale. Astfel, s-a stabilit că în oraș nu există clădiri cu înălțimea mai mare decât '''hmax'''. Acum primăria îi cere afișarea clădirilor în ordine descrescătoare, precum și verificarea, pentru fiecare clădire din lista ordonată, dacă înălțimea ei este egală cu media aritmetică a înălțimilor celor două clădiri vecine.

Gigel vă cere ajutorul ca să-și termine proiectul care a devenit mult prea greu.
== Date de intrare ==
Fișierul de intrare '''arhitectura2in.txt''' conține pe prima linie numărul '''n''', iar pe următoarele linii '''n''' numere naturale separate prin spații. Fiecare linie conține maxim '''100.000''' de valori.
== Date de ieşire ==
Fișierul de ieșire '''arhitectura2out.txt''' va conține doua linii cu '''n''' valori fiecare. Prima linie va conține înălțimile în ordine descrescătoare , iar a doua linie va conține '''n''' valori '''1''' sau '''0''', după cum înălțimea clădirii curente este sau nu egală cu media aritmetică a înălțimilor celor două clădiri vecine.
== Restricții și precizări ==
* '''1 ≤ n ≤ 2000000'''
* '''hmax ≤ 100000'''
* Pentru 40% din teste '''n ≤ 50000'''
* Pentru 80% din teste '''n ≤ 500000'''
* Considerăm că înaintea primei clădiri și după ultima clădire se află câte o pseudoclădire de înălțime '''0''' – care va interveni în verificarea cerută.
== Exemplul 1 ==
; arhitectura2in.txt
: 10
: 5 10 10 9 5 2 5 8 5 2
; arhitectura2out.txt
: Datele introduse corespund restricțiilor impuse.
: 10 10 9 8 5 5 5 5 2 2
: 0 0 1 0 0 1 1 0 0 0
== Explicație ==
Șirul devine '''10 10 9 8 5 5 5 5 2 2'''
Doar '''9''' si cei doi de '''5''' din mijloc respectă condiția.
== Exemplul 2 ==
; arhitectura2in.txt
: 2000001
: 5 10 10 9 5 2 5 8 5 2
; arhitectura2out.txt
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1192 - Arhitectura 2
def validare(numar_cladiri, inaltimi): # functia de validare a datelor de intrare

if numar_cladiri > 2000000 or numar_cladiri < 1:
raise ValueError

for inaltime in inaltimi:
if inaltime > 100000 or inaltime < 1: # fiecare inaltime trebuie sa fie intre 1 si 100000
raise ValueError

print("Datele de intrare corespund restrictiilor impuse\n")

def arhitectura(numar_cladiri, inaltimi): # functia de rezolvare
# Sortăm înălțimile în ordine descrescătoare
inaltimi.sort(reverse=True)

# Convertim lista de înălțimi într-un șir de caractere pentru a fi afișată
cladiri_ordonate = ' '.join(map(str, inaltimi))

# Inițializăm o listă goală pentru a stoca rezultatele verificării
verificare = []

# Parcurgem lista de înălțimi
for i in range(numar_cladiri):
# Dacă suntem la prima sau la ultima clădire, adăugăm '0' în lista de verificare
if i == 0 or i == numar_cladiri - 1:
verificare.append('0')
else:
# Dacă înălțimea clădirii curente este egală cu media aritmetică a înălțimilor celor două clădiri vecine,
# adăugăm '1' în lista de verificare
if inaltimi[i] == (inaltimi[i - 1] + inaltimi[i + 1]) / 2:
verificare.append('1')
else:
# Dacă nu, adăugăm '0' în lista de verificare
verificare.append('0')

# Convertim lista de verificare într-un șir de caractere pentru a fi afișată
return cladiri_ordonate, ' '.join(verificare)

if __name__ == '__main__':
numar_cladiri_input = int(input("Introduceți numărul de clădiri: "))
inaltimi_input = list(map(int, input("Introduceți înălțimile clădirilor, separate prin spațiu: ").split()))

try:
validare(numar_cladiri_input, inaltimi_input) # apelul functiei de validare
print(arhitectura(numar_cladiri_input, inaltimi_input)) # apelul functiei de rezolvare

except ValueError:
print("Datele de intrare nu corespund restrictiilor impuse")

</syntaxhighlight>

1981 - Divizori sir

2023-11-16T13:16:08Z

Zmicala Narcis:

== Cerinţa ==
Se dă următorul șir de numere naturale:

'''1, 3, 9, 25, 65, 161, 385, 897, 2049, 4609, 10241, 22529, 49153, 106497…'''

Pentru un număr natural n, citit de la tastatură, afișati numărul de divizori pentru fiecare dintre primii n termeni ai șirului.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''';
== Date de ieşire ==
Programul va afișa pe ecran cele '''n''' numere, reprezentând numărul de divizori ai fiecarui numar dintre cele '''n''', separate prin spații.
== Restricții și precizări ==
* '''0 < n < 60'''
== Exemplul 1 ==
; Intrare
: 4
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1 2 3 3
== Exemplul 2 ==
; Intrare
: -1
; Ieșire
: Datele introduse nu corespund restricțiilor impuse.
== Explicație ==
* 1 are un divizor,
* 3 are 2 divizori,
* 9 are 3 divizori,
* 25 are 3 divizori.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1981 - Divizori sir
def verificare_restrictii(n1):
# functia de verificare a datelor de intrare
if 0 < n1 < 60:
return True
else:
return False

def numar_divizori(n1):
# Initializam sirul de numere
sir = [2, 4]
# Generam primii n termeni ai sirului
for i in range(2, n1):
sir.append(2 * sir[i - 1] + 2 * sir[i - 2])
# Calculam numarul de divizori pentru fiecare termen al sirului
divizori = [len(set(i for i in range(1, int(x**0.5) + 1) if x % i == 0)) for x in sir]
return divizori

if __name__ == "__main__":
try:
# Citim datele de intrare
n = int(input())
if verificare_restrictii(n): # verificam datele de intrare
print("Datele de intrare corespund restrictiilor impuse.")
# Calculam numarul de divizori
rezultat = numar_divizori(n)
# Afisam rezultatul
print(' '.join(map(str, rezultat)))
else:
print("Datele de intrare nu corespund restrictiilor impuse.")
# ne asteptam la 2 tipuri de erori din cauza datelor de intrare, le tratam corespunzator
except ValueError:
print("Datele de intrare nu corespund restrictiilor impuse.")
except IndexError:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

1981 - Divizori sir

2023-11-16T13:14:19Z

Zmicala Narcis:

== Cerinţa ==
Se dă următorul șir de numere naturale:

'''1, 3, 9, 25, 65, 161, 385, 897, 2049, 4609, 10241, 22529, 49153, 106497…'''

Pentru un număr natural n, citit de la tastatură, afișati numărul de divizori pentru fiecare dintre primii n termeni ai șirului.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''';
== Date de ieşire ==
Programul va afișa pe ecran cele '''n''' numere, reprezentând numărul de divizori ai fiecarui numar dintre cele '''n''', separate prin spații.
== Restricții și precizări ==
* '''0 < n < 60'''
== Exemplul 1 ==
; Intrare
: 4
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1 2 3 3
== Exemplul 2 ==
; Intrare
: n
; Ieșire
: Datele introduse nu corespund restricțiilor impuse.
== Explicație ==
* 1 are un divizor,
* 3 are 2 divizori,
* 9 are 3 divizori,
* 25 are 3 divizori.
== Rezolvare ==
<syntaxhighlight lang="python" line>
# 1981 - Divizori sir
def verificare_restrictii(n1):
# functia de verificare a datelor de intrare
if 0 < n1 < 60:
return True
else:
return False

def numar_divizori(n1):
# Initializam sirul de numere
sir = [2, 4]
# Generam primii n termeni ai sirului
for i in range(2, n1):
sir.append(2 * sir[i - 1] + 2 * sir[i - 2])
# Calculam numarul de divizori pentru fiecare termen al sirului
divizori = [len(set(i for i in range(1, int(x**0.5) + 1) if x % i == 0)) for x in sir]
return divizori

if __name__ == "__main__":
try:
# Citim datele de intrare
n = int(input())
if verificare_restrictii(n): # verificam datele de intrare
print("Datele de intrare corespund restrictiilor impuse.")
# Calculam numarul de divizori
rezultat = numar_divizori(n)
# Afisam rezultatul
print(' '.join(map(str, rezultat)))
else:
print("Datele de intrare nu corespund restrictiilor impuse.")
# ne asteptam la 2 tipuri de erori din cauza datelor de intrare, le tratam corespunzator
except ValueError:
print("Datele de intrare nu corespund restrictiilor impuse.")
except IndexError:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>