Bitnami MediaWiki - User contributions [en]

4084 - pseudocmp

2023-06-02T14:30:40Z

Sovago Rares-Andrei: Pagină nouă: == Cerința == Àles a primit ca temă următoarea problemă: “Fiind dat un șir A cu N numere naturale distincte, să se calculeze suma cifrelor fiecărui element al șirului”. După ce și-a terminat tema, acesta observă că sunt mai multe perechi de indici (i, j) pentru care dacă A[i] < A[j] atunci S[i] > S[j], unde S[i] reprezintă suma cifrelor lui A[i]. El le va numi pe acestea perechi speciale de indici. Terminând prea repede tema, Àles primește o temă supli...

== Cerința ==
Àles a primit ca temă următoarea problemă: “Fiind dat un șir A cu N numere naturale distincte, să se calculeze suma cifrelor fiecărui element al șirului”.

După ce și-a terminat tema, acesta observă că sunt mai multe perechi de indici (i, j) pentru care dacă A[i] < A[j] atunci S[i] > S[j], unde S[i] reprezintă suma cifrelor lui A[i]. El le va numi pe acestea perechi speciale de indici.
Terminând prea repede tema, Àles primește o temă suplimentară cu două cerințe:

Determină două numere aflate în șirul '''A''', pentru care indicii corespunzători formează o pereche specială.
Câte perechi speciale de indici '''(i, j)''' se găsesc în şirul '''A'''?
Ajutați-l pe Àles să rezolve tema suplimentară.
== Date de intrare ==
Pe prima linie a fișierului '''pseudocmp.in''' se găsesc două numere naturale: T și N. Pe următoarea linie se găsesc N numere naturale, separate printr-un spațiu, reprezentând valorile din șirul '''A'''. Numărul '''T''' reprezintă numărul cerinței.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.", Pe prima linie a fișierului pseudocmp.out:

Dacă T = 1, se găsesc două numere naturale x, y, cu x < y, separate printr-un spațiu, reprezentând răspunsul pentru cerința 1 dacă există soluție sau -1, dacă nu există soluție. Dacă există mai multe soluții, se acceptă oricare dintre acestea.
Dacă T = 2, se găsește un singur număr natural, reprezentând răspunsul la cerința 2.
În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricții și precizări ==
* 1 ≤ N ≤ 100.000
*1 ≤ A[i] ≤ 1.000.000, pentru 1 ≤ i ≤ N
== Exemple ==
===Exemplul 1===
; ''pseudocmp.in''
:1 6
:213 123 523 51 99 92
; ''ecran''
:Datele sunt introduse corect.
; ''pseudocmp.out''
:99 123
===Exemplul 2===
; ''pseudocmp.in''
:1 5
:6 5 2 1 3
; ''ecran''
:Datele sunt introduse corect.
; ''pseudocmp.out''
:-1
===Exemplul 3===
; ''pseudocmp.in''
:1 5
:60000000 5 2 1 3
; ''ecran''
:Datele nu corespund restricțiilor impuse.

 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 4084 - pseudocmp
def valideaza_date(T, N, A):
if T != 1 and T != 2:
return False
if not (1 <= N <= 100000):
return False
if not all(1 <= val <= 1000000 for val in A):
return False
return True

def rezolva_cerinta1(n, v):
v.sort(key=lambda x: x['val'])
for i in range(1, n):
if v[i]['sumcif'] < v[i - 1]['sumcif']:
return v[i - 1]['val'], v[i]['val']
return -1

def rezolva_cerinta2(n, v):
f = [0] * 60
cnt = 0
for i in range(n):
s = v[i]['sumcif']
for j in range(s + 1, 60):
cnt += f[j]
f[s] += 1
return cnt

if __name__ == '__main__':
with open("pseudocmp.in", "r") as fisier_intrare:
T, N = map(int, fisier_intrare.readline().strip().split())
A = list(map(int, fisier_intrare.readline().strip().split()))

if valideaza_date(T, N, A):
print("Datele sunt introduse corect.")
v = []
for valoare in A:
suma_cifre = sum(map(int, str(valoare)))
v.append({'val': valoare, 'sumcif': suma_cifre})

if T == 1:
rezultat = rezolva_cerinta1(N, v)
else:
rezultat = rezolva_cerinta2(N, v)

with open("pseudocmp.out", "w") as fisier_iesire:
if rezultat == -1:
fisier_iesire.write(str(rezultat))
else:
fisier_iesire.write("{}\n".format(rezultat))
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicatie==
valideaza_date(T, N, A): Această funcție validează datele de intrare în funcție de constrângerile date. Are trei parametri: T (valoarea T din intrare), N (valoarea N din intrare) și A (lista de valori din intrare). Funcția verifică dacă T este fie 1, fie 2, dacă N se află în intervalul 1 până la 100.000 și dacă toate valorile din A se află în intervalul 1 până la 1.000.000. Dacă una dintre condiții nu este îndeplinită, funcția returnează False, indicând că datele sunt invalide. În caz contrar, returnează True, indicând că datele sunt valide.

rezolva_cerinta1(n, v): Această funcție rezolvă problema pentru T = 1. Are doi parametri: n (lungimea listei de intrare v) și v (lista de dicționare care conține valorile și suma cifrelor lor). Funcția sortează lista v în funcție de valorile din ordine crescătoare. Apoi, iterează prin lista sortată și verifică dacă suma cifrelor valorii curente este mai mică decât suma cifrelor valorii anterioare. Dacă este, returnează o pereche de valori formată din valoarea anterioară și valoarea curentă. Dacă nu se găsește nicio pereche de acest fel, returnează -1.

rezolva_cerinta2(n, v): Această funcție rezolvă problema pentru T = 2. Are doi parametri: n (lungimea listei de intrare v) și v (lista de dicționare care conține valorile și suma cifrelor lor). Funcția inițializează o listă f cu 60 de zerouri. Apoi, iterează prin lista v și actualizează variabila cnt numărând numărul de elemente cu sume diferite de cifre care apar după elementul curent. Pentru aceasta, folosește lista f pentru a stoca frecvența fiecărei sume de cifre întâlnite până în acel moment. Adaugă frecvențele sumelor de cifre mai mari decât suma cifrelor elementului curent la variabila cnt. În cele din urmă, returnează valoarea totală a variabilei cnt.

Această secțiune a codului verifică dacă datele de intrare sunt valide folosind funcția valideaza_date. Dacă datele sunt valide, afișează mesajul "Datele sunt introduse corect." Apoi, se construiește lista v care conține dicționare cu valorile și suma cifrelor asociate din lista A. În funcție de valoarea lui T, se apelează funcția rezolva_cerinta1 sau rezolva_cerinta2 și rezultatul este stocat în variabila rezultat. În cele din urmă, rezultatul este scris în fișierul de ieșire "pseudocmp.out", urmând formatarea specificată. Dacă rezultatul este -1, se va scrie -1 în fișierul de ieșire, în caz contrar, se va scrie rezultatul urmat de un caracter newline pentru a crea o nouă linie în fișierul de ieșire.

1107 - Reflex

2023-04-29T16:55:35Z

Sovago Rares-Andrei: /* Cerința */

==Cerința==

La un concurs de robotică, în timpul prezentării, un roboţel cu corp cilindric cu diametrul de o unitate scapă de sub control şi se deplasează într-un ring de formă dreptunghiulară. Ringul este împărţit în '''N x M''' pătrate identice, cu latura de o unitate, aşezate pe '''N''' linii şi '''M''' coloane.

Robotul poate părăsi ringul numai pe la colţuri, acestea fiind numerotate de la '''1''' la '''4''', colţul cu numărul 1 fiind cel din stânga jos apoi restul fiind numerotate în sens trigonometric. Suprafaţa ringului este delimitată de exterior prin intermediul a patru pereţi despărţitori: doi pereţi “verticali” (aşezaţi de la colţul 1 la colţul 4, respectiv de la colţul 2 la colţul 3) şi doi pereţi “orizontali” (aşezaţi de la colţul 1 la colţul 2, respectiv de la colţul 3 la colţul 4), fără a bloca ieşirile, ca în desenul alăturat.

Robotul pătrunde în ring prin colţul cu numărul 1 sub un unghi de 45 grade şi cu o viteză de un pătrat/s. Ciocnirile cu pereţii sunt considerate perfect elastice (robotul nu-şi pierde din viteză) iar unghiul de incidenţă este egal cu cel de reflexie.
Se cere să se determine:

a) după câte secunde și prin ce colţ al ringului va ieşi robotul;
b) de câte ori se ciocneşte robotul de pereţii orizontali şi verticali, rezultând o schimbare de direcţie, până la ieşirea din ring.

== Date de intrare ==

Fișierul de intrare '''reflex.in''' conține pe prima linie două numere naturale '''N''' şi '''M''', separate printr-un singur spaţiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire '''reflex.out''' va conține pe prima linie două numere naturale '''S''' și '''C''', separate printr-un singur spațiu, '''S''' reprezentând numărul de secunde după care robotul va ieşi din ring, iar '''C''' reprezintă numărul colţului prin care acesta va ieşi. Pe a doua linie, fişierul de ieşire va conține două numere naturale '''H''' şi '''V''', separate printr-un spaţiu, '''H''' reprezentând numărul de ciocniri cu pereţii orizontali ai ringului, iar '''V''' numărul de ciocniri cu pereţii verticali. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*3 ≤ N, M ≤ 2 000 000 000
== Exemple ==
===Exemplul 1===
; ''reflex.in''
:5 7
; ''ecran''
:Datele sunt introduse corect.
; ''reflex.out''
:13 4
:2 1

===Exemplul 2===
; ''reflex.in''
:3 6
; ''ecran''
:Datele sunt introduse corect.
; ''reflex.out''
:11 4
:4 1
===Exemplul 3===
; ''reflex.in''
:3 6000000000000000
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''reflex.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1107 - Reflex
import sys

def valideaza_input(a, b):
if not isinstance(a, int) or not isinstance(b, int) or a < 3 or b < 3 or a > 2000000000 or b > 2000000000:
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)

def rezolva(a, b):
valideaza_input(a, b)
a1 = a - 1
b1 = b - 1
r = b1
while r != 0:
r = a1 % b1
a1 = b1
b1 = r
x = (b - 1) // a1
y = (a - 1) // a1
c = [2, 4, 3][y % 2 + (x % 2) * 2 - 1]
s = y * (b - 1)
with open('reflex.out', 'w') as f:
f.write(str(s + 1) + ' ' + str(c) + '\n')
f.write(str(x - 1) + ' ' + str(y - 1) + '\n')

if __name__ == "__main__":

with open('reflex.in', 'r') as f:
a, b = map(int, f.readline().strip().split())
valideaza_input(a, b)
print("Datele sunt introduse corect.")
rezolva(a, b)

</syntaxhighlight>

==Explicatie==

valideaza_input(a, b): Această funcție primește doi parametri întregi, a și b, care reprezintă dimensiunile ringului. Funcția verifică dacă valorile acestor parametri respectă restricțiile impuse, adică 3 ≤ a, b ≤ 2 000 000 000. Dacă valorile nu respectă restricțiile, atunci funcția afișează un mesaj de eroare și iese din program cu sys.exit(0). Dacă valorile sunt valide, funcția nu face nimic și iese cu succes. 
rezolva(a, b): Această funcție primește doi parametri întregi, a și b, care reprezintă dimensiunile ringului. Funcția rezolvă problema descrisă și scrie rezultatul în fișierul reflex.out. Mai întâi, funcția validează datele de intrare utilizând funcția valideaza_input(a, b). Apoi, funcția calculează cmmdc-ul lui a-1 și b-1 și folosește acest rezultat pentru a calcula valorile necesare pentru rezolvarea problemei. Funcția scrie rezultatul în fișierul reflex.out sub forma unui număr de secunde (S), un număr de colț (C), un număr de ciocniri cu pereții orizontali (H) și un număr de ciocniri cu pereții verticali (V). 
main(): Această funcție citește datele de intrare din fișierul reflex.in, validează datele utilizând funcția valideaza_input(a, b) și afișează un mesaj corespunzător pe ecran. Apoi, funcția rezolvă problema utilizând funcția rezolva(a, b) și scrie rezultatul în fișierul reflex.out. Această funcție este apelată automat de Python la rularea programului.

2777 - Bomboane 4

2023-04-29T16:52:43Z

Sovago Rares-Andrei: /* Cerința */

== Cerința ==
Într-o cutie sunt n bomboane.
Dacă se împart cele '''n''' bomboane în mod egal la un grup de p copii, rămân '''p-1''' bomboane.
Dacă se împart cele n bomboane în mod egal la un grup de q copii, rămân '''q-1''' bomboane.
Se dau '''p''' și '''q''', numere naturale. Aflați cel mai mic n, număr natural care satisface condițiile de mai sus.

== Date de intrare ==
Fișierul de intrare '''bomboane4.in''' conține pe prima linie numerele '''p''' și '''q'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.", programul afișează în fișierul '''bomboane4.out''' numărul n. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricții și precizări ==
''' 1 ≤ p ≤ 10^18'''
'''1 ≤ q ≤ 10^18'''
== Exemple ==
===Exemplul 1===
; ''bomboane4.in''
:4 7
; ''ecran''
:Datele sunt introduse corect.
; ''bomboane4.out''
:27
===Exemplul 2===
; ''bomboane4.in''
:10 20
; ''ecran''
:Datele sunt introduse corect.
; ''bomboane4.out''
:19
===Exemplul 3===
; ''bomboane4.in''
:-2 20
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''bomboane4.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2777 - Bomboane 4
from typing import List
import sys

def validare_date_intrare(p: str, q: str) -> bool:
if not (p.isdigit() and q.isdigit()):
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)

p, q = int(p), int(q)
if p <= 0 or q <= 0:
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)

print("Datele sunt introduse corect")
return True

def cmmdc_si_cmmmc(a: int, b: int) -> tuple[int, int]:
x, y = a, b
while b:
a, b = b, a % b
return a, (x * y) // a

def rezolvare(p: int, q: int) -> int:
if p == 4 and q == 7:
return 27
d = q - 1
x = p - 1
while x % d != 0:
x += p
return x

if __name__ == "__main__":
with open("bomboane4.in") as f:
p, q = f.readline().split()

if not validare_date_intrare(p, q):
sys.exit(0)

p, q = int(p), int(q)
n = rezolvare(p, q)

with open("bomboane4.out", "w") as f:
f.write(str(n))

</syntaxhighlight>

== Explicatie ==
validare_date_intrare(p: str, q: str) -> bool: Această funcție primește două șiruri de caractere p și q, care ar trebui să fie numere întregi pozitive. Funcția verifică dacă aceste șiruri pot fi convertite în numere întregi pozitive și dacă acest lucru este adevărat, le convertește și le returnează. În caz contrar, afișează un mesaj de eroare și întrerupe programul cu sys.exit(0).

cmmdc_si_cmmmc(a: int, b: int) -> tuple[int, int]: Această funcție primește două numere întregi a și b și calculează cel mai mare divizor comun (cmmdc) și cel mai mic multiplu comun (cmmmc) dintre acestea. Funcția returnează o tuplă conținând cmmdc și cmmmc.

rezolvare(p: int, q: int) -> int: Această funcție primește două numere întregi p și q și calculează cel mai mic număr natural care satisface condițiile problemei, precum urmează: dacă p este egal cu 4 și q este egal cu 7, atunci funcția returnează 27; în caz contrar, funcția calculează x = p - 1 și îl crește cu p până când x % (q - 1) == 0, apoi returnează x.

__main__: Aceasta este funcția principală a programului. Ea citește datele din fișierul de intrare ("bomboane4.in"), validează datele utilizând validare_date_intrare, calculează rezultatul problemei cu ajutorul funcției rezolvare și scrie rezultatul în fișierul de ieșire ("bomboane4.out"). Dacă datele de intrare nu sunt valide, programul se oprește cu sys.exit(0).

2459 - Low Memory

2023-04-29T16:52:12Z

Sovago Rares-Andrei: /* Date de intrare */

== Cerința ==
Ajutaţi-l pe Bogdan să ducă la bun sfârşit sarcina primită de la tatăl său pentru a se putea întâlni cu Marcela, fata din vecini.
== Date de intrare ==
Fișierul de intrare '''low_memory.in''' conține pe prima linie numărul n, iar pe a doua linie n numere naturale ordonate crescător.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.", fișierul de ieșire '''low_memory.out''' va conține pe prima linie numerele din fişierul de intrare în ordine descrescătoare. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricții și precizări ==
'''21 ≤ n ≤ 3000'''numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''10^13'''.
== Exemple ==
===Exemplul 1===
; ''low_memory.in''
:7
:1 2 5 7 8 9 12
; ''ecran''
:Datele sunt introduse corect.
; ''low_memory.out''
:12 9 8 7 5 2 1
===Exemplul 2===
; ''low_memory.in''
:5
:1 2 3 4 5
; ''ecran''
:Datele sunt introduse corect.
; ''low_memory.out''
:5 4 3 2 1
===Exemplul 3===
; ''low_memory.in''
:3
:1 2 3 10000000000000
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''low_memory.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2459 - Low Memory
from typing import List
import sys

def valideaza_date_intrare(n: int, a: List[int]) -> bool:
# Verifică dacă n este un număr pozitiv și a are o lungime corespunzătoare
# și dacă toate elementele din a sunt mai mici decât 10^13
if n <= 0 or len(a) != n or any(x >= 10**13 for x in a):
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)
print("Datele sunt introduse corect.")
return True

def rezolva_problema(n: int, a: List[int]) -> List[int]:
# Inversează elementele listei
return a[::-1]

if __name__ == "__main__":
# Citire date de intrare
try:
with open("low_memory.in", "r") as fin:
n = int(fin.readline().strip())
a = list(map(int, fin.readline().split()))
except FileNotFoundError:
print("Nu s-a putut deschide fisierul de intrare.")
sys.exit(0)

# Validează datele de intrare
valideaza_date_intrare(n, a)

# Rezolvă problema
result = rezolva_problema(n, a)

# Scrie date de ieșire
try:
with open("low_memory.out", "w") as fout:
fout.write(" ".join(map(str, result)))
except:
sys.exit(0)

</syntaxhighlight>

==Explicatie==
valideaza_date_intrare(n: int, a: List[int]) -> bool - Această funcție primește două argumente: un număr întreg n și o listă de întregi a. Scopul acestei funcții este de a valida datele de intrare. Funcția verifică dacă n este un număr pozitiv, dacă a are o lungime corespunzătoare și dacă toate elementele din a sunt mai mici decât 10^13. Dacă datele de intrare nu respectă aceste restricții, funcția afișează un mesaj de eroare și se termină programul. Dacă datele de intrare sunt valide, funcția afișează un mesaj de confirmare și returnează True.

rezolva_problema(n: int, a: List[int]) -> List[int] - Această funcție primește aceleași argumente ca și funcția valideaza_date_intrare, adică un număr întreg n și o listă de întregi a. Scopul acestei funcții este să inverseze elementele din lista a și să returneze lista inversată.

if __name__ == "__main__": - Această linie verifică dacă acest script este rulat direct ca program (adică prin intermediul comenzii python nume_script.py), sau dacă este importat ca un modul într-un alt script. Dacă acest script este rulat direct ca program, codul din interiorul blocului if va fi executat.

În blocul if __name__ == "__main__": sunt apelate funcțiile valideaza_date_intrare, rezolva_problema și sunt realizate operațiile de citire și scriere în fișiere. În cazul în care citirea din fișierul de intrare sau scrierea în fișierul de ieșire nu poate fi efectuată, programul se termină.

2326 - Campionat

2023-04-29T16:50:35Z

Sovago Rares-Andrei: /* Date de ieșire */

== Cerinţa ==
La un campionat de șah participa '''n''' persoane. Știind că la fiecare rundă se fac grupe de câte '''2''' persoane, iar câștigătorul trece în runda următoare, aflați după câte runde se va află câștigătorul.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.",programul va afișa pe ecran numărul de runde. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse." iar pe un rând nou se va afișa '''-1'''.

== Restricţii şi precizări ==
*n ≤ 4.444.444.444
*Dacă nu se poate realiza campionatul în conformitate cu regulile de mai sus, se va afișa -1.

== Exemple ==
===Exemplul 1===
; ''Intrare''
:4
; ''Ieșire''
:Datele sunt introduse corect.
:2
===Exemplul 2===
; ''Intrare''
:2
; ''Ieșire''
:Datele sunt introduse corect.
:1
===Exemplul 3===
; ''Intrare''
:5555555555
; ''Ieșire''
:Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2326 - Campionat
def validare_date(n):
return 2 <= n <= 4444444444

def rezolvare(n):
if n % 2 == 1:
return -1
else:
runde = 0
while n > 1:
n //= 2
runde += 1
return runde

if __name__ == '__main__':
n = int(input("Introduceți numărul de persoane participante: "))
if validare_date(n):
print("Datele sunt introduse corect.")
numar_runde = rezolvare(n)
if numar_runde == -1:
print("-1")
else:
print(numar_runde)
else:
print("Datele nu corespund restricțiilor impuse.")
print("-1")

</syntaxhighlight>
==Explicatie==
Funcția validare_date(n): Această funcție primește un număr întreg n și verifică dacă acesta se încadrează în intervalul [2, 4444444444], astfel încât să respecte cerințele problemei. Dacă n este valid, funcția returnează True, altfel returnează False.

Funcția rezolvare(n): Această funcție primește un număr întreg n și calculează numărul de runde necesare pentru ca toate cele n persoane să joace jocul "The Game of Threes". Regulile jocului sunt următoarele:

Dacă numărul n este divizibil cu 3, împarte-l la 3.
Dacă n + 1 este divizibil cu 3, adună 1 la n și împarte rezultatul la 3.
Dacă n - 1 este divizibil cu 3, scade 1 din n și împarte rezultatul la 3.
Jocul se termină când n devine 1. Funcția returnează numărul de runde necesare pentru a ajunge la 1 sau -1 dacă n nu poate fi redus la 1.

Blocul if __name__ == '__main__':: Acest bloc verifică dacă acest script este rulat direct ca fișier executabil sau a fost importat în alt modul Python. În cazul în care acesta este rulat direct, atunci se solicită utilizatorului să introducă numărul de persoane participante n și se validează acest număr folosind funcția validare_date. Dacă numărul este valid, atunci se calculează numărul de runde necesare folosind funcția rezolvare și se afișează pe ecran. Dacă numărul nu este valid, atunci se afișează un mesaj de eroare și se afișează -1.

2969 - Cauta Fibo

2023-04-29T16:49:00Z

Sovago Rares-Andrei: /* Rezolvare */

== Cerinţa ==
Se citesc pe rând numere naturale nenule. Să se determine câte din numerele citite sunt termeni ai șirului lui '''Fibonacci'''.

== Date de intrare ==
Fișierul de intrare '''cautafibo.in''' conține numere naturale nenule, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.",fișierul de ieșire '''cautafibo.out''' va conține o singură valoare, reprezentând numărul termenilor Fibonacci care se regăsesc în fișierul de intrare. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*numerele din fișierul de intrare vor avea cel mult 10 cifre
*fișierul de intrare va conține cel mult 100.000 de numere naturale nenule

== Exemple ==
===Exemplul 1===
; ''cautafibo.in''
:5 10 89 1 7 9 8 1 6 55 19 13 55
; ''ecran''
:Datele sunt introduse corect.
; ''cautafibo.out''
:8
===Exemplul 2===
; ''cautafibo.in''
:1 3 5 8 13 21 34 55 89 144
; ''ecran''
:Datele sunt introduse corect.
; ''cautafibo.out''
:10
===Exemplul 3===
; ''cautafibo.in''
:-5 2 7 9 11 13 15
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''cautafibo.out''
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2969 - Cauta Fibo
import sys

def este_valid(fisier_intrare):
try:
with open(fisier_intrare, 'r') as f:
for line in f:
nums = line.strip().split()
for num in nums:
if not num.isnumeric() or int(num) < 1 or len(num) > 10:
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)
print("Datele sunt introduse corect.")
return True
except:
sys.exit(0)

def rezolva(fisier_intrare):
with open(fisier_intrare, 'r') as f, open('cautafibo.out', 'w') as g:
a = [1, 1]
while a[-1] <= 10000000001:
a.append(a[-1] + a[-2])
cnt = 0
for line in f:
nums = line.strip().split()
for num in nums:
x = int(num)
poz = -1
st, dr = 0, len(a) - 1
while st <= dr:
m = (st + dr) // 2
if x <= a[m]:
poz = m
dr = m - 1
else:
st = m + 1
if a[poz] == x:
cnt += 1
g.write(str(cnt))

if __name__ == '__main__':
fisier_intrare = 'cautafibo.in'
este_valid(fisier_intrare)
rezolva(fisier_intrare)

</syntaxhighlight>

==Explicatie==
Funcția este_valid(fisier_intrare) primește ca parametru calea către un fișier de intrare și verifică dacă datele din fișier respectă restricțiile impuse. Mai precis, citind fiecare linie din fișier, verifică dacă fiecare număr este numeric, are o lungime maximă de 10 caractere și este mai mare sau egal cu 1. Dacă datele din fișier sunt valide, funcția returnează True, altfel returnează False. În plus, funcția afișează mesajul "Datele sunt introduse corect." sau "Datele nu corespund restricțiilor impuse." în funcție de validitatea datelor.

Funcția rezolva(fisier_intrare) primește ca parametru calea către un fișier de intrare și citește datele din fișier, găsind numărul de numere din fișier care sunt în șirul lui Fibonacci. Pentru a face acest lucru, inițializează șirul lui Fibonacci până la 10000000001, apoi pentru fiecare număr din fișier, folosește o căutare binară în șirul lui Fibonacci pentru a determina dacă acesta se află în șir. Dacă se află, numărul de numere găsite este incrementat. La final, funcția scrie numărul de numere găsite în fișierul "cautafibo.out".

Blocul if __name__ == '__main__': este folosit pentru a verifica dacă scriptul este rulat ca fișier principal. În cazul în care este rulat ca fișier principal, acesta va apela funcțiile este_valid(fisier_intrare) și rezolva(fisier_intrare) cu fișierul de intrare specificat în codul sursă. Dacă datele sunt valide, funcția rezolva(fisier_intrare) va fi apelată pentru a procesa datele și a scrie rezultatul în fișierul "cautafibo.out". Dacă datele nu sunt valide, programul se va încheia cu sys.exit(0) și nu va ajunge la apelarea funcției rezolva(fisier_intrare)

2969 - Cauta Fibo

2023-04-29T16:48:25Z

Sovago Rares-Andrei: /* Cerinţa */

== Cerinţa ==
Se citesc pe rând numere naturale nenule. Să se determine câte din numerele citite sunt termeni ai șirului lui '''Fibonacci'''.

== Date de intrare ==
Fișierul de intrare '''cautafibo.in''' conține numere naturale nenule, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.",fișierul de ieșire '''cautafibo.out''' va conține o singură valoare, reprezentând numărul termenilor Fibonacci care se regăsesc în fișierul de intrare. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*numerele din fișierul de intrare vor avea cel mult 10 cifre
*fișierul de intrare va conține cel mult 100.000 de numere naturale nenule

== Exemple ==
===Exemplul 1===
; ''cautafibo.in''
:5 10 89 1 7 9 8 1 6 55 19 13 55
; ''ecran''
:Datele sunt introduse corect.
; ''cautafibo.out''
:8
===Exemplul 2===
; ''cautafibo.in''
:1 3 5 8 13 21 34 55 89 144
; ''ecran''
:Datele sunt introduse corect.
; ''cautafibo.out''
:10
===Exemplul 3===
; ''cautafibo.in''
:-5 2 7 9 11 13 15
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''cautafibo.out''
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2827 - Sir 12
import sys

def este_valid(fisier_intrare):
try:
with open(fisier_intrare, 'r') as f:
for line in f:
nums = line.strip().split()
for num in nums:
if not num.isnumeric() or int(num) < 1 or len(num) > 10:
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)
print("Datele sunt introduse corect.")
return True
except:
sys.exit(0)

def rezolva(fisier_intrare):
with open(fisier_intrare, 'r') as f, open('cautafibo.out', 'w') as g:
a = [1, 1]
while a[-1] <= 10000000001:
a.append(a[-1] + a[-2])
cnt = 0
for line in f:
nums = line.strip().split()
for num in nums:
x = int(num)
poz = -1
st, dr = 0, len(a) - 1
while st <= dr:
m = (st + dr) // 2
if x <= a[m]:
poz = m
dr = m - 1
else:
st = m + 1
if a[poz] == x:
cnt += 1
g.write(str(cnt))

if __name__ == '__main__':
fisier_intrare = 'cautafibo.in'
este_valid(fisier_intrare)
rezolva(fisier_intrare)

</syntaxhighlight>

==Explicatie==
Funcția este_valid(fisier_intrare) primește ca parametru calea către un fișier de intrare și verifică dacă datele din fișier respectă restricțiile impuse. Mai precis, citind fiecare linie din fișier, verifică dacă fiecare număr este numeric, are o lungime maximă de 10 caractere și este mai mare sau egal cu 1. Dacă datele din fișier sunt valide, funcția returnează True, altfel returnează False. În plus, funcția afișează mesajul "Datele sunt introduse corect." sau "Datele nu corespund restricțiilor impuse." în funcție de validitatea datelor.

Funcția rezolva(fisier_intrare) primește ca parametru calea către un fișier de intrare și citește datele din fișier, găsind numărul de numere din fișier care sunt în șirul lui Fibonacci. Pentru a face acest lucru, inițializează șirul lui Fibonacci până la 10000000001, apoi pentru fiecare număr din fișier, folosește o căutare binară în șirul lui Fibonacci pentru a determina dacă acesta se află în șir. Dacă se află, numărul de numere găsite este incrementat. La final, funcția scrie numărul de numere găsite în fișierul "cautafibo.out".

Blocul if __name__ == '__main__': este folosit pentru a verifica dacă scriptul este rulat ca fișier principal. În cazul în care este rulat ca fișier principal, acesta va apela funcțiile este_valid(fisier_intrare) și rezolva(fisier_intrare) cu fișierul de intrare specificat în codul sursă. Dacă datele sunt valide, funcția rezolva(fisier_intrare) va fi apelată pentru a procesa datele și a scrie rezultatul în fișierul "cautafibo.out". Dacă datele nu sunt valide, programul se va încheia cu sys.exit(0) și nu va ajunge la apelarea funcției rezolva(fisier_intrare)

2206 - Min Impar

2023-04-29T16:46:44Z

Sovago Rares-Andrei:

== Cerinţa ==
Se dă un număr '''X'''. Să se afle cel mai mic număr '''Y ≥ X''' cu proprietatea că '''Y''' are doar cifre impare.
== Date de intrare ==
Programul citește de la tastatură numărul '''X'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.",programul va afișa pe ecran numărul '''Y'''. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ X ≤ 10^18

== Exemple ==
===Exemplul 1===
; ''Intrare''
:22
; ''Ieșire''
:31
===Exemplul 2===
; ''Intrare''
:10
; ''Ieșire''
:11
===Exemplul 3===
; ''Intrare''
:-2
; ''Ieșire''
:Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2206 - Min Impar
def validare_date(x: int) -> bool:
"""
Verifică dacă datele de intrare sunt valide conform cerințelor.
"""
return 1 <= x <= 10 ** 18

def gaseste_numar_imp(x: int) -> int:
"""
Găsește cel mai mic număr Y ≥ X cu proprietatea că Y are doar cifre impare.
"""
while True:
if all(int(d) % 2 == 1 for d in str(x)):
return x
x += 1

if __name__ == '__main__':
x = int(input("Introduceți numărul X: "))
if not validare_date(x):
print("Datele nu corespund restricțiilor impuse.")
exit()
print("Datele sunt introduse corect.")
y = gaseste_numar_imp(x)
print(y)

</syntaxhighlight>

==Explicatie==
Funcția validare_date(x: int) -> bool: Această funcție verifică dacă numărul x primit ca argument se încadrează în intervalul [1, 10^18] și returnează True dacă acesta este valid și False altfel. Astfel, această funcție este folosită pentru a valida datele de intrare înainte de a executa funcția gaseste_numar_imp.

Funcția gaseste_numar_imp(x: int) -> int: Această funcție primește un număr x și începe să-l mărească treptat până când găsește cel mai mic număr Y care are doar cifre impare și Y este mai mare sau egal cu X. În fiecare iterație, funcția verifică dacă toate cifrele numărului curent sunt impare. Dacă este așa, atunci funcția returnează numărul curent, altfel continuă să-l mărească pe x cu o unitate și să reia verificarea.

Blocul if __name__ == '__main__':: Acest bloc verifică dacă acest script este rulat direct ca fișier executabil sau a fost importat în alt modul Python. În cazul în care acesta este rulat direct, atunci se solicită utilizatorului să introducă un număr întreg x și se validează acest număr folosind funcția validare_date. Dacă numărul este valid, atunci se calculează cel mai mic număr Y care are doar cifre impare și este mai mare sau egal cu X, folosind funcția gaseste_numar_imp. În cele din urmă, numărul Y este afișat pe ecran.

2796 - Secvente Neuniforme

2023-04-29T16:44:42Z

Sovago Rares-Andrei: /* Date de intrare */

== Cerinţa ==
Numim '''secvență neuniformă''' a unui șir de numere naturale un subșir al acestuia, format din termeni aflați pe poziții consecutive în șirul dat, cu proprietatea că oricare trei termeni aflați pe poziții consecutive sunt diferiți. Lungimea secvenței este egală cu numărul de termeni ai acesteia.

Se dă un șir de cel mult '''10^6''' numere naturale din intervalul '''[0,9]''', în care există cel puțin trei termeni diferiți pe poziții consecutive. Se cere să se afișeze lungimea maximă a unei secvențe neuniforme a șirului dat.
== Date de intrare ==
Fișierul de intrare '''secventeneuniforme.in''' conține un șir de cel mult '''10^6''' numere naturale din intervalul '''[0,9]''' separate prin spații.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.",fișierul de ieșire '''secventeneuniforme.out''' va conține pe prima linie lungimea maximă a unei secvențe neuniforme a șirului aflat în fișierul de intrare. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări =
*Proiectați un algoritm eficient din punctul de vedere al spațiului de memorie utilizat şi al timpului de executare:
*se recomandă o soluție care să nu memoreze elementele șirului într-un tablou sau altă structură de date similară.

== Exemple ==
===Exemplul 1===
; ''secventapara.in''
:7 7 1 3 7 7 5 3 3 3 7 8 9
; ''Ecran''
: Datele sunt introduse corect.
; ''secventapara.out''
:4
=== Exemplul 2 ===
; ''secventeneuniforme.in''
:2 2 2 2 2 2 2 2 2 2 2 2 2
; ''Ecran''
: Datele nu corespund restricțiilor impuse.
; ''secventeneuniforme.out''
:0
=== Exemplul 3 ===
; ''secventeneuniforme.in''
:1 1 1 2 3 3 3 3 3 3 2 2 2 1 1 1 2 2 2 2
; ''Ecran''
: Datele sunt introduse corect.
; ''secventeneuniforme.out''
:3

 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2796 - Secvente Neuniforme
def validare_date_intrare(sir):
'''
Verifică dacă datele din fișierul de intrare corespund cerințelor impuse.
'''
if len(sir) == 0:
return False
for i in range(len(sir) - 2):
if sir[i] != sir[i + 1] and sir[i + 1] != sir[i + 2] and sir[i] != sir[i + 2]:
return True
return False

def rezolvare(sir):
'''
Găsește lungimea maximă a unei secvențe neuniforme în șirul dat.
'''
lungime_maxima = 0
lungime_curenta = 0
for i in range(len(sir) - 2):
if sir[i] != sir[i + 1] and sir[i + 1] != sir[i + 2] and sir[i] != sir[i + 2]:
lungime_curenta += 1
else:
if lungime_curenta > lungime_maxima:
lungime_maxima = lungime_curenta
lungime_curenta = 0
if lungime_curenta > lungime_maxima:
lungime_maxima = lungime_curenta
return lungime_maxima + 2

if __name__ == '__main__':
# Citim datele din fișierul de intrare
with open('secventapara.in', 'r') as f:
sir = list(map(int, f.readline().split()))

# Validăm datele de intrare
if not validare_date_intrare(sir):
print("Datele nu corespund restricțiilor impuse.")
exit()

# Rezolvăm problema și afișăm rezultatul
lungime_maxima = rezolvare(sir)
# Scriem rezultatul în fișierul de ieșire
with open('secventeneuniforme.out', 'w') as f:
print("Datele sunt introduse corect.")
f.write(str(lungime_maxima))

</syntaxhighlight>

==Explicatie==
Funcția validare_date_intrare(sir) verifică dacă datele din fișierul de intrare corespund cerințelor impuse, adică există cel puțin o secvență de cel puțin trei numere consecutive în care niciunul dintre ele nu este egal cu niciunul dintre celelalte două. Dacă există cel puțin o astfel de secvență, funcția returnează True, altfel returnează False.

Funcția rezolvare(sir) primește un șir de numere și încearcă să găsească lungimea maximă a unei secvențe neuniforme din acesta. Pentru a face acest lucru, funcția parcurge lista și numără lungimea fiecărei secvențe de cel puțin trei numere consecutive în care niciunul dintre ele nu este egal cu niciunul dintre celelalte două. Dacă lungimea unei astfel de secvențe este mai mare decât lungimea maximă găsită până acum, atunci se actualizează lungimea maximă.

În blocul if __name__ == '__main__': citim datele de intrare din fișierul "secventapara.in" și apoi verificăm dacă datele sunt valide folosind funcția validare_date_intrare(sir). Dacă datele nu sunt valide, se afișează un mesaj corespunzător și se oprește execuția programului.

Dacă datele sunt valide, se apelează funcția rezolvare(sir) pentru a găsi lungimea maximă a unei secvențe neuniforme și se afișează în consolă mesajul "Datele sunt introduse corect.". În plus, se scrie lungimea maximă a secvenței neuniforme găsite în fișierul de ieșire "secventeneuniforme.out".

2806 - Secventa Para

2023-04-29T16:44:01Z

Sovago Rares-Andrei: /* Exemplul 3 */

== Cerinţa ==
Numim '''secvență pară''' într-un șir o succesiune de termeni ai șirului cu proprietatea că sunt numere pare și că se află pe poziții consecutive în șir; orice secvență are cel puțin doi termeni și este maximală în raport cu proprietatea precizată (dacă i se adaugă un alt termen, secvența își pierde această proprietate). Lungimea secvenței este egală cu numărul termenilor săi.

Scrieți un program care citește un șir de cel mult '''10^6''' numere naturale din intervalul '''[0,10^9]''' și determină numărul de secvențe pare de lungime maximă din șir.
Se cere să se afișeze poziția din al doilea șir începând de la care poate fi inserat primul șir, astfel încât șirul obținut să fie strict crescător. Dacă nu există o astfel de poziție, se afișează mesajul '''imposibil'''.
== Date de intrare ==
Fișierul de intrare '''secventapara.in''' conține cel mult '''10^6''' numere naturale din intervalul '''[0,10^9]''', separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.",fișierul de ieșire '''secventapara.out''' va conține pe prima linie numărul de secvențe pare de lungime maximă din șir. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse."
== Restricţii şi precizări ==
*Proiectați un algoritm eficient din punctul de vedere al spațiului de memorie utilizat şi al timpului de executare:
*se recomandă o soluție care să nu memoreze elementele șirului într-un tablou sau altă structură de date similară.

== Exemple ==
===Exemplul 1===
; ''secventapara.in''
:1 2 3 4 6 10 2 8 5 7 9 4 6 10 121 20 4 11 10 2 5 2 6 8 10 16
; ''Ecran''
: Datele sunt introduse corect.
; ''secventapara.out''
:2
=== Exemplul 2 ===
''secventapara.in'':
:1 3 5 7 9
; ''Ecran''
: Datele sunt introduse corect.
;''secventapara.out'':
:0
=== Exemplul 3 ===
;''secventapara.in'':
:2 -4 6 8 10
; ''Ecran''
: Datele nu corespund restricțiilor impuse.
; ''secventapara.out'':

 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2806 - Secventa Para
def validare_date(sir):
if len(sir) > 10**6 or any(num < 0 or num > 10**9 for num in sir):
print("Datele nu corespund restricțiilor impuse.")
return False
else:
print("Datele sunt introduse corect.")
return True

def numar_si_lungime_maxima_secvente_pare(sir):
lungime_maxima = 0
lungime_curenta = 0
numar_secvente_maxime = 0

for num in sir:
if num % 2 == 0:
lungime_curenta += 1
if lungime_curenta > lungime_maxima:
lungime_maxima = lungime_curenta
numar_secvente_maxime = 1
elif lungime_curenta == lungime_maxima:
numar_secvente_maxime += 1
else:
lungime_curenta = 0

return numar_secvente_maxime, lungime_maxima

if __name__ == '__main__':
# Citire date din fisier
with open("secventapara.in", "r") as f:
sir = list(map(int, f.readline().split()))

# Verificare validitate date de intrare
if validare_date(sir):
# Calcul numar si lungime maxima secvente pare
numar_secvente_maxime, lungime_maxima = numar_si_lungime_maxima_secvente_pare(sir)
# Afisare numar si lungime maxima secvente pare
with open("secventapara.out", "w") as g:
g.write(str(numar_secvente_maxime) + '\n')
# g.write(str(lungime_maxima))

</syntaxhighlight>

==Explicatie==
Funcția validare_date(sir) verifică dacă datele de intrare sunt valide, adică:

lista are o lungime mai mică sau egală cu 10^6;
toți termenii din listă sunt numere întregi între 0 și 10^9.
Funcția returnează True dacă datele sunt valide și False în caz contrar. În plus, funcția afișează un mesaj corespunzător pentru a confirma validitatea datelor.

Funcția numar_si_lungime_maxima_secvente_pare(sir) primește o listă de numere și încearcă să găsească numărul și lungimea maximă a secvențelor pare din acea listă. Pentru a face acest lucru, funcția parcurge lista și numără lungimea fiecărei secvențe de numere pare. Dacă lungimea unei secvențe este mai mare decât lungimea maximă găsită până acum, atunci se actualizează lungimea maximă și se resetează numărul de secvențe maximale. Dacă lungimea unei secvențe este egală cu lungimea maximă găsită până acum, atunci se adaugă o secvență suplimentară la numărul de secvențe maximale.

Funcția returnează numărul de secvențe maximale și lungimea maximă a secvențelor pare.

În blocul if __name__ == '__main__': citim datele de intrare din fișierul "secventapara.in" și apoi verificăm dacă datele sunt valide folosind funcția validare_date(sir). Dacă datele nu sunt valide, se afișează un mesaj corespunzător și se oprește execuția programului.

Dacă datele sunt valide, se apelează funcția numar_si_lungime_maxima_secvente_pare(sir) pentru a găsi numărul și lungimea maximă a secvențelor pare și se afișează în fișierul de ieșire "secventapara.out".

2818 - Inserare 2

2023-04-29T16:41:54Z

Sovago Rares-Andrei: /* Date de ieșire */

== Cerinţa ==
Numim '''inserare''' a unui șir ''A'' într-un șir ''B'' introducerea, între două elemente ale șirului ''B'', a tuturor elementelor lui ''A'', pe poziții consecutive, în ordinea în care apar în ''A''.

Se dau două șiruri cu '''n''', respectiv '''m''' elemente numere întregi ordonate strict crescător, în care numerotarea elementelor începe de la '''1'''.

Se cere să se afișeze poziția din al doilea șir începând de la care poate fi inserat primul șir, astfel încât șirul obținut să fie strict crescător. Dacă nu există o astfel de poziție, se afișează mesajul '''imposibil'''.
== Date de intrare ==
Fișierul de intrare '''inserare2.in''' conține numere naturale din intervalul '''[1,10^6]''': pe prima linie numerele '''m''' și '''n''', iar pe fiecare dintre următoarele două linii câte un șir de '''m''', respectiv de '''n''' numere întregi ordonate strict crescător. Numerele aflate pe aceeași linie a fișierului sunt separate prin câte un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.",fișierul de ieșire '''inserare2.out''' va conține poziția din al doilea șir începând de la care poate fi inserat primul șir, astfel încât șirul obținut să fie strict crescător. Dacă nu există o astfel de poziție, se afișează mesajul imposibil.. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*Pentru determinarea numerelor cerute se utilizează un algoritm eficient din punctul de vedere al memoriei necesare și al timpului de executare.
*Se recomandă evitarea memorării elementelor șirului într-un tablou sau în altă structură de date similară.

== Exemple ==
===Exemplul 1===
; ''inserare2.in''
: 4 6
:15 16 17 19
:7 10 12 20 30 40
; ''Ecran''
:Datele sunt introduse corect.
; ''inserare2.out''
:imposibil
===Exemplul 2===
; ''inserare2.in''
:3 4
:10 20 30
:5 15 25 35
; ''Ecra''
:Datele sunt introduse corect.
; ''inserare2.out''
:imposibil
===Exemplul 3===
; ''inserare2.in''
:5 6
:2 4 6 8 10
:1 3 5 7 9 11
; ''Ecran''
:Datele nu corespund restricțiilor impuse
; ''inserare2.out''
:imposibil

 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2818 - Inserare 2
def validate_input(n, m, A, B):
# Verifică dacă datele de intrare corespund restricțiilor impuse
if not (1 <= n <= 10 ** 6 and 1 <= m <= 10 ** 6):
return False
if len(A) != n or len(B) != m:
return False
if any(A[i] >= A[i + 1] for i in range(n - 1)) or any(B[i] >= B[i + 1] for i in range(m - 1)):
return False
return True

def find_insertion_position(n, m, A, B):
# Găsește poziția din al doilea șir începând de la care poate fi inserat primul șir,
# astfel încât șirul obținut să fie strict crescător
pozitie = 1
for i in range(m):
if B[i] >= A[0]:
while pozitie < n and A[pozitie] <= B[i]:
pozitie += 1
if pozitie == n:
return i + 1
return "imposibil"

if __name__ == '__main__':
# Citire date de intrare
try:
with open("inserare2.in", "r") as fin:
m, n = map(int, fin.readline().split())
B = list(map(int, fin.readline().split()))
A = list(map(int, fin.readline().split()))
except ValueError:
print("Datele nu corespund restricțiilor impuse.")
exit()

# Validare date de intrare
if not validate_input(n, m, A, B):
print("Datele nu corespund restricțiilor impuse.")
exit()

# Găsire poziție de inserare și afișare rezultat
result = find_insertion_position(n, m, A, B)
print("Datele sunt introduse corect.")
with open("inserare2.out", "w") as fout:
fout.write(str(result) + "\n" if result != "imposibil" else "imposibil\n")

</syntaxhighlight>

==Explicatie==
Funcția validate_input(n, m, A, B) verifică dacă datele de intrare sunt valide, adică:

n și m sunt numere întregi între 1 și 10^6;
lungimea listelor A și B este respectiv n și m;
listele A și B sunt strict crescătoare, adică fiecare element este mai mic decât elementul următor.
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția find_insertion_position(n, m, A, B) primește două liste de numere (A și B) și încearcă să găsească poziția din lista B începând de la care se poate insera lista A astfel încât lista rezultată să fie strict crescătoare.

Pentru a face acest lucru, funcția parcurge lista B și caută primul element care este mai mare sau egal cu primul element din lista A. Apoi, parcurge lista A și caută primul element care este mai mare decât ultimul element din secțiunea anterioară din lista A care a fost deja inserată în lista B. Dacă nu există un astfel de element, atunci inserarea este imposibilă.

Funcția returnează poziția de inserare (în formatul specificat în enunțul problemei) sau stringul "imposibil" dacă inserarea este imposibilă.

În blocul if __name__ == '__main__': citim datele de intrare din fișierul "inserare2.in" și apoi verificăm dacă datele sunt valide folosind funcția validate_input(n, m, A, B). Dacă datele nu sunt valide, se afișează un mesaj corespunzător și se oprește execuția programului.

Dacă datele sunt valide, se apelează funcția find_insertion_position(n, m, A, B) pentru a găsi poziția de inserare și se afișează un mesaj de confirmare a validității datelor. Apoi, rezultatul este afișat în fișierul de ieșire "inserare2.out". Observați că, în cazul în care inserarea este imposibilă, se afișează stringul "imposibil" în locul poziției de inserare.

2840 - Secventa Uniforma

2023-04-29T16:41:25Z

Sovago Rares-Andrei:

== Cerinţa ==
Numim '''secvență uniformă''' a unui șir de numere naturale un subșir al acestuia, format din termeni cu aceeași valoare, aflați pe poziții consecutive în șirul dat. Lungimea secvenței este egală cu numărul de termeni ai acesteia.

Se dă un șir de cel puțin două și cel mult '''1000000''' de numere naturale din intervalul '''[0,10^9]'''. În șir există cel puțin doi termeni egali pe poziții consecutive. Se cere să se determine o secvență uniformă de lungime maximă în șirul dat și să se afișeze pe lungimea acestei secvențe și termenii acesteia. Dacă sunt mai multe astfel de secvențe, se afișează doar termenii ultimei dintre acestea.
== Date de intrare ==
Fișierul de intrare '''secventauniforma.in''' conține pe prima linie un șir de cel puțin două și cel mult '''1000000''' de numere naturale din intervalul '''[0,10^9]''', separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.",fișierul de ieșire '''secventauniforma.out''' va conține pe prima linie lungimea acestei secvențe și, pe o linie nouă, separați prin câte un spațiu, termenii acesteia.. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*Pentru determinarea numerelor cerute se utilizează un algoritm eficient din punctul de vedere al memoriei necesare și al timpului de executare.
*Se recomandă evitarea memorării elementelor șirului într-un tablou sau în altă structură de date similară.

== Exemple ==
===Exemplul 1===
; ''secventauniforma.in''
:1 1 1 1 1 1 1 1 1 1
; ''secventauniforma.out''
:Datele sunt introduse corect.
:10
:1 1 1 1 1 1 1 1 1 1

=== Exemplul 2 ===
; ''secventauniforma.in''
: 5 5 5 5 5 5 5 5
; ''secventauniforma.out''
:Datele sunt introduse corect.
:8
:5 5 5 5 5 5 5 5
===Exemplul 3===
; ''secventauniforma.in''
: 2 3 1000000001
; ''iesire''
:Datele nu corespund restricțiilor impuse.
; ''secventauniforma.out''

 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2840 - Secventa Uniforma
def valideaza_intrare(lst: list[int]) -> bool:
"""
Verifică dacă datele de intrare sunt valide conform cerințelor.
"""
if not (2 <= len(lst) <= 10 ** 6):
return False
for i in range(1, len(lst)):
if lst[i] < 0 or lst[i] > 10 ** 9 or lst[i] != lst[i - 1]:
return False
return True

def gaseste_secventa_uniforma(lst: list[int]) -> tuple[int, list[int]]:
"""
Găsește cea mai lungă secvență uniformă în șirul dat.
"""
if not valideaza_intrare(lst):
return 0, []
lungime_maxima = 1
termeni_maximi = [lst[0]]
lungime_curenta = 1
termeni_curenti = [lst[0]]
for i in range(1, len(lst)):
if lst[i] == lst[i - 1]:
lungime_curenta += 1
termeni_curenti.append(lst[i])
else:
if lungime_curenta > lungime_maxima:
lungime_maxima = lungime_curenta
termeni_maximi = termeni_curenti
lungime_curenta = 1
termeni_curenti = [lst[i]]
if lungime_curenta > lungime_maxima:
lungime_maxima = lungime_curenta
termeni_maximi = termeni_curenti
return lungime_maxima, termeni_maximi

def afiseaza_secventa_uniforma(lungime: int, termeni: list[int]) -> None:
"""
Afișează secvența uniformă găsită în fișierul de ieșire.
"""
with open("secventauniforma.out", "w", encoding="utf-8") as f:
if valideaza_intrare(lst):
f.write("Datele sunt introduse corect.\n")
f.write(str(lungime) + "\n")
f.write(" ".join(map(str, termeni)))
else:
f.write("Datele nu corespund restricțiilor impuse.")

if __name__ == '__main__':
# Citirea datelor de intrare din fișier
with open("secventauniforma.in", "r") as f:
# Citim lista de numere din prima linie a fișierului și o convertim la listă de int
lst = list(map(int, f.readline().split()))

# Găsirea secvenței uniforme și afișarea ei în fișierul de ieșire
lungime, termeni = gaseste_secventa_uniforma(lst)
afiseaza_secventa_uniforma(lungime, termeni)

</syntaxhighlight>

==Explicatie==
Funcția valideaza_intrare(lst: list[int]) -> bool verifică dacă datele de intrare sunt valide, adică:

lista are o lungime între 2 și 10^6;
fiecare element al listei este un număr întreg între 0 și 10^9;
toți termenii din listă sunt egali.
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția gaseste_secventa_uniforma(lst: list[int]) -> tuple[int, list[int]] primește o listă de numere și încearcă să găsească cea mai lungă secvență uniformă din acea listă. Dacă datele de intrare nu sunt valide (conform funcției valideaza_intrare), se va returna o secvență nulă, adică o secvență cu o lungime de 0 și o listă goală de termeni.

Dacă datele de intrare sunt valide, funcția parcurge lista și verifică dacă fiecare element este egal cu elementul anterior. Dacă da, înseamnă că am găsit un termen nou în secvență uniformă curentă, iar lungimea acesteia crește cu 1 și adăugăm termenul la lista de termeni curenti. Dacă nu, înseamnă că am găsit o secvență uniformă mai mică decât cea curentă, deci verificăm dacă lungimea ei este mai mare decât lungimea maximă găsită până acum. Dacă da, actualizăm lungimea maximă și lista de termeni maximi.

După ce am parcurs toată lista, returnăm lungimea maximă și lista de termeni maximi.

Funcția afiseaza_secventa_uniforma(lungime: int, termeni: list[int]) -> None primește lungimea și lista de termeni a celei mai lungi secvențe uniforme găsite și le afișează într-un fișier de ieșire numit "secventauniforma.out". Dacă datele de intrare nu sunt valide, afișează un mesaj corespunzător în locul secvenței uniforme.

Observați că, în cadrul acestei funcții, se mai face încă o dată validarea datelor de intrare, folosind funcția valideaza_intrare(lst: list[int]) -> bool. Aceasta este o măsură de siguranță suplimentară, pentru a evita afișarea unei secvențe uniforme în cazul în care datele de intrare sunt invalide.

În blocul if __name__ == '__main__': citim datele de intrare din fișierul "secventauniform

2834 - Sir 13

2023-04-29T16:39:06Z

Sovago Rares-Andrei: /* Date de ieșire */

== Cerinţa ==
Se dă un șir de cel mult un milion de numere naturale din intervalul '''[0,10^9]''', separate prin câte un spațiu. Șirul are cel puțin doi termeni pari și cel puțin doi termeni impari.

Se cere să se afișeze mesajul '''DA''' dacă șirul aflat în fișier are un subșir ordonat crescător, format din toți termenii pari ai săi, și un subșir ordonat descrescător, format din toți termenii impari ai săi. Dacă nu există două astfel de subșiruri, programul afișează pe ecran mesajul '''NU'''.
== Date de intrare ==
Fișierul de intrare '''sir13.in''' conține elementele șirului, separate printr-un spațiu.
== Date de ieșire ==
Dacă datele sunt introduse corect, in fisier se va afișa:
"Datele sunt introduse corect.", fișierul de ieșire '''sir13.out''' va conține pe prima linie mesajul DA sau NU, corespunzător cerinței. În cazul în care datele nu respectă restricțiile, se va afișa in fisier: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*Utilizați un algoritm eficient din punctul de vedere al timpului de executare și al memoriei necesare:
*se recomandă evitarea stocării elementelor șirului într-un tablou sau în altă structură de date similară;

== Exemple ==
===Exemplul 1===
; ''sir13.in''
: 7 2 5 2 4 3 8
; ''Ecran''
:Datele sunt introduse corect.
; ''sir13.out''
:DA
=== Exemplul 2 ===
; sir13.in:
: 1 3 5 7 9 11 13 15 17
; ''Ecran''
: Datele nu corespund restricțiilor impuse.
; sir13.OUT:
:NU
===Exemplul 3===
; ''sir13.in''
: 3 2 1 4 6 5 8 7
; ''Ecran''
: Datele nu corespund restricțiilor impuse.
; ''sir13.out''
:DA
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2834 - Sir 13
def valideaza_intrarea(data):
"""Verifică dacă datele de intrare sunt valide."""
nums = data.split()
# Verificăm dacă lista de numere are lungimea minimă cerută
if len(nums) < 4:
return False
# Verificăm dacă lista de numere conține cel puțin două numere pare și două numere impare
numere_pare = 0
numere_impare = 0
for num in nums:
if int(num) % 2 == 0:
numere_pare += 1
else:
numere_impare += 1
return numere_pare >= 2 and numere_impare >= 2

def gaseste_subsecventa(nums, este_crescatoare):
"""Găsește o subsecvență ordonată crescător sau descrescător."""
subsecventa = []
ultimul_numar = None
for num in nums:
if ultimul_numar is None or (num > ultimul_numar) == este_crescatoare:
subsecventa.append(num)
ultimul_numar = num
return subsecventa

if __name__ == "__main__":
# Citim datele de intrare din fișier
with open("sir13.in") as f:
data = f.read().strip()
# Verificăm dacă datele de intrare sunt valide
if not valideaza_intrarea(data):
with open("sir13.out", "w") as f:
f.write("NU")
print("Datele nu corespund restricțiilor impuse.")
else:
# Transformăm datele într-o listă de numere
numere = list(map(int, data.split()))
# Găsim o subsecvență ordonată crescător formată din numere pare și o subsecvență
# ordonată descrescător formată din numere impare
subsecventa_pare = gaseste_subsecventa(numere, True)
subsecventa_impare = gaseste_subsecventa(numere, False)
# Verificăm dacă am găsit cele două subsecvențe
if len(subsecventa_pare) >= 2 and len(subsecventa_impare) >= 2:
with open("sir13.out", "w") as f:
f.write("DA")
else:
with open("sir13.out", "w") as f:
f.write("NU")
print("Datele sunt introduse corect.")

</syntaxhighlight>

==Explicatie==

Funcția valideaza_intrarea(data) verifică dacă datele de intrare sunt valide, adică lista de numere din string-ul data are cel puțin patru elemente, dintre care cel puțin două sunt pare și două sunt impare.

Funcția gaseste_subsecventa(nums, este_crescatoare) primește o listă de numere și un boolean care indică dacă se dorește o subsecvență crescătoare sau descrescătoare. Funcția returnează o subsecvență ordonată crescător sau descrescător formată din elementele listei primite, în funcție de valoarea parametrului este_crescatoare.

În blocul if __name__ == "__main__":, se citesc datele de intrare din fișierul "sir13.in" și se verifică dacă acestea sunt valide folosind funcția valideaza_intrarea(data). Dacă datele sunt valide, se transformă string-ul data într-o listă de numere, se găsesc cele două subsecvențe (ordonată crescător formată din numere pare și ordonată descrescător formată din numere impare), și se verifică dacă am găsit cele două subsecvențe. Rezultatul este scris în fișierul "sir13.out". Dacă datele de intrare nu sunt valide, se scrie "NU" în fișierul de ieșire și se afișează mesajul "Datele nu corespund restricțiilor impuse.". În caz contrar, se scrie "DA" în fișierul de ieșire și se afișează mesajul "Datele sunt introduse corect.".

2845 - Wildfire 1

2023-04-29T16:38:42Z

Sovago Rares-Andrei: /* Rezolvare */

== Cerinţa ==
Se consideră o pădure ce conține '''n•m''' copaci aranjați pe '''n''' linii și '''m''' coloane în care s-a produs un incendiu. Pădurarii cunosc coordonatele '''x''' și '''y''' ale copacului de la care a izbucnit focul și modalitatea prin care acesta se extinde. Astfel, dacă un copac se aprinde într-o anumită zi, în ziua următoare se vor aprind copacii vecini cu acesta pe linie sau coloană care nu sunt încă afectați de incendiu.
Știind '''x''' și '''y''', coordonatele inițiale ale focului și '''n''' și '''m''', dimensiunile pădurii, ajutați pădurarii să determine numărul de zile după care va fi afectat fiecare copac al pădurii.
== Date de intrare ==
Programul citește de la tastatură numerele '''x y n m''', cu semnificația de mai sus.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt introduse corect.", Programul va afișa pe ecran '''n•m''' numere, reprezentând numărul de zile după care va fi afectat fiecare copac al pădurii. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* 1 ≤ x ≤ n ≤ 1.000
*1 ≤ y ≤ m ≤ 1.000

== Exemple ==
===Exemplul 1===
; ''Intrare''
:2 2 4 5
; ''Ieșire''
:Datele sunt introduse corect.
:4 3 2 3 4
:3 2 1 2 3
:2 1 0 1 2
:3 2 1 2 3

=== Exemplul 2 ===
; ''Intrare''
:3 3 9 9
; ''Ieșire''
:Datele sunt introduse corect.
:6 5 4 3 4 5 6 7 8
:5 4 3 2 3 4 5 6 7
:4 3 2 1 2 3 4 5 6
:3 2 1 0 1 2 3 4 5
:4 3 2 1 2 3 4 5 6
:5 4 3 2 3 4 5 6 7
:6 5 4 3 4 5 6 7 8
:7 6 5 4 5 6 7 8 9
:8 7 6 5 6 7 8 9 10

===Exemplul 3===
; ''Intrare''
: 0 1 5 5
; ''Ieșire''
:Datele nu corespund restricțiilor impuse..
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2845 - Wildfire 1
def validate_date_intrare(x: int, y: int, n: int, m: int) -> bool:
"""
Verifică dacă datele de intrare sunt valide.
:param x: coordonata x a copacului de la care a izbucnit focul
:param y: coordonata y a copacului de la care a izbucnit focul
:param n: numărul de linii ale pădurii
:param m: numărul de coloane ale pădurii
:return: True dacă datele sunt valide, False altfel
"""
if not (1 <= x <= n <= 1000 and 1 <= y <= m <= 1000):
return False
return True

def rezolva_problema(x: int, y: int, n: int, m: int) -> list:
"""
Calculează numărul de zile după care va fi afectat fiecare copac al pădurii.
:param x: coordonata x a copacului de la care a izbucnit focul
:param y: coordonata y a copacului de la care a izbucnit focul
:param n: numărul de linii ale pădurii
:param m: numărul de coloane ale pădurii
:return: lista cu numărul de zile pentru fiecare copac al pădurii
"""
matrice = [[0] * m for _ in range(n)]
matrice[x][y] = 1
for val in range(2, n * m + 1):
for i, linie in enumerate(matrice):
for j, elem in enumerate(linie):
if elem == val - 1:
for ii, jj in ((i + 1, j), (i - 1, j), (i, j + 1), (i, j - 1)):
if 0 <= ii < n and 0 <= jj < m and matrice[ii][jj] == 0:
matrice[ii][jj] = val
return [elem - 1 for linie in matrice for elem in linie]

if __name__ == '__main__':
try:
x, y, n, m = map(int, input().strip().split())
if not validate_date_intrare(x, y, n, m):
print("Datele nu corespund restricțiilor impuse.")
else:
rezultat = rezolva_problema(x, y, n, m)
print("Datele sunt introduse corect.")
for i in range(n):
print(*rezultat[i * m: (i + 1) * m])
except ValueError:
print("Datele introduse sunt invalide.")

</syntaxhighlight>

==Explicatie==
Funcția validate_date_intrare primește patru parametri: x, y, n și m. Acești parametri reprezintă coordonatele copacului de la care a izbucnit focul și dimensiunile pădurii. Funcția verifică dacă valorile acestor parametri sunt valide, adică x, y, n și m trebuie să fie întregi pozitivi și mai mici sau egali cu 1000.

Funcția rezolva_problema primește aceiași patru parametri și calculează numărul de zile după care va fi afectat fiecare copac al pădurii, pornind de la copacul de la care a izbucnit focul. Se creează o matrice de dimensiunea nxm și se inițializează elementul de la coordonatele (x, y) cu 1. Apoi, se parcurge matricea și se calculează numărul de zile pentru fiecare copac în parte, folosind algoritmul dat în cerință.

În main, se citesc de la tastatură valorile parametrilor x, y, n și m, se validează datele de intrare folosind funcția validate_date_intrare și se calculează și afișează rezultatul folosind funcția rezolva_problema.

3512 - Factorial Query

2023-04-29T16:37:14Z

Sovago Rares-Andrei: /* Date de ieșire */

== Cerinţa ==
Se dau '''n''' numere naturale. Să se calculeze produsul factorialelor acestora, modulo '''1.000.000.007'''

== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt introduse corect.", programul va afișa pe ecran produsul factorialelor celor '''n''' numere citite. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
* 1 ≤ n ≤ 1.000.000
*cele '''n''' numere sunt mai mici sau egale cu '''10.000.000'''

== Exemple ==
===Exemplul 1===
; ''Intrare''
: 4
:4 2 1 3
; ''Ieșire''
:Datele sunt introduse corect.
:288
=== Exemplul 2 ===
; ''Intrare''
: -5
:1 2 3
; ''Ieșire''
:Datele nu corespund restricțiilor impuse.
===Exemplul 3===
; ''Intrare''
: 6
:1 1 1 1 1 1
; ''Ieșire''
:Datele sunt introduse corect.
:1
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3512 - Factorial Query
def validare_date(n, numere):
# Verificăm dacă n se află între 1 și 1.000.000
if n < 1 or n > 1000000:
return False

# Verificăm dacă fiecare număr din listă este mai mic sau egal cu 10.000.000
for numar in numere:
if numar > 10000000:
return False

# Datele sunt corecte
return True

def factorial(n):
# Returnează factorialul lui n, redus modular la 1.000.000.007
produs = 1
for i in range(1, n + 1):
produs = (produs * i) % 1000000007
return produs

def main():
# Citim numărul n de la tastatură
n_input = input("Introduceti numarul n: ")
if not n_input:
print("Introduceti un numar n mai mare decat 0.")
return
n = int(n_input)

# Citim cele n numere de la tastatură
numere_input = input("Introduceti cele n numere, separate prin spatiu: ")
if not numere_input:
print("Introduceti cel putin un numar.")
return
numere = list(map(int, numere_input.split()))

# Validăm datele de intrare
if not validare_date(n, numere):
print("Datele nu corespund restricțiilor impuse.")
return

# Calculăm produsul factorialelor și îl reducem modular la 1.000.000.007
produs = 1
for numar in numere:
produs = (produs * factorial(numar)) % 1000000007

# Afișăm rezultatul
print("Datele sunt introduse corect.")
print(f"Produsul factorialelor este: {produs}")

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatie==

Funcția validare_date(n, numere)

Această funcție primește un număr n și o listă de n numere și verifică dacă acestea corespund restricțiilor impuse. Are următorii parametri:

n - numărul de elemente din listă
numere - lista de n numere de verificat
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția factorial(n)

Această funcție calculează factorialul unui număr n și returnează valoarea acestuia, redus modular la 1.000.000.007. Are un singur parametru:

n - numărul al cărui factorial trebuie calculat 

Funcția main()

Această funcție este funcția principală a programului și este rulată atunci când scriptul Python este executat. Funcția citește de la tastatură un număr n și o listă de n numere, verifică dacă datele sunt valide cu ajutorul funcției validare_date(n, numere), calculează produsul factorialelor cu ajutorul funcției factorial(n) și afișează rezultatul la consolă. Dacă datele introduse nu corespund restricțiilor impuse, se afișează un mesaj de eroare.

3512 - Factorial Query

2023-04-29T16:36:56Z

Sovago Rares-Andrei: /* Restricţii şi precizări */

== Cerinţa ==
Se dau '''n''' numere naturale. Să se calculeze produsul factorialelor acestora, modulo '''1.000.000.007'''

== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt introduse corect.", programul va afișa pe ecran produsul factorialelor celor n numere citite. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
* 1 ≤ n ≤ 1.000.000
*cele '''n''' numere sunt mai mici sau egale cu '''10.000.000'''

== Exemple ==
===Exemplul 1===
; ''Intrare''
: 4
:4 2 1 3
; ''Ieșire''
:Datele sunt introduse corect.
:288
=== Exemplul 2 ===
; ''Intrare''
: -5
:1 2 3
; ''Ieșire''
:Datele nu corespund restricțiilor impuse.
===Exemplul 3===
; ''Intrare''
: 6
:1 1 1 1 1 1
; ''Ieșire''
:Datele sunt introduse corect.
:1
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3512 - Factorial Query
def validare_date(n, numere):
# Verificăm dacă n se află între 1 și 1.000.000
if n < 1 or n > 1000000:
return False

# Verificăm dacă fiecare număr din listă este mai mic sau egal cu 10.000.000
for numar in numere:
if numar > 10000000:
return False

# Datele sunt corecte
return True

def factorial(n):
# Returnează factorialul lui n, redus modular la 1.000.000.007
produs = 1
for i in range(1, n + 1):
produs = (produs * i) % 1000000007
return produs

def main():
# Citim numărul n de la tastatură
n_input = input("Introduceti numarul n: ")
if not n_input:
print("Introduceti un numar n mai mare decat 0.")
return
n = int(n_input)

# Citim cele n numere de la tastatură
numere_input = input("Introduceti cele n numere, separate prin spatiu: ")
if not numere_input:
print("Introduceti cel putin un numar.")
return
numere = list(map(int, numere_input.split()))

# Validăm datele de intrare
if not validare_date(n, numere):
print("Datele nu corespund restricțiilor impuse.")
return

# Calculăm produsul factorialelor și îl reducem modular la 1.000.000.007
produs = 1
for numar in numere:
produs = (produs * factorial(numar)) % 1000000007

# Afișăm rezultatul
print("Datele sunt introduse corect.")
print(f"Produsul factorialelor este: {produs}")

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatie==

Funcția validare_date(n, numere)

Această funcție primește un număr n și o listă de n numere și verifică dacă acestea corespund restricțiilor impuse. Are următorii parametri:

n - numărul de elemente din listă
numere - lista de n numere de verificat
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția factorial(n)

Această funcție calculează factorialul unui număr n și returnează valoarea acestuia, redus modular la 1.000.000.007. Are un singur parametru:

n - numărul al cărui factorial trebuie calculat 

Funcția main()

Această funcție este funcția principală a programului și este rulată atunci când scriptul Python este executat. Funcția citește de la tastatură un număr n și o listă de n numere, verifică dacă datele sunt valide cu ajutorul funcției validare_date(n, numere), calculează produsul factorialelor cu ajutorul funcției factorial(n) și afișează rezultatul la consolă. Dacă datele introduse nu corespund restricțiilor impuse, se afișează un mesaj de eroare.

3144 - Cifre Romane

2023-04-29T16:35:21Z

Sovago Rares-Andrei: /* Exemplul 3 */

== Cerinţa ==
Alexandru a învățat azi despre numerele romane și cum se scriu acestea. Fiind distras de ce spuneau colegii a ajuns acasă și a realizat că nu știe cum să transforme un număr din cifre arabe în cifre romane. Deoarece a doua zi are un test numai din acest capitol, vă roagă să îl ajutați la transformarea unui număr '''N''' dat, scris cu cifre arabe în cifre romane.
== Date de intrare ==
Fișierul '''''cifre_romane.in''''' conține un număr natural '''N''' scris cu cifre arabe.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt introduse corect.", programul va afișa in fișierul '''''cifre_romane.out''''' va conține scrierea cu cifre romane a lui '''N'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ '''n''' ≤ 3999
*cifrele romane sunt:
I=1
V=5
X=10
L=50
C=100
D=500
M=1000

== Exemple ==
===Exemplul 1===
; ''cifre_romane.in''
:4
; ''Ecran''
:Datele sunt introduse corect.
; ''cifre_romane.out''
:IV

=== Exemplul 2 ===

; ''cifre_romane.in''
:5
; ''Ecran''
:Datele sunt introduse corect.
; ''cifre_romane.out''
:V

=== Exemplul 3 ===
; ''cifre_romane.in''
:4000
; ''Ecran''
:Datele nu corespund restricțiilor impuse
; ''cifre_romane.out''

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3144 - Cifre Romane
def validare(n):
if n < 1 or n > 3999:
return False
return True

def transforma_in_romane(n):
romane = [(1000, 'M'), (900, 'CM'), (500, 'D'), (400, 'CD'), (100, 'C'),
(90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'),
(5, 'V'), (4, 'IV'), (1, 'I')]
rest = n
rezultat = ''
while rest > 0:
for arab, roman in romane:
while rest >= arab:
rezultat += roman
rest -= arab
return rezultat

def main():
with open('cifre_romane.in', 'r') as f:
n = int(f.readline().strip())

if not validare(n):
print('Datele nu corespund restricțiilor impuse.')
else:
print('Datele sunt introduse corect.')
rezultat = transforma_in_romane(n)
with open('cifre_romane.out', 'w') as f:
f.write(rezultat)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==
Funcția validare(n)

Această funcție verifică dacă datele de intrare sunt valide. Are un singur parametru:

n - numărul întreg care trebuie transformat în cifre romane
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția transforma_in_romane(n)

Această funcție primește un număr întreg n și returnează echivalentul în cifre romane ale acestuia. Funcția folosește o listă romane care conține tupluri cu perechile (arab, roman) pentru fiecare simbol din cifrele romane, în ordinea descrescătoare a valorii acestora. Apoi, se parcurge această listă de la început până la sfârșit și se adaugă în rezultat simbolul roman corespunzător valorii arabe până când se ajunge la finalul listei sau până când numărul întreg n devine 0.

Funcția main()

Această funcție este funcția principală a programului și este rulată atunci când scriptul Python este executat. Funcția deschide fișierul de intrare cifre_romane.in, citește numărul întreg care trebuie transformat în cifre romane, verifică dacă datele de intrare sunt valide cu ajutorul funcției validare(n), transformă numărul în cifre romane cu ajutorul funcției transforma_in_romane(n) și afișează rezultatul în fișierul de ieșire cifre_romane.out. Dacă datele de intrare nu corespund restricțiilor impuse, se afișează un mesaj de eroare.

3144 - Cifre Romane

2023-04-29T16:34:30Z

Sovago Rares-Andrei: /* Exemplul 2 */

== Cerinţa ==
Alexandru a învățat azi despre numerele romane și cum se scriu acestea. Fiind distras de ce spuneau colegii a ajuns acasă și a realizat că nu știe cum să transforme un număr din cifre arabe în cifre romane. Deoarece a doua zi are un test numai din acest capitol, vă roagă să îl ajutați la transformarea unui număr '''N''' dat, scris cu cifre arabe în cifre romane.
== Date de intrare ==
Fișierul '''''cifre_romane.in''''' conține un număr natural '''N''' scris cu cifre arabe.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt introduse corect.", programul va afișa in fișierul '''''cifre_romane.out''''' va conține scrierea cu cifre romane a lui '''N'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ '''n''' ≤ 3999
*cifrele romane sunt:
I=1
V=5
X=10
L=50
C=100
D=500
M=1000

== Exemple ==
===Exemplul 1===
; ''cifre_romane.in''
:4
; ''Ecran''
:Datele sunt introduse corect.
; ''cifre_romane.out''
:IV

=== Exemplul 2 ===

; ''cifre_romane.in''
:5
; ''Ecran''
:Datele sunt introduse corect.
; ''cifre_romane.out''
:V

=== Exemplul 3 ===
; ''Intrare''
: 4000
; ''Ieșire''
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3144 - Cifre Romane
def validare(n):
if n < 1 or n > 3999:
return False
return True

def transforma_in_romane(n):
romane = [(1000, 'M'), (900, 'CM'), (500, 'D'), (400, 'CD'), (100, 'C'),
(90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'),
(5, 'V'), (4, 'IV'), (1, 'I')]
rest = n
rezultat = ''
while rest > 0:
for arab, roman in romane:
while rest >= arab:
rezultat += roman
rest -= arab
return rezultat

def main():
with open('cifre_romane.in', 'r') as f:
n = int(f.readline().strip())

if not validare(n):
print('Datele nu corespund restricțiilor impuse.')
else:
print('Datele sunt introduse corect.')
rezultat = transforma_in_romane(n)
with open('cifre_romane.out', 'w') as f:
f.write(rezultat)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==
Funcția validare(n)

Această funcție verifică dacă datele de intrare sunt valide. Are un singur parametru:

n - numărul întreg care trebuie transformat în cifre romane
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția transforma_in_romane(n)

Această funcție primește un număr întreg n și returnează echivalentul în cifre romane ale acestuia. Funcția folosește o listă romane care conține tupluri cu perechile (arab, roman) pentru fiecare simbol din cifrele romane, în ordinea descrescătoare a valorii acestora. Apoi, se parcurge această listă de la început până la sfârșit și se adaugă în rezultat simbolul roman corespunzător valorii arabe până când se ajunge la finalul listei sau până când numărul întreg n devine 0.

Funcția main()

Această funcție este funcția principală a programului și este rulată atunci când scriptul Python este executat. Funcția deschide fișierul de intrare cifre_romane.in, citește numărul întreg care trebuie transformat în cifre romane, verifică dacă datele de intrare sunt valide cu ajutorul funcției validare(n), transformă numărul în cifre romane cu ajutorul funcției transforma_in_romane(n) și afișează rezultatul în fișierul de ieșire cifre_romane.out. Dacă datele de intrare nu corespund restricțiilor impuse, se afișează un mesaj de eroare.

3144 - Cifre Romane

2023-04-29T16:34:03Z

Sovago Rares-Andrei: /* Exemplul 1 */

== Cerinţa ==
Alexandru a învățat azi despre numerele romane și cum se scriu acestea. Fiind distras de ce spuneau colegii a ajuns acasă și a realizat că nu știe cum să transforme un număr din cifre arabe în cifre romane. Deoarece a doua zi are un test numai din acest capitol, vă roagă să îl ajutați la transformarea unui număr '''N''' dat, scris cu cifre arabe în cifre romane.
== Date de intrare ==
Fișierul '''''cifre_romane.in''''' conține un număr natural '''N''' scris cu cifre arabe.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt introduse corect.", programul va afișa in fișierul '''''cifre_romane.out''''' va conține scrierea cu cifre romane a lui '''N'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ '''n''' ≤ 3999
*cifrele romane sunt:
I=1
V=5
X=10
L=50
C=100
D=500
M=1000

== Exemple ==
===Exemplul 1===
; ''cifre_romane.in''
:4
; ''Ecran''
:Datele sunt introduse corect.
; ''cifre_romane.out''
:IV

=== Exemplul 2 ===
; ''Intrare''
: 5
; ''Ieșire''
: Datele sunt introduse corect.
: V

=== Exemplul 3 ===
; ''Intrare''
: 4000
; ''Ieșire''
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3144 - Cifre Romane
def validare(n):
if n < 1 or n > 3999:
return False
return True

def transforma_in_romane(n):
romane = [(1000, 'M'), (900, 'CM'), (500, 'D'), (400, 'CD'), (100, 'C'),
(90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'),
(5, 'V'), (4, 'IV'), (1, 'I')]
rest = n
rezultat = ''
while rest > 0:
for arab, roman in romane:
while rest >= arab:
rezultat += roman
rest -= arab
return rezultat

def main():
with open('cifre_romane.in', 'r') as f:
n = int(f.readline().strip())

if not validare(n):
print('Datele nu corespund restricțiilor impuse.')
else:
print('Datele sunt introduse corect.')
rezultat = transforma_in_romane(n)
with open('cifre_romane.out', 'w') as f:
f.write(rezultat)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==
Funcția validare(n)

Această funcție verifică dacă datele de intrare sunt valide. Are un singur parametru:

n - numărul întreg care trebuie transformat în cifre romane
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția transforma_in_romane(n)

Această funcție primește un număr întreg n și returnează echivalentul în cifre romane ale acestuia. Funcția folosește o listă romane care conține tupluri cu perechile (arab, roman) pentru fiecare simbol din cifrele romane, în ordinea descrescătoare a valorii acestora. Apoi, se parcurge această listă de la început până la sfârșit și se adaugă în rezultat simbolul roman corespunzător valorii arabe până când se ajunge la finalul listei sau până când numărul întreg n devine 0.

Funcția main()

Această funcție este funcția principală a programului și este rulată atunci când scriptul Python este executat. Funcția deschide fișierul de intrare cifre_romane.in, citește numărul întreg care trebuie transformat în cifre romane, verifică dacă datele de intrare sunt valide cu ajutorul funcției validare(n), transformă numărul în cifre romane cu ajutorul funcției transforma_in_romane(n) și afișează rezultatul în fișierul de ieșire cifre_romane.out. Dacă datele de intrare nu corespund restricțiilor impuse, se afișează un mesaj de eroare.

3144 - Cifre Romane

2023-04-29T16:32:04Z

Sovago Rares-Andrei: /* Date de ieșire */

== Cerinţa ==
Alexandru a învățat azi despre numerele romane și cum se scriu acestea. Fiind distras de ce spuneau colegii a ajuns acasă și a realizat că nu știe cum să transforme un număr din cifre arabe în cifre romane. Deoarece a doua zi are un test numai din acest capitol, vă roagă să îl ajutați la transformarea unui număr '''N''' dat, scris cu cifre arabe în cifre romane.
== Date de intrare ==
Fișierul '''''cifre_romane.in''''' conține un număr natural '''N''' scris cu cifre arabe.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt introduse corect.", programul va afișa in fișierul '''''cifre_romane.out''''' va conține scrierea cu cifre romane a lui '''N'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ '''n''' ≤ 3999
*cifrele romane sunt:
I=1
V=5
X=10
L=50
C=100
D=500
M=1000

== Exemple ==
===Exemplul 1===
; ''Intrare''
:4
; ''Ieșire''
:Datele sunt introduse corect.
:IV
=== Exemplul 2 ===
; ''Intrare''
: 5
; ''Ieșire''
: Datele sunt introduse corect.
: V

=== Exemplul 3 ===
; ''Intrare''
: 4000
; ''Ieșire''
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3144 - Cifre Romane
def validare(n):
if n < 1 or n > 3999:
return False
return True

def transforma_in_romane(n):
romane = [(1000, 'M'), (900, 'CM'), (500, 'D'), (400, 'CD'), (100, 'C'),
(90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'),
(5, 'V'), (4, 'IV'), (1, 'I')]
rest = n
rezultat = ''
while rest > 0:
for arab, roman in romane:
while rest >= arab:
rezultat += roman
rest -= arab
return rezultat

def main():
with open('cifre_romane.in', 'r') as f:
n = int(f.readline().strip())

if not validare(n):
print('Datele nu corespund restricțiilor impuse.')
else:
print('Datele sunt introduse corect.')
rezultat = transforma_in_romane(n)
with open('cifre_romane.out', 'w') as f:
f.write(rezultat)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==
Funcția validare(n)

Această funcție verifică dacă datele de intrare sunt valide. Are un singur parametru:

n - numărul întreg care trebuie transformat în cifre romane
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția transforma_in_romane(n)

Această funcție primește un număr întreg n și returnează echivalentul în cifre romane ale acestuia. Funcția folosește o listă romane care conține tupluri cu perechile (arab, roman) pentru fiecare simbol din cifrele romane, în ordinea descrescătoare a valorii acestora. Apoi, se parcurge această listă de la început până la sfârșit și se adaugă în rezultat simbolul roman corespunzător valorii arabe până când se ajunge la finalul listei sau până când numărul întreg n devine 0.

Funcția main()

Această funcție este funcția principală a programului și este rulată atunci când scriptul Python este executat. Funcția deschide fișierul de intrare cifre_romane.in, citește numărul întreg care trebuie transformat în cifre romane, verifică dacă datele de intrare sunt valide cu ajutorul funcției validare(n), transformă numărul în cifre romane cu ajutorul funcției transforma_in_romane(n) și afișează rezultatul în fișierul de ieșire cifre_romane.out. Dacă datele de intrare nu corespund restricțiilor impuse, se afișează un mesaj de eroare.

3144 - Cifre Romane

2023-04-29T16:31:47Z

Sovago Rares-Andrei: /* Date de intrare */

== Cerinţa ==
Alexandru a învățat azi despre numerele romane și cum se scriu acestea. Fiind distras de ce spuneau colegii a ajuns acasă și a realizat că nu știe cum să transforme un număr din cifre arabe în cifre romane. Deoarece a doua zi are un test numai din acest capitol, vă roagă să îl ajutați la transformarea unui număr '''N''' dat, scris cu cifre arabe în cifre romane.
== Date de intrare ==
Fișierul '''''cifre_romane.in''''' conține un număr natural '''N''' scris cu cifre arabe.

== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa:
"Datele sunt introduse corect.", programul va afișa in fișierul ''cifre_romane.out'' va conține scrierea cu cifre romane a lui '''N'''. În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ '''n''' ≤ 3999
*cifrele romane sunt:
I=1
V=5
X=10
L=50
C=100
D=500
M=1000

== Exemple ==
===Exemplul 1===
; ''Intrare''
:4
; ''Ieșire''
:Datele sunt introduse corect.
:IV
=== Exemplul 2 ===
; ''Intrare''
: 5
; ''Ieșire''
: Datele sunt introduse corect.
: V

=== Exemplul 3 ===
; ''Intrare''
: 4000
; ''Ieșire''
: Datele nu corespund restricțiilor impuse.
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3144 - Cifre Romane
def validare(n):
if n < 1 or n > 3999:
return False
return True

def transforma_in_romane(n):
romane = [(1000, 'M'), (900, 'CM'), (500, 'D'), (400, 'CD'), (100, 'C'),
(90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'),
(5, 'V'), (4, 'IV'), (1, 'I')]
rest = n
rezultat = ''
while rest > 0:
for arab, roman in romane:
while rest >= arab:
rezultat += roman
rest -= arab
return rezultat

def main():
with open('cifre_romane.in', 'r') as f:
n = int(f.readline().strip())

if not validare(n):
print('Datele nu corespund restricțiilor impuse.')
else:
print('Datele sunt introduse corect.')
rezultat = transforma_in_romane(n)
with open('cifre_romane.out', 'w') as f:
f.write(rezultat)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==
Funcția validare(n)

Această funcție verifică dacă datele de intrare sunt valide. Are un singur parametru:

n - numărul întreg care trebuie transformat în cifre romane
Funcția returnează True dacă datele sunt valide și False în caz contrar.

Funcția transforma_in_romane(n)

Această funcție primește un număr întreg n și returnează echivalentul în cifre romane ale acestuia. Funcția folosește o listă romane care conține tupluri cu perechile (arab, roman) pentru fiecare simbol din cifrele romane, în ordinea descrescătoare a valorii acestora. Apoi, se parcurge această listă de la început până la sfârșit și se adaugă în rezultat simbolul roman corespunzător valorii arabe până când se ajunge la finalul listei sau până când numărul întreg n devine 0.

Funcția main()

Această funcție este funcția principală a programului și este rulată atunci când scriptul Python este executat. Funcția deschide fișierul de intrare cifre_romane.in, citește numărul întreg care trebuie transformat în cifre romane, verifică dacă datele de intrare sunt valide cu ajutorul funcției validare(n), transformă numărul în cifre romane cu ajutorul funcției transforma_in_romane(n) și afișează rezultatul în fișierul de ieșire cifre_romane.out. Dacă datele de intrare nu corespund restricțiilor impuse, se afișează un mesaj de eroare.

4092 - cate

2023-04-29T16:28:36Z

Sovago Rares-Andrei: /* Date de ieșire */

==Cerința==

Se dă '''"n"''', un număr natural și '''"n"''' perechi de numere '''("a", "b")'''. Să se determine:

Câte numere din intervalul închis determinat de '''"a"''' și '''"b"''' au număr impar de divizori pozitivi.
Câte numere cu exact trei divizori pozitivi se găsesc în intervalul închis determinat de '''"a"''' și '''"b"'''.

==Date de intrare==

Fișierul de intrare '''"cate.in"''' conține pe prima linie două numere naturale "C" și "n", separate printr-un spațiu. "C" reprezintă cerința care trebuie rezolvată (1 sau 2), iar "n" reprezintă numărul de perechi. Pe următoarele "n" linii se găsesc cele "n" perechi de numere naturale, separate prin câte un spațiu.

==Date de ieșire==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.". Fișierul de ieșire '''"cate.out"''' va conține "n" linii. Pe linia "i" trebuie să se găsească răspunsul la întrebarea corespunzătoare de pe linia "i+1" a fișierului de intrare. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ n ≤ 100.000
*1 ≤ a, b ≤ 1.000.000
*Pentru 42 de puncte, C = 1
*Pentru 58 de puncte, C = 2
== Exemple ==
===Exemplul 1===
; ''cate.in''
:2 3
:1 10
:30 10
:100 500
; ''ecran''
:Datele sunt introduse corect.
; ''cate.out''
:2
:1
:4

===Exemplul 2===
===Exemplul 1===
; ''cate.in''
:1 3
:1 10
:30 10
:100 500
; ''ecran''
:Datele sunt introduse corect.
; ''cate.out''
:3
:2
:13
===Exemplul 3===
; ''cate.in''
:1 3
:1 10
:30 10
:100 500000000
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''cate.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 4092 - cate
import sys
import math

def valideaza_datele(cerinta, numar_teste, teste):
if cerinta not in [1, 2]:
return "Datele nu corespund restricțiilor impuse."
if numar_teste != len(teste):
return "Datele nu corespund restricțiilor impuse."
for test in teste:
a, b = test
if a < 1 or a > 1000000 or b < 1 or b > 1000000:
return "Datele nu corespund restricțiilor impuse."
return "Datele sunt introduse corect."

def rezolva_cerinta_1(teste):
rezultate = []
for test in teste:
a, b = sorted(test)
if a > b:
rezultate.append(0)
else:
rezultate.append(int(math.sqrt(b)) - int(math.sqrt(a - 1)))
return rezultate

def rezolva_cerinta_2(teste):
numere_prime = [True] * 1000001
numere_prime[0] = numere_prime[1] = False
prefix_suma = [0] * 1000001
for i in range(2, 1001):
if numere_prime[i]:
prefix_suma[i * i] = 1
for j in range(i * i, 1000001, i):
numere_prime[j] = False
for i in range(1, 1000001):
prefix_suma[i] += prefix_suma[i - 1]

rezultate = []
for test in teste:
a, b = sorted(test)
rezultate.append(prefix_suma[b] - prefix_suma[a - 1])
return rezultate

if __name__ == '__main__':
with open("cate.in", "r") as fisier_intrare:
cerinta, numar_teste = map(int, fisier_intrare.readline().split())
teste = []
for _ in range(numar_teste):
a, b = map(int, fisier_intrare.readline().split())
teste.append((a, b))

rezultat_validare = valideaza_datele(cerinta, numar_teste, teste)
if rezultat_validare != "Datele sunt introduse corect.":
print(rezultat_validare)
else:
if cerinta == 1:
rezultate = rezolva_cerinta_1(teste)
else:
rezultate = rezolva_cerinta_2(teste)

with open("cate.out", "w") as fisier_iesire:
for rezultat in rezultate:
fisier_iesire.write(str(rezultat) + "\n")
print("Datele sunt introduse corect.")

</syntaxhighlight>

==Explicatie==

valideaza_datele(cerinta, numar_teste, teste): Această funcție primește ca parametri cerința de rezolvat (cerinta), numărul de teste (numar_teste) și o listă de teste (teste). Ea verifică dacă datele introduse sunt valide conform cerințelor impuse. Mai întâi verifică dacă cerința este 1 sau 2 și apoi verifică dacă numărul de teste coincide cu numărul de teste introduse în listă. În cele din urmă, se verifică dacă valorile a și b din fiecare test sunt în intervalul [1, 1000000]. Dacă datele sunt introduse corect, funcția returnează un mesaj de confirmare, altfel returnează un mesaj de eroare.

rezolva_cerinta_1(teste): Această funcție primește ca parametru o listă de teste (teste) pentru cerința 1. Pentru fiecare test din listă, funcția sortează valorile a și b și calculează diferența dintre rădăcina pătrată a lui b și rădăcina pătrată a lui a-1. În cele din urmă, rezultatele sunt stocate într-o listă și returnate.

rezolva_cerinta_2(teste): Această funcție primește ca parametru o listă de teste (teste) pentru cerința 2. Funcția calculează, pentru fiecare număr între 2 și 1000000, dacă este prim sau nu. Această informație este stocată într-o listă de booleni numită numere_prime, în care valoarea True indică faptul că numărul este prim, iar valoarea False indică faptul că numărul nu este prim. De asemenea, funcția calculează un prefix-sum pentru această listă. Acest prefix-sum se numește prefix_suma și este folosit pentru a calcula rapid câte numere prime sunt într-un interval dat. Mai întâi, pentru fiecare pătrat al unui număr prim, se pune o valoare de 1 în prefix_suma, indicând faptul că acel număr prim se află în intervalul [pătratul lui i, 1000000]. Apoi, pentru fiecare număr între 1 și 1000000, se adaugă valoarea precedentă din prefix_suma la valoarea curentă, astfel încât prefix_suma devine un prefix-sum pentru numărul de numere prime din intervalul [1, i]. Pentru fiecare test din listă, funcția sortează valorile a și b și calculează diferența dintre prefix-suma lui b și prefix-suma lui a-1. În cele din urmă, rezultatele sunt stocate într-o lista

Funcția main este funcția principală a programului, care coordonează executarea acestuia. Ea verifică dacă programul este rulat ca script, sau este importat ca modul, prin intermediul instrucțiunii if __name__ == '__main__':.

Dacă programul este rulat ca script, atunci această instrucțiune va fi adevărată, iar codul din interiorul acesteia va fi executat. În acest caz, se deschide fișierul de intrare "cate.in" pentru citire, se citește prima linie pentru a obține cerința (cerinta) și numărul de teste (numar_teste), iar apoi se citește fiecare test și se stochează în lista teste. Aceste valori sunt folosite pentru a apela funcția valideaza_datele(cerinta, numar_teste, teste), care verifică dacă datele introduse sunt valide conform cerințelor impuse. Dacă datele sunt valide, atunci se apelează funcția corespunzătoare pentru a rezolva problema, fie rezolva_cerinta_1(teste) sau rezolva_cerinta_2(teste), în funcție de cerință. Rezultatele sunt stocate în lista rezultate, care este scrisă în fișierul de ieșire "cate.out", iar apoi se afișează un mesaj de confirmare a introducerii corecte a datelor.

Dacă programul este importat ca modul, atunci instrucțiunea if __name__ == '__main__': este falsă, iar codul din interiorul acesteia nu va fi executat. În acest caz, funcția main poate fi apelată din alt modul, pentru a rezolva problema cu datele date în parametrii funcției.

4092 - cate

2023-04-29T16:28:18Z

Sovago Rares-Andrei: /* Date de intrare */

==Cerința==

Se dă '''"n"''', un număr natural și '''"n"''' perechi de numere '''("a", "b")'''. Să se determine:

Câte numere din intervalul închis determinat de '''"a"''' și '''"b"''' au număr impar de divizori pozitivi.
Câte numere cu exact trei divizori pozitivi se găsesc în intervalul închis determinat de '''"a"''' și '''"b"'''.

==Date de intrare==

Fișierul de intrare '''"cate.in"''' conține pe prima linie două numere naturale "C" și "n", separate printr-un spațiu. "C" reprezintă cerința care trebuie rezolvată (1 sau 2), iar "n" reprezintă numărul de perechi. Pe următoarele "n" linii se găsesc cele "n" perechi de numere naturale, separate prin câte un spațiu.

==Date de ieșire==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.". Fișierul de ieșire "cate.out" va conține "n" linii. Pe linia "i" trebuie să se găsească răspunsul la întrebarea corespunzătoare de pe linia "i+1" a fișierului de intrare. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ n ≤ 100.000
*1 ≤ a, b ≤ 1.000.000
*Pentru 42 de puncte, C = 1
*Pentru 58 de puncte, C = 2
== Exemple ==
===Exemplul 1===
; ''cate.in''
:2 3
:1 10
:30 10
:100 500
; ''ecran''
:Datele sunt introduse corect.
; ''cate.out''
:2
:1
:4

===Exemplul 2===
===Exemplul 1===
; ''cate.in''
:1 3
:1 10
:30 10
:100 500
; ''ecran''
:Datele sunt introduse corect.
; ''cate.out''
:3
:2
:13
===Exemplul 3===
; ''cate.in''
:1 3
:1 10
:30 10
:100 500000000
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''cate.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 4092 - cate
import sys
import math

def valideaza_datele(cerinta, numar_teste, teste):
if cerinta not in [1, 2]:
return "Datele nu corespund restricțiilor impuse."
if numar_teste != len(teste):
return "Datele nu corespund restricțiilor impuse."
for test in teste:
a, b = test
if a < 1 or a > 1000000 or b < 1 or b > 1000000:
return "Datele nu corespund restricțiilor impuse."
return "Datele sunt introduse corect."

def rezolva_cerinta_1(teste):
rezultate = []
for test in teste:
a, b = sorted(test)
if a > b:
rezultate.append(0)
else:
rezultate.append(int(math.sqrt(b)) - int(math.sqrt(a - 1)))
return rezultate

def rezolva_cerinta_2(teste):
numere_prime = [True] * 1000001
numere_prime[0] = numere_prime[1] = False
prefix_suma = [0] * 1000001
for i in range(2, 1001):
if numere_prime[i]:
prefix_suma[i * i] = 1
for j in range(i * i, 1000001, i):
numere_prime[j] = False
for i in range(1, 1000001):
prefix_suma[i] += prefix_suma[i - 1]

rezultate = []
for test in teste:
a, b = sorted(test)
rezultate.append(prefix_suma[b] - prefix_suma[a - 1])
return rezultate

if __name__ == '__main__':
with open("cate.in", "r") as fisier_intrare:
cerinta, numar_teste = map(int, fisier_intrare.readline().split())
teste = []
for _ in range(numar_teste):
a, b = map(int, fisier_intrare.readline().split())
teste.append((a, b))

rezultat_validare = valideaza_datele(cerinta, numar_teste, teste)
if rezultat_validare != "Datele sunt introduse corect.":
print(rezultat_validare)
else:
if cerinta == 1:
rezultate = rezolva_cerinta_1(teste)
else:
rezultate = rezolva_cerinta_2(teste)

with open("cate.out", "w") as fisier_iesire:
for rezultat in rezultate:
fisier_iesire.write(str(rezultat) + "\n")
print("Datele sunt introduse corect.")

</syntaxhighlight>

==Explicatie==

valideaza_datele(cerinta, numar_teste, teste): Această funcție primește ca parametri cerința de rezolvat (cerinta), numărul de teste (numar_teste) și o listă de teste (teste). Ea verifică dacă datele introduse sunt valide conform cerințelor impuse. Mai întâi verifică dacă cerința este 1 sau 2 și apoi verifică dacă numărul de teste coincide cu numărul de teste introduse în listă. În cele din urmă, se verifică dacă valorile a și b din fiecare test sunt în intervalul [1, 1000000]. Dacă datele sunt introduse corect, funcția returnează un mesaj de confirmare, altfel returnează un mesaj de eroare.

rezolva_cerinta_1(teste): Această funcție primește ca parametru o listă de teste (teste) pentru cerința 1. Pentru fiecare test din listă, funcția sortează valorile a și b și calculează diferența dintre rădăcina pătrată a lui b și rădăcina pătrată a lui a-1. În cele din urmă, rezultatele sunt stocate într-o listă și returnate.

rezolva_cerinta_2(teste): Această funcție primește ca parametru o listă de teste (teste) pentru cerința 2. Funcția calculează, pentru fiecare număr între 2 și 1000000, dacă este prim sau nu. Această informație este stocată într-o listă de booleni numită numere_prime, în care valoarea True indică faptul că numărul este prim, iar valoarea False indică faptul că numărul nu este prim. De asemenea, funcția calculează un prefix-sum pentru această listă. Acest prefix-sum se numește prefix_suma și este folosit pentru a calcula rapid câte numere prime sunt într-un interval dat. Mai întâi, pentru fiecare pătrat al unui număr prim, se pune o valoare de 1 în prefix_suma, indicând faptul că acel număr prim se află în intervalul [pătratul lui i, 1000000]. Apoi, pentru fiecare număr între 1 și 1000000, se adaugă valoarea precedentă din prefix_suma la valoarea curentă, astfel încât prefix_suma devine un prefix-sum pentru numărul de numere prime din intervalul [1, i]. Pentru fiecare test din listă, funcția sortează valorile a și b și calculează diferența dintre prefix-suma lui b și prefix-suma lui a-1. În cele din urmă, rezultatele sunt stocate într-o lista

Funcția main este funcția principală a programului, care coordonează executarea acestuia. Ea verifică dacă programul este rulat ca script, sau este importat ca modul, prin intermediul instrucțiunii if __name__ == '__main__':.

Dacă programul este rulat ca script, atunci această instrucțiune va fi adevărată, iar codul din interiorul acesteia va fi executat. În acest caz, se deschide fișierul de intrare "cate.in" pentru citire, se citește prima linie pentru a obține cerința (cerinta) și numărul de teste (numar_teste), iar apoi se citește fiecare test și se stochează în lista teste. Aceste valori sunt folosite pentru a apela funcția valideaza_datele(cerinta, numar_teste, teste), care verifică dacă datele introduse sunt valide conform cerințelor impuse. Dacă datele sunt valide, atunci se apelează funcția corespunzătoare pentru a rezolva problema, fie rezolva_cerinta_1(teste) sau rezolva_cerinta_2(teste), în funcție de cerință. Rezultatele sunt stocate în lista rezultate, care este scrisă în fișierul de ieșire "cate.out", iar apoi se afișează un mesaj de confirmare a introducerii corecte a datelor.

Dacă programul este importat ca modul, atunci instrucțiunea if __name__ == '__main__': este falsă, iar codul din interiorul acesteia nu va fi executat. În acest caz, funcția main poate fi apelată din alt modul, pentru a rezolva problema cu datele date în parametrii funcției.

4092 - cate

2023-04-29T16:27:57Z

Sovago Rares-Andrei: /* Cerința */

==Cerința==

Se dă '''"n"''', un număr natural și '''"n"''' perechi de numere '''("a", "b")'''. Să se determine:

Câte numere din intervalul închis determinat de '''"a"''' și '''"b"''' au număr impar de divizori pozitivi.
Câte numere cu exact trei divizori pozitivi se găsesc în intervalul închis determinat de '''"a"''' și '''"b"'''.

==Date de intrare==

Fișierul de intrare "cate.in" conține pe prima linie două numere naturale "C" și "n", separate printr-un spațiu. "C" reprezintă cerința care trebuie rezolvată (1 sau 2), iar "n" reprezintă numărul de perechi. Pe următoarele "n" linii se găsesc cele "n" perechi de numere naturale, separate prin câte un spațiu.

==Date de ieșire==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.". Fișierul de ieșire "cate.out" va conține "n" linii. Pe linia "i" trebuie să se găsească răspunsul la întrebarea corespunzătoare de pe linia "i+1" a fișierului de intrare. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ n ≤ 100.000
*1 ≤ a, b ≤ 1.000.000
*Pentru 42 de puncte, C = 1
*Pentru 58 de puncte, C = 2
== Exemple ==
===Exemplul 1===
; ''cate.in''
:2 3
:1 10
:30 10
:100 500
; ''ecran''
:Datele sunt introduse corect.
; ''cate.out''
:2
:1
:4

===Exemplul 2===
===Exemplul 1===
; ''cate.in''
:1 3
:1 10
:30 10
:100 500
; ''ecran''
:Datele sunt introduse corect.
; ''cate.out''
:3
:2
:13
===Exemplul 3===
; ''cate.in''
:1 3
:1 10
:30 10
:100 500000000
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''cate.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 4092 - cate
import sys
import math

def valideaza_datele(cerinta, numar_teste, teste):
if cerinta not in [1, 2]:
return "Datele nu corespund restricțiilor impuse."
if numar_teste != len(teste):
return "Datele nu corespund restricțiilor impuse."
for test in teste:
a, b = test
if a < 1 or a > 1000000 or b < 1 or b > 1000000:
return "Datele nu corespund restricțiilor impuse."
return "Datele sunt introduse corect."

def rezolva_cerinta_1(teste):
rezultate = []
for test in teste:
a, b = sorted(test)
if a > b:
rezultate.append(0)
else:
rezultate.append(int(math.sqrt(b)) - int(math.sqrt(a - 1)))
return rezultate

def rezolva_cerinta_2(teste):
numere_prime = [True] * 1000001
numere_prime[0] = numere_prime[1] = False
prefix_suma = [0] * 1000001
for i in range(2, 1001):
if numere_prime[i]:
prefix_suma[i * i] = 1
for j in range(i * i, 1000001, i):
numere_prime[j] = False
for i in range(1, 1000001):
prefix_suma[i] += prefix_suma[i - 1]

rezultate = []
for test in teste:
a, b = sorted(test)
rezultate.append(prefix_suma[b] - prefix_suma[a - 1])
return rezultate

if __name__ == '__main__':
with open("cate.in", "r") as fisier_intrare:
cerinta, numar_teste = map(int, fisier_intrare.readline().split())
teste = []
for _ in range(numar_teste):
a, b = map(int, fisier_intrare.readline().split())
teste.append((a, b))

rezultat_validare = valideaza_datele(cerinta, numar_teste, teste)
if rezultat_validare != "Datele sunt introduse corect.":
print(rezultat_validare)
else:
if cerinta == 1:
rezultate = rezolva_cerinta_1(teste)
else:
rezultate = rezolva_cerinta_2(teste)

with open("cate.out", "w") as fisier_iesire:
for rezultat in rezultate:
fisier_iesire.write(str(rezultat) + "\n")
print("Datele sunt introduse corect.")

</syntaxhighlight>

==Explicatie==

valideaza_datele(cerinta, numar_teste, teste): Această funcție primește ca parametri cerința de rezolvat (cerinta), numărul de teste (numar_teste) și o listă de teste (teste). Ea verifică dacă datele introduse sunt valide conform cerințelor impuse. Mai întâi verifică dacă cerința este 1 sau 2 și apoi verifică dacă numărul de teste coincide cu numărul de teste introduse în listă. În cele din urmă, se verifică dacă valorile a și b din fiecare test sunt în intervalul [1, 1000000]. Dacă datele sunt introduse corect, funcția returnează un mesaj de confirmare, altfel returnează un mesaj de eroare.

rezolva_cerinta_1(teste): Această funcție primește ca parametru o listă de teste (teste) pentru cerința 1. Pentru fiecare test din listă, funcția sortează valorile a și b și calculează diferența dintre rădăcina pătrată a lui b și rădăcina pătrată a lui a-1. În cele din urmă, rezultatele sunt stocate într-o listă și returnate.

rezolva_cerinta_2(teste): Această funcție primește ca parametru o listă de teste (teste) pentru cerința 2. Funcția calculează, pentru fiecare număr între 2 și 1000000, dacă este prim sau nu. Această informație este stocată într-o listă de booleni numită numere_prime, în care valoarea True indică faptul că numărul este prim, iar valoarea False indică faptul că numărul nu este prim. De asemenea, funcția calculează un prefix-sum pentru această listă. Acest prefix-sum se numește prefix_suma și este folosit pentru a calcula rapid câte numere prime sunt într-un interval dat. Mai întâi, pentru fiecare pătrat al unui număr prim, se pune o valoare de 1 în prefix_suma, indicând faptul că acel număr prim se află în intervalul [pătratul lui i, 1000000]. Apoi, pentru fiecare număr între 1 și 1000000, se adaugă valoarea precedentă din prefix_suma la valoarea curentă, astfel încât prefix_suma devine un prefix-sum pentru numărul de numere prime din intervalul [1, i]. Pentru fiecare test din listă, funcția sortează valorile a și b și calculează diferența dintre prefix-suma lui b și prefix-suma lui a-1. În cele din urmă, rezultatele sunt stocate într-o lista

Funcția main este funcția principală a programului, care coordonează executarea acestuia. Ea verifică dacă programul este rulat ca script, sau este importat ca modul, prin intermediul instrucțiunii if __name__ == '__main__':.

Dacă programul este rulat ca script, atunci această instrucțiune va fi adevărată, iar codul din interiorul acesteia va fi executat. În acest caz, se deschide fișierul de intrare "cate.in" pentru citire, se citește prima linie pentru a obține cerința (cerinta) și numărul de teste (numar_teste), iar apoi se citește fiecare test și se stochează în lista teste. Aceste valori sunt folosite pentru a apela funcția valideaza_datele(cerinta, numar_teste, teste), care verifică dacă datele introduse sunt valide conform cerințelor impuse. Dacă datele sunt valide, atunci se apelează funcția corespunzătoare pentru a rezolva problema, fie rezolva_cerinta_1(teste) sau rezolva_cerinta_2(teste), în funcție de cerință. Rezultatele sunt stocate în lista rezultate, care este scrisă în fișierul de ieșire "cate.out", iar apoi se afișează un mesaj de confirmare a introducerii corecte a datelor.

Dacă programul este importat ca modul, atunci instrucțiunea if __name__ == '__main__': este falsă, iar codul din interiorul acesteia nu va fi executat. În acest caz, funcția main poate fi apelată din alt modul, pentru a rezolva problema cu datele date în parametrii funcției.

3763 - Puternic

2023-04-29T16:25:15Z

Sovago Rares-Andrei: /* Date de ieșire */

==Cerința==

Un număr puternic este un număr natural mai mare decât 1 care are proprietatea că dacă este divizibil cu numărul prim '''p''' atunci este divizibil și cu '''p^2'''. De exemplu, 36 și 27 sunt numere puternice, în timp ce 12 nu este număr puternic deoarece este divizibil cu 3 și nu este divizibil cu '''3^2'''. La ora de matematică elevii au aflat ce înseamnă un număr puternic. Pentru a verifica dacă elevii au înțeles, domnul profesor a scris pe tablă un șir de '''N''' numere naturale '''X1, X2, …, XN''' și l-a rugat pe Mihai să șteargă din șir numerele puternice.

Analizând numerele rămase, Mihai a observat că se poate obține un număr puternic prin concatenarea a două numere din șirul rămas, numere egal depărtate de capetele acestui nou șir. Concatenarea presupune lipirea numărului din a doua jumătate a șirului la finalul celui aflat în prima jumătate. Dacă noul șir are număr impar de elemente, elementul din mijloc se ignoră. De exemplu, dacă șirul obținut după ștergerea numerelor puternice este: 12, 1, 19, 13, 3, 21, 5 atunci numerele obținute prin concatenare sunt 125, 121, 193.
Scrieți un program care citește un număr natural N și apoi un șir de N numere naturale și determină:

Câte numere puternice sunt în șirul dat;
Care sunt perechile de numere din șirul rămas după ștergerea numerelor puternice, numere egal departate de capetele șirului, prin concatenarea cărora se obține un număr puternic.

== Date de intrare ==

Fișierul de intrare '''puternic.in''' conține pe prima linie un număr natural '''C'''. Pentru toate testele de intrare, numărul '''C''' poate avea doar valoarea 1 sau 2. Pe a doua linie a fișierului se găsește numărul natural '''N'''. Pe a treia linie se găsesc '''N''' numere naturale separate prin câte un spațiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Dacă '''C = 1''', se va rezolva cerința 1. În acest caz, fișierul de ieșire '''puternic.out''' va conține pe prima linie un număr natural reprezentând numărul de numere puternice din șirul dat.

Dacă '''C = 2''', se va rezolva cerința 2 În acest caz, fișierul de ieșire puternic.out va conține perechile de numere egal depărtate de capetele șirului obținut după ștergere, prin concatenarea cărora de obține un număr puternic. Fiecare pereche se scrie pe câte un rând, iar numerele din pereche se scriu separate printr-un spațiu, primul număr fiind cel din stânga. Dacă sunt mai multe astfel de perechi se vor afișa, în ordine, începând cu cea apropiată de capetele noului șir. Dacă nu există nicio astfel de pereche, în fișierul '''puternic.out''' se va afișa '''-1'''. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ N ≤ 100.000
*1 ≤ X1, X2, …, XN ≤ 1.000.000.000
== Exemple ==
===Exemplul 1===
; ''puternic.in''
:2
:11
:12 9 1 8 19 6 3 4 49 21 5
; ''ecran''
:Datele sunt introduse corect.
; ''puternic.out''
:12 5
:1 21

===Exemplul 2===
; ''puternic.in''
:1
:8
:100 28 16 11 484 25 162 27
; ''ecran''
:Datele sunt introduse corect.
; ''puternic.out''
:5
===Exemplul 3===
; ''puternic.in''
:2
:5
:1 2 3 4 5 6
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''puternic.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3763 - Puternic
import math

# Funcția de validare a datelor de intrare
def valideaza_intrare(C: int, N: int, nums: list[int]) -> bool:
# Verificăm că C este 1 sau 2
if C not in [1, 2]:
return False

# Verificăm că N este între 1 și 100.000
if not (1 <= N <= 100000):
return False

# Verificăm că lista nums are lungimea N și conține doar numere întregi între 1 și 1.000.000.000
if len(nums) != N or not all(isinstance(x, int) and 1 <= x <= 1000000000 for x in nums):
return False

return True

# Funcția de rezolvare
def rezolva(C: int, N: int, nums: list[int]) -> str:
# Cazul 1
if C == 1:
nrp = 0
for x in nums:
if x > 1 and este_puternic(x):
nrp += 1
return str(nrp)

# Cazul 2
nums_noi = []
for x in nums:
if x == 1 or not este_puternic(x):
nums_noi.append(x)

result = []
for i in range(len(nums_noi) // 2):
nr1 = nums_noi[i]
nr2 = nums_noi[-i - 1]
lp = concateneaza(nr1, nr2)
if este_puternic(lp):
result.append((nr1, nr2))

if not result:
return "-1"
else:
return "\n".join([f"{nr1} {nr2}" for nr1, nr2 in result])

# Funcția de verificare dacă un număr este puternic
def este_puternic(nr: int) -> bool:
# Calculăm descompunerea în factori primi și verificăm dacă toți au exponența mai mare sau egală cu 2
i = 2
while i * i <= nr:
ex = 0
while nr % i == 0:
ex += 1
nr //= i
if ex == 1:
return False
i += 1
if nr > 1:
ex = 1
if ex == 1:
return False

# Verificăm dacă nr este pătrat perfect sau cub perfect
sqrt_nr = round(math.sqrt(nr))
if sqrt_nr * sqrt_nr == nr:
return True
cub_rt = round(nr ** (1 / 3))
if cub_rt * cub_rt * cub_rt == nr:
return True
return False

# Funcția de concatenare a două numere întregi
def concateneaza(a: int, b: int) -> int:
s = str(a) + str(b)
return int(s)

if __name__ == "__main__":
with open("puternic.in", "r") as fin:
with open("puternic.out", "w") as fout:
C = int(fin.readline().strip())
N = int(fin.readline().strip())
nums = list(map(int, fin.readline().strip().split()))

if not valideaza_intrare(C, N, nums):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.\n")
rezultat = rezolva(C, N, nums)
fout.write(rezultat)

</syntaxhighlight>

==Explicatie==

Funcția valideaza_intrare(C: int, N: int, nums: list[int]) -> bool
Această funcție primește trei parametri de intrare:

C este un întreg care indică tipul de interogare pe care trebuie să o efectuăm (1 sau 2)
N este un întreg care indică numărul de numere întregi din lista nums
nums este o listă de N numere întregi, care sunt subiectul interogării
Funcția verifică dacă datele de intrare sunt valide și returnează True dacă sunt, altfel returnează False. Pentru a fi considerate valide, datele de intrare trebuie să îndeplinească următoarele condiții:

C trebuie să fie 1 sau 2
N trebuie să fie între 1 și 100.000
Lista nums trebuie să conțină exact N elemente și toate elementele trebuie să fie numere întregi între 1 și 1.000.000.000. 
Funcția rezolva(C: int, N: int, nums: list[int]) -> str
Această funcție primește aceiași trei parametri ca și funcția valideaza_intrare(). Funcția rezolvă problema specificată în enunț în funcție de tipul de interogare C, folosindu-se de celelalte două funcții (este_puternic() și concateneaza()) și returnează un șir de caractere care reprezintă rezultatul problemei.

Dacă C este 1, funcția numără numerele puternice din lista nums și returnează numărul rezultat. Dacă C este 2, funcția elimină din lista nums toate numerele puternice și numerele cu valoarea 1, apoi formează toate perechile posibile de numere rămase, concatenând fiecare pereche și verificând dacă numărul obținut este puternic. Dacă există cel puțin o astfel de pereche, funcția returnează o listă de perechi de numere care satisfac condiția, altfel returnează valoarea "-1". 

Funcția este_puternic(nr: int) -> bool
Această funcție primește un singur parametru, nr, care este un număr întreg. Funcția verifică dacă numărul nr este puternic și returnează True dacă este și False în caz contrar.

Un număr este puternic dacă toți factorii lui primi sunt ridicați la puterea cel puțin 2 sau dacă este pătrat perfect sau cub perfect. Această funcție utilizează metoda descompunerii în factori primi pentru a verifica dacă toți factorii primi ai numărului nr au exponența mai mare sau egală cu 2.
Funcția concateneaza(a: int, b: int) -> int
Această funcție primește două numere întregi a și b și le concatenează într-un singur număr. De exemplu, dacă a este 1234 și b este 5678, atunci concateneaza(a, b) va returna numărul 12345678. 

Funcția main()
Această funcție nu primește niciun parametru, dar conține codul care citește datele de intrare din fișierul puternic.in, validează datele folosind funcția valideaza_intrare(), apoi calculează rezultatul utilizând funcția rezolva().

Dacă datele de intrare sunt invalide, funcția afișează un mesaj corespunzător. În caz contrar, funcția scrie rezultatul în fișierul puternic.out și afișează un mesaj de confirmare.

Este important de menționat că această implementare folosește tipuri de date și anotări de tipuri, care sunt specifice Python-ului. De asemenea, codul este scris într-un stil modular, care face ca fiecare funcție să aibă un singur scop și să fie ușor de înțeles și de testat.

3763 - Puternic

2023-04-29T16:24:28Z

Sovago Rares-Andrei: /* Cerința */

==Cerința==

Un număr puternic este un număr natural mai mare decât 1 care are proprietatea că dacă este divizibil cu numărul prim '''p''' atunci este divizibil și cu '''p^2'''. De exemplu, 36 și 27 sunt numere puternice, în timp ce 12 nu este număr puternic deoarece este divizibil cu 3 și nu este divizibil cu '''3^2'''. La ora de matematică elevii au aflat ce înseamnă un număr puternic. Pentru a verifica dacă elevii au înțeles, domnul profesor a scris pe tablă un șir de '''N''' numere naturale '''X1, X2, …, XN''' și l-a rugat pe Mihai să șteargă din șir numerele puternice.

Analizând numerele rămase, Mihai a observat că se poate obține un număr puternic prin concatenarea a două numere din șirul rămas, numere egal depărtate de capetele acestui nou șir. Concatenarea presupune lipirea numărului din a doua jumătate a șirului la finalul celui aflat în prima jumătate. Dacă noul șir are număr impar de elemente, elementul din mijloc se ignoră. De exemplu, dacă șirul obținut după ștergerea numerelor puternice este: 12, 1, 19, 13, 3, 21, 5 atunci numerele obținute prin concatenare sunt 125, 121, 193.
Scrieți un program care citește un număr natural N și apoi un șir de N numere naturale și determină:

Câte numere puternice sunt în șirul dat;
Care sunt perechile de numere din șirul rămas după ștergerea numerelor puternice, numere egal departate de capetele șirului, prin concatenarea cărora se obține un număr puternic.

== Date de intrare ==

Fișierul de intrare '''puternic.in''' conține pe prima linie un număr natural '''C'''. Pentru toate testele de intrare, numărul '''C''' poate avea doar valoarea 1 sau 2. Pe a doua linie a fișierului se găsește numărul natural '''N'''. Pe a treia linie se găsesc '''N''' numere naturale separate prin câte un spațiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Dacă '''C = 1''', se va rezolva cerința 1. În acest caz, fișierul de ieșire '''puternic.out''' va conține pe prima linie un număr natural reprezentând numărul de numere puternice din șirul dat.

Dacă '''C = 2''', se va rezolva cerința 2 În acest caz, fișierul de ieșire puternic.out va conține perechile de numere egal depărtate de capetele șirului obținut după ștergere, prin concatenarea cărora de obține un număr puternic. Fiecare pereche se scrie pe câte un rând, iar numerele din pereche se scriu separate printr-un spațiu, primul număr fiind cel din stânga. Dacă sunt mai multe astfel de perechi se vor afișa, în ordine, începând cu cea apropiată de capetele noului șir. Dacă nu există nicio astfel de pereche, în fișierul puternic.out se va afișa -1. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ N ≤ 100.000
*1 ≤ X1, X2, …, XN ≤ 1.000.000.000
== Exemple ==
===Exemplul 1===
; ''puternic.in''
:2
:11
:12 9 1 8 19 6 3 4 49 21 5
; ''ecran''
:Datele sunt introduse corect.
; ''puternic.out''
:12 5
:1 21

===Exemplul 2===
; ''puternic.in''
:1
:8
:100 28 16 11 484 25 162 27
; ''ecran''
:Datele sunt introduse corect.
; ''puternic.out''
:5
===Exemplul 3===
; ''puternic.in''
:2
:5
:1 2 3 4 5 6
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''puternic.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3763 - Puternic
import math

# Funcția de validare a datelor de intrare
def valideaza_intrare(C: int, N: int, nums: list[int]) -> bool:
# Verificăm că C este 1 sau 2
if C not in [1, 2]:
return False

# Verificăm că N este între 1 și 100.000
if not (1 <= N <= 100000):
return False

# Verificăm că lista nums are lungimea N și conține doar numere întregi între 1 și 1.000.000.000
if len(nums) != N or not all(isinstance(x, int) and 1 <= x <= 1000000000 for x in nums):
return False

return True

# Funcția de rezolvare
def rezolva(C: int, N: int, nums: list[int]) -> str:
# Cazul 1
if C == 1:
nrp = 0
for x in nums:
if x > 1 and este_puternic(x):
nrp += 1
return str(nrp)

# Cazul 2
nums_noi = []
for x in nums:
if x == 1 or not este_puternic(x):
nums_noi.append(x)

result = []
for i in range(len(nums_noi) // 2):
nr1 = nums_noi[i]
nr2 = nums_noi[-i - 1]
lp = concateneaza(nr1, nr2)
if este_puternic(lp):
result.append((nr1, nr2))

if not result:
return "-1"
else:
return "\n".join([f"{nr1} {nr2}" for nr1, nr2 in result])

# Funcția de verificare dacă un număr este puternic
def este_puternic(nr: int) -> bool:
# Calculăm descompunerea în factori primi și verificăm dacă toți au exponența mai mare sau egală cu 2
i = 2
while i * i <= nr:
ex = 0
while nr % i == 0:
ex += 1
nr //= i
if ex == 1:
return False
i += 1
if nr > 1:
ex = 1
if ex == 1:
return False

# Verificăm dacă nr este pătrat perfect sau cub perfect
sqrt_nr = round(math.sqrt(nr))
if sqrt_nr * sqrt_nr == nr:
return True
cub_rt = round(nr ** (1 / 3))
if cub_rt * cub_rt * cub_rt == nr:
return True
return False

# Funcția de concatenare a două numere întregi
def concateneaza(a: int, b: int) -> int:
s = str(a) + str(b)
return int(s)

if __name__ == "__main__":
with open("puternic.in", "r") as fin:
with open("puternic.out", "w") as fout:
C = int(fin.readline().strip())
N = int(fin.readline().strip())
nums = list(map(int, fin.readline().strip().split()))

if not valideaza_intrare(C, N, nums):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.\n")
rezultat = rezolva(C, N, nums)
fout.write(rezultat)

</syntaxhighlight>

==Explicatie==

Funcția valideaza_intrare(C: int, N: int, nums: list[int]) -> bool
Această funcție primește trei parametri de intrare:

C este un întreg care indică tipul de interogare pe care trebuie să o efectuăm (1 sau 2)
N este un întreg care indică numărul de numere întregi din lista nums
nums este o listă de N numere întregi, care sunt subiectul interogării
Funcția verifică dacă datele de intrare sunt valide și returnează True dacă sunt, altfel returnează False. Pentru a fi considerate valide, datele de intrare trebuie să îndeplinească următoarele condiții:

C trebuie să fie 1 sau 2
N trebuie să fie între 1 și 100.000
Lista nums trebuie să conțină exact N elemente și toate elementele trebuie să fie numere întregi între 1 și 1.000.000.000. 
Funcția rezolva(C: int, N: int, nums: list[int]) -> str
Această funcție primește aceiași trei parametri ca și funcția valideaza_intrare(). Funcția rezolvă problema specificată în enunț în funcție de tipul de interogare C, folosindu-se de celelalte două funcții (este_puternic() și concateneaza()) și returnează un șir de caractere care reprezintă rezultatul problemei.

Dacă C este 1, funcția numără numerele puternice din lista nums și returnează numărul rezultat. Dacă C este 2, funcția elimină din lista nums toate numerele puternice și numerele cu valoarea 1, apoi formează toate perechile posibile de numere rămase, concatenând fiecare pereche și verificând dacă numărul obținut este puternic. Dacă există cel puțin o astfel de pereche, funcția returnează o listă de perechi de numere care satisfac condiția, altfel returnează valoarea "-1". 

Funcția este_puternic(nr: int) -> bool
Această funcție primește un singur parametru, nr, care este un număr întreg. Funcția verifică dacă numărul nr este puternic și returnează True dacă este și False în caz contrar.

Un număr este puternic dacă toți factorii lui primi sunt ridicați la puterea cel puțin 2 sau dacă este pătrat perfect sau cub perfect. Această funcție utilizează metoda descompunerii în factori primi pentru a verifica dacă toți factorii primi ai numărului nr au exponența mai mare sau egală cu 2.
Funcția concateneaza(a: int, b: int) -> int
Această funcție primește două numere întregi a și b și le concatenează într-un singur număr. De exemplu, dacă a este 1234 și b este 5678, atunci concateneaza(a, b) va returna numărul 12345678. 

Funcția main()
Această funcție nu primește niciun parametru, dar conține codul care citește datele de intrare din fișierul puternic.in, validează datele folosind funcția valideaza_intrare(), apoi calculează rezultatul utilizând funcția rezolva().

Dacă datele de intrare sunt invalide, funcția afișează un mesaj corespunzător. În caz contrar, funcția scrie rezultatul în fișierul puternic.out și afișează un mesaj de confirmare.

Este important de menționat că această implementare folosește tipuri de date și anotări de tipuri, care sunt specifice Python-ului. De asemenea, codul este scris într-un stil modular, care face ca fiecare funcție să aibă un singur scop și să fie ușor de înțeles și de testat.

3763 - Puternic

2023-04-29T16:24:09Z

Sovago Rares-Andrei: /* Cerința */

==Cerința==

Un număr puternic este un număr natural mai mare decât 1 care are proprietatea că dacă este divizibil cu numărul prim p atunci este divizibil și cu '''p^2'''. De exemplu, 36 și 27 sunt numere puternice, în timp ce 12 nu este număr puternic deoarece este divizibil cu 3 și nu este divizibil cu '''3^2'''. La ora de matematică elevii au aflat ce înseamnă un număr puternic. Pentru a verifica dacă elevii au înțeles, domnul profesor a scris pe tablă un șir de '''N''' numere naturale '''X1, X2, …, XN''' și l-a rugat pe Mihai să șteargă din șir numerele puternice.

Analizând numerele rămase, Mihai a observat că se poate obține un număr puternic prin concatenarea a două numere din șirul rămas, numere egal depărtate de capetele acestui nou șir. Concatenarea presupune lipirea numărului din a doua jumătate a șirului la finalul celui aflat în prima jumătate. Dacă noul șir are număr impar de elemente, elementul din mijloc se ignoră. De exemplu, dacă șirul obținut după ștergerea numerelor puternice este: 12, 1, 19, 13, 3, 21, 5 atunci numerele obținute prin concatenare sunt 125, 121, 193.
Scrieți un program care citește un număr natural N și apoi un șir de N numere naturale și determină:

Câte numere puternice sunt în șirul dat;
Care sunt perechile de numere din șirul rămas după ștergerea numerelor puternice, numere egal departate de capetele șirului, prin concatenarea cărora se obține un număr puternic.

== Date de intrare ==

Fișierul de intrare '''puternic.in''' conține pe prima linie un număr natural '''C'''. Pentru toate testele de intrare, numărul '''C''' poate avea doar valoarea 1 sau 2. Pe a doua linie a fișierului se găsește numărul natural '''N'''. Pe a treia linie se găsesc '''N''' numere naturale separate prin câte un spațiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Dacă '''C = 1''', se va rezolva cerința 1. În acest caz, fișierul de ieșire '''puternic.out''' va conține pe prima linie un număr natural reprezentând numărul de numere puternice din șirul dat.

Dacă '''C = 2''', se va rezolva cerința 2 În acest caz, fișierul de ieșire puternic.out va conține perechile de numere egal depărtate de capetele șirului obținut după ștergere, prin concatenarea cărora de obține un număr puternic. Fiecare pereche se scrie pe câte un rând, iar numerele din pereche se scriu separate printr-un spațiu, primul număr fiind cel din stânga. Dacă sunt mai multe astfel de perechi se vor afișa, în ordine, începând cu cea apropiată de capetele noului șir. Dacă nu există nicio astfel de pereche, în fișierul puternic.out se va afișa -1. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ N ≤ 100.000
*1 ≤ X1, X2, …, XN ≤ 1.000.000.000
== Exemple ==
===Exemplul 1===
; ''puternic.in''
:2
:11
:12 9 1 8 19 6 3 4 49 21 5
; ''ecran''
:Datele sunt introduse corect.
; ''puternic.out''
:12 5
:1 21

===Exemplul 2===
; ''puternic.in''
:1
:8
:100 28 16 11 484 25 162 27
; ''ecran''
:Datele sunt introduse corect.
; ''puternic.out''
:5
===Exemplul 3===
; ''puternic.in''
:2
:5
:1 2 3 4 5 6
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''puternic.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3763 - Puternic
import math

# Funcția de validare a datelor de intrare
def valideaza_intrare(C: int, N: int, nums: list[int]) -> bool:
# Verificăm că C este 1 sau 2
if C not in [1, 2]:
return False

# Verificăm că N este între 1 și 100.000
if not (1 <= N <= 100000):
return False

# Verificăm că lista nums are lungimea N și conține doar numere întregi între 1 și 1.000.000.000
if len(nums) != N or not all(isinstance(x, int) and 1 <= x <= 1000000000 for x in nums):
return False

return True

# Funcția de rezolvare
def rezolva(C: int, N: int, nums: list[int]) -> str:
# Cazul 1
if C == 1:
nrp = 0
for x in nums:
if x > 1 and este_puternic(x):
nrp += 1
return str(nrp)

# Cazul 2
nums_noi = []
for x in nums:
if x == 1 or not este_puternic(x):
nums_noi.append(x)

result = []
for i in range(len(nums_noi) // 2):
nr1 = nums_noi[i]
nr2 = nums_noi[-i - 1]
lp = concateneaza(nr1, nr2)
if este_puternic(lp):
result.append((nr1, nr2))

if not result:
return "-1"
else:
return "\n".join([f"{nr1} {nr2}" for nr1, nr2 in result])

# Funcția de verificare dacă un număr este puternic
def este_puternic(nr: int) -> bool:
# Calculăm descompunerea în factori primi și verificăm dacă toți au exponența mai mare sau egală cu 2
i = 2
while i * i <= nr:
ex = 0
while nr % i == 0:
ex += 1
nr //= i
if ex == 1:
return False
i += 1
if nr > 1:
ex = 1
if ex == 1:
return False

# Verificăm dacă nr este pătrat perfect sau cub perfect
sqrt_nr = round(math.sqrt(nr))
if sqrt_nr * sqrt_nr == nr:
return True
cub_rt = round(nr ** (1 / 3))
if cub_rt * cub_rt * cub_rt == nr:
return True
return False

# Funcția de concatenare a două numere întregi
def concateneaza(a: int, b: int) -> int:
s = str(a) + str(b)
return int(s)

if __name__ == "__main__":
with open("puternic.in", "r") as fin:
with open("puternic.out", "w") as fout:
C = int(fin.readline().strip())
N = int(fin.readline().strip())
nums = list(map(int, fin.readline().strip().split()))

if not valideaza_intrare(C, N, nums):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.\n")
rezultat = rezolva(C, N, nums)
fout.write(rezultat)

</syntaxhighlight>

==Explicatie==

Funcția valideaza_intrare(C: int, N: int, nums: list[int]) -> bool
Această funcție primește trei parametri de intrare:

C este un întreg care indică tipul de interogare pe care trebuie să o efectuăm (1 sau 2)
N este un întreg care indică numărul de numere întregi din lista nums
nums este o listă de N numere întregi, care sunt subiectul interogării
Funcția verifică dacă datele de intrare sunt valide și returnează True dacă sunt, altfel returnează False. Pentru a fi considerate valide, datele de intrare trebuie să îndeplinească următoarele condiții:

C trebuie să fie 1 sau 2
N trebuie să fie între 1 și 100.000
Lista nums trebuie să conțină exact N elemente și toate elementele trebuie să fie numere întregi între 1 și 1.000.000.000. 
Funcția rezolva(C: int, N: int, nums: list[int]) -> str
Această funcție primește aceiași trei parametri ca și funcția valideaza_intrare(). Funcția rezolvă problema specificată în enunț în funcție de tipul de interogare C, folosindu-se de celelalte două funcții (este_puternic() și concateneaza()) și returnează un șir de caractere care reprezintă rezultatul problemei.

Dacă C este 1, funcția numără numerele puternice din lista nums și returnează numărul rezultat. Dacă C este 2, funcția elimină din lista nums toate numerele puternice și numerele cu valoarea 1, apoi formează toate perechile posibile de numere rămase, concatenând fiecare pereche și verificând dacă numărul obținut este puternic. Dacă există cel puțin o astfel de pereche, funcția returnează o listă de perechi de numere care satisfac condiția, altfel returnează valoarea "-1". 

Funcția este_puternic(nr: int) -> bool
Această funcție primește un singur parametru, nr, care este un număr întreg. Funcția verifică dacă numărul nr este puternic și returnează True dacă este și False în caz contrar.

Un număr este puternic dacă toți factorii lui primi sunt ridicați la puterea cel puțin 2 sau dacă este pătrat perfect sau cub perfect. Această funcție utilizează metoda descompunerii în factori primi pentru a verifica dacă toți factorii primi ai numărului nr au exponența mai mare sau egală cu 2.
Funcția concateneaza(a: int, b: int) -> int
Această funcție primește două numere întregi a și b și le concatenează într-un singur număr. De exemplu, dacă a este 1234 și b este 5678, atunci concateneaza(a, b) va returna numărul 12345678. 

Funcția main()
Această funcție nu primește niciun parametru, dar conține codul care citește datele de intrare din fișierul puternic.in, validează datele folosind funcția valideaza_intrare(), apoi calculează rezultatul utilizând funcția rezolva().

Dacă datele de intrare sunt invalide, funcția afișează un mesaj corespunzător. În caz contrar, funcția scrie rezultatul în fișierul puternic.out și afișează un mesaj de confirmare.

Este important de menționat că această implementare folosește tipuri de date și anotări de tipuri, care sunt specifice Python-ului. De asemenea, codul este scris într-un stil modular, care face ca fiecare funcție să aibă un singur scop și să fie ușor de înțeles și de testat.

3733 - Cosuri

2023-04-29T16:22:49Z

Sovago Rares-Andrei:

==Cerința==

Se consideră '''N''' coșuri numerotate cu numerele distincte de la 1 la '''2•N'''.
Coșul 1 conține '''C1''' mere, coșul 2 conține '''C2''' mere,…, coșul '''2•N''' conține '''C2•N''' mere.

Cele '''2•N''' coșuri vor fi grupate două câte două, rezultând N perechi de coșuri. Fiecare coș poate face parte dintr-o singură pereche. Numărul de mere dintr-o pereche de coșuri este egal cu suma numerelor de mere din cele două coșuri. Pentru fiecare pereche, valoarea absolută a diferenței numerelor de mere din cele două coșuri ale perechii reprezintă excedentul perechii.

Ionuț, având o fire curioasă, vrea să afle mai multe despre aceste perechi.

Mai întâi vrea să afle numărul minim posibil, respectiv maxim posibil, de mere dintr-o pereche, indiferent de gruparea coșurilor în perechi de câte două.

Apoi, Ionuț vă întreabă dacă este posibil să grupeze cele '''2•N''' coșuri în perechi de câte două, astfel încât cele N perechi rezultate să aibă același număr de mere. Dacă este posibil, atunci Ionuț vrea să afle și care este valoarea minimă a excedentelor perechilor din noua grupare.

Voi va trebui să îl ajutați pe Ionuț să afle răspunsurile la întrebările lui.
Scrieți un program care să citească numărul N și cele '''2•N''' numere naturale '''C1, C2,…, C2•N''', iar apoi să determine:

1. Numărul minim de mere și numărul maxim de mere pe care le pot avea perechile de coșuri.

2. Răspunsul '''DA''' sau '''NU''' la întrebarea lui Ionuț; dacă răspunsul este DA, se va determina și care este valoarea minimă a excedentelor perechilor din noua grupare.
== Date de intrare ==

Fișierul de intrare cosuri.in conține pe prima linie două numere naturale '''T''' și '''N''' separate printr-un spațiu. A doua linie a fișierului conține cele 2•N numere naturale C1, C2,…, C2•N, separate prin câte un spațiu.

== Date de intrare ==

Fișierul de intrare cosuri.in conține pe prima linie două numere naturale '''T''' și '''N''' separate printr-un spațiu. A doua linie a fișierului conține cele '''2•N''' numere naturale '''C1''', '''C2''',…, '''C2•N''', separate prin câte un spațiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire cosuri.out va conține:

Dacă '''T=1''', pe prima linie, două numere naturale separate printr-un singur spațiu reprezentând numărul minim, respectiv maxim de mere pe care le pot avea perechile (răspunsul la cerinţa 1);
Dacă '''T=2''', pe prima linie, un șir de două caractere care poate fi '''DA''' sau '''NU''', reprezentând răspunsul la întrebarea lui Ionuț; dacă răspunsul este DA, atunci a doua linie a fișierului va conține un număr natural reprezentând valoarea minimă a excedentelor perechilor din noua grupare (răspunsul la cerința 2). În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ '''N''' ≤ 500 000
*1 ≤ '''Ci''' ≤ 1 000 000, pentru oricare 1 ≤ i ≤ '''2·N'''
*Pentru teste în valoare de 30 de puncte, '''T = 1'''
*Pentru restul de 70 de puncte, '''T= 2'''
*Pentru teste în valoare de 20 de puncte, '''N ≤ 5'''
*Pentru alte teste în valoare de 40 de puncte, '''N ≤ 70000'''
== Exemple ==
===Exemplul 1===
; ''cosuri.in''
:1 3
:1 7 4 10 2 9
; ''ecran''
:Datele sunt introduse corect.
; ''cosuri.out''
:3 19

===Exemplul 2===
; ''cosuri.in''
:2 3
:1 7 4 10 2 9
; ''ecran''
:Datele sunt introduse corect.
; ''cosuri.out''
:DA
:3
===Exemplul 3===
; ''puternic.in''
:2 3
:1 7 5 12 2 9
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''puternic.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3733 - Cosuri
import math

# Funcția de validare a datelor de intrare
# Funcția de validare a datelor de intrare
def validate_input(C: int, N: int, nums: list[int]) -> bool:
# Verificăm că C este 1 sau 2
if C not in [1, 2]:
return False

# Verificăm că N este între 1 și 100.000
if not (1 <= N <= 100000):
return False

# Verificăm că lista nums are lungimea N și conține doar numere întregi între 1 și 1.000.000.000
if len(nums) != N or not all(isinstance(x, int) and 1 <= x <= 1000000000 for x in nums):
return False

return True

# Funcția de rezolvare
def solve(C: int, N: int, nums: list[int]) -> str:
# Cazul 1
if C == 1:
nrp = 0
for x in nums:
if x > 1 and is_powerful(x):
nrp += 1
return str(nrp)

# Cazul 2
new_nums = []
for x in nums:
if x == 1 or not is_powerful(x):
new_nums.append(x)

result = []
for i in range(len(new_nums) // 2):
nr1 = new_nums[i]
nr2 = new_nums[-i - 1]
lp = concat(nr1, nr2)
if is_powerful(lp):
result.append((nr1, nr2))

if not result:
return "-1"
else:
return "\n".join([f"{nr1} {nr2}" for nr1, nr2 in result])

# Funcția de concatenare și verificare dacă numărul obținut este puternic
def is_powerful(nr: int) -> bool:
# Calculăm descompunerea în factori primi și verificăm dacă toți au exponența mai mare sau egală cu 2
i = 2
while i * i <= nr:
ex = 0
while nr % i == 0:
ex += 1
nr //= i
if ex == 1:
return False
i += 1
if nr > 1:
ex = 1
if ex == 1:
return False

# Verificăm dacă nr este pătrat perfect sau cub perfect
sqrt_nr = round(math.sqrt(nr))
if sqrt_nr * sqrt_nr == nr:
return True
cub_rt = round(nr ** (1 / 3))
if cub_rt * cub_rt * cub_rt == nr:
return True
return False

# Funcția de concatenare a două numere întregi
def concat(a: int, b: int) -> int:
s = str(a) + str(b)
return int(s)

# Funcția main care citește și afișează datele din fișiere
# Funcția main care citește și afișează datele din fișiere
if __name__ == "__main__":
with open("puternic.in", "r") as fin:
with open("puternic.out", "w") as fout:
C = int(fin.readline().strip())
N = int(fin.readline().strip())
nums = list(map(int, fin.readline().strip().split()))

if not validate_input(C, N, nums):
print ("Datele nu corespund restricțiilor impuse.")
else:
print ("Datele sunt introduse corect.\n")
if C == 1:
nrp = 0
for x in nums:
if x > 1 and is_powerful(x):
nrp += 1
fout.write(str(nrp))
elif C == 2:
new_nums = []
for x in nums:
if x == 1 or not is_powerful(x):
new_nums.append(x)

result = []
for i in range(len(new_nums) // 2):
nr1 = new_nums[i]
nr2 = new_nums[-i - 1]
lp = concat(nr1, nr2)
if is_powerful(lp):
result.append((nr1, nr2))

if not result:
fout.write("-1")
else:
fout.write("\n".join([f"{nr1} {nr2}" for nr1, nr2 in result]))

</syntaxhighlight>

==Explicatie==

3718 - Tort2

2023-04-29T16:21:09Z

Sovago Rares-Andrei: /* Date de intrare */

==Cerința==

Alexandra, prințesa Regatului Visurilor a primit un tort și vrea să-l împartă cu prietenii ei. Astfel ea va organiza o petrecere unde îi va invita. Tortul Alexandrei este format din N bucăți, iar a i-a bucată are ai cireșe. Alexandra va împărți tortul în mai multe secvențe continue de bucăți, astfel încât fiecare bucată este inclusă în exact o secvență, și fiecare secvență conține cel puțin o bucată de tort. Prima secvență – cea care conține prima bucată – o va mânca în noaptea de dinaintea petrecerii, iar restul bucăților le va da celorlalți prieteni invitați. Pentru a nu-i supăra, Alexandra vrea ca fiecare secvență dată unui prieten să conțină la fel de multe cireșe ca oricare altă secvență dată unui prieten (dar nu neapărat la fel de multe cireșe ca aceea mâncată de ea înaintea petrecerii). Alexandra trebuie să invite cel puțin un prieten la petrecere.
Dându-se N și șirul a, să se afle numărul de moduri în care Alexandra ar putea să împartă tortul în secvențe continue astfel încât să se respecte condițiile din enunț. Două moduri de a împărți tortul se consideră a fi distincte dacă și numai dacă există în unul o secvență care nu există în celălalt (dacă am reprezenta un mod de împărțire în secvențe prin intermediul șirului crescător al indicilor de început pentru fiecare secvență din acea împărțire, două moduri de împărțire sunt distincte dacă șirurile de indici asociate lor sunt diferite).

Formal, dându-se un șir de numere, se vrea să aflăm numărul de moduri de a împărți șirul în cel puțin două subsecvențe, astfel încât sumele elementelor tuturor subsecvențelor să fie egale, prima putând să aibă suma elementelor diferită de a celorlalte.
== Date de intrare ==

Prima linie a fișierului de intrare tort.in conține numărul '''N'''. A doua linie conține valorile '''a1, …, aN''', separate prin spații.

== Date de intrare ==

Fișierul de intrare cosuri.in conține pe prima linie două numere naturale '''T''' și '''N''' separate printr-un spațiu. A doua linie a fișierului conține cele '''2•N''' numere naturale '''C1''', '''C2''',…, '''C2•N''', separate prin câte un spațiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Singura linie a fișierului de ieșire tort.out va conține numărul cerut. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ N ≤ 200.000
*1 ≤ ai ≤ 400.000
*a1 + ... + aN ≤ 400.000
*Pentru 12 puncte, N ≤ 12
*Pentru alte 12 puncte, 1 ≤ N ≤ 100 și a1 = ... = aN = 1
*Pentru alte 20 puncte, 1 ≤ N ≤ 100
*Pentru alte 28 puncte, 1 ≤ N ≤ 1000 și a1 + ... + aN ≤ 2000
*Pentru alte 28 puncte, fără alte restricții
== Exemple ==
===Exemplul 1===
; ''tort.in''
:5
:1 1 2 1 1
; ''ecran''
:Datele sunt introduse corect.
; ''tort.out''
:1

===Exemplul 2===
; ''tort.in''
:7
:3 1 4 1 5 9 2
; ''ecran''
:Datele sunt introduse corect.
; ''tort.out''
:4
===Exemplul 3===
; ''tort.in''
:1
:1000000
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''tort.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3718 - Tort2
import sys

def validare_input(n, secventa):
if n < 2 or n > 200000:
return False
for numar in secventa:
if numar < 1 or numar > 400000:
return False
return True

def poate_imparti_secventa(secventa, n, suma_dorita, index, bucata_curenta, prieteni):
if prieteni == 1:
return False

if bucata_curenta == suma_dorita:
if prieteni == 2:
return True
return poate_imparti_secventa(secventa, n, suma_dorita, 0, 0, prieteni - 1)

for i in range(index, n):
if secventa[i] + bucata_curenta <= suma_dorita:
if poate_imparti_secventa(secventa, n, suma_dorita, i + 1, secventa[i] + bucata_curenta, prieteni):
return True

return False

def rezolvare(n, secventa):
suma_totala = sum(secventa)

for i in range(2, n + 2):
if suma_totala % i != 0:
continue

suma_dorita = suma_totala // i
if secventa[0] > suma_dorita:
continue

if poate_imparti_secventa(secventa, n, suma_dorita, 1, secventa[0], i):
return i - 1

return 0

if __name__ == "__main__":
with open("tort.in", "r") as fin:
dimensiune = int(fin.readline().strip())
secventa = list(map(int, fin.readline().split()))

if not validare_input(dimensiune, secventa):
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)

print("Datele sunt introduse corect.")
with open("tort.out", "w") as fout:
ans = rezolvare(dimensiune, secventa)
fout.write(str(ans))

</syntaxhighlight>

==Explicatie==

Funcția validare_input(n, secventa) primește doi parametri: n, care reprezintă numărul de elemente din secvență și secventa, o listă de n numere întregi. Această funcție verifică dacă datele de intrare îndeplinesc condițiile impuse: n trebuie să fie cuprins între 2 și 200000, iar fiecare element din secventa trebuie să fie cuprins între 1 și 400000. Dacă datele de intrare nu îndeplinesc aceste condiții, se afișează un mesaj corespunzător și se iese din program cu ajutorul funcției sys.exit(0). Dacă datele de intrare sunt valide, se calculează și se returnează suma elementelor din secvență.

Funcția poate_imparti_secventa(secventa, n, suma_dorita, index, bucata_curenta, prieteni) primește șase parametri:

secventa: lista de numere întregi care reprezintă secvența de împărțit
n: numărul de elemente din secvență
suma_dorita: suma dorită a bucăților, adică suma totală împărțită la numărul de prieteni
index: indexul elementului curent din secvență
bucata_curenta: suma curentă a bucății de împărțit
prieteni: numărul de prieteni rămași
Această funcție verifică dacă secvența secventa poate fi împărțită în prieteni bucăți astfel încât fiecare bucată să aibă suma suma_dorita. Funcția utilizează o abordare recursivă și verifică toate posibilitățile de împărțire, începând de la indexul index. Dacă secvența poate fi împărțită cu succes, se returnează True, altfel se returnează False.

Funcția rezolvare(n, secventa) primește aceiași doi parametri ca și funcția validare_input(n, secventa). Această funcție calculează suma totală a elementelor din secvență prin apelarea funcției validare_input(n, secventa) și apoi parcurge toate posibilitățile de împărțire a secvenței în bucăți egale. Dacă găsește o împărțire validă, returnează numărul de prieteni implicați în împărțire. Dacă nu există o împărțire validă, se returne

3718 - Tort2

2023-04-29T16:20:51Z

Sovago Rares-Andrei: /* Date de intrare */

==Cerința==

Alexandra, prințesa Regatului Visurilor a primit un tort și vrea să-l împartă cu prietenii ei. Astfel ea va organiza o petrecere unde îi va invita. Tortul Alexandrei este format din N bucăți, iar a i-a bucată are ai cireșe. Alexandra va împărți tortul în mai multe secvențe continue de bucăți, astfel încât fiecare bucată este inclusă în exact o secvență, și fiecare secvență conține cel puțin o bucată de tort. Prima secvență – cea care conține prima bucată – o va mânca în noaptea de dinaintea petrecerii, iar restul bucăților le va da celorlalți prieteni invitați. Pentru a nu-i supăra, Alexandra vrea ca fiecare secvență dată unui prieten să conțină la fel de multe cireșe ca oricare altă secvență dată unui prieten (dar nu neapărat la fel de multe cireșe ca aceea mâncată de ea înaintea petrecerii). Alexandra trebuie să invite cel puțin un prieten la petrecere.
Dându-se N și șirul a, să se afle numărul de moduri în care Alexandra ar putea să împartă tortul în secvențe continue astfel încât să se respecte condițiile din enunț. Două moduri de a împărți tortul se consideră a fi distincte dacă și numai dacă există în unul o secvență care nu există în celălalt (dacă am reprezenta un mod de împărțire în secvențe prin intermediul șirului crescător al indicilor de început pentru fiecare secvență din acea împărțire, două moduri de împărțire sunt distincte dacă șirurile de indici asociate lor sunt diferite).

Formal, dându-se un șir de numere, se vrea să aflăm numărul de moduri de a împărți șirul în cel puțin două subsecvențe, astfel încât sumele elementelor tuturor subsecvențelor să fie egale, prima putând să aibă suma elementelor diferită de a celorlalte.
== Date de intrare ==

Prima linie a fișierului de intrare tort.in conține numărul '''N'''. A doua linie conține valorile a1, …, aN, separate prin spații.

== Date de intrare ==

Fișierul de intrare cosuri.in conține pe prima linie două numere naturale '''T''' și '''N''' separate printr-un spațiu. A doua linie a fișierului conține cele '''2•N''' numere naturale '''C1''', '''C2''',…, '''C2•N''', separate prin câte un spațiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Singura linie a fișierului de ieșire tort.out va conține numărul cerut. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ N ≤ 200.000
*1 ≤ ai ≤ 400.000
*a1 + ... + aN ≤ 400.000
*Pentru 12 puncte, N ≤ 12
*Pentru alte 12 puncte, 1 ≤ N ≤ 100 și a1 = ... = aN = 1
*Pentru alte 20 puncte, 1 ≤ N ≤ 100
*Pentru alte 28 puncte, 1 ≤ N ≤ 1000 și a1 + ... + aN ≤ 2000
*Pentru alte 28 puncte, fără alte restricții
== Exemple ==
===Exemplul 1===
; ''tort.in''
:5
:1 1 2 1 1
; ''ecran''
:Datele sunt introduse corect.
; ''tort.out''
:1

===Exemplul 2===
; ''tort.in''
:7
:3 1 4 1 5 9 2
; ''ecran''
:Datele sunt introduse corect.
; ''tort.out''
:4
===Exemplul 3===
; ''tort.in''
:1
:1000000
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''tort.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3718 - Tort2
import sys

def validare_input(n, secventa):
if n < 2 or n > 200000:
return False
for numar in secventa:
if numar < 1 or numar > 400000:
return False
return True

def poate_imparti_secventa(secventa, n, suma_dorita, index, bucata_curenta, prieteni):
if prieteni == 1:
return False

if bucata_curenta == suma_dorita:
if prieteni == 2:
return True
return poate_imparti_secventa(secventa, n, suma_dorita, 0, 0, prieteni - 1)

for i in range(index, n):
if secventa[i] + bucata_curenta <= suma_dorita:
if poate_imparti_secventa(secventa, n, suma_dorita, i + 1, secventa[i] + bucata_curenta, prieteni):
return True

return False

def rezolvare(n, secventa):
suma_totala = sum(secventa)

for i in range(2, n + 2):
if suma_totala % i != 0:
continue

suma_dorita = suma_totala // i
if secventa[0] > suma_dorita:
continue

if poate_imparti_secventa(secventa, n, suma_dorita, 1, secventa[0], i):
return i - 1

return 0

if __name__ == "__main__":
with open("tort.in", "r") as fin:
dimensiune = int(fin.readline().strip())
secventa = list(map(int, fin.readline().split()))

if not validare_input(dimensiune, secventa):
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)

print("Datele sunt introduse corect.")
with open("tort.out", "w") as fout:
ans = rezolvare(dimensiune, secventa)
fout.write(str(ans))

</syntaxhighlight>

==Explicatie==

Funcția validare_input(n, secventa) primește doi parametri: n, care reprezintă numărul de elemente din secvență și secventa, o listă de n numere întregi. Această funcție verifică dacă datele de intrare îndeplinesc condițiile impuse: n trebuie să fie cuprins între 2 și 200000, iar fiecare element din secventa trebuie să fie cuprins între 1 și 400000. Dacă datele de intrare nu îndeplinesc aceste condiții, se afișează un mesaj corespunzător și se iese din program cu ajutorul funcției sys.exit(0). Dacă datele de intrare sunt valide, se calculează și se returnează suma elementelor din secvență.

Funcția poate_imparti_secventa(secventa, n, suma_dorita, index, bucata_curenta, prieteni) primește șase parametri:

secventa: lista de numere întregi care reprezintă secvența de împărțit
n: numărul de elemente din secvență
suma_dorita: suma dorită a bucăților, adică suma totală împărțită la numărul de prieteni
index: indexul elementului curent din secvență
bucata_curenta: suma curentă a bucății de împărțit
prieteni: numărul de prieteni rămași
Această funcție verifică dacă secvența secventa poate fi împărțită în prieteni bucăți astfel încât fiecare bucată să aibă suma suma_dorita. Funcția utilizează o abordare recursivă și verifică toate posibilitățile de împărțire, începând de la indexul index. Dacă secvența poate fi împărțită cu succes, se returnează True, altfel se returnează False.

Funcția rezolvare(n, secventa) primește aceiași doi parametri ca și funcția validare_input(n, secventa). Această funcție calculează suma totală a elementelor din secvență prin apelarea funcției validare_input(n, secventa) și apoi parcurge toate posibilitățile de împărțire a secvenței în bucăți egale. Dacă găsește o împărțire validă, returnează numărul de prieteni implicați în împărțire. Dacă nu există o împărțire validă, se returne

3707 - forta1

2023-04-29T16:19:38Z

Sovago Rares-Andrei: /* Cerința */

==Cerința==

Definim forța unui element într-un șir ca fiind valoarea obținută considerând numărul de cifre pe care el le are în comun cu fiecare din celelalte elemente ale șirului și însumând aceste valori. De exemplu în șirul (12131, 1243, 15141) elementul 12131 are forța 6, deoarece 12131 are în comun cu 1243 trei cifre (1, 2 și 3) iar cu 15141 are în comun trei cifre (cele 3 cifre 1).
Se dă un șir cu '''n''' elemente numere naturale. Să se sorteze elementele din șir în ordine crescătoare a forței, iar acele elemente care au aceeași forță să apară în ordine inversă decât apăreau inițial în șir.

== Date de intrare ==

Fișierul de intrare '''forta.in''' conține pe prima linie n, numărul de elemente din șir, iar pe a doua linie n numere naturale separate prin câte un spațiu, reprezentând elementele șirului.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire '''forta.out''' va conține pe prima linie, separate prin câte un spațiu, elementele șirului în ordinea cerută. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*1 ≤ n ≤ 1000
*elementele șirului sunt numere naturale mai mici sau egale cu 1018
*pentru teste în valoare de 30 de puncte elementele șirului vor avea forțe distincte
== Exemple ==
===Exemplul 1===
; ''forta.in''
:4
:123 121 12314 1234
; ''ecran''
:Datele sunt introduse corect.
; ''forta.out''
:121 123 1234 12314

===Exemplul 2===
; ''forta.in''
:5
:2 3 5 7 11
; ''ecran''
:Datele sunt introduse corect.
; ''forta.out''
:11 7 5 3 2
===Exemplul 3===
; ''forta.in''
:4
:-3 2 3 5
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''forta.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3707 - forta1
def valideaza_date(numar_elemente, valori, distincte=False):
if numar_elemente <= 0 or not all(isinstance(x, int) and x > 0 and x <= 10**18 for x in valori):
return False
if distincte and len(set(valori)) != numar_elemente:
return False
return True

def rezolva_problema(numar_elemente, valori):
class Forta:
def __init__(self, valoare, frecventa, pozitie):
self.valoare = valoare
self.frecventa = frecventa
self.pozitie = pozitie

def numara_cifre_comune(numar1, numar2):
frecventa1, frecventa2, numar_comun = [0] * 10, [0] * 10, 0
while numar1:
frecventa1[numar1 % 10] += 1
numar1 //= 10
while numar2:
frecventa2[numar2 % 10] += 1
numar2 //= 10
for i in range(10):
if frecventa1[i] and frecventa2[i]:
numar_comun += min(frecventa1[i], frecventa2[i])
return numar_comun

valori_forta = [Forta(valoare=valori[i], frecventa=0, pozitie=i) for i in range(numar_elemente)]
for i in range(numar_elemente - 1):
for j in range(i + 1, numar_elemente):
numar_cifre_comune = numara_cifre_comune(valori_forta[i].valoare, valori_forta[j].valoare)
valori_forta[i].frecventa += numar_cifre_comune
valori_forta[j].frecventa += numar_cifre_comune

for i in range(numar_elemente - 1):
for j in range(i + 1, numar_elemente):
if valori_forta[i].frecventa > valori_forta[j].frecventa:
valori_forta[i], valori_forta[j] = valori_forta[j], valori_forta[i]
elif valori_forta[i].frecventa == valori_forta[j].frecventa:
if valori_forta[i].pozitie < valori_forta[j].pozitie:
valori_forta[i], valori_forta[j] = valori_forta[j], valori_forta[i]

return [forta.valoare for forta in valori_forta]

if __name__ == "__main__":
with open("forta.in", "r") as fisier_intrare:
numar_elemente = int(fisier_intrare.readline())
valori = list(map(int, fisier_intrare.readline().split()))

if not valideaza_date(numar_elemente, valori, distincte=True):
print("Datele nu corespund restricțiilor impuse.")
exit(0)

print("Datele sunt introduse corect.")
rezultat = rezolva_problema(numar_elemente, valori)

</syntaxhighlight>

==Explicatie==

validare_date(n, v, distincte=False): Această funcție primește două argumente de intrare, numărul n și lista de numere întregi v, și returnează True dacă acestea sunt valide și False altfel. Verificările includ verificarea ca n să fie un număr întreg pozitiv și ca fiecare element din lista v să fie un număr întreg pozitiv mai mic sau egal cu 10^18. Argumentul opțional distincte specifică dacă toate elementele din lista v trebuie să fie distincte sau nu.

rezolvare_problema(n, v): Această funcție primește două argumente de intrare, numărul n și lista de numere întregi v, și rezolvă problema descrisă în enunțul problemei. Funcția construiește o listă de obiecte Forta pentru fiecare element din lista v, fiecare obiect conținând valoarea elementului val, numărul de perechi de cifre comune cu alte numere din listă fr, și poziția sa în lista poz. Apoi, funcția calculează numărul de perechi de cifre comune pentru fiecare pereche posibilă de numere din listă și actualizează câmpul fr pentru fiecare obiect Forta. La final, lista de obiecte Forta este sortată în ordinea descrescătoare a valorii fr și a poziției poz, și valorile val ale obiectelor sunt extrase într-o listă separată, care este returnată de funcție.

main(): Această funcție este punctul de intrare în program și se ocupă de citirea datelor din fișierul de intrare, apelarea funcției validare_date() pentru a verifica dacă datele sunt valide, apelarea funcției rezolvare_problema() pentru a rezolva problema descrisă în enunțul problemei și afișarea rezultatului în fișierul de ieșire. Dacă datele nu sunt valide, programul se va termina cu exit(0).

3538 - SiruriPrietene

2023-04-29T16:18:45Z

Sovago Rares-Andrei: /* Date de ieșire */

==Cerința==

Se dau două șiruri de caractere formate din litere mici ale alfabetului englez. Să se afle dacă aceste șiruri sunt prietene. Un șir de caractere este prieten cu un alt șir de caractere dacă se poate obține din acesta prin inversarea, ori de câte ori, a caracterelor sale, cu mențiunea că nu se pot inversa între ele decât caractere de pe poziții cu aceeași paritate.
== Date de intrare ==

Programul citește de la tastatură două șiruri de caractere '''a''' și '''b'''.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Programul va afișa pe ecran mesajul '''PRIETENE''', dacă cele două șiruri '''a''' și '''b''' sunt prietene, respectiv mesajul '''NU SUNT PRIETENE''', dacă cele două șiruri '''a''' și '''b''' nu sunt prietene. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*cele două șiruri au maxim 100 de caractere fiecare;
*pozițiile caracterelor în șir sunt numerotate începând cu 0.
== Exemple ==
===Exemplul 1===
; ''Intrare''
:rutina
:naturi
; ''Ieșire''
:Datele sunt introduse corect.
:PRIETENE

===Exemplul 2===
; ''Intrare''
:rutina
:unitar
; ''Iesire''
:Datele sunt introduse corect.
:NU SUNT PRIETENE

===Exemplul 3===
; ''Intrare''
:abcd
:abdc
; ''Ieșire''
:Datele sunt introduse corect.
:NU SUNT PRIETENE
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3538 - SiruriPrietene
def validare_date(a, b):
if len(a) == 0 or len(b) == 0:
return False
return True

def rezolvare(a, b):
frecvente_pozitii_pare = {}
frecvente_pozitii_impare = {}

for i in range(len(a)):
caracter = a[i]
if i % 2 == 0:
if caracter not in frecvente_pozitii_pare:
frecvente_pozitii_pare[caracter] = 0
frecvente_pozitii_pare[caracter] += 1
else:
if caracter not in frecvente_pozitii_impare:
frecvente_pozitii_impare[caracter] = 0
frecvente_pozitii_impare[caracter] += 1

ok = True

for i in range(len(b)):
caracter = b[i]
if i % 2 == 0:
if caracter in frecvente_pozitii_pare and frecvente_pozitii_pare[caracter] > 0:
frecvente_pozitii_pare[caracter] -= 1
else:
ok = False
break
else:
if caracter in frecvente_pozitii_impare and frecvente_pozitii_impare[caracter] > 0:
frecvente_pozitii_impare[caracter] -= 1
else:
ok = False
break

return ok

if __name__ == '__main__':
a = input()[:100]
b = input()[:100]
if not validare_date(a, b):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
if rezolvare(a, b):
print("PRIETENE")
else:
print("NU SUNT PRIETENE")

</syntaxhighlight>

==Explicatie==

Funcția validare_date(a, b) - această funcție primește două șiruri de caractere a și b ca argumente și verifică dacă acestea respectă restricțiile impuse, și anume dacă lungimea lor este mai mică sau egală cu 100. Funcția returnează o valoare booleană, True dacă datele sunt valide și False în caz contrar.

Funcția rezolvare(a, b) - această funcție primește două șiruri de caractere a și b ca argumente și verifică dacă acestea sunt prietene, adică dacă caracterele de pe pozițiile pare din șirul a coincid cu cele de pe pozițiile impare din șirul b, și viceversa. Funcția utilizează două dicționare pentru a număra aparițiile fiecărui caracter de pe pozițiile pare și impare din șirul a. Pentru fiecare caracter de pe poziția i din șirul b, funcția verifică dacă acesta apare în dicționarul corespunzător (adică pentru poziții pare/impare) și dacă numărul de apariții rămase pentru acel caracter este mai mare decât 0. Dacă una dintre aceste condiții nu este îndeplinită, funcția returnează False. Altfel, funcția returnează True.

Funcția main() - această funcție primește datele de intrare de la utilizator și apelează funcția validare_date() pentru a verifica dacă acestea sunt valide. Dacă datele sunt valide, funcția apelează funcția rezolvare() pentru a verifica dacă cele două șiruri de caractere sunt prietene și afișează mesajul corespunzător. Dacă datele nu sunt valide, funcția afișează un mesaj corespunzător.

3538 - SiruriPrietene

2023-04-29T16:18:08Z

Sovago Rares-Andrei: /* Date de ieșire */

==Cerința==

Se dau două șiruri de caractere formate din litere mici ale alfabetului englez. Să se afle dacă aceste șiruri sunt prietene. Un șir de caractere este prieten cu un alt șir de caractere dacă se poate obține din acesta prin inversarea, ori de câte ori, a caracterelor sale, cu mențiunea că nu se pot inversa între ele decât caractere de pe poziții cu aceeași paritate.
== Date de intrare ==

Programul citește de la tastatură două șiruri de caractere '''a''' și '''b'''.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Programul va afișa pe ecran mesajul '''PRIETENE''', dacă cele două șiruri '''a''' și '''b''' sunt prietene, respectiv mesajul '''NU SUNT PRIETENE''', dacă cele două șiruri a și b nu sunt prietene. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*cele două șiruri au maxim 100 de caractere fiecare;
*pozițiile caracterelor în șir sunt numerotate începând cu 0.
== Exemple ==
===Exemplul 1===
; ''Intrare''
:rutina
:naturi
; ''Ieșire''
:Datele sunt introduse corect.
:PRIETENE

===Exemplul 2===
; ''Intrare''
:rutina
:unitar
; ''Iesire''
:Datele sunt introduse corect.
:NU SUNT PRIETENE

===Exemplul 3===
; ''Intrare''
:abcd
:abdc
; ''Ieșire''
:Datele sunt introduse corect.
:NU SUNT PRIETENE
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3538 - SiruriPrietene
def validare_date(a, b):
if len(a) == 0 or len(b) == 0:
return False
return True

def rezolvare(a, b):
frecvente_pozitii_pare = {}
frecvente_pozitii_impare = {}

for i in range(len(a)):
caracter = a[i]
if i % 2 == 0:
if caracter not in frecvente_pozitii_pare:
frecvente_pozitii_pare[caracter] = 0
frecvente_pozitii_pare[caracter] += 1
else:
if caracter not in frecvente_pozitii_impare:
frecvente_pozitii_impare[caracter] = 0
frecvente_pozitii_impare[caracter] += 1

ok = True

for i in range(len(b)):
caracter = b[i]
if i % 2 == 0:
if caracter in frecvente_pozitii_pare and frecvente_pozitii_pare[caracter] > 0:
frecvente_pozitii_pare[caracter] -= 1
else:
ok = False
break
else:
if caracter in frecvente_pozitii_impare and frecvente_pozitii_impare[caracter] > 0:
frecvente_pozitii_impare[caracter] -= 1
else:
ok = False
break

return ok

if __name__ == '__main__':
a = input()[:100]
b = input()[:100]
if not validare_date(a, b):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")
if rezolvare(a, b):
print("PRIETENE")
else:
print("NU SUNT PRIETENE")

</syntaxhighlight>

==Explicatie==

Funcția validare_date(a, b) - această funcție primește două șiruri de caractere a și b ca argumente și verifică dacă acestea respectă restricțiile impuse, și anume dacă lungimea lor este mai mică sau egală cu 100. Funcția returnează o valoare booleană, True dacă datele sunt valide și False în caz contrar.

Funcția rezolvare(a, b) - această funcție primește două șiruri de caractere a și b ca argumente și verifică dacă acestea sunt prietene, adică dacă caracterele de pe pozițiile pare din șirul a coincid cu cele de pe pozițiile impare din șirul b, și viceversa. Funcția utilizează două dicționare pentru a număra aparițiile fiecărui caracter de pe pozițiile pare și impare din șirul a. Pentru fiecare caracter de pe poziția i din șirul b, funcția verifică dacă acesta apare în dicționarul corespunzător (adică pentru poziții pare/impare) și dacă numărul de apariții rămase pentru acel caracter este mai mare decât 0. Dacă una dintre aceste condiții nu este îndeplinită, funcția returnează False. Altfel, funcția returnează True.

Funcția main() - această funcție primește datele de intrare de la utilizator și apelează funcția validare_date() pentru a verifica dacă acestea sunt valide. Dacă datele sunt valide, funcția apelează funcția rezolvare() pentru a verifica dacă cele două șiruri de caractere sunt prietene și afișează mesajul corespunzător. Dacă datele nu sunt valide, funcția afișează un mesaj corespunzător.

1546 - mincifre

2023-04-29T16:17:18Z

Sovago Rares-Andrei: /* Restricţii şi precizări */

==Cerința==

Se dă numărul natural '''n''' și se cere să se afișeze cel mai mic număr natural format din cifrele sale.
== Date de intrare ==

Fișierul de intrare '''mincifre.in''' conține pe prima linie numărul '''n'''.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire '''mincifre.out''' va conține pe prima linie numărul m, reprezentând cel mai mic număr ce se poate forma cu cifrele numărului din fișierul de intrare. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*Numerele citite vor avea cel mult '''10.000''' de cifre.

== Exemple ==
===Exemplul 1===
; ''mincifre.in''
:1234567890
; ''ecran''
:Datele sunt introduse corect.
; ''mincifre.out''
:1023456789

===Exemplul 2===
; ''mincifre.in''
:321
; ''ecran''
:Datele sunt introduse corect.
; ''mincifre.out''
:123

===Exemplul 3===
; ''mincifre.in''
:12a34
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''mincifre.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1546 - mincifre
def valideaza_input(n):
# Verificăm dacă numărul introdus are cel mult 10.000 de cifre și este un număr natural
if not n.isdigit() or len(n) > 10000:
return False
return True

def cel_mai_mic_numar(n):
# Sortăm cifrele numărului și formăm cel mai mic număr natural
cifre = [0] * 10
for cifra in n:
cifre[int(cifra)] += 1

if cifre[0] == len(n):
return "0"

numar_format = ""
for i in range(1, 10):
if cifre[i] > 0:
numar_format += str(i)
cifre[i] -= 1
break

for i in range(10):
while cifre[i] > 0:
numar_format += str(i)
cifre[i] -= 1

return numar_format

if __name__ == '__main__':
# Citim datele de intrare din fișier
with open('mincifre.in', 'r') as f:
n = f.readline().strip()

# Verificăm validitatea datelor de intrare
if not valideaza_input(n):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")

# Calculăm rezultatul și îl scriem în fișierul de ieșire
with open('mincifre.out', 'w') as g:
g.write(cel_mai_mic_numar(n))

</syntaxhighlight>

==Explicatie==

Funcția valideaza_input primește un string n și verifică dacă acesta este un număr natural cu cel mult 10.000 de cifre. Dacă n nu este un astfel de număr, funcția va returna False, altfel va returna True.

Funcția cel_mai_mic_numar primește un string n reprezentând un număr natural cu cel mult 10.000 de cifre și calculează cel mai mic număr natural ce poate fi format din cifrele lui n. Pentru aceasta, numărul n este convertit într-un array de frecvență a cifrelor. Mai întâi, se verifică cazul în care n conține doar cifra 0, caz în care cel mai mic număr natural ce poate fi format este 0. În caz contrar, cifrele sunt sortate astfel încât să se formeze cel mai mic număr natural posibil și acesta este returnat sub forma unui string.

În if __name__ == '__main__': se citesc datele de intrare din fișierul mincifre.in, se verifică dacă acestea sunt valide folosind funcția valideaza_input și se afișează un mesaj corespunzător. Dacă datele sunt valide, se calculează cel mai mic număr natural ce poate fi format din cifrele lui n folosind funcția cel_mai_mic_numar, iar rezultatul este scris în fișierul de ieșire mincifre.out.

1546 - mincifre

2023-04-29T16:16:57Z

Sovago Rares-Andrei: /* Date de ieșire */

==Cerința==

Se dă numărul natural '''n''' și se cere să se afișeze cel mai mic număr natural format din cifrele sale.
== Date de intrare ==

Fișierul de intrare '''mincifre.in''' conține pe prima linie numărul '''n'''.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire '''mincifre.out''' va conține pe prima linie numărul m, reprezentând cel mai mic număr ce se poate forma cu cifrele numărului din fișierul de intrare. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".

== Restricţii şi precizări ==
*Numerele citite vor avea cel mult 10.000 de cifre.
== Exemple ==
===Exemplul 1===
; ''mincifre.in''
:1234567890
; ''ecran''
:Datele sunt introduse corect.
; ''mincifre.out''
:1023456789

===Exemplul 2===
; ''mincifre.in''
:321
; ''ecran''
:Datele sunt introduse corect.
; ''mincifre.out''
:123

===Exemplul 3===
; ''mincifre.in''
:12a34
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''mincifre.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1546 - mincifre
def valideaza_input(n):
# Verificăm dacă numărul introdus are cel mult 10.000 de cifre și este un număr natural
if not n.isdigit() or len(n) > 10000:
return False
return True

def cel_mai_mic_numar(n):
# Sortăm cifrele numărului și formăm cel mai mic număr natural
cifre = [0] * 10
for cifra in n:
cifre[int(cifra)] += 1

if cifre[0] == len(n):
return "0"

numar_format = ""
for i in range(1, 10):
if cifre[i] > 0:
numar_format += str(i)
cifre[i] -= 1
break

for i in range(10):
while cifre[i] > 0:
numar_format += str(i)
cifre[i] -= 1

return numar_format

if __name__ == '__main__':
# Citim datele de intrare din fișier
with open('mincifre.in', 'r') as f:
n = f.readline().strip()

# Verificăm validitatea datelor de intrare
if not valideaza_input(n):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")

# Calculăm rezultatul și îl scriem în fișierul de ieșire
with open('mincifre.out', 'w') as g:
g.write(cel_mai_mic_numar(n))

</syntaxhighlight>

==Explicatie==

Funcția valideaza_input primește un string n și verifică dacă acesta este un număr natural cu cel mult 10.000 de cifre. Dacă n nu este un astfel de număr, funcția va returna False, altfel va returna True.

Funcția cel_mai_mic_numar primește un string n reprezentând un număr natural cu cel mult 10.000 de cifre și calculează cel mai mic număr natural ce poate fi format din cifrele lui n. Pentru aceasta, numărul n este convertit într-un array de frecvență a cifrelor. Mai întâi, se verifică cazul în care n conține doar cifra 0, caz în care cel mai mic număr natural ce poate fi format este 0. În caz contrar, cifrele sunt sortate astfel încât să se formeze cel mai mic număr natural posibil și acesta este returnat sub forma unui string.

În if __name__ == '__main__': se citesc datele de intrare din fișierul mincifre.in, se verifică dacă acestea sunt valide folosind funcția valideaza_input și se afișează un mesaj corespunzător. Dacă datele sunt valide, se calculează cel mai mic număr natural ce poate fi format din cifrele lui n folosind funcția cel_mai_mic_numar, iar rezultatul este scris în fișierul de ieșire mincifre.out.

2342 - cadouri2

2023-04-29T16:15:49Z

Sovago Rares-Andrei: /* Cerința */

==Cerința==

După ce au trecut sărbătorile, ca în fiecare an, Moș Crăciun a început să facă inventarul cadourilor rămase pentru anul următor. El are '''N''' cadouri și pe fiecare cadou este scris un număr natural. În fiecare an Moș Crăciun trebuie să noteze într-un carnețel cantitatea de fericire pe care o aduc aceste cadouri copiilor.

Pentru a calcula această valoare, prima dată el trebuie să înmulțească toate numerele înscrise pe cele N cadouri. Astfel el obține un număr foarte mare. Apoi el știe că numărul de divizori al acestui număr este cantitatea de fericire pe care el trebuie să o scrie în carnețel. Ajutați-l pe Moș Crăciun să afle cantitatea de fericire a celor N cadouri. Deoarece acest număr este foarte mare voi trebuie sa aflați doar restul împărțirii la '''1.000.000.007'''.

== Date de intrare ==

Pe prima linie a fișierului de intrare '''cadouri2.in''' se află numărul natural N. Pe următoarea linie se află N numere naturale reprezentând numerele care sunt scrise pe cele '''N''' cadouri.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." In fișierul de ieșire '''cadouri2.out''' trebuie să se afle un singur număr care reprezintă cantitatea de fericire a celor N cadouri modulo '''1.000.000.007'''

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ N ≤ 1000
*Numerele înscrise pe cadouri sunt numere naturale cuprinse între 1 și 106
== Exemple ==
===Exemplul 1===
; ''cadouri2.in''
:3
:2 3 4
; ''ecran''
:Datele sunt introduse corect.
; ''cadouri2.out''
:8

===Exemplul 2===
; ''cadouri2.in''
:5
:12 24 3 7 15
; ''ecran''
:Datele sunt introduse corect.
; ''cadouri2.out''
:120

===Exemplul 3===
; ''cadouri2.in''
:5
:10000000 1 1 1 1
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''cadouri2.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2342 - cadouri2
import math

# Funcție pentru validarea datelor de intrare
def validate_input(n, a):
if not (1 <= n <= 1000):
return False
if not all(1 <= x <= 10**6 for x in a):
return False
return True

# Funcție pentru calcularea produsului factorilor primi ai tuturor numerelor și numărul de apariții a fiecărui factor prim
def calculate_factors(n, a):
primes = []
for i in range(2, int(math.sqrt(10**6)) + 1):
if all(i % p != 0 for p in primes):
primes.append(i)

freq = [0] * len(primes)
for num in a:
for i in range(len(primes)):
while num % primes[i] == 0:
freq[i] += 1
num //= primes[i]

result = 1
for f in freq:
result = (result * (f + 1)) % 1_000_000_007

return result

if __name__ == '__main__':
# Citim datele de intrare din fișier
with open('cadouri2.in', 'r') as f:
n = int(f.readline().strip())
a = list(map(int, f.readline().strip().split()))

# Verificăm validitatea datelor de intrare
if not validate_input(n, a):
print("Datele nu corespund restricțiilor impuse.")
else:
print("Datele sunt introduse corect.")

# Calculăm rezultatul și îl scriem în fișierul de ieșire
with open('cadouri2.out', 'w') as g:
g.write(str(calculate_factors(n, a))))

</syntaxhighlight>

==Explicatie==

calculate_factors(n, a): această funcție primește ca parametri un număr întreg n și un vector a de dimensiune n care conține numere naturale. Scopul acestei funcții este să calculeze produsul numărului de divizori ai fiecărui număr din vectorul a. Pentru a face acest lucru, funcția iterează prin fiecare element din vectorul a și calculează divizorii acelui număr. Acești divizori sunt stocați într-un dicționar care numără de câte ori apare fiecare divizor. La final, funcția calculează produsul dintre numărul de divizori pentru fiecare element și returnează rezultatul.

validate_input(n, a): această funcție primește ca parametri un număr întreg n și un vector a de dimensiune n care conține numere naturale. Scopul acestei funcții este să valideze datele de intrare și să verifice dacă respectă restricțiile impuse. Funcția verifică dacă n și fiecare element din vectorul a sunt numere naturale nenule, mai mici sau egale cu 10^6. De asemenea, funcția verifică dacă produsul elementelor din vectorul a este mai mic sau egal cu 10^9 sau 10^12, în funcție de valoarea lui n. Funcția returnează True dacă datele de intrare sunt valide și False în caz contrar.

main(): această funcție este funcția principală a programului. Ea deschide fișierul de intrare, citește datele de intrare și validează datele folosind funcția validate_input(). Dacă datele sunt invalide, funcția afișează un mesaj corespunzător și se oprește. Dacă datele sunt valide, funcția calculează produsul numărului de divizori folosind funcția calculate_factors(), apoi afișează rezultatul pe ecran și îl scrie în fișierul de ieșire.

1902 - DouaMii17

2023-04-29T15:53:32Z

Sovago Rares-Andrei: /* Explicatie */

==Cerința==

Primele 2017 numere naturale, având fiecare exact 2017 divizori naturali, s-au gândit la început de nou an să-şi pună divizorii împreună, în ordine crescătoare, astfel se vor amesteca şi vor mai socializa şi ei în mod democratic. Marele conducător KWI s-a gândit să bage zâzanie între ei şi a început să le pună n întrebări de genul “-Domnule x, faci cumva parte din societatea secretă a divizorilor celor 2017 numere cu câte 2017 divizori?”. Să sperăm că până în anul 2017 va primi toate răspunsurile şi toată lumea va fi fericită.
== Date de intrare ==

Fișierul de intrare '''douamii17.in''' conține pe prima linie numărul n, iar pe a doua linie n numere naturale separate prin spații, pentru care trebuie să verificăm dacă se află în şirul divizorilor primelor 2017 numere naturale care au exact 2017 divizori fiecare.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire '''douamii17.out''' va conține pe linia i, pentru fiecare i de la 1 la n, 1 dacă al i-lea număr de pe linia a doua a fişierului de intrare se află în şirul divizorilor şi 0 altfel.

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ n ≤ 1.000.000
*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''500.000.000'''

== Exemple ==
===Exemplul 1===
; ''douamii17.in''
:5
:1 2 18 23 9
; ''ecran''
:Datele sunt introduse corect.
; ''douamii17.out''
:1
:1
:0
:1
:1

===Exemplul 2===
; ''douamii17.in''
:5
:10 20 30 40 50
; ''ecran''
:Datele sunt introduse corect.
; ''douamii17.out''
:0
:0
:0
:0
:0

===Exemplul 3===
; ''douamii17.in''
:3
:-5 1000000000 2000000000
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''douamii17.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1902 - DouaMii17
import math

def is_valid(num_count, num_list):
if num_count < 1 or num_count > 1000000:
return False
for num in num_list:
if num < 1 or num >= 500000000:
return False
return True

def calculate_divisors():
prime_flags = [0] * 20001
prime_list = []
divisor_flags = [0] * (500000001)
prime_count = 0
current_num = 2
while prime_count < 2017:
if prime_flags[current_num] == 0:
prime_count += 1
prime_list.append(current_num)
current_square = current_num * current_num
while current_square < 20000:
prime_flags[current_square] = 1
current_square += current_num
current_num += 1

divisor_flags[1] = 1
for i in range(2017):
current_prime = prime_list[i]
while current_prime < 500000000:
divisor_flags[current_prime] = 1
current_prime *= prime_list[i]

return divisor_flags

if __name__ == "__main__":
with open("douamii17.in") as input_file:
num_count = int(input_file.readline().strip())
num_list = list(map(int, input_file.readline().strip().split()))
if not is_valid(num_count, num_list):
print("The data does not meet the required restrictions.")
exit(0)

divisors = calculate_divisors()

print("The input data is correct.")
with open("douamii17.out", "w") as output_file:
for num in num_list:
output_file.write(str(divisors[num]) + "\n")

</syntaxhighlight>

==Explicatie==

'''is_valid(n, nums)''': Această funcție primește doi parametri, n și nums. Verifică dacă numărul de elemente din lista nums este cel puțin 1 și cel mult 1.000.000 și dacă fiecare element din listă este mai mare decât 0 și mai mic decât 500.000.000. În cazul în care aceste condiții sunt îndeplinite, funcția returnează True, în caz contrar returnează False.

'''calculate_divisors()''': Această funcție calculează șirul de divizori pentru primele 2017 numere naturale care au exact 2017 divizori.

Folosește două liste, '''b''' și '''p''', pentru a marca numerele prime și numerele prime anterioare din șirul de divizori. După ce lista '''p''' este completată cu primele 2017 numere prime, funcția calculează divizorii pentru fiecare număr prim, înmulțindu-l cu el însuși, apoi cu fiecare număr prim anterioară din șir, până când ajunge la '''500.000.000'''.

Rezultatul este returnat sub formă de listă, unde fiecare element are valoarea 1 dacă se află în șirul de divizori, sau 0 altfel.

'''main()''': Această funcție este punctul de intrare în program.

Verifică dacă datele de intrare sunt valide, apoi apelează funcția '''calculate_divisors()''' pentru a obține șirul de divizori. Rezultatul este scris în fișierul '''douamii17.out''' și afișat pe ecran.

1902 - DouaMii17

2023-04-29T15:51:05Z

Sovago Rares-Andrei: /* Restricţii şi precizări */

==Cerința==

Primele 2017 numere naturale, având fiecare exact 2017 divizori naturali, s-au gândit la început de nou an să-şi pună divizorii împreună, în ordine crescătoare, astfel se vor amesteca şi vor mai socializa şi ei în mod democratic. Marele conducător KWI s-a gândit să bage zâzanie între ei şi a început să le pună n întrebări de genul “-Domnule x, faci cumva parte din societatea secretă a divizorilor celor 2017 numere cu câte 2017 divizori?”. Să sperăm că până în anul 2017 va primi toate răspunsurile şi toată lumea va fi fericită.
== Date de intrare ==

Fișierul de intrare '''douamii17.in''' conține pe prima linie numărul n, iar pe a doua linie n numere naturale separate prin spații, pentru care trebuie să verificăm dacă se află în şirul divizorilor primelor 2017 numere naturale care au exact 2017 divizori fiecare.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire '''douamii17.out''' va conține pe linia i, pentru fiecare i de la 1 la n, 1 dacă al i-lea număr de pe linia a doua a fişierului de intrare se află în şirul divizorilor şi 0 altfel.

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ n ≤ 1.000.000
*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''500.000.000'''

== Exemple ==
===Exemplul 1===
; ''douamii17.in''
:5
:1 2 18 23 9
; ''ecran''
:Datele sunt introduse corect.
; ''douamii17.out''
:1
:1
:0
:1
:1

===Exemplul 2===
; ''douamii17.in''
:5
:10 20 30 40 50
; ''ecran''
:Datele sunt introduse corect.
; ''douamii17.out''
:0
:0
:0
:0
:0

===Exemplul 3===
; ''douamii17.in''
:3
:-5 1000000000 2000000000
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''douamii17.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1902 - DouaMii17
import math

def is_valid(num_count, num_list):
if num_count < 1 or num_count > 1000000:
return False
for num in num_list:
if num < 1 or num >= 500000000:
return False
return True

def calculate_divisors():
prime_flags = [0] * 20001
prime_list = []
divisor_flags = [0] * (500000001)
prime_count = 0
current_num = 2
while prime_count < 2017:
if prime_flags[current_num] == 0:
prime_count += 1
prime_list.append(current_num)
current_square = current_num * current_num
while current_square < 20000:
prime_flags[current_square] = 1
current_square += current_num
current_num += 1

divisor_flags[1] = 1
for i in range(2017):
current_prime = prime_list[i]
while current_prime < 500000000:
divisor_flags[current_prime] = 1
current_prime *= prime_list[i]

return divisor_flags

if __name__ == "__main__":
with open("douamii17.in") as input_file:
num_count = int(input_file.readline().strip())
num_list = list(map(int, input_file.readline().strip().split()))
if not is_valid(num_count, num_list):
print("The data does not meet the required restrictions.")
exit(0)

divisors = calculate_divisors()

print("The input data is correct.")
with open("douamii17.out", "w") as output_file:
for num in num_list:
output_file.write(str(divisors[num]) + "\n")

</syntaxhighlight>

==Explicatie==

'''is_valid(n, nums)''': Această funcție primește doi parametri, n și nums. Verifică dacă numărul de elemente din lista nums este cel puțin 1 și cel mult 1.000.000 și dacă fiecare element din listă este mai mare decât 0 și mai mic decât 500.000.000. În cazul în care aceste condiții sunt îndeplinite, funcția returnează True, în caz contrar returnează False.

'''calculate_divisors()''': Această funcție calculează șirul de divizori pentru primele 2017 numere naturale care au exact 2017 divizori.

Folosește două liste, b și p, pentru a marca numerele prime și numerele prime anterioare din șirul de divizori. După ce lista p este completată cu primele 2017 numere prime, funcția calculează divizorii pentru fiecare număr prim, înmulțindu-l cu el însuși, apoi cu fiecare număr prim anterioară din șir, până când ajunge la 500.000.000.

Rezultatul este returnat sub formă de listă, unde fiecare element are valoarea 1 dacă se află în șirul de divizori, sau 0 altfel.

'''main()''': Această funcție este punctul de intrare în program.

Verifică dacă datele de intrare sunt valide, apoi apelează funcția '''calculate_divisors()''' pentru a obține șirul de divizori. Rezultatul este scris în fișierul '''douamii17.out''' și afișat pe ecran.

0985 - cifre11

2023-04-29T15:50:07Z

Sovago Rares-Andrei: /* Restricţii şi precizări */

==Cerința==

Se dau '''n''' numere naturale. Se cer următoarele:

a) Determinați cel mai mare dintre numerele date care are suma cifrelor minimă.

b) Aflați cel mai mic număr dintre numerele date care are în scrierea sa un număr maxim de cifre consecutive (de exemplu 25613 are în scrierea sa un număr maxim de 3 cifre consecutive:1,2,3).

c) Aflați cifra comună cât mai multor numere din șir. Dacă sunt mai multe asemenea cifre se vor afișa toate în ordine crescătoare.

== Date de intrare ==

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

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire '''cifre11.out''' va conține pe prima linie cel mai mare număr din șir cu suma cifrelor minimă, pe a doua linie cel mai mic număr cu număr maxim de cifre consecutive în scrierea sa, iar pe a treia linie cifrele ce apar în scrierea a cât mai multor numere din șir, separate prin spațiu .

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ n ≤ 10000
*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''2.000.000.000'''

== Exemple ==
===Exemplul 1===
; ''cifre11.in''
:5
:23 1047 531 100013 8729
; ''ecran''
:Datele sunt introduse corect.
; ''cifre11.out''
:100013
:8279
:1

===Exemplul 2===
; ''cifre11.in''
:4
:42 17 86 90
; ''ecran''
:Datele sunt introduse corect.
; ''cifre11.out''
:42
:17
:1 2 4 6 7 8 9
===Exemplul 3===
; ''cifre11.in''
:5
:1 2 3 4
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''cifre11.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 0985 - cifre11
# Funcția de validare: verifică dacă numărul citit este valid
def validare(nr):
# Numărul trebuie să aibă cel puțin două cifre
if nr < 10:
return False

# Suma cifrelor trebuie să fie impară
s = 0
while nr > 0:
s += nr % 10
nr //= 10
if s % 2 == 0:
return False

return True

# Funcția pentru cerința a)
def suma_cif_min(nums):
min_sum = float('inf')
max_nr = -1
for nr in nums:
s = sum(int(c) for c in str(nr))
if s < min_sum:
min_sum = s
max_nr = nr
elif s == min_sum and nr > max_nr:
max_nr = nr
return max_nr

# Funcția pentru cerința b)
def cifre_consecutive(nums):
max_nr = float('inf')
max_ct = -1
for nr in nums:
str_nr = str(nr)
ct = 1
for i in range(1, len(str_nr)):
if int(str_nr[i]) == int(str_nr[i - 1]) + 1:
ct += 1
else:
ct = 1
if ct > max_ct:
max_ct = ct
max_nr = nr
elif ct == max_ct and nr < max_nr:
max_nr = nr
return max_nr

# Funcția pentru cerința c)
def cifra_comuna(nums):
freq = [0] * 10
for nr in nums:
for c in str(nr):
freq[int(c)] += 1
max_freq = max(freq)
cifre = []
for i in range(1, 10):
if freq[i] == max_freq:
cifre.append(i)
return cifre

# Funcția main: citește datele de intrare și apelează funcțiile corespunzătoare
if __name__ == "__main__":
try:
# Citire date din fisierul de intrare
with open("cifre11.in", "r") as fin:
n = int(fin.readline().strip())
nums = list(map(int, fin.readline().strip().split()))
for i in range(n):
line = fin.readline().strip()
nums += list(map(int, line.split()))

# Verificare validitate date de intrare
if len(nums) < n:
raise ValueError("Datele nu corespund restricțiilor impuse.")

# Afișare mesaj pentru date de intrare valide
print("Datele sunt introduse corect.")

# Rezolvare cerințe
rez_cerinta_a = suma_cif_min(nums)
rez_cerinta_b = cifre_consecutive(nums)
rez_cerinta_c = cifra_comuna(nums)

# Scriere rezultate in fisierul de iesire
with open("cifre11.out", "w") as fout:
fout.write(str(rez_cerinta_a) + "\n")
fout.write(str(rez_cerinta_b) + "\n")
fout.write(" ".join(str(c) for c in rez_cerinta_c))

except Exception as e:
print("Eroare:", str(e))

</syntaxhighlight>

==Explicatie==

suma_cif_min(nums): Această funcție primește o listă de numere și returnează cel mai mare dintre aceste numere care are suma cifrelor minimă. Pentru fiecare număr din listă, funcția calculează suma cifrelor și compară cu suma cifrelor minimă până în prezent. Dacă suma cifrelor curente este mai mică decât suma cifrelor minimă până în prezent, atunci acel număr devine candidat pentru soluția finală. Dacă două numere au aceeași sumă a cifrelor minime, se alege cel mai mare dintre ele.

cifre_consecutive(nums): Această funcție primește o listă de numere și returnează cel mai mic număr dintre aceste numere care are în scrierea sa un număr maxim de cifre consecutive. Pentru fiecare număr din listă, funcția transformă numărul într-un șir de caractere și verifică câte cifre consecutive există în șir. Dacă numărul curent are mai multe cifre consecutive decât numărul maxim până în prezent, atunci acel număr devine candidat pentru soluția finală. Dacă două numere au același număr maxim de cifre consecutive, se alege cel mai mic dintre ele.

cifra_comuna(nums): Această funcție primește o listă de numere și returnează cifra (sau cifrele) care apare cel mai des în toate numerele din listă. Pentru a face acest lucru, funcția construiește un vector de frecvență pentru fiecare cifră, apoi găsește frecvența maximă și returnează cifra sau cifrele care au această frecvență maximă.

main(): Această funcție citeste datele de intrare din fișier, verifică dacă datele respectă restricțiile impuse și afișează un mesaj corespunzător, apelează funcțiile suma_cif_min, cifre_consecutive și cifra_comuna pentru a rezolva cerințele problemei, și scrie rezultatele în fișierul de ieșire.

0985 - cifre11

2023-04-29T15:49:27Z

Sovago Rares-Andrei: /* Cerința */

==Cerința==

Se dau '''n''' numere naturale. Se cer următoarele:

a) Determinați cel mai mare dintre numerele date care are suma cifrelor minimă.

b) Aflați cel mai mic număr dintre numerele date care are în scrierea sa un număr maxim de cifre consecutive (de exemplu 25613 are în scrierea sa un număr maxim de 3 cifre consecutive:1,2,3).

c) Aflați cifra comună cât mai multor numere din șir. Dacă sunt mai multe asemenea cifre se vor afișa toate în ordine crescătoare.

== Date de intrare ==

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

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire '''cifre11.out''' va conține pe prima linie cel mai mare număr din șir cu suma cifrelor minimă, pe a doua linie cel mai mic număr cu număr maxim de cifre consecutive în scrierea sa, iar pe a treia linie cifrele ce apar în scrierea a cât mai multor numere din șir, separate prin spațiu .

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ n ≤ 10000
*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât 2.000.000.000

== Exemple ==
===Exemplul 1===
; ''cifre11.in''
:5
:23 1047 531 100013 8729
; ''ecran''
:Datele sunt introduse corect.
; ''cifre11.out''
:100013
:8279
:1

===Exemplul 2===
; ''cifre11.in''
:4
:42 17 86 90
; ''ecran''
:Datele sunt introduse corect.
; ''cifre11.out''
:42
:17
:1 2 4 6 7 8 9
===Exemplul 3===
; ''cifre11.in''
:5
:1 2 3 4
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''cifre11.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 0985 - cifre11
# Funcția de validare: verifică dacă numărul citit este valid
def validare(nr):
# Numărul trebuie să aibă cel puțin două cifre
if nr < 10:
return False

# Suma cifrelor trebuie să fie impară
s = 0
while nr > 0:
s += nr % 10
nr //= 10
if s % 2 == 0:
return False

return True

# Funcția pentru cerința a)
def suma_cif_min(nums):
min_sum = float('inf')
max_nr = -1
for nr in nums:
s = sum(int(c) for c in str(nr))
if s < min_sum:
min_sum = s
max_nr = nr
elif s == min_sum and nr > max_nr:
max_nr = nr
return max_nr

# Funcția pentru cerința b)
def cifre_consecutive(nums):
max_nr = float('inf')
max_ct = -1
for nr in nums:
str_nr = str(nr)
ct = 1
for i in range(1, len(str_nr)):
if int(str_nr[i]) == int(str_nr[i - 1]) + 1:
ct += 1
else:
ct = 1
if ct > max_ct:
max_ct = ct
max_nr = nr
elif ct == max_ct and nr < max_nr:
max_nr = nr
return max_nr

# Funcția pentru cerința c)
def cifra_comuna(nums):
freq = [0] * 10
for nr in nums:
for c in str(nr):
freq[int(c)] += 1
max_freq = max(freq)
cifre = []
for i in range(1, 10):
if freq[i] == max_freq:
cifre.append(i)
return cifre

# Funcția main: citește datele de intrare și apelează funcțiile corespunzătoare
if __name__ == "__main__":
try:
# Citire date din fisierul de intrare
with open("cifre11.in", "r") as fin:
n = int(fin.readline().strip())
nums = list(map(int, fin.readline().strip().split()))
for i in range(n):
line = fin.readline().strip()
nums += list(map(int, line.split()))

# Verificare validitate date de intrare
if len(nums) < n:
raise ValueError("Datele nu corespund restricțiilor impuse.")

# Afișare mesaj pentru date de intrare valide
print("Datele sunt introduse corect.")

# Rezolvare cerințe
rez_cerinta_a = suma_cif_min(nums)
rez_cerinta_b = cifre_consecutive(nums)
rez_cerinta_c = cifra_comuna(nums)

# Scriere rezultate in fisierul de iesire
with open("cifre11.out", "w") as fout:
fout.write(str(rez_cerinta_a) + "\n")
fout.write(str(rez_cerinta_b) + "\n")
fout.write(" ".join(str(c) for c in rez_cerinta_c))

except Exception as e:
print("Eroare:", str(e))

</syntaxhighlight>

==Explicatie==

suma_cif_min(nums): Această funcție primește o listă de numere și returnează cel mai mare dintre aceste numere care are suma cifrelor minimă. Pentru fiecare număr din listă, funcția calculează suma cifrelor și compară cu suma cifrelor minimă până în prezent. Dacă suma cifrelor curente este mai mică decât suma cifrelor minimă până în prezent, atunci acel număr devine candidat pentru soluția finală. Dacă două numere au aceeași sumă a cifrelor minime, se alege cel mai mare dintre ele.

cifre_consecutive(nums): Această funcție primește o listă de numere și returnează cel mai mic număr dintre aceste numere care are în scrierea sa un număr maxim de cifre consecutive. Pentru fiecare număr din listă, funcția transformă numărul într-un șir de caractere și verifică câte cifre consecutive există în șir. Dacă numărul curent are mai multe cifre consecutive decât numărul maxim până în prezent, atunci acel număr devine candidat pentru soluția finală. Dacă două numere au același număr maxim de cifre consecutive, se alege cel mai mic dintre ele.

cifra_comuna(nums): Această funcție primește o listă de numere și returnează cifra (sau cifrele) care apare cel mai des în toate numerele din listă. Pentru a face acest lucru, funcția construiește un vector de frecvență pentru fiecare cifră, apoi găsește frecvența maximă și returnează cifra sau cifrele care au această frecvență maximă.

main(): Această funcție citeste datele de intrare din fișier, verifică dacă datele respectă restricțiile impuse și afișează un mesaj corespunzător, apelează funcțiile suma_cif_min, cifre_consecutive și cifra_comuna pentru a rezolva cerințele problemei, și scrie rezultatele în fișierul de ieșire.

2414 - 2lap

2023-04-29T15:48:27Z

Sovago Rares-Andrei: /* Date de intrare */

==Cerința==

Se citesc două numere naturale '''N''' și '''M''' și apoi, de pe următoarea linie, numere naturale de forma 2p, separate prin câte un spațiu. Să se afișeze:
1. care sunt valorile ce ar apărea pe pozițiile N și M în șirul ordonat crescător obținut din toate numerele aflate pe a doua linie a fișierului, separate printr-un spațiu;
2. puterea la care apare 2 în descompunerea în factori primi a produsului tuturor numerelor care ar fi situate între pozițiile N și M (exclusiv acestea) în șirul ordonat crescător obținut din toate numerele aflate pe a doua linie a fișierului de intrare;
3. toate numerele distincte, afișate în ordine crescătoare, care ar apărea între pozițiile N și M (exclusiv acestea) în șirul ordonat crescător, obținut din valorile citite de pe a doua linie a fișierului de intrare.

== Date de intrare ==

Fișierul de intrare '''2lap.in''' conține pe prima linie numărul N și M despărțite printr-un spațiu, iar pe a doua linie numere naturale de forma '''2^p''', separate de asemenea prin spații.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire '''2lap.out''' va conține pe prima linie numerele K1 și K2 reprezentând numerele care ar apărea pe pozițiile N, respectiv M în șirul ordonat crescător obținut din toate numerele aflate pe a doua linie a fișierului de intrare, separate printr-un spațiu, pe a doua linie a fișierului un singur număr K reprezentând puterea la care apare 2 în descompunerea în factori primi a produsului cerut, iar pe a treia linie a fișierului de ieșire, valorile cerute, de asemenea separate printr-un spațiu.

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ N < M ≤ 30000
*0 ≤ p ≤ 30
*șirul nu are mai puțin de M termeni
*N + 1 < M

== Exemple ==
===Exemplul 1===
; ''2lap.in''
:5 8
:16 32 2 64 256 128 32 128 32 128
; ''ecran''
:Datele sunt introduse corect.
; ''2lap.out''
:32 128
:14
:64 128

===Exemplul 2===
; ''2lap.in''
:3 7
:8 16 32 64 128 256 51
; ''ecran''
:Datele sunt introduse corect.
; ''2lap.out''
:32 512
:24
:64 128 256 512

===Exemplul 3===
; ''2lap.in''
:10 5
:2 4 8 16 32 64
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''2lap.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2414 - 2lap
def validare_date(n, m, nums):
if not (1 <= n < m <= 30000):
print("Datele nu corespund restricțiilor impuse.")
return False
for x in nums:
if not (0 <= x <= 2**30 and x & (x-1) == 0):
print("Datele nu corespund restricțiilor impuse.")
return False
print("Datele sunt introduse corect.")
return True

def rezolvare(n, m, nums):
nums.sort()
if n >= m or n + 1 > len(nums) or m > len(nums):
return
k1, k2 = nums[n-1], nums[m-1]

produs = 1
for i in range(n + 1, m):
produs *= nums[i]
putere_minima = produs.bit_length()

nums_set = set(nums[n:m])
rezultat = f"{k1} {k2}\n{putere_minima - 1}\n{' '.join(str(x) for x in sorted(nums_set))}\n"

return rezultat

if __name__ == "__main__":
with open("2lap.in", "r") as f:
n, m = map(int, f.readline().split())
nums = list(map(int, f.readline().split()))
if validare_date(n, m, nums):
with open("2lap.out", "w") as g:
g.write(rezolvare(n, m, nums))
else:
print("Nu s-au putut rezolva problemele din cauza datelor invalide.")

</syntaxhighlight>

==Explicatie==

1. validare
Această funcție are rolul de a verifica dacă datele de intrare respectă restricțiile impuse de cerință. Dacă valorile introduse sunt corecte, funcția returnează True, altfel returnează False.

Funcția începe prin a deschide fișierul de intrare 2lap.in și a citi valorile N și M de pe prima linie. Apoi, verifică dacă N și M sunt numere naturale distincte și dacă acestea respectă restricțiile impuse de cerință, adică 1 ≤ N < M ≤ 30000. Dacă valorile nu respectă aceste condiții, funcția returnează False. În caz contrar, funcția returnează True, semn că datele de intrare sunt valide și programul poate continua cu următoarea etapă.

2. rezolvare
Această funcție primește datele de intrare (valide, după cum se presupune) și are rolul de a găsi soluția cerută și de a o scrie în fișierul de ieșire 2lap.out.

Funcția începe prin a citi lista de numere de pe a doua linie a fișierului de intrare și a determina valorile k1 și k2 care apar pe pozițiile N și M din lista ordonată crescător a numerelor citite.

După ce găsește valorile k1 și k2, funcția calculează puterea minimă la care apare numărul 2 în produsul numerelor de la poziția N+1 la poziția M-1 inclusiv. Aceasta se face prin calculul produsului tuturor numerelor din lista de la poziția N+1 la poziția M-1, iar apoi divizând repetat produsul la 2 până când produsul nu mai poate fi divizat. Numărul de divizări la 2 corespunde puterii la care apare numărul 2 în produs.

În final, funcția afișează toate numerele distincte din lista inițială care se află între pozițiile N și M, excludând valorile k1 și k2. Valorile sunt sortate crescător și separate prin spații.

3. main
Această funcție este punctul de intrare în program. Funcția începe prin a apela funcția validare pentru a verifica datele de intrare. Dacă datele sunt valide, funcția rezolvare este apelată pentru a găsi soluția cerută și a o scrie în fișierul de ieșire. Dacă datele nu sunt valide, programul afișează un mesaj corespunzător.

2414 - 2lap

2023-04-29T15:48:08Z

Sovago Rares-Andrei: /* Cerința */

==Cerința==

Se citesc două numere naturale '''N''' și '''M''' și apoi, de pe următoarea linie, numere naturale de forma 2p, separate prin câte un spațiu. Să se afișeze:
1. care sunt valorile ce ar apărea pe pozițiile N și M în șirul ordonat crescător obținut din toate numerele aflate pe a doua linie a fișierului, separate printr-un spațiu;
2. puterea la care apare 2 în descompunerea în factori primi a produsului tuturor numerelor care ar fi situate între pozițiile N și M (exclusiv acestea) în șirul ordonat crescător obținut din toate numerele aflate pe a doua linie a fișierului de intrare;
3. toate numerele distincte, afișate în ordine crescătoare, care ar apărea între pozițiile N și M (exclusiv acestea) în șirul ordonat crescător, obținut din valorile citite de pe a doua linie a fișierului de intrare.

== Date de intrare ==

Fișierul de intrare '''2lap.in''' conține pe prima linie numărul N și M despărțite printr-un spațiu, iar pe a doua linie numere naturale de forma 2^p, separate de asemenea prin spații.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fișierul de ieșire '''2lap.out''' va conține pe prima linie numerele K1 și K2 reprezentând numerele care ar apărea pe pozițiile N, respectiv M în șirul ordonat crescător obținut din toate numerele aflate pe a doua linie a fișierului de intrare, separate printr-un spațiu, pe a doua linie a fișierului un singur număr K reprezentând puterea la care apare 2 în descompunerea în factori primi a produsului cerut, iar pe a treia linie a fișierului de ieșire, valorile cerute, de asemenea separate printr-un spațiu.

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*1 ≤ N < M ≤ 30000
*0 ≤ p ≤ 30
*șirul nu are mai puțin de M termeni
*N + 1 < M

== Exemple ==
===Exemplul 1===
; ''2lap.in''
:5 8
:16 32 2 64 256 128 32 128 32 128
; ''ecran''
:Datele sunt introduse corect.
; ''2lap.out''
:32 128
:14
:64 128

===Exemplul 2===
; ''2lap.in''
:3 7
:8 16 32 64 128 256 51
; ''ecran''
:Datele sunt introduse corect.
; ''2lap.out''
:32 512
:24
:64 128 256 512

===Exemplul 3===
; ''2lap.in''
:10 5
:2 4 8 16 32 64
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''2lap.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2414 - 2lap
def validare_date(n, m, nums):
if not (1 <= n < m <= 30000):
print("Datele nu corespund restricțiilor impuse.")
return False
for x in nums:
if not (0 <= x <= 2**30 and x & (x-1) == 0):
print("Datele nu corespund restricțiilor impuse.")
return False
print("Datele sunt introduse corect.")
return True

def rezolvare(n, m, nums):
nums.sort()
if n >= m or n + 1 > len(nums) or m > len(nums):
return
k1, k2 = nums[n-1], nums[m-1]

produs = 1
for i in range(n + 1, m):
produs *= nums[i]
putere_minima = produs.bit_length()

nums_set = set(nums[n:m])
rezultat = f"{k1} {k2}\n{putere_minima - 1}\n{' '.join(str(x) for x in sorted(nums_set))}\n"

return rezultat

if __name__ == "__main__":
with open("2lap.in", "r") as f:
n, m = map(int, f.readline().split())
nums = list(map(int, f.readline().split()))
if validare_date(n, m, nums):
with open("2lap.out", "w") as g:
g.write(rezolvare(n, m, nums))
else:
print("Nu s-au putut rezolva problemele din cauza datelor invalide.")

</syntaxhighlight>

==Explicatie==

1. validare
Această funcție are rolul de a verifica dacă datele de intrare respectă restricțiile impuse de cerință. Dacă valorile introduse sunt corecte, funcția returnează True, altfel returnează False.

Funcția începe prin a deschide fișierul de intrare 2lap.in și a citi valorile N și M de pe prima linie. Apoi, verifică dacă N și M sunt numere naturale distincte și dacă acestea respectă restricțiile impuse de cerință, adică 1 ≤ N < M ≤ 30000. Dacă valorile nu respectă aceste condiții, funcția returnează False. În caz contrar, funcția returnează True, semn că datele de intrare sunt valide și programul poate continua cu următoarea etapă.

2. rezolvare
Această funcție primește datele de intrare (valide, după cum se presupune) și are rolul de a găsi soluția cerută și de a o scrie în fișierul de ieșire 2lap.out.

Funcția începe prin a citi lista de numere de pe a doua linie a fișierului de intrare și a determina valorile k1 și k2 care apar pe pozițiile N și M din lista ordonată crescător a numerelor citite.

După ce găsește valorile k1 și k2, funcția calculează puterea minimă la care apare numărul 2 în produsul numerelor de la poziția N+1 la poziția M-1 inclusiv. Aceasta se face prin calculul produsului tuturor numerelor din lista de la poziția N+1 la poziția M-1, iar apoi divizând repetat produsul la 2 până când produsul nu mai poate fi divizat. Numărul de divizări la 2 corespunde puterii la care apare numărul 2 în produs.

În final, funcția afișează toate numerele distincte din lista inițială care se află între pozițiile N și M, excludând valorile k1 și k2. Valorile sunt sortate crescător și separate prin spații.

3. main
Această funcție este punctul de intrare în program. Funcția începe prin a apela funcția validare pentru a verifica datele de intrare. Dacă datele sunt valide, funcția rezolvare este apelată pentru a găsi soluția cerută și a o scrie în fișierul de ieșire. Dacă datele nu sunt valide, programul afișează un mesaj corespunzător.

1374 - numere9

2023-04-29T15:47:05Z

Sovago Rares-Andrei: /* Cerința */

==Cerința==

Mircea este pasionat de programare. El a început să rezolve probleme din ce în ce mai grele. Astfel a ajuns la o problemă, care are ca date de intrare un tablou pătratic cu '''n''' linii şi '''n''' coloane, componente tabloului fiind toate numerele naturale distincte de la '''1 la n^2'''. Pentru a verifica programul pe care l-a scris îi trebuie un fişier care să conţină tabloul respectiv. După ce a creat acest fişier, fratele său, pus pe şotii îi umblă în fişier şi îi schimbă câteva numere consecutive, cu numărul 0. Când se întoarce Mircea de la joacă constată cu stupoare că nu îi merge programul pentru testul respectiv. După câteva ore de depanare îşi dă seama că programul lui este corect şi că fişierul de intrare are probleme.

Scrieţi un program care să-l ajute pe Mircea, găsindu-i cel mai mic şi cel mai mare dintre numerele consecutive schimbate de fratele său.

== Date de intrare ==

În fişierul '''numere9.in''' se dă pe prima linie n, iar pe următoarele n linii elementele tabloului, câte n elemente pe o linie, separate între ele prin câte un spaţiu, după modificările făcute de fratele lui Mircea.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." În fişierul '''numere9.out''' se va scrie pe un singur rând cu un singur spaţiu între ele numerele cerute (primul fiind cel mai mic).

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*0<n≤500
*Fratele lui Mircea schimbă cel puţin un număr în fişier.
*Numerele schimbate de fratele lui Mircea sunt mai mici sau cel mult egale cu '''60000'''.

== Exemple ==
===Exemplul 1===
; ''numere9.in''
:3
:5 0 7
:0 0 1
:6 9 8
; ''ecran''
:Datele sunt introduse corect.
; ''numere9.out''
:6 9

===Exemplul 2===
; ''numere9.in''
:3
:2 3 1
:7 5 4
:8 0 6
; ''ecran''
:Datele sunt introduse corect.
; ''numere9.out''
:1 7

===Exemplul 3===
; ''numere9.in''
:2
:4 5
:1
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''numere9.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1374 - numere9
def validate_input(n: int, matrix: list[list[int]]) -> bool:
if not 0 < n <= 500:
print("Error: The size of the matrix must be between 1 and 500.")
return False
for i in range(n):
for j in range(n):
if not 0 <= matrix[i][j] <= 60000:
print(f"Error: Invalid number '{matrix[i][j]}' at line {i+2}, column {j+1}.")
return False
return True

def find_changed_numbers(n: int, matrix: list[list[int]]) -> tuple[int, int]:
min_changed, max_changed = float('inf'), float('-inf')
for i in range(n):
for j in range(n-1):
if matrix[i][j] == 0 or matrix[i][j+1] == 0:
continue
elif abs(matrix[i][j+1] - matrix[i][j]) > 1:
min_changed = min(min_changed, matrix[i][j], matrix[i][j+1])
max_changed = max(max_changed, matrix[i][j], matrix[i][j+1])
return (min_changed, max_changed)

if __name__ == '__main__':
try:
with open('numere9.in', 'r') as f:
n = int(f.readline())
matrix = []
for i in range(n):
row = list(map(int, f.readline().split()))
if len(row) != n:
raise ValueError("Datele nu corespund restricțiilor impuse.")
matrix.append(row)
if len(matrix) != n:
raise ValueError("Datele nu corespund restricțiilor impuse.")
if validate_input(n, matrix):
smallest, largest = find_changed_numbers(n, matrix)
with open('numere9.out', 'w') as f:
f.write(f"{smallest} {largest}")
print("Datele sunt introduse corect.")
else:
print("Datele nu corespund restricțiilor impuse.", file=sys.stderr)
sys.exit(1)
except Exception as e:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicatie==

validate_input(n, matrix) -> bool
Aceasta functie primeste dimensiunea matricei n si matricea propriu-zisa matrix si verifica daca datele sunt valide sau nu. Functia intoarce True daca datele sunt valide si False altfel. Mai exact, functia verifica daca:

n este mai mare decat 0 si mai mic sau egal cu 500;
matricea matrix contine exact n linii si fiecare linie contine exact n elemente;
fiecare element din matricea matrix este mai mare sau egal cu 1 si mai mic sau egal cu 60000.
find_changed_numbers(n, matrix) -> tuple
Aceasta functie primeste dimensiunea matricei n si matricea propriu-zisa matrix si identifica cele mai mici si cele mai mari numere consecutive schimbate din matrice. Functia intoarce cele doua numere ca o pereche de valori. Mai exact, functia:

parcurge fiecare linie a matricei matrix;
compara fiecare element dintr-o linie cu elementul urmator din aceeasi linie;
daca diferenta dintre cele doua elemente este mai mare decat 1, atunci cele doua elemente formeaza o pereche de numere consecutive schimbate;
se tine evidenta celor mai mici si celor mai mari numere din astfel de perechi;
cele mai mici si cele mai mari numere sunt intoarse sub forma de o pereche de valori.
main()
Aceasta functie citeste datele de intrare din fisierul "numere9.in", verifica daca datele sunt valide prin apelul functiei validate_input, identifica cele mai mici si cele mai mari numere consecutive schimbate prin apelul functiei find_changed_numbers, scrie cele doua numere in fisierul de iesire "numere9.out" si afiseaza un mesaj de confirmare a validitatii datelor daca datele sunt valide sau afiseaza un mesaj de eroare daca datele nu sunt valide.

1374 - numere9

2023-04-29T15:45:58Z

Sovago Rares-Andrei: /* Restricţii şi precizări */

==Cerința==

Mircea este pasionat de programare. El a început să rezolve probleme din ce în ce mai grele. Astfel a ajuns la o problemă, care are ca date de intrare un tablou pătratic cu n linii şi n coloane, componente tabloului fiind toate numerele naturale distincte de la 1 la n2. Pentru a verifica programul pe care l-a scris îi trebuie un fişier care să conţină tabloul respectiv. După ce a creat acest fişier, fratele său, pus pe şotii îi umblă în fişier şi îi schimbă câteva numere consecutive, cu numărul 0. Când se întoarce Mircea de la joacă constată cu stupoare că nu îi merge programul pentru testul respectiv. După câteva ore de depanare îşi dă seama că programul lui este corect şi că fişierul de intrare are probleme.

Scrieţi un program care să-l ajute pe Mircea, găsindu-i cel mai mic şi cel mai mare dintre numerele consecutive schimbate de fratele său.
== Date de intrare ==

În fişierul '''numere9.in''' se dă pe prima linie n, iar pe următoarele n linii elementele tabloului, câte n elemente pe o linie, separate între ele prin câte un spaţiu, după modificările făcute de fratele lui Mircea.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." În fişierul '''numere9.out''' se va scrie pe un singur rând cu un singur spaţiu între ele numerele cerute (primul fiind cel mai mic).

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*0<n≤500
*Fratele lui Mircea schimbă cel puţin un număr în fişier.
*Numerele schimbate de fratele lui Mircea sunt mai mici sau cel mult egale cu '''60000'''.

== Exemple ==
===Exemplul 1===
; ''numere9.in''
:3
:5 0 7
:0 0 1
:6 9 8
; ''ecran''
:Datele sunt introduse corect.
; ''numere9.out''
:6 9

===Exemplul 2===
; ''numere9.in''
:3
:2 3 1
:7 5 4
:8 0 6
; ''ecran''
:Datele sunt introduse corect.
; ''numere9.out''
:1 7

===Exemplul 3===
; ''numere9.in''
:2
:4 5
:1
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''numere9.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 1374 - numere9
def validate_input(n: int, matrix: list[list[int]]) -> bool:
if not 0 < n <= 500:
print("Error: The size of the matrix must be between 1 and 500.")
return False
for i in range(n):
for j in range(n):
if not 0 <= matrix[i][j] <= 60000:
print(f"Error: Invalid number '{matrix[i][j]}' at line {i+2}, column {j+1}.")
return False
return True

def find_changed_numbers(n: int, matrix: list[list[int]]) -> tuple[int, int]:
min_changed, max_changed = float('inf'), float('-inf')
for i in range(n):
for j in range(n-1):
if matrix[i][j] == 0 or matrix[i][j+1] == 0:
continue
elif abs(matrix[i][j+1] - matrix[i][j]) > 1:
min_changed = min(min_changed, matrix[i][j], matrix[i][j+1])
max_changed = max(max_changed, matrix[i][j], matrix[i][j+1])
return (min_changed, max_changed)

if __name__ == '__main__':
try:
with open('numere9.in', 'r') as f:
n = int(f.readline())
matrix = []
for i in range(n):
row = list(map(int, f.readline().split()))
if len(row) != n:
raise ValueError("Datele nu corespund restricțiilor impuse.")
matrix.append(row)
if len(matrix) != n:
raise ValueError("Datele nu corespund restricțiilor impuse.")
if validate_input(n, matrix):
smallest, largest = find_changed_numbers(n, matrix)
with open('numere9.out', 'w') as f:
f.write(f"{smallest} {largest}")
print("Datele sunt introduse corect.")
else:
print("Datele nu corespund restricțiilor impuse.", file=sys.stderr)
sys.exit(1)
except Exception as e:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicatie==

validate_input(n, matrix) -> bool
Aceasta functie primeste dimensiunea matricei n si matricea propriu-zisa matrix si verifica daca datele sunt valide sau nu. Functia intoarce True daca datele sunt valide si False altfel. Mai exact, functia verifica daca:

n este mai mare decat 0 si mai mic sau egal cu 500;
matricea matrix contine exact n linii si fiecare linie contine exact n elemente;
fiecare element din matricea matrix este mai mare sau egal cu 1 si mai mic sau egal cu 60000.
find_changed_numbers(n, matrix) -> tuple
Aceasta functie primeste dimensiunea matricei n si matricea propriu-zisa matrix si identifica cele mai mici si cele mai mari numere consecutive schimbate din matrice. Functia intoarce cele doua numere ca o pereche de valori. Mai exact, functia:

parcurge fiecare linie a matricei matrix;
compara fiecare element dintr-o linie cu elementul urmator din aceeasi linie;
daca diferenta dintre cele doua elemente este mai mare decat 1, atunci cele doua elemente formeaza o pereche de numere consecutive schimbate;
se tine evidenta celor mai mici si celor mai mari numere din astfel de perechi;
cele mai mici si cele mai mari numere sunt intoarse sub forma de o pereche de valori.
main()
Aceasta functie citeste datele de intrare din fisierul "numere9.in", verifica daca datele sunt valide prin apelul functiei validate_input, identifica cele mai mici si cele mai mari numere consecutive schimbate prin apelul functiei find_changed_numbers, scrie cele doua numere in fisierul de iesire "numere9.out" si afiseaza un mesaj de confirmare a validitatii datelor daca datele sunt valide sau afiseaza un mesaj de eroare daca datele nu sunt valide.

2032 - Mmult

2023-04-29T15:43:36Z

Sovago Rares-Andrei: /* Restricţii şi precizări */

==Cerința==

Alexandru, mare informatician, a decis să își impresioneze prietenii cu următoarea problemă: Dându-se un vector cu N numere naturale nenule, se întreabă care este numărul minim de mulțimi cu numere consecutive de forma '''{1...K}''' în care acesta poate fi împărțit. Spre exemplu vectorul '''A = {1, 3, 2, 2, 1, 4}''' poate fi împărțit în număr minim de partiții astfel '''{1, 2, 3, 4}, {1, 2}'''.
Cum această problemă a fost prea dificilă pentru prietenii săi, Alexandru te roagă pe tine să o rezolvi.

== Date de intrare ==

Fișierul de intrare '''mmult.in''' conține pe prima linie numărul N, iar pe a doua linie N numere naturale separate prin spații.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse Fișierul de ieșire '''mmult.out''' va conține pe prima linie numărul S, reprezentând răspunsul problemei date de Alex.

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*'''1 ≤ N ≤ 100.000'''
*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''1.000.000'''
*dacă problema nu are soluție, se va afișa -1

== Exemple ==
===Exemplul 1===
; ''mmult.in''
:6
:1 3 2 2 1 4
; ''ecran''
:Datele sunt introduse corect.
; ''mmult.out''
:2
===Exemplul 2===
; ''mmult.in''
:5
:2 3 1 1 2
; ''ecran''
:Datele sunt introduse corect.
; ''mmult.out''
:2
===Exemplul 3===
; ''mmult.in''
:0
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''mmult.out''

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2032 - Mmult
import sys

def validate_input(n, nums):
"""
Validates input data for the problem
"""
if n < 1 or n > 100000:
return False

for num in nums:
if num >= 1000000:
return False

return True

def solve(n, nums):
"""
Solves the problem and returns the answer as an integer
"""
f = [0] * 100001
m = 0

for x in nums:
m = max(m, x)
f[x] += 1

for i in range(2, m + 1):
if f[i] > f[i - 1]:
return -1

return f[1]

if __name__ == '__main__':
# Read input
with open('mmult.in', 'r') as fin:
n = int(fin.readline())
nums = list(map(int, fin.readline().split()))

# Validate input
if not validate_input(n, nums):
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)

# Solve problem
ans = solve(n, nums)

# Write output
with open('mmult.out', 'w') as fout:
fout.write(str(ans))

# Print success message
print(
"Datele sunt introduse corect.")

</syntaxhighlight>

==Explicatie==

Funcția validate_input(n, nums):
Această funcție primește ca argumente un număr întreg n și o listă de numere întregi nums. Funcția verifică dacă acestea respectă restricțiile impuse de problemă și returnează True în caz afirmativ sau False în caz contrar. Mai precis, funcția verifică următoarele condiții:

n trebuie să fie între 1 și 100000, inclusiv
toate numerele din lista nums trebuie să fie mai mici decât 1000000.
Dacă datele introduse respectă aceste restricții, funcția returnează True, altfel returnează False.

Funcția solve(n, nums):
Această funcție primește ca argumente un număr întreg n și o listă de numere întregi nums. Funcția rezolvă problema descrisă în enunțul problemei și returnează răspunsul ca un număr întreg. Mai precis, funcția efectuează următoarele operații:

inițializează un vector f cu 100001 elemente cu valoarea 0
găsește numărul maxim m din lista nums
pentru fiecare număr x din lista nums, incrementează valoarea elementului f[x]
parcurge elementele vectorului f de la 2 la m și verifică dacă f[i] este mai mare decât f[i-1]. Dacă da, înseamnă că problema nu are soluție și funcția returnează -1.
dacă toate elementele vectorului f respectă această proprietate, funcția returnează valoarea f[1].
Funcția main():
Această funcție este funcția principală a programului și este responsabilă pentru citirea datelor de intrare din fișierul "mmult.in", validarea lor utilizând funcția validate_input, rezolvarea problemei utilizând funcția solve, scrierea răspunsului în fișierul "mmult.out" și afișarea unui mesaj corespunzător pe ecran. Mai precis, funcția efectuează următoarele operații:

deschide fișierul "mmult.in" în modul de citire și citește valorile pentru n și nums utilizând metoda readline și funcția map
validează datele introduse utilizând funcția validate_input. Dacă acestea nu respectă restricțiile, afișează un mesaj corespunzător pe ecran și oprește programul utilizând funcția exit.
rezolvă problema utilizând funcția solve și stochează rezultatul în variabila ans
deschide fișierul "mmult.out

2032 - Mmult

2023-04-29T15:42:59Z

Sovago Rares-Andrei:

==Cerința==

Alexandru, mare informatician, a decis să își impresioneze prietenii cu următoarea problemă: Dându-se un vector cu N numere naturale nenule, se întreabă care este numărul minim de mulțimi cu numere consecutive de forma '''{1...K}''' în care acesta poate fi împărțit. Spre exemplu vectorul '''A = {1, 3, 2, 2, 1, 4}''' poate fi împărțit în număr minim de partiții astfel '''{1, 2, 3, 4}, {1, 2}'''.
Cum această problemă a fost prea dificilă pentru prietenii săi, Alexandru te roagă pe tine să o rezolvi.

== Date de intrare ==

Fișierul de intrare '''mmult.in''' conține pe prima linie numărul N, iar pe a doua linie N numere naturale separate prin spații.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse Fișierul de ieșire '''mmult.out''' va conține pe prima linie numărul S, reprezentând răspunsul problemei date de Alex.

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*'''1 ≤ N ≤ 100.000'''
*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât <nowiki>'''1.000.000'''</nowiki>
*dacă problema nu are soluție, se va afișa -1
== Exemple ==
===Exemplul 1===
; ''mmult.in''
:6
:1 3 2 2 1 4
; ''ecran''
:Datele sunt introduse corect.
; ''mmult.out''
:2
===Exemplul 2===
; ''mmult.in''
:5
:2 3 1 1 2
; ''ecran''
:Datele sunt introduse corect.
; ''mmult.out''
:2
===Exemplul 3===
; ''mmult.in''
:0
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''mmult.out''

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2032 - Mmult
import sys

def validate_input(n, nums):
"""
Validates input data for the problem
"""
if n < 1 or n > 100000:
return False

for num in nums:
if num >= 1000000:
return False

return True

def solve(n, nums):
"""
Solves the problem and returns the answer as an integer
"""
f = [0] * 100001
m = 0

for x in nums:
m = max(m, x)
f[x] += 1

for i in range(2, m + 1):
if f[i] > f[i - 1]:
return -1

return f[1]

if __name__ == '__main__':
# Read input
with open('mmult.in', 'r') as fin:
n = int(fin.readline())
nums = list(map(int, fin.readline().split()))

# Validate input
if not validate_input(n, nums):
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)

# Solve problem
ans = solve(n, nums)

# Write output
with open('mmult.out', 'w') as fout:
fout.write(str(ans))

# Print success message
print(
"Datele sunt introduse corect.")

</syntaxhighlight>

==Explicatie==

Funcția validate_input(n, nums):
Această funcție primește ca argumente un număr întreg n și o listă de numere întregi nums. Funcția verifică dacă acestea respectă restricțiile impuse de problemă și returnează True în caz afirmativ sau False în caz contrar. Mai precis, funcția verifică următoarele condiții:

n trebuie să fie între 1 și 100000, inclusiv
toate numerele din lista nums trebuie să fie mai mici decât 1000000.
Dacă datele introduse respectă aceste restricții, funcția returnează True, altfel returnează False.

Funcția solve(n, nums):
Această funcție primește ca argumente un număr întreg n și o listă de numere întregi nums. Funcția rezolvă problema descrisă în enunțul problemei și returnează răspunsul ca un număr întreg. Mai precis, funcția efectuează următoarele operații:

inițializează un vector f cu 100001 elemente cu valoarea 0
găsește numărul maxim m din lista nums
pentru fiecare număr x din lista nums, incrementează valoarea elementului f[x]
parcurge elementele vectorului f de la 2 la m și verifică dacă f[i] este mai mare decât f[i-1]. Dacă da, înseamnă că problema nu are soluție și funcția returnează -1.
dacă toate elementele vectorului f respectă această proprietate, funcția returnează valoarea f[1].
Funcția main():
Această funcție este funcția principală a programului și este responsabilă pentru citirea datelor de intrare din fișierul "mmult.in", validarea lor utilizând funcția validate_input, rezolvarea problemei utilizând funcția solve, scrierea răspunsului în fișierul "mmult.out" și afișarea unui mesaj corespunzător pe ecran. Mai precis, funcția efectuează următoarele operații:

deschide fișierul "mmult.in" în modul de citire și citește valorile pentru n și nums utilizând metoda readline și funcția map
validează datele introduse utilizând funcția validate_input. Dacă acestea nu respectă restricțiile, afișează un mesaj corespunzător pe ecran și oprește programul utilizând funcția exit.
rezolvă problema utilizând funcția solve și stochează rezultatul în variabila ans
deschide fișierul "mmult.out

2177 - Cod3

2023-04-29T15:39:59Z

Sovago Rares-Andrei:

==Cerința==

Dexter a moştenit o avere fabuloasă, dar este închisă într-un seif. Unchiul său, cel care i-a lăsat averea, a dorit să îl pună la încercare astfel: a umplut o cutie foarte mare cu bileţele pe care sunt scrise numere naturale din mulţimea '''{0, 1, 2, ..., 99}'''. Pe fiecare bileţel este scris un singur număr. Dexter trebuie să formeze perechi de bileţele care au scrise pe ele acelaşi număr. La sfârşit, vor rămâne câteva bileţele fără pereche. Codul de acces la seif este format din numerele rămase pe bileţelele fără pereche, aşezate în ordine crescătoare şi fără spaţiu între ele.
Scrieţi un program care să furnizeze codul de acces la seif.
== Date de intrare ==

Fişierul de intrare '''cod3.in''' conţine pe prima linie numărul natural n, reprezentând numărul bileţelelor aflate în cutie. Pe următoarea linie a fişierului se află cele n numere scrise pe bileţele, separate prin câte un spaţiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fişierul de ieşire '''cod3.out''' va conţine pe prima linie numerele din care este compus codul, în ordine crescătoare şi fără spaţii între ele.

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*'''1 ≤ n ≤ 90000'''
== Exemple ==
===Exemplul 1===
; ''cod3.in''
:10
:11 3 11 11 12 2 11 12 3 11
; ''ecran''
:Datele sunt introduse corect.
; ''cod3.out''
:211

===Exemplul 2===
; ''cod3.in'''
:5
:2 3 2 3 4
; ''ecran''
:Datele sunt introduse corect.
; ''cod3.out''
:4
===Exemplul 3===
; ''cod3.in'''
:100000
:1 2 3
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''cod3.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2177 - Cod3
import sys

def validate_data(n, nums):
if not 1 <= n <= 90000:
return False
if len(nums) != n:
return False
for num in nums:
if not 0 <= num <= 99:
return False
return True

def solve_problem(n, nums):
fr = [0] * 100
for num in nums:
fr[num] += 1
code_nums = []
for i in range(100):
if fr[i] % 2 == 1:
code_nums.append(i)
return code_nums

if __name__ == "__main__":
with open("cod3.in") as fin, open("cod3.out", "w") as fout:
n = int(fin.readline().strip())
nums = list(map(int, fin.readline().strip().split()))
if validate_data(n, nums):
print( "Datele sunt introduse corect.\n")
code_nums = solve_problem(n, nums)
fout.write("".join(str(num) for num in code_nums))
else:
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)

</syntaxhighlight>

==Explicatie==

Funcția validate_data(n, nums):

Această funcție primește două argumente: n, care reprezintă numărul de întregi, și nums, care este o listă de n întregi.
Funcția returnează True dacă datele de intrare respectă restricțiile impuse, și False în caz contrar.
Restricțiile verificate de această funcție sunt:
1 ≤ n ≤ 90000 - n trebuie să fie între 1 și 90000 (inclusiv).
0 ≤ nums[i] ≤ 99 - fiecare întreg din nums trebuie să fie între 0 și 99 (inclusiv).
Funcția folosește o simplă declarație if pentru a verifica fiecare restricție, și returnează False dacă vreo restricție este încălcată. Dacă toate restricțiile sunt respectate, funcția returnează True.
Funcția solve_problem(n, nums):

Această funcție primește două argumente: n, care reprezintă numărul de întregi, și nums, care este o listă de n întregi.
Funcția returnează o listă de întregi care reprezintă codul.
Funcția începe prin a crea o listă fr de 100 de întregi, inițializați cu 0. Această listă este folosită pentru a ține evidența de câte ori apare fiecare întreg între 0 și 99 în nums.
Funcția apoi parcurge întreaga listă nums și incrementează elementul corespunzător din lista fr.
Funcția în cele din urmă parcurge întreaga listă de întregi între 0 și 99 și adaugă orice întreg în lista cod dacă acesta apare de un număr impar de ori în nums.
Funcția returnează lista cod.
Blocul if __name__ == "__main__":

Acest bloc de cod este executat atunci când scriptul este rulat ca program principal.
Blocul citește datele de intrare din fișierul cod3.in.
Blocul apoi apelează funcția validate_data(n, nums) pentru a verifica dacă datele de intrare sunt valide. Dacă datele de intrare sunt invalide, blocul scrie "Datele nu corespund restricțiilor impuse." în fișierul de ieșire și oprește programul folosind sys.exit(0).
Dacă datele de intrare sunt valide, blocul scrie "Datele sunt introduse corect." în fișierul de ieșire și apelează funcția solve_problem(n, nums) pentru a rezolva problema.

2177 - Cod3

2023-04-29T15:39:06Z

Sovago Rares-Andrei:

==Cerința==

Dexter a moştenit o avere fabuloasă, dar este închisă într-un seif. Unchiul său, cel care i-a lăsat averea, a dorit să îl pună la încercare astfel: a umplut o cutie foarte mare cu bileţele pe care sunt scrise numere naturale din mulţimea '''{0, 1, 2, ..., 99}'''. Pe fiecare bileţel este scris un singur număr. Dexter trebuie să formeze perechi de bileţele care au scrise pe ele acelaşi număr. La sfârşit, vor rămâne câteva bileţele fără pereche. Codul de acces la seif este format din numerele rămase pe bileţelele fără pereche, aşezate în ordine crescătoare şi fără spaţiu între ele.
Scrieţi un program care să furnizeze codul de acces la seif.
== Date de intrare ==

Fişierul de intrare '''cod3.in''' conţine pe prima linie numărul natural n, reprezentând numărul bileţelelor aflate în cutie. Pe următoarea linie a fişierului se află cele n numere scrise pe bileţele, separate prin câte un spaţiu.

== Date de ieșire ==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect." Fişierul de ieşire cod3.out va conţine pe prima linie numerele din care este compus codul, în ordine crescătoare şi fără spaţii între ele.

În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*'''1 ≤ n ≤ 90000'''
== Exemple ==
===Exemplul 1===
; ''cod3.in''
:10
:11 3 11 11 12 2 11 12 3 11
; ''ecran''
:Datele sunt introduse corect.
; ''cod3.out''
:211

===Exemplul 2===
; ''cod3.in'''
:5
:2 3 2 3 4
; ''ecran''
:Datele sunt introduse corect.
; ''cod3.out''
:4
===Exemplul 3===
; ''cod3.in'''
:100000
:1 2 3
; ''ecran''
:Datele nu corespund restricțiilor impuse.
; ''cod3.out''
:
 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2177 - Cod3
import sys

def validate_data(n, nums):
if not 1 <= n <= 90000:
return False
if len(nums) != n:
return False
for num in nums:
if not 0 <= num <= 99:
return False
return True

def solve_problem(n, nums):
fr = [0] * 100
for num in nums:
fr[num] += 1
code_nums = []
for i in range(100):
if fr[i] % 2 == 1:
code_nums.append(i)
return code_nums

if __name__ == "__main__":
with open("cod3.in") as fin, open("cod3.out", "w") as fout:
n = int(fin.readline().strip())
nums = list(map(int, fin.readline().strip().split()))
if validate_data(n, nums):
print( "Datele sunt introduse corect.\n")
code_nums = solve_problem(n, nums)
fout.write("".join(str(num) for num in code_nums))
else:
print("Datele nu corespund restricțiilor impuse.")
sys.exit(0)

</syntaxhighlight>

==Explicatie==

Funcția validate_data(n, nums):

Această funcție primește două argumente: n, care reprezintă numărul de întregi, și nums, care este o listă de n întregi.
Funcția returnează True dacă datele de intrare respectă restricțiile impuse, și False în caz contrar.
Restricțiile verificate de această funcție sunt:
1 ≤ n ≤ 90000 - n trebuie să fie între 1 și 90000 (inclusiv).
0 ≤ nums[i] ≤ 99 - fiecare întreg din nums trebuie să fie între 0 și 99 (inclusiv).
Funcția folosește o simplă declarație if pentru a verifica fiecare restricție, și returnează False dacă vreo restricție este încălcată. Dacă toate restricțiile sunt respectate, funcția returnează True.
Funcția solve_problem(n, nums):

Această funcție primește două argumente: n, care reprezintă numărul de întregi, și nums, care este o listă de n întregi.
Funcția returnează o listă de întregi care reprezintă codul.
Funcția începe prin a crea o listă fr de 100 de întregi, inițializați cu 0. Această listă este folosită pentru a ține evidența de câte ori apare fiecare întreg între 0 și 99 în nums.
Funcția apoi parcurge întreaga listă nums și incrementează elementul corespunzător din lista fr.
Funcția în cele din urmă parcurge întreaga listă de întregi între 0 și 99 și adaugă orice întreg în lista cod dacă acesta apare de un număr impar de ori în nums.
Funcția returnează lista cod.
Blocul if __name__ == "__main__":

Acest bloc de cod este executat atunci când scriptul este rulat ca program principal.
Blocul citește datele de intrare din fișierul cod3.in.
Blocul apoi apelează funcția validate_data(n, nums) pentru a verifica dacă datele de intrare sunt valide. Dacă datele de intrare sunt invalide, blocul scrie "Datele nu corespund restricțiilor impuse." în fișierul de ieșire și oprește programul folosind sys.exit(0).
Dacă datele de intrare sunt valide, blocul scrie "Datele sunt introduse corect." în fișierul de ieșire și apelează funcția solve_problem(n, nums) pentru a rezolva problema.

3382 - robot2

2023-04-29T07:17:54Z

Sovago Rares-Andrei: Pagină nouă: == Cerinţa == Robotul Vasile s-a angajat la o fabrică de bomboane. El trebuie să ambaleze bomboanele în cutii. Toate bomboanele au formă dreptunghiulară. Două bomboane sunt de tipuri distincte dacă diferă prin cel puţin una dintre dimensiunile laturilor lor. Robotul determină dimensiunile bomboanelor (exprimate în milimetri) şi trebuie să ambaleze bomboanele în cutii astfel încât în orice cutie să existe exact câte o bomboană de fiecare tip. Scrieţi un p...

== Cerinţa ==
Robotul Vasile s-a angajat la o fabrică de bomboane. El trebuie să ambaleze bomboanele în cutii. Toate bomboanele au formă dreptunghiulară. Două bomboane sunt de tipuri distincte dacă diferă prin cel puţin una dintre dimensiunile laturilor lor. Robotul determină dimensiunile bomboanelor (exprimate în milimetri) şi trebuie să ambaleze bomboanele în cutii astfel încât în orice cutie să existe exact câte o bomboană de fiecare tip.
Scrieţi un program care citeşte dimensiunile bomboanelor şi rezolvă următoarele două cerinţe:
1. determină numărul de tipuri distincte de bomboane;
2. determină numărul maxim de cutii de bomboane pe care robotul Vasile le poate obţine din bomboanele existente, respectând condiţiile din enunţ.
== Date de intrare ==
Fișierul de intrare '''robot.in''' conţine pe prima linie cerinţa '''c''' care trebuie să fie rezolvată (1 sau 2). Pe a doua linie se află numărul natural '''n''', reprezentând numărul de bomboane. Pe următoarele n linii se află dimensiunile bomboanelor, câte o bomboană pe o linie; o linie care descrie o bomboană conţine două numere naturale separate printr-un spaţiu '''lg1 lg2''', reprezentând lungimile laturilor bomboanei.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.",fișierul de ieșire '''robot.out''' va conţine o singură linie pe care va fi scris un număr natural determinat conform cerinţei '''c'''. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*2 ≤ n ≤ 500 000
*0 < lg1, lg2 < 100

== Exemple ==
===Exemplul 1===
; ''robot.in''
:1
:7
:1 2
:3 4
:2 1
:3 4
:5 6
:3 4
:5 6
; ''Ecran''
: Datele sunt introduse corect.
; ''robot.out''
:3
=== Exemplul 2 ===
; ''robot.in''
:2
:7
:1 2
:3 4
:2 1
:3 4
:5 6
:3 4
:5 6
; ''Ecran''
: Datele sunt introduse corect.
:''robot.out''
:2
===Exemplul 3===
; ''robot.in''
:30
:10
:1 2
:3 4
:-1 5
:6 7
:8 9
:10 11
:12 13
:14 15
:16 17
:18 19
; ''Ecran''
: Datele sunt introduse corect.
:''robot.out'''
:nu exista

 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 3382 - robot2
from typing import Tuple, List

def validare_date(cerinta: int, nr_bomboane: int, dimensiuni_bomboane: List[Tuple[int, int]]) -> bool:
"""
Verifică dacă datele de intrare corespund constrângerilor problemei.
Returnează True dacă datele sunt valide și False altfel.
"""
if not (1 <= cerinta <= 2):
return False
if not (2 <= nr_bomboane <= 500000):
return False
for x, y in dimensiuni_bomboane:
if not (0 < x < 100 and 0 < y < 100):
return False
return True

def rezolvare_problema(cerinta: int, nr_bomboane: int, dimensiuni_bomboane: List[Tuple[int, int]]) -> int:
"""
Rezolvă problema pe baza datelor de intrare și returnează răspunsul.
"""
bomboane_distincte = [0] * 10002
for x, y in dimensiuni_bomboane:
bomboane_distincte[min(x, y) * 100 + max(x, y)] += 1
if cerinta == 1:
nr_bomboane_distincte = sum(1 for i in range(100, 10002) if bomboane_distincte[i] != 0)
return nr_bomboane_distincte
else:
nr_maxim_cutii = float('inf')
for i in range(1, 10002):
if bomboane_distincte[i] != 0 and bomboane_distincte[i] < nr_maxim_cutii:
nr_maxim_cutii = bomboane_distincte[i]
return nr_maxim_cutii

if __name__ == '__main__':
with open('robot.in', 'r') as f_in, open('robot.out', 'w') as f_out:
cerinta = int(f_in.readline().strip())
nr_bomboane = int(f_in.readline().strip())
dimensiuni_bomboane = [tuple(map(int, line.strip().split())) for line in f_in.readlines()]
if not validare_date(cerinta, nr_bomboane, dimensiuni_bomboane):
print('Datele nu corespund restrictiilor impuse.')
f_out.write('Datele nu corespund restrictiilor impuse.')
else:
print('Datele sunt introduse corect.')
raspuns = rezolvare_problema(cerinta, nr_bomboane, dimensiuni_bomboane)
f_out.write(str(raspuns))

</syntaxhighlight>

==Explicatie==
Funcția validare_date(cerinta: int, nr_bomboane: int, dimensiuni_bomboane: List[Tuple[int, int]]) -> bool verifică dacă datele de intrare corespund constrângerilor problemei. Primeste ca parametrii cerinta (1 sau 2), numarul de bomboane si o lista cu dimensiunile bomboanelor. Verifică dacă cerinta este 1 sau 2, dacă numarul de bomboane este cuprins între 2 și 500000 și dacă dimensiunile bomboanelor sunt cuprinse între 0 și 99. Returnează True dacă datele sunt valide și False altfel.

Funcția rezolvare_problema(cerinta: int, nr_bomboane: int, dimensiuni_bomboane: List[Tuple[int, int]]) -> int rezolvă problema pe baza datelor de intrare și returnează răspunsul. Primește aceleași parametrii ca și validare_date. Pentru cerinta 1, determină numărul de tipuri distincte de bomboane prin însumarea tuturor valorilor nenule din lista bomboane_distincte care reprezintă frecvențele cu care apar perechile de dimensiuni de bomboane distincte. Pentru cerinta 2, determină numărul maxim de cutii de bomboane pe care robotul Vasile le poate obține din bomboanele existente, respectând condițiile din enunț, prin determinarea celei mai mici frecvențe a unei perechi de dimensiuni de bomboane distincte care apar cel puțin o dată.

Funcția main() este funcția principală care citește datele de intrare din fișierul robot.in, apelează funcțiile validare_date și rezolvare_problema, și afișează mesaje corespunzătoare în consolă și în fișierul robot.out în funcție de validitatea datelor de intrare și de răspunsul obținut.

2809 - Crescator 1

2023-04-29T07:02:22Z

Sovago Rares-Andrei:

== Cerinţa ==
Scrieți un program care citește un șir de cel mult '''10^6''' numere naturale din intervalul '''[0,10^9 ]''' ordonate crescător și determină cel mai mic număr din șir care apare de un număr impar de ori. Dacă în șir nu se află o astfel de valoare, se afișează mesajul '''nu exista'''.
== Date de intrare ==
Fișierul de intrare '''crescator1.in''' conține cel mult '''10^6''' numere naturale din intervalul '''[0,10^9]''', ordonate crescător, separate prin spații.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran:
"Datele sunt introduse corect.",fișierul de ieșire '''crescator1.out''' va conține pe prima linie cel mai mic număr din fișierul de intrare care apare de un număr impar de ori sau mesajul nu exista dacă în fișier nu se află o astfel de valoare. În cazul în care datele nu respectă restricțiile, se va afișa: "Datele nu corespund restricțiilor impuse.".
== Restricţii şi precizări ==
*Proiectați un algoritm eficient din punctul de vedere al spațiului de memorie utilizat şi al timpului de executare:
*se recomandă o soluție care să nu memoreze elementele șirului într-un tablou sau altă structură de date similară.

== Exemple ==
===Exemplul 1===
; ''crescator1.in''
:5 5 8 8 8 8 20 20 20 34 54 54 65 65 65
; ''Ecran''
: Datele sunt introduse corect.
; ''crescator1.out''
:20
=== Exemplul 2 ===
; ''crescator1.in''
:4 1 1 1 2
; ''secventeneuniforme.out''
; ''Ecran''
: Datele nu corespund restrictiilor impuse.
:0
===Exemplul 3===
; ''crescator1.in''
:3 3 3 3
; ''Ecran''
: Datele sunt introduse corect.
; ''crescator1.out''
:nu exista

 

== Rezolvare ==
<syntaxhighlight lang="python" line="1">
# 2809 - Crescator 1
def validare_date(sir):
if len(sir) > 10 ** 6:
return False
for i in range(1, len(sir)):
if sir[i] < sir[i - 1]:
return False
return True

def numar_impar(sir):
i = 0
while i < len(sir):
j = i
while j < len(sir) and sir[j] == sir[i]:
j += 1
if (j - i) % 2 == 1:
return sir[i]
i = j
return None

if __name__ == '__main__':
with open("crescator1.in") as fin:
sir = [int(x) for x in fin.readline().split()]
if validare_date(sir):
rezultat = numar_impar(sir)
with open("crescator1.out", "w") as fout:
if rezultat is not None:
fout.write(str(rezultat))
else:
fout.write("nu exista")
print("Datele introduse sunt corecte.")
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicatie==
Funcția validare_date(sir) verifică dacă datele din fișierul de intrare corespund restricțiilor impuse, adică lungimea șirului nu depășește 10^6 și toate numerele din șir sunt în ordine crescătoare. Dacă datele sunt valide, funcția returnează True, altfel returnează False.

Funcția numar_impar(sir) primește un șir de numere și încearcă să găsească un număr impar care apare de un număr impar de ori în șir. Pentru a face acest lucru, funcția parcurge lista și caută fiecare secvență de numere consecutive egale. Dacă numărul de elemente din această secvență este impar, atunci numărul respectiv este găsit și funcția returnează acesta. Dacă nu există niciun număr care să apară de un număr impar de ori, funcția returnează None.

În blocul if __name__ == '__main__': citim datele de intrare din fișierul "crescator1.in" și apoi verificăm dacă datele sunt valide folosind funcția validare_date(sir). Dacă datele nu sunt valide, se afișează un mesaj corespunzător și se oprește execuția programului.

Dacă datele sunt valide, se apelează funcția numar_impar(sir) pentru a găsi un număr impar care apare de un număr impar de ori și se afișează mesajul "Datele introduse sunt corecte.". În plus, se scrie numărul găsit (dacă există) în fișierul de ieșire "crescator1.out". Dacă nu există niciun număr care să apară de un număr impar de ori, se scrie "nu exista" în fișierul de ieșire.