Bitnami MediaWiki - User contributions [en]

2246 - Adobe

2023-05-07T11:24:45Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Domnul Eboda dorește să se angajeze la firma Adobe. La interviu el primește următoarea problemă. Se dă un șir de caractere format din litere și caracterele <code>*</code>, <code>+</code> și <code>-</code>. Domnul Eboda trebuie să determine câte subsecvențe de lungime <code>5</code> sunt anagrame ale cuvântului <code>ADOBE</code>. Regulile suplimentare sunt că nu se face distincție între literele mari și cele mici și în plus, caracterul <code>+...

==Cerința==
Domnul Eboda dorește să se angajeze la firma Adobe. La interviu el primește următoarea problemă.

Se dă un șir de caractere format din litere și caracterele <code>*</code>, <code>+</code> și <code>-</code>. Domnul Eboda trebuie să determine câte subsecvențe de lungime <code>5</code> sunt anagrame ale cuvântului <code>ADOBE</code>. Regulile suplimentare sunt că nu se face distincție între literele mari și cele mici și în plus, caracterul <code>+</code> poate suplini oricare consoană, caracterul <code>-</code> suplinește orice vocală, iar <code>*</code> suplinește orice literă. Cu aceste reguli putem spune că următoarele secvențe de cinci caractere sunt anagrame ale cuvântului <code>adobe</code>: <code>aeobd</code>, <code>dBoAE</code>, <code>db---</code>, <code>Ae-++</code>, <code>*****</code>, <code>++---</code>, <code>ad*-+</code>.

==Date de intrare==
Programul citește de la tastatură șirul de caractere.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa un singur număr natural reprezentând numărul de subsecvențe de lungime <code>5</code> care sunt anagrame ale cuvântului <code>ADOBE</code>.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* Șirul va avea cel mult <code>100 000</code> de caractere și nu conține alte caractere în afara celor precizate în enunț.

==Exemplu 1==
;Intrare
:ebodaE+m***++
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:4
===Explicație===
Cele patru subsecvențe sunt: <code>eboda</code>, <code>bodaE</code>, <code>odaE+</code> și <code>***++</code>.
==Exemplu 2==
;Intrare
:e1b2o3d4a5E6+7m8*9*0*9+8+76
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
# 2246 - Adobe
import re

def conditii(sir):
if re.match("^[a-zA-Z*+-]*$", sir):
return True

def adobe(sir):
# Șirul este case-insensitive, deci poate fi convertit în litere mici
sir = sir.lower()
# Ținem cont de subsecvențe
nr_subsecvente = 0

# Pentru fiecare grupare de 5 caractere
for i in range(0, len(sir)-5):
# Dacă este anagramă a cuvântului "adobe"...
if sorted(sir[i:i + 5]) == sorted("adobe"):
# ...creștem numărul de subsecvențe
nr_subsecvente += 1
continue
# Altfel...
else:
subsir = sir[i:i + 5]
# Inițializăm numărul de consoane, vocale și litere lipsă
# "Adobe" conține 2 consoane, 3 vocale; în total 5 litere
consoane_lipsa, vocale_lipsa, litere_lipsa = 2, 3, 5
# Pentru fiecare caracter din subsir...
for caracter in subsir:
# ...dacă caracterul este *...
if caracter == "*":
# ...scădem numărul de vocale, consoane și litere lipsă
litere_lipsa -= 1
vocale_lipsa -= 1
consoane_lipsa -= 1
continue
# ...dacă caracterul este vocală sau -...
if caracter in ("a", "o", "e", "-"):
# ...scădem numărul de vocale și litere lipsă
vocale_lipsa -= 1
litere_lipsa -= 1
continue
# ...dacă caracterul este consoană sau +...
if caracter in ("b", "d", "+"):
# ...scădem numărul de consoane și litere lipsă
consoane_lipsa -= 1
litere_lipsa -= 1
continue

# Dacă nu mai lipsesc consoane, vocale sau litere...
if consoane_lipsa+vocale_lipsa+litere_lipsa == 0:
# ...creștem numărul de subsecvențe
nr_subsecvente += 1

print(nr_subsecvente)

if __name__ == "__main__":
sir = input()

if not conditii(sir):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
adobe(sir)

</syntaxhighlight>

1544 - Muzical

2023-05-07T10:35:52Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Gigel în timp ce așteptă să meargă la doctor se joacă cu noul lui telefon. A observat ca atunci când este pe ecranul de start și apasă pe o tastă numerică se aude o notă muzicală. Dar lui i-a venit ideea să codeze fiecare notă muzicală în acest mod: * Nota <code>do1</code> cu numărul <code>0</code> * Nota <code>re</code> cu numărul <code>1</code> * Nota <code>mi</code> cu numărul <code>2</code> * Nota <code>fa</code> cu numărul <code>3</cod...

==Cerința==
Gigel în timp ce așteptă să meargă la doctor se joacă cu noul lui telefon. A observat ca atunci când este pe ecranul de start și apasă pe o tastă numerică se aude o notă muzicală.

Dar lui i-a venit ideea să codeze fiecare notă muzicală în acest mod:

* Nota <code>do1</code> cu numărul <code>0</code>
* Nota <code>re</code> cu numărul <code>1</code>
* Nota <code>mi</code> cu numărul <code>2</code>
* Nota <code>fa</code> cu numărul <code>3</code>
* Nota <code>sol</code> cu numărul <code>4</code>
* Nota <code>la</code> cu numărul <code>5</code>
* Nota <code>si</code> cu numărul <code>6</code>
* Nota <code>do2</code> cu numărul <code>7</code>

El creează un cântec, ia notele muzicale și le codează ca mai sus, le adună, iar apoi împarte suma la <code>8</code> și restul rămas este nota maximă.

Ajutați-l pe Gigel sa afle nota maximă!

==Date de intrare==
Fișierul de intrare <code>muzical.in</code> conține pe prima linie numărul <code>n</code> și pe a doua linie <code>n</code> note muzicale.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa nota maximă.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

*<code>n ≤ 100.000</code>

==Exemplu 1==
;Intrare
:8
:do1 re mi fa sol la si do2
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:sol
===Explicație===
<code>do1</code> se codifică prin <code>0</code>

<code>re</code> se codifică prin <code>1</code>

<code>mi</code> se codifică prin <code>2</code>

<code>fa</code> se codifică prin <code>3</code>

<code>sol</code> se codifică prin <code>4</code>

<code>la</code> se codifică prin <code>5</code>

<code>si</code> se codifică prin <code>6</code>

<code>do2</code> se codifică prin <code>7</code>

Adunând codificările notelor se obține suma <code>28</code>, iar restul sumei la împărțirea prin <code>8</code> este <code>4</code>, deci nota maximă este <code>sol</code>.

==Exemplu 2==
;Intrare
:5000000
:do1 re mi fa sol la si do2
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
# 1544 - Muzical
def conditii(n, note_muzicale):
return n <= 100_000 and \
all(nota in ("do1", "re", "mi", "fa", "sol", "la", "si", "do2") for nota in note_muzicale)

def muzical(note_muzicale):
# Inițializăm un dicționar cu notele muzicale și codificările lor
note_dictionar = {
"do1": 0, "re": 1, "mi": 2,
"fa": 3, "sol": 4, "la": 5,
"si": 6, "do2": 7
}
# Însumăm codificările notelor muzicale
suma_note = sum(note_dictionar[nota] for nota in note_muzicale)
rest = suma_note % 8

# Preluăm din dicționar nota muzicală corespunzătoare restului obținut
print(note_muzicale[rest])

if __name__ == "__main__":
n = int(input())
note_muzicale = [nota for nota in input().split()]

if not conditii(n, note_muzicale):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
muzical(note_muzicale)

</syntaxhighlight>

1298 - Suma 34

2023-05-07T10:14:58Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Fiind dat un număr natural <code>n</code>, se cere să se calculeze suma cifrelor numărului care reprezintă numărul de numere de <code>n</code> cifre formate cu cifrele <code>3</code> şi <code>4</code>. ==Date de intrare== Programul citește de la tastatură numărul <code>n</code>. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse." Pe următoarea linie se va afișa numărul <code>S</code>, reprezentând...

==Cerința==
Fiind dat un număr natural <code>n</code>, se cere să se calculeze suma cifrelor numărului care reprezintă numărul de numere de <code>n</code> cifre formate cu cifrele <code>3</code> şi <code>4</code>.

==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa numărul <code>S</code>, reprezentând suma cerută.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 100.000</code>

==Exemplu 1==
;Intrare
:4
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:7
===Explicație===
Numerele de <code>4</code> cifre formate cu cifrele <code>3</code> şi <code>4</code> sunt <code>3333</code> , <code>3334</code> , <code>3343</code> , <code>3433</code> , <code>4333</code> , <code>3344</code> , <code>3434</code> , <code>4334</code> , <code>4343</code> , <code>4433</code> , <code>3443</code> , <code>3444</code> , <code>4344</code> , <code>4434</code> , <code>4443</code> , <code>4444</code>. Deci sunt <code>16</code> numere, iar suma cifrelor este <code>S=7</code>.
==Exemplu 2==
;Intrare
:-5
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
# 1298 - Suma34
def conditii(n):
return 1 <= n <= 100_000

def suma34(n):
# Numărul fiind alcătuit din n cifre, fiecare cifră din acel număr poate fi 3 sau 4, adică avem doar 2 posibilități.
# Multiplicând numărul de posibilități (2) de n ori, obținem 2^n.
numere_posibile = 2**n
# Însumăm cifrele din numărul obținut.
suma_cifre = sum([int(cifra) for cifra in str(numere_posibile)])
print(suma_cifre)

if __name__ == "__main__":
n = int(input())

if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
suma34(n)

</syntaxhighlight>

2253 - Vacanta de Vara

2023-05-07T10:06:06Z

Ardelean Alexandru:

==Cerința==
Gigel este acum în clasa a XII-a și nu dorește să dea examenul de Bacalaureat, ci să ajungă direct la vacanța de vară. Pentru a se teleporta în timp și a ajunge la o zi după examen, acesta se folosește de o aplicație pentru mobil. Însă doar elevii foarte inteligenți au dreptul să călătorească în timp, motiv pentru care Gigel trebuie să dovedească că face parte din acea categorie. Aplicația îi generează un număr natural aleatoriu, <code>N</code> și <code>N</code> cifre aleatorii. Pentru a intra în aplicație, Gigel trebuie să introducă codul de securitate, care este cel mai mic număr care se poate forma din toate cele <code>N</code> cifre.

Gigel nu poate face singur acest lucru, dar își dorește mult să vină vacanța de vară și vă roagă pe voi să-i generați codul de securitate.

==Date de intrare==
Fișierul de intrare <code>vacantadevara.in</code> conține pe prima linie numărul <code>N</code>, iar pe a doua linie <code>N</code> numere naturale separate prin spații.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa numărul reprezentând codul de securitate.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ N ≤ 1000</code>
* Se garantează faptul că există cel puțin o cifră nenulă.

==Exemplu 1==
;Intrare
:10
:6 0 0 7 4 1 0 1 0 8
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1000014678
===Explicație===
Cel mai mic număr care se poate forma din cifrele: <code>6</code>, <code>0</code>, <code>0</code>, <code>7</code>, <code>4</code>, <code>1</code>, <code>0</code>, <code>1</code>, <code>0</code> și <code>8</code> este <code>1000014678</code>.
==Exemplu 2==
;Intrare
:-5
:0 0 0 0 0 0 0 0 0 0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
# 2253 - Vacanta De Vara
def conditii(n, cifre):
return 1 <= n <= 1_000 and \
len(cifre) == n and \
all(0 <= x <= 9 for x in cifre) and \
any(x > 0 for x in cifre)

def vacanta_de_vara(cifre):
# Mai întâi sortăm cifrele
cifre.sort()
# Dacă prima cifră este 0, o mutăm pe prima poziție nenulă
# Dacă prima cifră nu este 0, deja avem cel mai mic număr posibil format din cifrele date
if cifre[0] == 0:
# Pentru fiecare cifră...
for i in range(1, len(cifre)):
# ...dacă cifra este nenulă...
if cifre[i] != 0:
# ...interschimbăm 0 cu această cifră și ieșim din loop deoarece am obținut cel mai mic număr posibil
cifre[0], cifre[i] = cifre[i], cifre[0]
break

return "".join(str(cif) for cif in cifre)

if __name__ == "__main__":
n = int(input())
cifre = [int(x) for x in input().split()]

if not conditii(n, cifre):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
vacanta_de_vara(cifre)

</syntaxhighlight>

2253 - Vacanta de Vara

2023-05-07T10:00:33Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Gigel este acum în clasa a XII-a și nu dorește să dea examenul de Bacalaureat, ci să ajungă direct la vacanța de vară. Pentru a se teleporta în timp și a ajunge la o zi după examen, acesta se folosește de o aplicație pentru mobil. Însă doar elevii foarte inteligenți au dreptul să călătorească în timp, motiv pentru care Gigel trebuie să dovedească că face parte din acea categorie. Aplicația îi generează un număr natural aleatoriu, <code...

==Cerința==
Gigel este acum în clasa a XII-a și nu dorește să dea examenul de Bacalaureat, ci să ajungă direct la vacanța de vară. Pentru a se teleporta în timp și a ajunge la o zi după examen, acesta se folosește de o aplicație pentru mobil. Însă doar elevii foarte inteligenți au dreptul să călătorească în timp, motiv pentru care Gigel trebuie să dovedească că face parte din acea categorie. Aplicația îi generează un număr natural aleatoriu, <code>N</code> și <code>N</code> cifre aleatorii. Pentru a intra în aplicație, Gigel trebuie să introducă codul de securitate, care este cel mai mic număr care se poate forma din toate cele <code>N</code> cifre.

Gigel nu poate face singur acest lucru, dar își dorește mult să vină vacanța de vară și vă roagă pe voi să-i generați codul de securitate.

==Date de intrare==
Fișierul de intrare <code>vacantadevara.in</code> conține pe prima linie numărul <code>N</code>, iar pe a doua linie <code>N</code> numere naturale separate prin spații.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa numărul reprezentând codul de securitate.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ N ≤ 1000</code>
* Se garantează faptul că există cel puțin o cifră nenulă.

==Exemplu 1==
;Intrare
:10
:6 0 0 7 4 1 0 1 0 8
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1000014678
===Explicație===
Cel mai mic număr care se poate forma din cifrele: <code>6</code>, <code>0</code>, <code>0</code>, <code>7</code>, <code>4</code>, <code>1</code>, <code>0</code>, <code>1</code>, <code>0</code> și <code>8</code> este <code>1000014678</code>.
==Exemplu 2==
;Intrare
:-5
:0 0 0 0 0 0 0 0 0 0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
# 2253 - Vacanta De Vara
def conditii(n, cifre):
return 1 <= n <= 1_000 and \
len(cifre) == n and \
all(0 <= x <= 9 for x in cifre) and \
any(x > 0 for x in cifre) and \

def vacanta_de_vara(cifre):
# Mai întâi sortăm cifrele
cifre.sort()
# Dacă prima cifră este 0, o mutăm pe prima poziție nenulă
# Dacă prima cifră nu este 0, deja avem cel mai mic număr posibil format din cifrele date
if cifre[0] == 0:
# Pentru fiecare cifră...
for i in range(1, len(cifre)):
# ...dacă cifra este nenulă...
if cifre[i] != 0:
# ...interschimbăm 0 cu această cifră și ieșim din loop deoarece am obținut cel mai mic număr posibil
cifre[0], cifre[i] = cifre[i], cifre[0]
break

return "".join(str(cif) for cif in cifre)

if __name__ == "__main__":
n = int(input())
cifre = [int(x) for x in input().split()]

if not conditii(n, cifre):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
vacanta_de_vara(cifre)

</syntaxhighlight>

0279 - Distincte

2023-05-07T09:32:42Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se dă un şir cu <code>n</code> elemente, numere naturale cu cel mult <code>8</code> cifre, ordonate crescător. Afişaţi în ordine crescătoare elementele distincte din şir. ==Date de intrare== Fişierul de intrare <code>distincte.in</code> conţine pe prima linie numărul <code>n</code>; urmează cele <code>n</code> elemente ale şirului, dispuse pe mai multe linii şi separate prin spaţii. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de int...

==Cerința==
Se dă un şir cu <code>n</code> elemente, numere naturale cu cel mult <code>8</code> cifre, ordonate crescător. Afişaţi în ordine crescătoare elementele distincte din şir.

==Date de intrare==
Fişierul de intrare <code>distincte.in</code> conţine pe prima linie numărul <code>n</code>; urmează cele <code>n</code> elemente ale şirului, dispuse pe mai multe linii şi separate prin spaţii.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se vor afișa elementele distincte din şir, în ordine crescătoare, fiecare pe o linie.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 10.000</code>

==Exemplu 1==
;Intrare
:7
:111 111 111 2111 4111 71111 71111
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:111 2111 4111 71111
==Exemplu 3==
;Intrare
:-5
:111 111 111 2111 4111 71111 71111
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0279 - Distincte
def conditii(n, numere):
return len(numere) == n and \
1 <= n <= 10_000 and \
numere == sorted(numere) and \
all(len(str(nr)) <= 8 for nr in numere)

def distincte(numere):
# set() este o funcție built-in care elimină duplicatele dintr-o listă
# Folosim sorted() deoarece set() nu returnează un obiect sortat
print(" ".join(str(x) for x in sorted(set(numere))))

if __name__ == "__main__":
n = int(input())
numere = [int(x) for x in input().split()]

while len(numere) < n:
numere.extend([int(x) for x in input().split()])

if not conditii(n, numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
distincte(numere)

</syntaxhighlight>

4306 - Nr Div Fact

2023-05-07T09:16:52Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se citește un număr natural <code>n</code>. Calculați și afișați numărul de divizori pozitivi ai numărului <code>n!</code>. ==Date de intrare== Programul citește de la tastatură numărul <code>n</code>. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse." Pe următoarea linie se va afișa numărul de divizori pozitivi ai numărului <code>n!</code>. În cazul în care datele introduse de la tastatură...

==Cerința==
Se citește un număr natural <code>n</code>. Calculați și afișați numărul de divizori pozitivi ai numărului <code>n!</code>.

==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa numărul de divizori pozitivi ai numărului <code>n!</code>.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

*<code>n<=100000</code>.

==Exemplu 1==
;Intrare
:4
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:8
===Explicație===
Factorialul lui 4 este egal cu 24, iar 24 are 8 divizori (1, 2, 3, 4, 6, 8, 12, 24).
==Exemplu 2==
;Intrare
:<code>500000</code>
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#4306 - NrDivFact
def conditii(n):
return n <= 100_000

def nr_div_fact(n):
# Calculăm factorialul lui n
n_factorial = 1
for i in range(1, n + 1):
n_factorial *= i

nr_divizori = 0
# Pentru fiecare număr de la 1 la n_factorial...
for i in range(1, n_factorial + 1):
# ...dacă n_factorial se împarte la i...
if n_factorial % i == 0:
# ...atunci i este divizor al lui n_factorial
nr_divizori += 1

print(nr_divizori)

if __name__ == "__main__":
n = int(input())
if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
nr_div_fact(n)

</syntaxhighlight>

3466 - Num Sum Div

2023-05-07T08:48:01Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Pentru un număr natural <code>x</code> notăm cu <code>S</code> suma divizorilor săi diferiți de <code>x</code>. Dacă <code>S</code> este strict mai mică decât <code>x</code>, atunci <code>x</code> se numește număr deficient, dacă <code>S</code> este egală cu <code>x</code>, atunci <code>x</code> se numește număr perfect, iar dacă <code>S</code> este strict mai mare decât <code>x</code>, atunci <code>x</code> se numește număr abundent. Se dă un...

==Cerința==
Pentru un număr natural <code>x</code> notăm cu <code>S</code> suma divizorilor săi diferiți de <code>x</code>. Dacă <code>S</code> este strict mai mică decât <code>x</code>, atunci <code>x</code> se numește număr deficient, dacă <code>S</code> este egală cu <code>x</code>, atunci <code>x</code> se numește număr perfect, iar dacă <code>S</code> este strict mai mare decât <code>x</code>, atunci <code>x</code> se numește număr abundent.

Se dă un șir de <code>n</code> numere naturale. Să se calculeze câte numere sunt deficiente, perfecte, respectiv abundente.

==Date de intrare==
Fișierul de intrare <code>num_sum_div.in</code> conține pe prima linie numărul <code>n</code>, iar pe a doua linie <code>n</code> numere naturale separate prin spații.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se vor afișa <code>3</code> numere separate prin câte un spațiu, reprezentând câți termeni ai șirului sunt numere deficiente, perfecte, respectiv abundente.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 10.000</code>
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât <code>5.000.000.000</code>

==Exemplu 1==
;Intrare
:10
:2 6 8 20 21 13 14 15 12 24
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:6 1 3
===Explicație===
În fișierul de intrare sunt <code>6</code> numere deficiente, un singur număr perfect și <code>3</code> numere abundente.
==Exemplu 2==
;Intrare
:-5
:2 6 8 20 21 13 14 15 12 24
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#3466 - Num Sum Div
def conditii(n, numere):
return len(numere) == n and \
1 <= n <= 10_000 and \
all(nr < 5_000_000_000 for nr in numere)

def num_sum_div(numere):
deficiente, perfecte, abundente = 0, 0, 0

for nr in numere:
# Însumăm toți divizorii ai lui 'nr'
suma = sum(divizor for divizor in range(1, nr // 2 + 1) if nr % divizor == 0)
# Dacă suma este mai mică decât 'nr' ...
if suma < nr:
# ... incrementăm numărul de deficiente
deficiente += 1
# Dacă suma este egală cu 'nr' ...
elif suma == nr:
# ... incrementăm numărul de perfecte
perfecte += 1
# Dacă suma este mai mare decât 'nr' ...
else:
# ... incrementăm numărul de abundente
abundente += 1

# Afisăm numărul de deficiente, perfecte și abundente în ordinea cerută de enunț
print(deficiente, perfecte, abundente)

if __name__ == "__main__":
n = int(input())
numere = [int(x) for x in input().split()]
if not conditii(n, numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
num_sum_div(numere)

</syntaxhighlight>

2285 - B2

2023-05-07T08:26:33Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Fie un număr natural <code>n</code>, <code>n < 262</code>. Să se afişeze toate numerele naturale mai mici sau egale cu <code>n</code>, cu proprietatea că reprezentarea lor in baza <code>2</code> are exact două cifre <code>1</code>. ==Date de intrare== Fişierul de intrare <code>b2.in</code> conţine pe prima linie numărul natural <code>n</code>. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse...

==Cerința==
Fie un număr natural <code>n</code>, <code>n < 262</code>. Să se afişeze toate numerele naturale mai mici sau egale cu <code>n</code>, cu proprietatea că reprezentarea lor in baza <code>2</code> are exact două cifre <code>1</code>.

==Date de intrare==
Fişierul de intrare <code>b2.in</code> conţine pe prima linie numărul natural <code>n</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se vor afișa în ordine crescătoare numerele cerute, pe o singură linie cu spaţiu între ele.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>3 ≤ n < 262</code>

==Exemplu 1==
;Intrare
:20
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:3 5 6 9 10 12 17 18 20
==Exemplu 2==
;Intrare
:1
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2285 B2
def conditii(n):
return 3 <= n < 2**62

def b2(n):
rezultat = []
# Parcurgem numerele naturale de la 1 la n
# Folosim n+1 pentru a-l include și pe n
for i in range(1, n+1):
# bin() este o funcție built-in care transformă un număr în reprezentarea sa binară
# Secționăm reprezentarea [2:] pentru a elimina prefixul "0b"
binary = bin(i)[2:]
# count() este o funcție built-in care numără de câte ori apare un subșir într-un șir
# Dacă avem exact două cifre "1", îl adăugăm la rezultat
if binary.count('1') == 2:
rezultat.append(i)

# Sortăm și printăm vectorul rezultat
print(" ".join([str(x) for x in sorted(rezultat)]))

if __name__ == "__main__":
n = int(input())
if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
b2(n)

</syntaxhighlight>

0989 - Sum Perm

2023-05-07T08:14:07Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se dau <code>n</code> cifre zecimale: <code>a1</code>, <code>a2</code>, … , <code>an</code>. Determinaţi suma: <code>S = a1a2...an + ana1...an-1 + a2a3...ana1</code>, în care fiecare termen este obţinut prin permutarea circulară spre dreapta a cifrelor termenului precedent cu o poziţie. ==Date de intrare== Fișieru...

==Cerința==
Se dau <code>n</code> cifre zecimale: <code>a1</code>, <code>a2</code>, … , <code>an</code>. Determinaţi suma: <code>S = a1a2...an + ana1...an-1 + a2a3...ana1</code>, în care fiecare termen este obţinut prin permutarea circulară spre dreapta a cifrelor termenului precedent cu o poziţie.

==Date de intrare==
Fișierul de intrare <code>sumperm.in</code> conține pe prima linie numărul <code>n</code>, iar pe a doua linie cele <code>n</code> cifre separate prin spații.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa numărul <code>S</code>, reprezentând suma calculată.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>2 ≤ n ≤ 9</code>

==Exemplu 1==
;Intrare
:3
:2 5 4
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1221
===Explicație===
<code>S=254 + 425 + 542 =1221</code>.
==Exemplu 2==
;Intrare
:1
:2 5 4
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0989 Sum Perm
def conditii(n, cifre):
return n == len(cifre) and 2 <= n <= 9

def sumperm(cifre):
# Inițializăm suma ca fiind concatenarea cifrelor din vectorul cifre
suma = int("".join([cif for cif in cifre]))

# Iterăm vectorul cifre de n ori, unde n = lungimea vectorului-1
# Îl rotim cu 1 mai puțin decât lungimea sa pentru a nu repeta suma inițială
for i in range(len(cifre) - 1):
# append() este o funcție built-in care adaugă un element la sfârșitul unui vector
# pop() este o funcție built-in care elimină un element dintr-un vector și returnează valoarea sa
cifre.append(cifre.pop(0))
# Concatenăm cifrele din vectorul modificat și le convertim la int, apoi le adunăm la suma inițială
suma += int("".join([cif for cif in cifre]))

print(suma)

if __name__ == "__main__":
n = int(input())
cifre = [x for x in input().split()]
if not conditii(n, cifre):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
sumperm(cifre)

</syntaxhighlight>

1141 - Ech

2023-05-07T07:37:13Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Numim număr echilibrat un număr natural pentru care suma cifrelor de pe poziţii pare este egală cu suma cifrelor de pe poziţii impare. De exemplu numărul <code>13552</code> este echilibrat, pentru că <code>1+5+2=8=3+5</code>. Dat fiind un număr natural <code>N</code> să se determine cel mai mic număr echilibrat, strict mai mare decât <code>N</code>. ==Date de intrare== Fișierul de intrare <code>ech.in</code> conține pe prima linie numărul <code>N...

==Cerința==
Numim număr echilibrat un număr natural pentru care suma cifrelor de pe poziţii pare este egală cu suma cifrelor de pe poziţii impare.

De exemplu numărul <code>13552</code> este echilibrat, pentru că <code>1+5+2=8=3+5</code>.

Dat fiind un număr natural <code>N</code> să se determine cel mai mic număr echilibrat, strict mai mare decât <code>N</code>.

==Date de intrare==
Fișierul de intrare <code>ech.in</code> conține pe prima linie numărul <code>N</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa cel mai mic număr echilibrat, strict mai mare decât <code>N</code>.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* Numărul <code>N</code> are cel mult <code>23</code> de cifre.

==Exemplu 1==
;Intrare
:99
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:110
===Explicație===
<code>1+0=1</code>.
==Exemplu 2==
;Intrare
:123133
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:123134
===Explicație===
<code>1+3+3=2+1+4</code>.
==Exemplu 3==
;Intrare
:123456789098765432101234567890987654321012345678909876543210
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1141 Ech
def conditii(n):
return len(str(n)) <= 23

def is_echilibrat(n):
# Ținem cont de sumele cifrelor de pe poziții impare și pare
suma_impara = 0
suma_para = 0
for i in range(len(str(n))):
# Dacă indicele este par (indicele 0, 2, 4...),
# adunăm la suma cifrelor impare (indicele 0 înseamnă poziția 1, indicele 2 = poziția 3 etc.)
if i % 2 == 0:
suma_impara += int(str(n)[i])
# Dacă indicele este impar (indicele 1, 3, 5...),
# adunăm la suma cifrelor pare (indicele 1 înseamnă poziția 2, indicele 3 = poziția 4 etc.)
else:
suma_para += int(str(n)[i])

return suma_impara == suma_para

def ech(n):
# Pornim de la n+1 deoarece rezultatul trebuie să fie strict mai mare decât n
n += 1

# Atâta timp cât numărul nu este echilibrat, îl incrementăm
while not is_echilibrat(n):
n += 1

# La ieșirea din while, n este un număr echilibrat
print(n)

if __name__ == "__main__":
n = int(input())
if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
ech(n)

</syntaxhighlight>

0129 - Sortare

2023-05-07T07:14:34Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se dă un vector cu <code>n</code> elemente numere întregi. Să se ordoneze descrescător elementele vectorului. ==Date de intrare== Fişierul de intrare <code>sortare.in</code> conţine pe prima linie numărul <code>n</code> si pe a doua linie <code>n</code> numere întregi separate prin spaţii. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse." Pe următoarea linie se vor afișa cele <code>n</code> eleme...

==Cerința==
Se dă un vector cu <code>n</code> elemente numere întregi.

Să se ordoneze descrescător elementele vectorului.

==Date de intrare==
Fişierul de intrare <code>sortare.in</code> conţine pe prima linie numărul <code>n</code> si pe a doua linie <code>n</code> numere întregi separate prin spaţii.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se vor afișa cele <code>n</code> elemente ale vectorului, ordonate conform cerinței, separate printr-un spațiu.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

*<code>0 < n ≤ 100</code>

*valoarea absolută a numerelor de pe a doua linie a fişierului de intrare va fi mai mică decât <code>2<big>30</big></code>

==Exemplu 1==
;Intrare
:6
:8 2 9 4 5 7
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:9 8 7 5 4 2

==Exemplu 2==
;Intrare
:-2
:8 2 9 4 5 7
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0129 Sortare
def conditii(n, numere):
return len(numere) == n and \
0 < n <= 100 and \
all(abs(nr) < 2**30 for nr in numere)

def sortare(numere):
# sorted() este o funcție built-in care sortează o listă dată
# reverse=True înseamnă că lista va fi sortată descrescător
rezultat = sorted(numere, reverse=True)
print(" ".join([str(x) for x in rezultat]))

if __name__ == "__main__":
n = int(input())
numere = [int(x) for x in input().split()]
if not conditii(n, numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
sortare(numere)

</syntaxhighlight>

0086 - Half Sort

2023-05-07T06:57:12Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se dă un vector cu <code>n</code> elemente numere întregi, <code>n</code> fiind număr par. Să se ordoneze crescător elementele din prima jumătate a vectorului și descrescător elementele din a doua jumătate. ==Date de intrare== Fişierul de intrare <code>halfsort.in</code> conţine pe prima linie numărul <code>n</code> si pe a doua linie <code>n</code> numere întregi separate prin spaţii. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de...

==Cerința==
Se dă un vector cu <code>n</code> elemente numere întregi, <code>n</code> fiind număr par.

Să se ordoneze crescător elementele din prima jumătate a vectorului și descrescător elementele din a doua jumătate.

==Date de intrare==
Fişierul de intrare <code>halfsort.in</code> conţine pe prima linie numărul <code>n</code> si pe a doua linie <code>n</code> numere întregi separate prin spaţii.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se vor afișa cele <code>n</code> elemente ale vectorului, ordonate conform cerinței, separate printr-un spațiu.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 100</code>, <code>n</code> număr par

* valoarea absolută a numerelor de pe a doua linie a fişierului de intrare va fi mai mică decât <code>1.000.000.000</code>

==Exemplu 1==
;Intrare
:6
:8 2 9 4 5 7
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:2 8 9 7 5 4

==Exemplu 2==
;Intrare
:-2
:8 2 9 4 5 7
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0086 Half Sort
def conditii(n, numere):
return len(numere) == n and \
1 <= n <= 100 and \
n % 2 == 0 and \
all(abs(nr) < 1_000_000_000 for nr in numere)

def half_sort(numere):
# Secționăm și sortăm crescător prima jumătate a listei: numere[ :len(numere)//2]
# Secționăm și sortăm descrescător a doua jumătate a listei: numere[len(numere)//2: ]
# Folosim operatorul + pentru a concatena elementele celor două liste
rezultat = sorted(numere[:len(numere)//2], reverse=False) + \
sorted(numere[len(numere)//2:], reverse=True)
print(" ".join([str(x) for x in rezultat]))

if __name__ == "__main__":
n = int(input())
numere = [int(x) for x in input().split()]
if not conditii(n, numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
half_sort(numere)

</syntaxhighlight>

0130 - Sort Cif

2023-05-07T06:41:20Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se dă un vector cu <code>n</code> elemente numere întregi. Să se ordoneze crescător elementele unui vector crescător după suma cifrelor. ==Date de intrare== Fişierul de intrare <code>sortcif.in</code> conţine pe prima linie numărul <code>n</code> si pe a doua linie <code>n</code> numere întregi separate prin spaţii. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse." Pe următoarea linie se vor afi...

==Cerința==
Se dă un vector cu <code>n</code> elemente numere întregi.

Să se ordoneze crescător elementele unui vector crescător după suma cifrelor.

==Date de intrare==
Fişierul de intrare <code>sortcif.in</code> conţine pe prima linie numărul <code>n</code> si pe a doua linie <code>n</code> numere întregi separate prin spaţii.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se vor afișa cele <code>n</code> elemente ale vectorului, ordonate conform cerinței, separate printr-un spațiu.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>0 < n ≤ 100</code>

* valoarea absolută a numerelor de pe a doua linie a fişierului de intrare va fi mai mică decât <code>2<big>30</big></code>.

==Exemplu 1==
;Intrare
:6
:89 22 91 4005 51 721
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:22 51 4005 91 721 89

==Exemplu 2==
;Intrare
:-2
:89 22 91 4005 51 721
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0130 Sort Cif
def conditii(n, numere):
return len(numere) == n and \
0 < n <= 1000 and \
all(abs(nr) < 2**30 for nr in numere)

def sort_cif(numere):
rezultat = sorted(numere, key=lambda numar: sum([int(cifra) for cifra in str(numar)]))
# cheia de sortare returneaza suma cifrelor unui număr, SCif(numar) -> sum([int(cifra) for cifra in str(numar)])
# Numerele sunt sortate după SCif(x)
print(" ".join([str(x) for x in rezultat]))

if __name__ == "__main__":
n = int(input())
numere = [int(x) for x in input().split()]
if not conditii(n, numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
sort_cif(numere)

</syntaxhighlight>

3902 - Sort Sum

2023-05-07T06:19:11Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Scrie un program care citind un șir de numere naturale afișează numerele citite ordonate crescător după suma cifrelor lor, iar dacă suma cifrelor este egală, descrescător după valoarea lor. ==Date de intrare== Fișierul de intrare <code>sortsum.in</code> conține pe prima linie numere naturale separate prin spații. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse." Pe următoarea linie se vor afișa...

==Cerința==
Scrie un program care citind un șir de numere naturale afișează numerele citite ordonate crescător după suma cifrelor lor, iar dacă suma cifrelor este egală, descrescător după valoarea lor.

==Date de intrare==
Fișierul de intrare <code>sortsum.in</code> conține pe prima linie numere naturale separate prin spații.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se vor afișa numerele ordonate conform cerinței.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* în fișier vor fi mai puțin de <code>1.000.000</code> de numere

*numerele din fișierul de intrare vor fi mai mici decât <code>10.000.000</code>

==Exemplu 1==
;Intrare
:102 60 51 600 21 3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:102 21 3 600 60 51

==Exemplu 2==
;Intrare
:10516212154212 651621215516212150 5162121551 60516212150 2605116051 605160513
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#3902 - Sort Sum
def conditii(numere):
return len(numere) < 1_000_000 and \
all(nr < 100_000_000 for nr in numere)

def sort_sum(numere):
rezultat = sorted(numere, key=lambda numar: (sum([int(cifra) for cifra in str(numar)]), -numar))
# cheia de sortare returneaza un tuplu de 2 elemente:
# 1) suma cifrelor unui număr, SCif(numar) -> sum([int(cifra) for cifra in str(numar)])
# 2) numărul în sine, dar negat -> -numar
# Numerele sunt sortate după SCif(x). Dacă două numere au aceeași SCif, atunci sunt sortate după valoarea lor negată.
# Negăm numărul pentru a-l sorta descrescător.
print(" ".join([str(x) for x in rezultat]))

if __name__ == "__main__":
numere = [int(x) for x in input().split()]
if not conditii(numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
sort_sum(numere)

</syntaxhighlight>

1347 - A k cifra dintr-un numar

2023-05-07T05:09:28Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se construiește un număr natural <code>N</code> ale cărui prime <code>51</code> cifre sunt: <code>N = 112233445566778899100111122133144155166177188199200......</code> Deduceți regula prin care se construiește numărul <code>N</code> și stabiliți care este cea de a <code>K</code>-a cifră din scrierea acestui număr. Scrieţi un program care citeşte numărul <code>K</code> şi care determină cea de a <code>K</code>-a cifră din scrierea lui <code>N</co...

==Cerința==
Se construiește un număr natural <code>N</code> ale cărui prime <code>51</code> cifre sunt:

<code>N = 112233445566778899100111122133144155166177188199200......</code>

Deduceți regula prin care se construiește numărul <code>N</code> și stabiliți care este cea de a <code>K</code>-a cifră din scrierea acestui număr.

Scrieţi un program care citeşte numărul <code>K</code> şi care determină cea de a <code>K</code>-a cifră din scrierea lui <code>N</code>.

==Date de intrare==
Programul citește din fișierul <code>kcifra.in</code>, de pe prima linie, numărul natural nenul <code>K</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa un număr natural (o cifră) reprezentând cea de a <code>K</code>-a cifră din scrierea numărului <code>N</code> construit.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ K ≤ 588888</code>

*<code>K</code> număr natural

==Exemplu 1==
;Intrare
:10
;Ieșire
:5

===Explicație===
Primele <code>10</code> cifre ale lui <code>N</code> sunt: 1 1 2 2 3 3 4 4 5 <code>5</code>.

==Exemplu 2==
;Intrare
:51
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:0

===Explicație===
Primele <code>51</code> cifre ale lui <code>N</code> sunt: <code>112233445566778899100111122133144155166177188199200</code>.

==Exemplu 3==
;Intrare
:-2
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1347 K cifra
def conditii(k):
if not is_natural(k):
return False

return 1 <= int(k) <= 588_888

def is_natural(k):
try:
# Dacă 'k' poate fi convertit la un număr întreg, verificăm dacă este pozitiv
# (numerele naturale sunt numere întregi pozitive)
return int(k) > 0
except ValueError:
return False

def k_cifra(k):
# Generarea numărului N
n = ''
i = 1
# Generăm numărul N doar până la cea de a k-a cifră
while len(n) < k:
# Secvența N urmărește regula: pentru orice i -> n(i) = i + ultima cifră a lui i
# ex: pentru i=12 -> n(i)=122. pentru i=150 -> n(i)=1500
n += str(i)+str(i)[-1]

# Pasul următor
i += 1

print(n[k-1])

if __name__ == "__main__":
k = input()
if not conditii(k):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
k_cifra(int(k))

</syntaxhighlight>

2433 - Cufar

2023-05-06T16:26:06Z

Ardelean Alexandru:

==Cerința==
Vrăjitoarea cea bună are un cufăr în care este închisă piatra magică de către piticii lăzii cu ajutorul unui cifru digital. Piticii i-au dat vrăjitoarei o cutie în care sunt <code>n</code> cartonașe. Pe fiecare cartonaș este scris un număr natural pe care vrăjitoarea îl va folosi să deschidă lada. Valorile scrise pe cartonașe sunt distincte între ele.

Pentru a afla cifrul trebuie să procedeze astfel: extrage fiecare cartonaș din cutie și apoi determină valoarea magică asociată numărului natural scris pe cartonaș. Pentru fiecare cartonaș valoarea magică este dată de al <code>k</code>-lea divizor prim al numărului înscris pe acesta. Vrăjitoarea trebuie să adune valorile magice obținute pentru cele <code>n</code> cartonașe și apoi să introducă în ordine cifrele valorii obținute, pentru a descuia lada.

Deoarece vrăjitoarea nu are timp la dispoziție vă roagă pe voi să o ajutați să rezolve următoarele probleme:

1. Să afle valoarea magică pentru un cartonaș dat;

2. Să afle cifrul cufărului.

==Date de intrare==
Fișierul de intrare este <code>cufar.in</code>. Pe prima linie a fișierului de intrare se găsesc o valoare <code>p</code> care poate fi doar <code>1</code> sau <code>2</code> și numărul <code>n</code> de cartonașe despărțite prin câte un spațiu.

Dacă <code>p</code> este <code>1</code> pe linia a doua a fișierului de intrare se găsesc două valori reprezentând numărul de pe cartonașul dat și valoarea <code>k</code>, separate printr-un spațiu, cu semnificația de mai sus.

Dacă <code>p</code> este <code>2</code> pe următoarele <code>n</code> linii ale fișierului de intrare se găsesc câte două valori, separate prin câte un spațiu, reprezentând numărul de pe cartonaș și valoarea lui <code>k</code> pentru fiecare din cele <code>n</code> cartonașe.

==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Dacă valoarea lui <code>p</code> este <code>1</code>, atunci se va rezolva doar cerința <code>1</code> și pe următorul rând se va afișa valoarea magică asociată cartonașului dat.

Dacă valoarea lui <code>p</code> este <code>2</code>, atunci se va rezolva doar cerința <code>2</code> și pe următorul rând se va afișa cifrul necesar deschiderii cufărului.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n < 1 000 000</code>
* <code>2 ≤ valoarea înscrisă pe un cartonaș ≤ 1 000 000</code>

* Se garantează că pentru fiecare pereche <code>(număr, k)</code>, <code>număr</code> are cel puțin <code>k</code> divizori primi.

==Exemplu 1==
;Intrare
:1 1
:30 3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:5
===Explicație===
<code>p = 1</code>, <code>n = 1</code>

Se rezolvă doar prima cerință. Al treilea divizor prim al numărului <code>30</code> este <code>5</code>.

==Exemplu 2==
;Intrare
:2 5
:30 3
:64 1
:105 2
:1001 3
:5474 4
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:48
===Explicație===
<code>p = 2</code>, <code>n = 5</code>

Se rezolvă doar a doua cerință. Al treilea divizor prim al numărului <code>30</code> este <code>5</code>.

Primul divizor prim al numărului <code>64</code> este <code>2</code>.

Al doilea divizor prim al numărului <code>105</code> este <code>5</code>.

Al treilea divizor prim al numărului <code>1001</code> este <code>13</code>.

Al patrulea divizor prim al numărului <code>5474</code> este <code>23</code>.

Suma căutată va fi <code>S = 5 + 2 + 5 + 13 + 23</code>, de unde rezultă cifrul <code>48</code>.

==Exemplu 3==
;Intrare
:2 3
:1 3
:1000000 1
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2433 Cufar
def conditie_n(n):
return 1 <= n < 1_000_000

def conditie_cartonas(cartonas):
return 2 <= cartonas < 1_000_000

def prim(nr):
# Dace nr <= 1, atunci nr nu este prim.
if nr < 2:
return False
# Dacă de la 2 până la rădăcina pătrată a lui nr există un divizor a lui nr, atunci nr nu este prim.
for i in range(2, int(nr**0.5) + 1):
if nr % i == 0:
return False

return True

def cufar(cartonas, k):
nr = 0

# Iterăm toate numerele de la 2 la cartonas
for i in range(2, cartonas+1):
# Dacă i este divizor al lui cartonas și este prim...
if cartonas % i == 0 and prim(i):
# ... incrementăm nr
nr += 1
# Dacă nr este egal cu k, atunci am găsit al k-lea divizor prim al lui cartonas
if nr == k:
return i

return nr

if __name__ == "__main__":
p, n = [int(x) for x in input().split()]

if not conditie_n(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
# Iterăm de la 1 până la n
suma = 0
for i in range(n):
# La fiecare iterație, citim 2 valori: cartonas și k
cartonas, k = [int(x) for x in input().split()]
if not conditie_cartonas(cartonas):
print("Datele de intrare nu corespund restricțiilor impuse.")
exit(0)
# Adăugăm la variabila suma rezultatul funcției cufar
suma += cufar(cartonas, k)

print("Datele de intrare corespund restricțiilor impuse.")
print(suma)

</syntaxhighlight>

2494 - Desc Mult

2023-05-06T15:49:33Z

Ardelean Alexandru:

==Cerința==
Se consideră două șiruri <code>D=(D1,D2,...,Dn)</code> și <code>E=(E1,E2,... ,En)</code> ce reprezintă descompunerea în factori primi pentru un număr natural nenul <code>X</code>, după cum urmează: <code>Di</code> – factorul prim, <code>Ei</code> – puterea la care apare factorul prim <code>Di</code> în descompunerea numărului <code>X (1≤i≤n)</code>, unde <code>n</code> reprezintă numărul factorilor primi.

Să se determine:

1. numărul total de divizori naturali ai lui <code>X</code>

2. divizorii lui <code>X</code> care aparțin intervalului <code>[A,B]</code>, unde <code>A</code> și <code>B</code> sunt două numere naturale date.

==Date de intrare==
Fișierul de ieșire <code>descmult.in</code> conține pe prima linie un număr natural <code>C</code> care reprezintă cerința ce trebuie rezolvată (<code>C=1</code> sau <code>C=2</code>).

A doua linie conține, despărțite prin câte un spațiu, trei numere naturale <code>n A B</code>, cu semnificația din enunț.

Pe linie a treia se află <code>n</code> numere naturale, separate prin câte un spațiu, ce reprezintă factorii primi <code>D1 D2 ... Dn</code> din descompunerea lui <code>X</code>.

Pe linia a patra se află <code>n</code> numere naturale, separate prin câte un spațiu, ce reprezintă puterile la care apar acești factori <code>E1 E2 ... En</code>.

==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pentru <code>C=1</code> se va rezolva doar prima cerință. În acest caz, pe următorul rând se va afișa un singur număr natural nenul ce reprezintă numărul total de divizori naturali ai lui <code>X</code>.

Pentru <code>C=2</code> se va rezolva cea de-a doua cerință. În acest caz, pe următorul rând se va afișa, separați prin câte un spațiu, divizorii lui <code>X</code> ce aparțin intervalului <code>[A,B]</code>.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>2 ≤ n ≤ 20</code>
* <code>1 ≤ A ≤ B ≤ 107</code>

* <code>2 ≤ Di < 1000</code> (numere prime distincte), <code>1≤i≤n</code>

* <code>1 ≤ Ei ≤ 10</code>, <code>1≤i≤n</code>

* Se garantează că numărul maxim de divizori naturali ai lui <code>X ≤ 10</code> <code>19</code>
* Intervalul <code>[A,B]</code> conține cel puțin un divizor
* Numărul maxim de divizori aflați în intervalul <code>[A,B]</code> este <code>≤ 10</code> <code>6</code>
* Ordinea de afișare a divizorilor nu este importantă
* Pentru rezolvarea corectă a cerinței <code>1</code> se acordă <code>20</code> de puncte, iar pentru cea de-a doua cerință se acordă <code>80</code> de puncte.

==Exemplu 1==
;Intrare
:1
:4 30 50
:3 2 5 11
:1 3 2 1
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:48

===Explicație===
<code>X=31*23*52*111=6600</code> și are <code>48</code> de divizori: <code>1, 2, 3, 4, 5, 6, 8, 10, 11, 12, 15, 20, 22, 24, 25, 30, 33, 40, 44, 50, 55, 60, 66, 75, 88, 100, 110, 120, 132, 150, 165, 200, 220, 264, 275, 300, 330, 440, 550, 600, 660, 825, 1100, 1320, 1650, 2200, 3300, 6600</code>.

==Exemplu 2==
;Intrare
:2
:4 30 50
:3 2 5 11
:1 3 2 1
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:30 44 50 40 33

===Explicație===
<code>X=31*23*52*111=6600</code>.

Divizorii ce aparțin intervalului <code>[30,50]</code> sunt: <code>30,33,40,44,50</code>. Ordinea de afișare a divizorilor nu este importantă.

==Exemplu 3==
;Intrare
:1
:4 30 50
:3 2 5 11
:1 10 15 1
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2494 Desc Mult

def conditii(n, A, B, nr_naturale_factori_primi, nr_naturale_puteri):
if not 2 <= n <= 20:
return False
if not len(nr_naturale_puteri) == len(nr_naturale_factori_primi) == n:
return False
if not 1 <= A <= B <= 10**7:
return False

for nr_f_p in nr_naturale_factori_primi:
if not 2 <= nr_f_p < 1_000:
return False

for nr_n_p in nr_naturale_puteri:
if not 1 <= nr_n_p <= 10:
return False

return True

def divizori(n, nr_naturale_puteri):
# Calculăm numărul de divizori ai unui număr cu factorizarea în factori primi
nr_divizori = 1
for i in range(n):
nr_divizori *= nr_naturale_puteri[i] + 1

return nr_divizori

def divizori_interval(n, nr_naturale_puteri, nr_naturale_factori_primi, a, b):
# Găsim divizorii unui număr în intervalul [a, b]
x = 1
for i in range(n):
x *= (nr_naturale_factori_primi[i] ** nr_naturale_puteri[i])

divizori_solutie = []
# Pentru fiecare număr din intervalul [a, b]...
for i in range(a, b+1):
# ... verificăm dacă este divizor al lui x
if x % i == 0:
# Dacă da, îl adăugăm în lista de soluții
divizori_solutie.append(i)

return " ".join([str(x) for x in sorted(divizori_solutie)])

def descmult(c, n, A, B, nr_naturale_factori_primi, nr_naturale_puteri):
# c este numărul cerinței
if c == 1:
print(divizori(n, nr_naturale_puteri))
elif c == 2:
print(divizori_interval(n, nr_naturale_puteri, nr_naturale_factori_primi, A, B))

if __name__ == "__main__":
c = int(input())
n, A, B = [int(x) for x in input().split()]
nr_naturale_factori_primi = [int(x) for x in input().split()]
nr_naturale_puteri = [int(x) for x in input().split()]

if not conditii(n, A, B, nr_naturale_factori_primi, nr_naturale_puteri):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
descmult(c, n, A, B, nr_naturale_factori_primi, nr_naturale_puteri)

</syntaxhighlight>

2148 - ADN

2023-05-06T15:26:37Z

Ardelean Alexandru:

==Cerința==
Pe Marte s-au descoperit <code>N</code> marțieni, identificați de către oamenii de știință de pe Pământ prin numerele de la <code>1</code> la <code>N</code>. Cercetările au dovedit că ADN-ul oricărui marțian <code>X</code> este format din mulțimea factorilor primi din descompunerea lui <code>X</code>. De exemplu <code>ADN(6)={2,3}</code>.

Se știe că marțianul cu numărul de ordine <code>Y</code> îl moștenește pe marțianul cu numărul de ordine <code>X</code> dacă <code>ADN(X)</code> este inclus în <code>ADN(Y)</code>, adică mulțimea factorilor primi ai lui <code>X</code> este inclusă în mulțimea factorilor primi ai lui <code>Y</code>.

De exemplu, marțianul <code>6</code> îl moștenește pe marțianul <code>3</code> deoarece <code>ADN(3)={3}</code> este inclus în <code>ADN(6)={2,3}</code>.

Trebuie să specificăm că se pot întâlni situații extreme în care <code>X</code> îl moștenește pe <code>Y</code> dar și <code>Y</code> îl moștenește pe <code>X</code>, atunci când cei doi marțieni au ADN-urile egale. Este situația marțianului <code>12</code> care îl moștenește pe <code>6</code> dar și <code>6</code> îl moștenește pe <code>12</code>.

Realizați un program care, considerând mulțimea celor <code>N</code> marțieni, determină numărul de perechi de marțieni <code>(Y, X)</code> pentru care <code>Y</code> îl moștenește pe <code>X</code>, unde <code>1 ≤ X ≤ N</code> și <code>1 ≤ Y ≤ N</code>.

==Date de intrare==
Fișierul de intrare <code>adn.in</code> conține pe prima linie numărul <code>N</code>, reprezentând numărul de marțieni.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa numărul de perechi determinat.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ N ≤ 5 000 000</code>
* Pe planeta Marte orice marțian <code>X</code> îl moștenește pe <code>X.</code>
* Orice marțian îl moștenește pe marțianul <code>1</code> deoarece <code>ADN(1)={}</code>, adică mulțimea vidă, care se consideră inclusă în orice mulțime nevidă.
* Se garantează că numărul de perechi determinat are cel mult nouă cifre.

==Exemplu 1==
;Intrare
:6
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:16

===Explicație===
<code>ADN(1)={}</code>, <code>ADN(2)={2}</code>, <code>ADN(3)={3}</code>, <code>ADN(4)={2}</code>, <code>ADN(5)={5}</code>, <code>ADN(6)={2,3}</code>.

Perechile de marțieni determinate sunt <code>(1,1)</code>; <code>(2,2)</code>; <code>(3,3)</code>; <code>(4,4)</code>; <code>(5,5)</code>; <code>(6,6)</code>; <code>(4,2)</code>; <code>(2,4)</code>; <code>(6,2)</code>; <code>(6,3)</code>; <code>(6,4)</code>; <code>(2,1)</code> ; <code>(3,1)</code>; <code>(4,1)</code>; <code>(5,1)</code>; <code>(6,1)</code>.

==Exemplu 2==
;Intrare
:19
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:88

==Exemplu 3==
;Intrare
:38
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:251

== Exemplu 4 ==
;Intrare
:99
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:961

== Exemplu 5 ==
;Intrare
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2148 ADN
def conditii(n):
return 1 <= n <= 5_000_000

def ADN(n):
martieni_adn = {}
nr_perechi = 0

# Inițializăm un dicționar cu cheile de la 1 la n și valorile 1
for i in range(1, n + 1):
martieni_adn[i] = 1

# Folosim Ciurul lui Eratostene pentru a calcula factorizarea în numere prime a fiecărui număr de la 2 la n
for i in range(2, n + 1):
# Dacă martieni_adn[i] == 1, atunci i este un număr prim
if martieni_adn[i] == 1:
# Setăm factorizarea în numere prime a lui martieni_adn[i] să fie pasul i
martieni_adn[i] = i
# Folosind algoritmul Ciurului lui Eratostene, marcam toți multiplii lui i cu factorul prim i
j = 2
while j * i <= n:
martieni_adn[i * j] = martieni_adn[i * j] * i
# Incrementăm j pentru a considera următorul multiplu al lui i
j += 1

# Calculăm numărul de perechi de marțieni cu ADN-e distincte
for i in range(1, n + 1):
nr_perechi += int(n / martieni_adn[i])

print(nr_perechi)

if __name__ == "__main__":
n = int(input())

if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
ADN(n)

</syntaxhighlight>

2136 - Peste

2023-05-06T15:13:33Z

Ardelean Alexandru:

==Cerința==
Ursul: Bună, cumătră! Da cât peşte ai? Dă-mi şi mie, că tare mi-i poftă!

Vulpea: Ia mai pune-ţi pofta-n cui. Dacă vrei pește, du-te şi-ţi înmoaie coada-n baltă şi vei avea ce să mănânci.

Ursul: Învaţă-mă, te rog, cumătră, că eu nu ştiu cum se prinde peştele.

Vulpea: Alei, cumetre! da’ nu ştii că nevoia te-nvaţă ce nici nu gândeşti? Du-te deseară la baltă și bagă-ţi coada-n apă. Stai pe loc, fără să te mişti, până spre ziuă. Între timp, ia foaia aceasta pe care am scris <code>N</code> numere naturale și până dimineață trebuie să procedezi în felul următor:

* elimini exact două cifre alăturate din fiecare număr scris pe foaie, astfel încât, celelalte cifre rămase după eliminare să formeze, de la stânga la dreapta, cel mai mare număr posibil (de exemplu, din numărul <code>77196</code>, elimini cifrele <code>7</code> și <code>1</code> pentru a obține cel mai mare număr posibil <code>796</code>).
* toate cele N numere obținute la pasul anterior, le lipești unul după altul, în ce ordine vrei tu. Uitându-te de la stânga la dreapta la cifrele numerelor lipite, observi că s-a format un nou număr <code>X</code>. Ai grijă cum procedezi, căci până dimineață, atâta pește se va prinde de coada ta cât vei obține tu valoarea lui <code>X</code>.

Ajutați-l pe urs să prindă cât mai mult pește posibil.
Scrieți un program care citește <code>N</code> numere naturale și determină:

# Cel mai mare număr de eliminări efectuate cu aceleași două cifre alăturate.
# Cel mai mare număr natural <code>X</code> determinat astfel încât ursul să prindă cât mai mult pește.

==Date de intrare==
Fișierul de intrare <code>peste.in</code> conține pe prima linie numărul natural <code>P</code> care poate avea valoarea <code>1</code> sau <code>2</code> și reprezintă numărul cerinței. Cea de-a doua linie conține un număr natural <code>N</code> cu semnificaţia din enunţ, iar pe următoarele <code>N</code> linii, cele <code>N</code> numere scrise pe foaia ce i-a dat-o vulpea ursului, câte un număr natural pe fiecare linie a fișierului.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa un singur număr natural determinat conform cerinței problemei.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."
==Restricții și precizări==

* <code>1 ≤ n ≤ 100</code>, fiecare dintre cele N numere au cel puțin 3 și cel mult 18 cifre;

==Exemplu 1==
;Intrare
:1
:4
:1791
:802
:777
:77196
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:2
===Explicație===
Se va rezolva cerința 1 și în fișier sunt patru numere cu care vom proceda astfel:

* din <code>1791</code> eliminăm cifrele <code>1</code> și <code>7</code> iar numărul rezultat este <code>91</code>
* din <code>802</code> eliminăm cifrele <code>0</code> și <code>2</code> iar numărul rezultat este <code>8</code>
* din <code>777</code> eliminăm cifrele <code>7</code> și <code>7</code> iar numărul rezultat este <code>7</code>
* din <code>77196</code> eliminăm <code>7</code> și <code>1</code> iar numărul rezultat este <code>796</code>

S-au efectuat două eliminări cu aceleași două cifre alăturate: <code>1</code> și <code>7</code>.

==Exemplu 2==
;Intrare
:2
:4
:1791
:802
:777
:77196
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:9187967
===Explicație===
Cu aceleași patru numere din exemplul precedent, vom rezolva cerința 2.

În urma eliminărilor efectuate s-au obținut numerele: <code>91 8 7 796</code>

Cel mai mare număr posibil, obținut prin lipirea acestor numere este <code>9187967</code>.

==Exemplu 3==
;Intrare
:2 4
:22
:802
:777
:123456196
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2136 Peste
def conditii(nums):
if not 1 <= len(nums) <= 100:
return False

for nr in nums:
if not 3 <= len(str(nr)) <= 18:
return False

return True

def inlatura(num):
# list() transformă un string într-o listă de caractere
cifre = list(num)
nr_max = 0
cifre_sterse = []

# Iterăm peste perechi de cifre adiacente și le eliminăm pentru a găsi numărul maxim
for i in range(len(cifre)-1):
# Identificăm cifrele adiacente de eliminat și le stocăm într-o listă
stergere = [min(cifre[i], cifre[i + 1]), max(cifre[i], cifre[i + 1])]
# Creăm o nouă listă, excluzând cifrele eliminate
# Pentru fiecare cifră din listă, dacă indicele ei nu este i sau i+1, o adăugăm în noua listă
cifre_ramase = [cif for idx, cif in enumerate(cifre) if idx not in [i, i + 1]]
# Convertim cifrele rămase într-un număr întreg pentru a găsi numărul maxim
nr_obtinut = int(''.join(cifre_ramase))
# Dacă numărul maxim obținut este mai mare decât numărul maxim anterior,
# actualizăm cifrele stocate și numărul maxim
if nr_obtinut > nr_max:
cifre_sterse = stergere
nr_max = nr_obtinut

return cifre_sterse, nr_max

def nr_eliminari(cifre_eliminate):
# Găsim cifra care a fost eliminată de cele mai multe ori
return max(
set([elem for sublist in cifre_eliminate for elem in sublist]),
key=cifre_eliminate.count
)

def cel_mai_mare(numere_maxime):
# Sortăm în ordine descrescătoare și le concatenăm
numere_sortate = sorted(numere_maxime, reverse=True)
result = ''.join(numere_sortate)
return result

def peste(p, numere):
cifre_eliminate = []
numere_maxime = []

# Pentru fiecare număr, eliminăm cifrele adiacente și găsim numărul maxim în urma înlăturării
for nr in numere:
cifre_sterse, nr_maxim = inlatura(nr)
# Adăugăm cifrele eliminate și numărul maxim în listele separate
cifre_eliminate.append(cifre_sterse)
numere_maxime.append(str(nr_maxim))

# p este cerința problemei
if p == 1:
print(nr_eliminari(cifre_eliminate))
if p == 2:
print(cel_mai_mare(numere_maxime))

if __name__ == "__main__":
p = int(input())
n = int(input())
numere = []
for i in range(n):
numere.append(input())

if not conditii(numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
peste(p, numere)

</syntaxhighlight>

2351 - Numere 23

2023-05-06T14:54:48Z

Ardelean Alexandru:

==Cerința==
Se numește număr 3-prim, un număr natural care se poate descompune în produs de cel mult <code>3</code> numere prime, nu neapărat distincte. Cunoscând numerele naturale <code>n</code> și <code>k</code>, construiți un șir format din primele <code>n</code> numere 3-prime. Ordinea numerelor în șir va fi stabilită astfel încât, extrăgând pe rând numerele din șir, începând cu primul număr și apoi câte un număr din <code>k</code> în <code>k</code> poziții, circular, să obținem în ordine crescătoare, șirul primelor <code>n</code> numere 3-prime. Parcurgerea circulară înseamnă că după elementul aflat în vector pe locul <code>n</code>, urmează elementul de pe locul <code>1</code>.

Cunoscând numerele <code>n</code>, <code>k</code> și <code>c</code> (<code>c = 1</code> sau <code>c = 2</code>), se cere:

1. dacă <code>c = 1</code>, să se afișeze cel mai mare din cele <code>n</code> numere 3-prime.

2. dacă <code>c = 2</code>, să se construiască șirul de <code>n</code> numere care îndeplinește condiția din enunț.

==Date de intrare==
Fișierul de intrare <code>numere23.in</code> conţine pe prima linie, despărțite prin câte un spațiu, numerele naturale <code>n</code>, <code>k</code> și <code>c</code>, cu semnificaţia din enunţ.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Dacă <code>c = 1</code>, atunci pe următorul rând se va afișa un singur număr ce reprezintă cel mai mare din cele <code>n</code> numere 3-prime. Dacă <code>c = 2</code>, atunci se vor afișa despărțite prin câte un spațiu, șirul celor <code>n</code> numere 3-prime.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."
==Restricții și precizări==

* <code>0 < k < n ≤ 10000</code>

* numerotarea elementelor în vector se face de la <code>1</code>

==Exemplu 1==
;Intrare
:5 3 2
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:2 6 4 3 5
===Explicație===
Primele cinci numere 3-prime sunt: <code>2</code>, <code>3</code>, <code>4</code>, <code>5</code>, și <code>6</code>. Șirul de numere <code>2</code>, <code>6</code>, <code>4</code>, <code>3</code>, <code>5</code> parcurs din <code>3</code> în <code>3</code>, va forma în ordine crescătoare șirul de numere inițial.
==Exemplu 2==
;Intrare
:10 4 2
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:2 11 10 5 3 8 7 9 4 6
===Explicație===
Primele <code>10</code> numere 3-prime sunt: <code>2</code>, <code>3</code>, <code>4</code>, <code>5</code>, <code>6</code>, <code>7</code>, <code>8</code>, <code>9</code>, <code>10</code>, <code>11</code>. Șirul de numere <code>2</code>, <code>11</code>, <code>10</code>, <code>5</code>, <code>3</code>, <code>8</code>, <code>7</code>, <code>9</code>, <code>4</code>, <code>6</code>, parcurs din <code>4</code> în <code>4</code>, va forma în ordine crescătoare șirul de numere inițial.
==Exemplu 3==
;Intrare
:5 3 1
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:6
===Explicație===
Primele <code>10</code> numere 3-prime sunt: <code>2</code>, <code>3</code>, <code>4</code>, <code>5</code>, <code>6</code>, <code>7</code>, <code>8</code>, <code>9</code>, <code>10</code>, <code>11</code>. Șirul de numere <code>2</code>, <code>11</code>, <code>10</code>, <code>5</code>, <code>3</code>, <code>8</code>, <code>7</code>, <code>9</code>, <code>4</code>, <code>6</code>, parcurs din <code>4</code> în <code>4</code>, va forma în ordine crescătoare șirul de numere inițial.
==Exemplu 4==
;Intrare
:3 10 1
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2351 Numere 23
def conditii(k, n):
return 0 < k < n <= 10_000

def prim3(n):
# Dacă n este mai mic decât 2, nu este 3-prim
if n < 2:
return False

divizor, nr_factori_primi = 2, 0
# Cât timp n este mai mare decât 1 și nu am găsit 3 factori primi:
while n != 1 and nr_factori_primi <= 3:
# Cât timp n este divizibil cu divizorul curent și nu am găsit 3 factori primi:
while n % divizor == 0 and nr_factori_primi <= 3:
# Împărțim n la divizorul curent și creștem numărul de factori primi găsiți
n //= divizor
nr_factori_primi += 1
# Trecem la următorul divizor
divizor += 1

# Dacă n este 1 și am găsit 3 factori primi, n este 3-prim
if n == 1 and nr_factori_primi <= 3:
return True

return False

def cel_mai_mare(n):
rezultat = 1
# Cât timp n este nenul:
while n > 0:
# Creștem rezultatul până când găsim un număr 3-prim
rezultat += 1
# Dacă rezultatul este 3-prim, scădem 1 din n
if prim3(rezultat):
n -= 1

return rezultat

def sir_circular(n, k):
val, poz, nr_n = 1, 1, n
# Găsim cel mai mic număr 3-prim și îl asignăm pe prima poziție din vector
while not prim3(val):
val += 1
vector = [0] * (n + 1)
vector[1] = val
nr_n -= 1

# Continuăm să adăugăm numere 3-prime în vector până când vectorul conține n numere
while nr_n > 0:
# Căutăm următorul număr 3-prim și îl asignăm pe poziția curentă din vector
val += 1
while not prim3(val):
val += 1

# Trecem la următoarea poziție liberă din vector
nr_k = k
while nr_k > 0:
poz += 1
if poz > n:
poz = poz % n
if vector[poz] == 0:
nr_k -= 1

# Asignăm numărul 3-prim curent pe poziția curentă din vector
vector[poz] = val
nr_n -= 1

# Returnăm numerele din vector separate prin câte un spațiu
return " ".join(str(x) for x in vector[1:])

def numere23(c, n, k):
# c este cerința enunțului
if c == 1:
print(cel_mai_mare(n))
elif c == 2:
print(sir_circular(n, k))

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

if not conditii(k, n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
numere23(c, n, k)

</syntaxhighlight>

2115 - Prajituri

2023-05-06T14:36:33Z

Ardelean Alexandru:

==Cerința==
Ilinca şi verişoara ei Daria, merg la un curs de gătit. Ilinca a făcut o prăjitură cu <code>N</code> straturi, iar Daria a făcut o prăjitură cu <code>M</code> straturi, straturile prăjiturilor fiind aşezate unul după altul pe orizontală şi având diverse culori. E posibil ca unele straturi din prăjitură să aibă aceeaşi culoare.

Ilinca a observat că dacă ar tăia prăjitura ei la capete ar putea obţine o prăjitură la fel ca prăjitura Dariei. Ilinca spune că astfel „extrage” din prăjitura ei prăjitura Dariei. La o extragere, Ilinca taie întotdeauna un număr minim de straturi din partea stângă (straturi pe care le mănâncă imediat) şi câte straturi sunt necesare în partea dreaptă pentru a obţine o prăjitură identică cu prăjitura Dariei. Prăjitura extrasă o aşază pe o farfurie şi continuă „extragerile” din bucata rămasă în partea dreaptă.

Scrieţi un program care să citească numerele naturale <code>N</code> şi <code>M</code> (reprezentând numărul de straturi din prăjitura Ilincăi respectiv Dariei) şi <code>a1,a2,...,aN</code> şi <code>b1,b2,...,bM</code> (reprezentând culorile straturilor din prăjitura Ilincăi respectiv din prăjitura Dariei) şi care să determine:

a) numărul de straturi pe care le taie Ilinca din capătul din stânga şi numărul de straturi pe care le taie din capătul din dreapta la prima extragere;

b) numărul de prăjituri identice cu prăjitura Dariei care se vor afla pe farfurie, după efectuarea tuturor extragerilor;

c) numărul maxim de prăjituri la fel ca prăjitura Dariei care pot fi obţinute din prăjitura Ilincăi dacă aceasta ar rearanja straturile prăjiturii ei într-o ordine convenabilă.

==Date de intrare==
Fişierul de intrare <code>prajituri.in</code> conţine pe prima linie numerele naturale <code>N M</code> reprezentând numărul de straturi din prăjitura Ilincăi, respectiv a Dariei. A doua linie a fişierului conţine, în ordine, cele <code>N</code> numere <code>a1,a2,...,aN</code>, separate prin câte un spaţiu, reprezentând, în ordine de la stânga la dreapta, culorile straturilor din prăjitura Ilincăi. A treia linie a fişierului conţine, în ordine, cele <code>M</code> numere <code>b1,b2,...,bM</code>, separate prin câte un spaţiu, reprezentând, în ordine de la stânga la dreapta, culorile straturilor din prăjitura Dariei.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se vor afișa două numere, separate printr-un spaţiu, reprezentând numărul de straturi tăiate din stânga, respectiv numărul de straturi tăiate din dreapta din prăjitura Ilincăi la prima extragere, separate prin spaţiu. Al treilea rând va conţine un număr natural reprezentând numărul de prăjituri aflate pe farfurie după efectuarea tuturor extragerilor. Al patrulea rând va conţine un număr natural reprezentând numărul maxim de prăjituri la fel ca prăjitura Dariei care se pot obţine din prăjitura Ilincăi dacă aceasta ar rearanja convenabil straturile prăjiturii ei.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ M ≤ N ≤ 10.000</code>
* <code>1 ≤ ai ≤ 100, (1 ≤ i ≤ N)</code>
* <code>1 ≤ bi ≤ 100, (1 ≤ i ≤ M)</code>
* <code>N, M, a1, a2, ..., aN, b1, b2, ..., bM sunt numere naturale;</code>
* <code>Întotdeauna se poate obţine din prăjitura Ilincăi cel puţin o prăjitură la fel ca prăjitura Dariei</code>

==Exemplu 1==
;Intrare
:5 3
:6 2 2 2 2
:6 2 2
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:0 2
:1
:1

===Explicație===
Prăjitura Ilincăi are <code>5</code> straturi, iar a Dariei <code>3</code> straturi, pentru a obţine prăjitura Dariei, Ilinca trebuie să taie din stânga <code>0</code> straturi şi din dreapta <code>2</code> straturi, se poate obţine doar o prăjitură ca a Dariei indiferent de procedeul folosit

==Exemplu 2==
;Intrare
:10 2
:5 6 8 8 6 8 6 8 6 6
:6 8
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1 7
:3
:4

===Explicație===
Prăjitura Ilincăi are <code>10</code> straturi, iar a Dariei <code>2</code> straturi, pentru a obţine prăjitura Dariei, Ilinca trebuie să taie din stânga <code>1</code> strat şi din dreapta <code>7</code> straturi. Prin procedeul de tăiere se pot obţine <code>3</code> prăjituri la fel ca prăjitura Dariei. Prin rearanjarea straturilor se pot obţine maxim <code>4</code> prăjituri la fel ca prăjitura Dariei.

==Exemplu 3==
;Intrare
:2 10
:5 0 8 8 101 8 6 0 6 6
:101 0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2115 Prajituri

def conditii(n, m, straturi_ilinca, straturi_daria):
if not 1 <= m <= n <= 10_000:
return False
for i in range(n):
if not 1 <= straturi_ilinca[i] <= 100:
return False
for i in range(m):
if not 1 <= straturi_daria[i] <= 100:
return False

return True

def prajituri(n, m, straturi_ilinca, straturi_daria):
# Ținem cont de frecvența fiecărui element din cele două liste
frecv_ilinca = [0] * 101
frecv_daria = [0] * 101

# Calculăm frecvența fiecărui element din cele două liste folosind lungimea listelor (n și m)
for i in range(n):
frecv_ilinca[straturi_ilinca[i]] += 1
for i in range(m):
frecv_daria[straturi_daria[i]] += 1

nr, stanga, dreapta, ok = 0, -1, 0, 1

# Iterăm toate pozițiile de început posibile pentru straturi_daria în straturi_ilinca
i = 0
while i <= n - m:
ok = 1
# Verificăm dacă subșirul curent din straturi_ilinca coincide cu cu straturi_daria
for j in range(m):
if straturi_ilinca[i + j] != straturi_daria[j]:
ok = 0
break

# Dacă da, actualizăm variabilele folosite pentru a calcula numărul de apariții
# ale lui straturi_daria în straturi_ilinca
if ok:
nr += 1
if stanga == -1:
stanga, dreapta = i, n - m - i
i += m
# Dacă nu, trecem la următorul subșir din straturi_ilinca
else:
i += 1

# Calculăm numărul de apariții ale lui straturi_daria în straturi_ilinca găsind numărul minim de apariții
# ale fiecărui element din straturi_daria în straturi_ilinca
aparitii = n
for i in range(1, 101):
if frecv_daria[i] != 0:
aparitii = min(aparitii, frecv_ilinca[i] // frecv_daria[i])

print(f"{stanga} {dreapta}")
print(nr)
print(aparitii)

if __name__ == "__main__":
n, m = [int(x) for x in input().split()]
straturi_ilinca = [int(x) for x in input().split()]
straturi_daria = [int(x) for x in input().split()]

if not conditii(n, m, straturi_ilinca, straturi_daria):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
prajituri(n, m, straturi_ilinca, straturi_daria)

</syntaxhighlight>

2974 - Z Zid

2023-05-06T14:25:22Z

Ardelean Alexandru:

==Cerința==
Fie un zid perfect dreptunghiular de înălțime <code>H</code> și lățime <code>W</code>, format din cărămizi de înălțime <code>1</code> și lățime variabilă, lipite între ele.

Să se taie acest zid pe verticală astfel încât numărul de cărămizi ce trebuie tăiate să fie minim. În cazul în care există mai multe astfel de locuri unde poate fi tăiat zidul, se dorește ca diferența lățimilor celor două bucăți obținute să fie cât mai mică.

==Date de intrare==
Fișierul de intrare <code>zzid.in</code> conține pe prima linie numerele <code>H</code> și <code>W</code>. Pe fiecare din următoarele <code>H</code> linii va fi descris un rând al zidului în felul următor: un număr <code>Ni</code>, reprezentând numărul de cărămizi de pe rândul <code>i</code>, urmat de <code>Ni</code> numere, reprezentând lățimea cărămizilor de pe rândul <code>i</code>, în ordinea în care apar. Suma lățimilor cărămizilor de pe fiecare rând este egală cu <code>W</code>. Toate numerele din fișierul de intrare sunt naturale.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se vor afișa două numere naturale separate printr-un spațiu: numărul minim necesar de cărămizi ce trebuie tăiate astfel încât să se taie zidul în două bucăți, respectiv diferența minimă dintre cele două lățimi ale zidurilor.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>2 ≤ W ≤ 1.000.000.000</code>
* <code>2 ≤ H ≤ 100.000</code>

* Sunt maximum <code>1.000.000</code> cărămizi
* Pentru <code>30%</code> din teste <code>H</code> si <code>W</code> sunt mai mici decât <code>1000</code>
* Pentru alte <code>20%</code> din teste <code>H ≤ 1000</code>
* Zidul nu poate fi rotit

==Exemplu 1==
;Intrare
:3 10
:1 10
:2 5 5
:3 2 3 5
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1 0

===Explicație===
Zidul se poate tăia fix la jumătate, și doar cărămida de pe primul rând trebuie tăiată.

==Exemplu 2==
;Intrare
:3 10
:1 10
:2 5 0
:3 2 5 5
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2974 Z Zid
def conditii(inaltime, latime, zid):
if not 2 <= latime <= 1_000_000_000:
return False

if not 2 <= inaltime <= 100_000:
return False

for rand in range(len(zid)):
if not sum(zid[rand]) == latime:
return False

return True

def zzid(inaltime, latime, zid):
# Creeăm un dicționar pentru a stoca frecvența fiecărei sume de segmente de zid
frecv_sume = {}
maxim = 0
taietura = 0
suma_curenta = 0

# Iterăm peste fiecare rând de segmente de zid
for i in range(inaltime):
lungime = len(zid[i])
# Iterăm peste fiecare segment din rândul curent
for j in range(lungime):
# Adăugăm segmentul curent la suma curentă
segment = zid[i][j]
suma_curenta += segment
# Dacă suma este egală cu lățimea zidului, trecem la următorul segment
if suma_curenta == latime:
continue
# Dacă suma există deja în dicționar...
if suma_curenta in frecv_sume:
# ...incrementăm numărul de apariții
frecv_sume[suma_curenta] += 1
else:
# ...altfel, adăugăm suma în dicționar cu numărul de apariții 1
frecv_sume[suma_curenta] = 1
# Dacă numărul de apariții al sumei curente din dicționar este mai mare decât numărul maxim de apariții,
# actualizăm numărul maxim de apariții și tăietura corespunzătoare
if frecv_sume[suma_curenta] > maxim:
maxim = frecv_sume[suma_curenta]
taietura = suma_curenta
# Dacă numărul de apariții al sumei curente din dicționar este egal cu numărul maxim de apariții și
# tăietura curentă este mai aproape de lățimea dorită a zidului decât tăietura anterioară, actualizăm
# tăietura corespunzătoare
if frecv_sume[suma_curenta] == maxim and abs(latime - taietura - taietura) > abs(latime - suma_curenta - suma_curenta):
taietura = suma_curenta
# Resetăm suma curentă pentru următorul rând
suma_curenta = 0

# Printăm numărul minim de rânduri care trebuie tăiate și tăietura corespunzătoare
print(f"{inaltime-maxim} {abs(taietura-latime+taietura)}")

if __name__ == "__main__":
inaltime, latime = [int(x) for x in input().split()]

zid = []

for i in range(inaltime):
latimi = [int(x) for x in input().split()[1:]]
zid.append(latimi)

if not conditii(inaltime, latime, zid):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
zzid(inaltime, latime, zid)

</syntaxhighlight>

2105 - More Time

2023-05-06T14:18:02Z

Ardelean Alexandru:

==Cerința==
La banca Moretime, moneda este <code>Time</code>-ul. Cei <code>n</code> clienţi ai băncii au conturi identificate prin valori naturale nenule, distincte două câte două. La deschiderea contului, fiecare client a depus un fond de siguranţă reprezentat printr-un număr natural nenul (cantitatea de <code>Time</code> aferentă contului, ce poate fi folosită de bancă, pentru urgenţe majore). Un client al băncii este considerat premium dacă numărul său de cont începe şi se termină cu aceeaşi cifră nenulă.

Lumea este lovită de criza de timp şi banca Moretime a hotărât să susţină doar clienţii premium printr-un program special. Astfel, banca va colecta fondurile de siguranţă ale unora dintre clienţii premium iar suma obţinută o va folosi integral pentru a finanţa, cu cantităţi egale de <code>Time</code>, pe fiecare client premium, inclusiv pe cei de la care a colectat fondul.

Cunoscând <code>n</code>, numărul de clienţi, conturile şi valorile fondurilor de siguranţă ale acestora, să se determine:

'''a.''' numărul clienţilor premium;

'''b.''' numărul clienţilor premium ce pot fi aleşi de bancă astfel încât suma fondurilor de siguranţă colectată de la aceştia să poată fi distribuită în mod egal fiecărui client premium;

'''c.''' numerelor de cont ale celor selectaţi la punctul '''b)'''.

==Date de intrare==
Fişierul text <code>moretime.in</code> conţine pe prima linie <code>n</code>, numărul de clienţi ai băncii iar pe următoarele <code>n</code> linii perechi de numere, separate prin câte un spaţiu, reprezentând numărul contului şi valoarea fondului de siguranţă, pentru fiecare dintre cei <code>n</code> clienţi.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa <code>cp</code>, numărul de <code>clienţi premium</code>, pe al treilea rând <code>p</code>, numărul de <code>clienţi premium</code> ce pot fi aleşi de bancă în condiţiile de mai sus iar pe al patrulea rând, un şir de <code>p</code> numere separate prin câte un spaţiu, reprezentând conturile acestor clienţi. Dacă sunt mai multe soluţii se va scrie una dintre acestea.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ p ≤ cp ≤ n ≤ 10000</code>
* Moneda Time nu este divizibilă.
* Numerele de cont sunt numere naturale cu cel puţin două şi cel mult cinci cifre.
* Fondurile de siguranţă sunt numere naturale nenule mai mici decât <code>100000</code>.
* Pentru răspunsuri corecte se acordă punctaje parţiale astfel: <code>a) 30%; a)+b)+c) 100%</code>

==Exemplu 1==
;Intrare
:6
:112 100
:217 50
:1231 200
:3000 500
:2902 200
:44 100
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:3
:2
:2902 44

===Explicație===

* sunt <code>3</code> clienţi premium; pot fi aleşi <code>2</code> clienţi premium pentru colectarea fondurilor de siguranţă;
* clienţii cu conturile <code>2902</code> şi <code>44</code> pot fi aleşi pentru că suma fondurilor lor <code>(200+100=300)</code> poate fi împărţită în mod egal celor <code>3</code> clienţi premium (fiecare ar primi <code>100</code>).

==Exemplu 2==
;Intrare
:5
:121 -1
:21712 50
:12311 200
:30003 500
:129021 150000
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2105 More time
def conditii(clienti, clienti_premium):
return all((
(0 <= client['fond'] <= 100_000 for client in clienti),
(2 <= len(str(client['idx'])) <= 5 for client in clienti),
(1 <= len(clienti_premium) <= len(clienti) <= 10_000)
))

def is_premium(client_idx):
sir_client_idx = str(client_idx)
# Un client este premium dacă primul și ultimul caracter din ID-ul său sunt egale
return sir_client_idx[0] == sir_client_idx[-1]

def moretime(clienti_premium):
clienti_premium_nr = len(clienti_premium)

# Inițializăm o listă pentru a ține cont de suma acumulată a fondurilor pentru fiecare client premium
suma = [0] * (clienti_premium_nr + 1)

# Iterăm prin fiecare client premium și actualizăm suma acumulată
for i in range(clienti_premium_nr):
# Suma acumulată pentru clientul i+1 este suma acumulată pentru clientul i plus fondul clientului i
suma[i + 1] = suma[i] + clienti_premium[i]['fond']

# Dacă suma acumulată este divizibilă cu numărul de clienți premium...
if suma[i + 1] % clienti_premium_nr == 0:
# Printăm numărul de clienți din ciclu și indicii lor, apoi ieșim din program
print(i + 1)
for j in range(i + 1):
print(clienti_premium[j]['idx'], end=' ')
exit()

# Dacă nu există cicluri cu toți clienții premium, găsim cel mai lung ciclu cu doi clienți premium
i_nou, j_nou = -1, -1
for i in range(clienti_premium_nr):
for j in range(i + 1, clienti_premium_nr):
# Verificăm dacă diferența dintre suma acumulată celor doi clienți este divizibilă cu numărul de clienți premium
if suma[i + 1] % clienti_premium_nr == suma[j + 1] % clienti_premium_nr:
i_nou = i
j_nou = j

# Printăm lungimea celui mai lung ciclu cu doi clienți premium și indicii lor
print(j_nou - i_nou)
for i in range(i_nou + 1, j_nou + 1):
print(clienti_premium[i]['idx'], end=' ')

if __name__ == "__main__":
n = int(input())
clienti = []
for i in range(n):
idx, fond = input().split()
clienti.append({'idx': int(idx), 'fond': int(fond)})

clienti_premium = []
for i in range(n):
if is_premium(clienti[i]['idx']):
clienti_premium.append({'idx': clienti[i]['idx'], 'fond': clienti[i]['fond']})

if not conditii(clienti, clienti_premium):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
moretime(clienti_premium)

</syntaxhighlight>

2056 - Popcorn

2023-05-06T13:55:25Z

Ardelean Alexandru:

==Cerința==
Cu toții știm că popcornul este o adevărată delicatesă culinară. În pregătirile tale pentru lotul de anul acesta (și pentru petrecerile de după), ai făcut comandă de <code>N</code> tipuri de floricele de porumb pentru microunde. Fiecare tip are asociate <code>3</code> valori:

* <code>A[i]</code> = Timpul (în secunde) la care orice floricică de acel tip “pocnește”;
* <code>B[i]</code> = Timpul (în secunde) la care orice floricică de acel tip “se arde”;
* <code>C[i]</code> = Cantitatea (în floricele) a respectivului tip.

Mai ai la dispoziție <code>M</code> pungi pentru floricele de unică folosință de capacitate foarte mare (practic, infinită) și un cuptor cu microunde. Cum, bineînțeles, nimănui nu îi plac floricelele nefăcute sau cele arse, îți dorești să le partiționezi convenabil în cele <code>M</code> pungi și apoi să le introduci pe rând în cuptorul cu microunde, setându-i un timp de preparare <code>prep[i]</code> corespunzător, astfel încât după cele <code>M</code> tranșe să obții cât mai multe floricele comestibile.

Formal, o floricică de tipul <code>i</code> introdusă în punga <code>j</code> , setată la timpul (în secunde) de preparare <code>prep[j]</code> este comestibilă dacă și numai dacă <code>A[i] ≤ prep[j] < B[i]</code>.

Fiind date cele <code>N</code> tipuri de floricele și numărul de pungi disponibile, trebuie să găsești o partiție convenabilă și timpii optimi de preparare pentru fiecare pungă, astfel încât la final să obții numărul maxim de floricele comestibile, pe care să îl afișezi în fișierul de ieșire. Prea ușor!

==Date de intrare==
Fișierul de intrare <code>popcorn.in</code> conține pe prima linie numerele naturale <code>N</code> și <code>M</code> , separate printr-un spațiu, cu semnificația din enunț. Pe următoarele <code>N</code> linii se vor afla valorile <code>A[i]</code> , <code>B[i]</code> , <code>C[i]</code> corespunzătoare fiecărui tip de floricele.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa un singur număr natural reprezentând numărul maxim de floricele comestibile care se poate obține.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ M ≤ N ≤ 200 000</code>
* <code>1 ≤ A[i] < B[i] ≤ 200 000</code>
* Numărul total de floricele nu depășește <code>109</code>
* '''Unele pungi pot fi goale !'''
* <code>X = max{N, B[1], B[2], …, B[N]}</code>

==Exemplu 1==
;Intrare
:5 2
:2 4 3
:1 5 6
:4 8 10
:7 8 2
:10 11 2
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:21

===Explicație===
Avem <code>5</code> tipuri de floricele și <code>2</code> pungi disponibile.

Una din soluțiile posibile este:

* Punga <code>1</code> va conține tipurile <code>1</code> și <code>2</code> și va fi preparată la timpul <code>3</code>.
* Punga <code>2</code> va conține tipurile <code>3, 4, 5</code> și va fi preparată la timpul <code>7</code>.

Toate tipurile de floricele vor fi preparate cu succes, în afară de tipul <code>5</code>, care vor rămâne în stadiul de boabe.

==Exemplu 2==
;Intrare
:3 3
:1 2 2
:2 3 3
:1 3 5
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:10

===Explicație===
Putem alege pungile astfel:

* Punga <code>1</code> va conține tipurile <code>1, 3</code> și va fi preparată la timpul <code>1</code>.
* Punga <code>2</code> va conține tipul <code>2</code> și va fi preparată la timpul <code>2</code>.
* Punga <code>3</code> va fi goală.

==Exemplu 3==
;Intrare
:3 3
:2 1 2
:3 2 3
:1 3 5
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2056 Popcorn
T_POCNIRE = 0
T_ARDERE = 1
CANTITATE = 2

def conditii(n_tipuri, n_pungi, tipuri_floricele):
for tip in tipuri_floricele:
if not 1 <= tip[T_POCNIRE] < tip[T_ARDERE] <= 200_000:
return False

if sum([tip[CANTITATE] for tip in tipuri_floricele]) > 10**9:
return False

if not 1 <= n_pungi <= n_tipuri <= 200_000:
return False

x = [tip[T_ARDERE] for tip in tipuri_floricele]
x.append(n_tipuri)

x_max = max(x)

if not n_pungi <= x_max <= 50_000:
return False

return True

def popcorn(n_tipuri, n_pungi, floricele):
# Inițializăm o listă bidimensională pentru a stoca cantitatea de popcorn care poate fi preparată pentru fiecare
# tip de popcorn și pentru fiecare pas de timp

# Lista are n_tipuri rânduri și 50,000 coloane, deoarece fiecare tip de popcorn poate fi preparat pentru maxim
# 50,000 de pași de timp
nr = [[0 for j in range(50_000)] for i in range(n_tipuri)]
for i in range(n_tipuri):
# Pentru fiecare tip de popcorn, parcurgem pașii de timp când popcorn-ul poate fi preparat
# (de la T_POCNIRE la T_ARDERE)
for k in range(floricele[i][T_POCNIRE], floricele[i][T_ARDERE]):
if k < floricele[i][T_ARDERE]:
nr[i][k] = floricele[i][CANTITATE]

# Inițializăm o altă listă bidimensională cu n_tipuri+1 rânduri și n_pungi+1 coloane
# Fiecare element din listă va stoca cantitatea maximă de popcorn care poate fi pusă în j pungi
# folosind primele i tipuri de popcorn
dinamic = [[0 for j in range(n_pungi+1)] for i in range(n_tipuri+1)]
for i in range(1, n_tipuri+1):
for j in range(1, n_pungi+1):
for k in range(j, -1, -1):
# Calculăm cantitatea maximă de popcorn care poate fi pusă în j pungi folosind primele i tipuri de popcorn,
# bazat pe cantitatea de popcorn care poate fi preparată pentru fiecare tip și pas de timp, stocată în lista "nr"
dinamic[i][j] = max(dinamic[i][j], dinamic[i-1][k] + sum(nr[i-1][:j-k]))

# Printăm cantitatea maximă de popcorn care poate fi pusă în pungi,
# care este valoarea din colțul din dreapta jos al tabelei "dinamic"
print(max(dinamic[-1]))

if __name__ == "__main__":
n_tipuri, n_pungi = [int(x) for x in input().split(" ")]

floricele = []

for i in range(n_tipuri):
timp_pana_la_pocnire, timp_pana_la_ardere, cantitate = [int(x) for x in input().split()]
floricele.append([timp_pana_la_pocnire, timp_pana_la_ardere, cantitate])

if not conditii(n_tipuri, n_pungi, floricele):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
popcorn(n_tipuri, n_pungi, floricele)

</syntaxhighlight>

2104 - Factorial 3

2023-05-06T13:39:52Z

Ardelean Alexandru:

==Cerința==
Factorialul unui număr natural nenul <code>n</code>, notat <code>n!</code>, se defineşte ca fiind produsul numerelor naturale de la <code>1</code> la <code>n</code>. Una dintre modalităţile de reprezentare a factorialului este prin enumerarea factorilor primi pe care îi conţine şi a exponenţilor acestora.

Fiind dat un număr natural <code>n</code>, scrieţi un program care determină suma exponenţilor factorilor primi corespunzători descompunerii în factori primi a lui <code>n</code> factorial.

==Date de intrare==
Fişierul de intrare <code>factorial3.in</code> conţine pe prima linie numărul natural <code>n</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa un număr reprezentând suma exponenţilor numerelor prime din descompunerea în factori primi a lui <code>n!</code>.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

*<code>2 ≤ n ≤ 100.000</code>

==Exemplu 1==
;Intrare
:5
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:5

===Explicație===
<code>5! = 1*2*3*4*5 = 23*31*51</code><code>3+1+1=5</code>

==Exemplu 2==
;Intrare
:1
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2104 Factorial3
def conditii(n):
return 2 <= n <= 100_000

def factori_primi(n):
factori = []

# Dacă n este par, îl împărțim la 2 până nu mai este par și adăugăm 2 la lista de factori primi
while n % 2 == 0:
n //= 2
factori.append(2)

# Check odd numbers as potential factors starting from 3 up to sqrt(n)
# Verificăm numere impare începând cu 3 până la rădăcina pătrată a lui n
i = 3
while i*i <= n:
# Dacă i este factor prim, îl adăugăm la lista de factori primi
if n % i == 0:
n //= i
factori.append(i)
# Dacă nu, trecem la următorul număr impar (3+2=5, 5+2=7, 7+2=9, 9+2=11 ...)
else:
i += 2

if n > 2:
factori.append(n)

return factori

def factorial3(n):
factori = []
# Pentru fiecare număr de la 2 la n+1, adăugăm factorii primi ai săi la lista de factori
# extend() este o funcție built-in care adaugă elementele unui iterable la un alt iterable
for i in range(2, n+1):
factori.extend(factori_primi(i))
# Creăm un dicționar care are ca chei factorii primi și ca valori numărul de apariții ale fiecărui factor prim
factor_prim_nr = {}
# Pentru fiecare factor prim din lista de factori...
for factor in factori:
# ...îl adăugăm în dicționar și incrementăm numărul de apariții
# get() este o funcție built-in care returnează valoarea asociată unei chei dintr-un dicționar,
# iar dacă cheia nu există, returnează valoarea default (în cazul nostru 0)
factor_prim_nr[factor] = factor_prim_nr.get(factor, 0) + 1

print(sum(factor_prim_nr.values()))

if __name__ == "__main__":
n = int(input())
if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
factorial3(n)

</syntaxhighlight>

1783 - Find Min

2023-05-06T13:26:08Z

Ardelean Alexandru:

==Cerința==
Se dă un șir <code>P</code> de lungime <code>N</code> cu elemente distincte din mulțimea <code>{1,2..,N}</code>. Pentru fiecare poziție <code>i</code> din șirul <code>P</code> se cere să aflați cea mai mică poziție <code>j</code>, astfel încât <code>P[j] < P[i]</code> și <code>j < i</code>. În caz că o astfel de poziție nu există se consideră <code>-1</code> ca soluție.

==Date de intrare==
Fișierul de intrare <code>findmin.in</code> conţine pe prima linie <code>N</code>, reprezentând lungimea șirului iar pe a doua linie <code>N</code> numere naturale, reprezentând elementele șirului <code>P</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se vor afișa <code>N</code> numere despărțite prin câte un spațiu, unde al <code>i</code>-lea număr reprezintă răspunsul pentru al <code>i</code>-lea element din șir.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ N ≤ 1 000 000</code>

* Șirul <code>P</code> este indexat de la <code>1</code>.

==Exemplu 1==
;Intrare
:7
:5 6 7 3 1 4 2
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:-1 1 1 -1 -1 4 5

===Explicație===
Pentru primele <code>2</code> elemente răspunsurile sunt <code>-1</code> respectiv <code>1</code>. Pentru al <code>3</code>-lea element răspunsul e poziția <code>1</code>(se observă că și <code>P[2] < P[3]</code>). Pentru elementele de pe pozițiile <code>4</code> și <code>5</code> răspunsurile sunt: <code>-1</code> și <code>-1</code>. Răspunsul pentru al <code>6</code>-lea element: poziția <code>4</code> (se observa că și <code>P[5] < P[6]</code>). În final, răspunsul pentru ultimul elementul: poziția <code>5</code>.

==Exemplu 2==
;Intrare
:1000001
:1 2 3 3 3
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1783 Find Min
def conditii(n, sir_p):
restrictii = (
1 <= min(sir_p),
max(sir_p) <= 1_000_000,
1 <= n <= 1_000_000,
len(sir_p) == n
)

return all(restrictii)

def findmin(sir_p):
sir = []

# Pentru fiecare element din sir_p
for i in range(len(sir_p)):
# Căutăm primul element mai mic decât el
minim = -1
for j in range(i):
# Dacă găsim unul...
if sir_p[j] < sir_p[i]:
# ...îl salvăm și ne oprim
minim = j
break
# Dacă nu găsim niciunul, minimul rămâne -1
# Altfel, adăugăm 1 la minim deoarece conform cerinței, indexarea șirului P începe de la 1
sir.append(f"{minim+1 if minim != -1 else -1}")

print(" ".join(sir))

if __name__ == "__main__":
n = int(input())
sir_p = [int(x) for x in input().split()]
if not conditii(n, sir_p):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
findmin(sir_p)

</syntaxhighlight>

0747 - Turism

2023-05-06T13:11:42Z

Ardelean Alexandru:

==Cerința==
În oraşul Z sunt un număr de <code>n</code> obiective turistice, numerotate de la <code>1</code> la <code>n</code>. Pentru a ajuta turiştii să viziteze oraşul, primăria a cumpărat un autobuz special ce are <code>k</code> locuri şi care va parcurge cele <code>n</code> puncte de atracţie turistică începând cu obiectivul numerotat cu <code>1</code>, apoi obiectivul numerotat cu <code>2</code>, …, până la obiectivul numerotat cu <code>n</code> şi apoi revine la obiectivul <code>1</code>, traseul având formă circulară. În fiecare staţie aşteaptă un anumit număr de călători; pentru fiecare călător se ştie numărul de staţii pe care doreşte să le parcurgă. Călătorii au acces în autobuz numai dacă sunt locuri libere, în ordinea în care așteaptă în stație, iar cei care nu pot urca părăsesc staţia; la următoarea oprire în staţia respectivă vor aştepta alţi călători. Pentru fiecare staţie parcursă costul unui bilet este <code>1</code> leu. Autobuzul va face pentru ultima urcare a călătorilor şi un ultim tur în care doar coboară călători şi nu urcă nimeni. Se cere numărul de curse complete realizate şi suma încasată pentru cursele realizate.

Determinarea valorilor ce reprezintă suma încasată şi numărul de curse complete realizate.

==Date de intrare==
Fișierul de intrare <code>turism.in</code> conține pe prima linie trei numere naturale: <code>n</code>(numărul de staţii), <code>k</code>(numărul de locuri) şi <code>m</code>(numărul de opriri) separate printr-un spaţiu. Pe următoarele <code>m</code> linii secvenţe de valori ce reprezintă numărul de călători din stația respectivă şi pentru fiecare călător numărul staţiilor pe care le parcurge dacă are loc în mijlocul de transport, cu un spaţiu între ele.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa numărul ce reprezintă suma încasată şi numărul de curse realizate, separate prin exact un spațiu.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

*<code>0 < n ≤ 200,n ≤ m ≤ 10000, 2 < k ≤ 100</code>

*<code>0 <</code> numărul de staţii parcurse de un călător <code>≤ n</code>

*<code>autobuzul opreşte în fiecare staţie</code>
*<code>în fiecare staţie sunt cel mult k călători</code>

==Exemplu 1==
;Intrare
:10 8 16
:9 4 2 6 8 1 1 1 3 2
:2 1 3
:2 1 1
:2 1 2
:2 10 7
:2 10 1
:2 2 2
:2 2 2
:2 2 6
:2 4 1
:2 4 1
:4 3 1 1 1
:3 1 1 1
:8 5 7 4 10 2 3 2 5
:4 1 10 1 1
:4 1 1 1 10
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:138 3

===Explicație===
În prima staţie urcă primii <code>8</code> în autobuz, în a doua coboara <code>3</code>(cei <code>3</code> care au ales sa parcurga numai <code>1</code> staţie) şi urca <code>2</code>, şi aşa mai departe până se parcurg toate cele <code>16</code> opriri alea autobuzului. Suma încasată este : <code>138</code>.

==Exemplu 2==
;Intrare
:16 8 9
:9 4 2 6 8 1 1 20 3 2
:2 1 3
:2 20 1
:2 1 2
:2 10 7
:2 50 1
:3 2 2
:4 2 2
:2 2 6
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0747 Turism
def conditii(nr_statii, nr_locuri, nr_opriri):
restrictii = (
0 < nr_statii <= 200,
nr_statii <= nr_opriri <= 10_000,
2 < nr_locuri <= 100
)

return all(restrictii)

def conditii_calatori(nr_statii, nr_calatori, calatori):
if not nr_calatori == len(calatori):
return False

for c in calatori:
if not 0 < c <= nr_statii:
return False

return True

if __name__ == "__main__":
scaune = [0] * 110
cost = 0

nr_statii, nr_locuri, nr_opriri = [int(x) for x in input().split()]

if not conditii(nr_statii, nr_locuri, nr_opriri):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
# Pentru fiecare oprire...
for i in range(1, nr_opriri+1):
# ...scădem 1 din fiecare scaun ocupat
for j in range(1, nr_locuri+1):
if scaune[j]:
scaune[j] -= 1
# Inițializăm poziția primului scaun liber cu 1
poz = 1

rand_input = [int(x) for x in input().split()]
nr_calatori = rand_input[0]
calatori = rand_input[1:]

if not conditii_calatori(nr_statii, nr_calatori, calatori):
print("Datele de intrare nu corespund restricțiilor impuse.")
exit(0)

# Pentru fiecare călător...
for cal in calatori:
# ...căutăm primul scaun liber și îl ocupăm
while poz <= nr_locuri and scaune[poz]:
poz += 1
if poz <= nr_locuri:
scaune[poz] = cal
cost += cal

print("Datele de intrare corespund restricțiilor impuse.")

# Calculăm numărul de opriri necesare bazat pe numărul maxim de călători per stație
maxim = scaune[0]
for i in range(1, nr_locuri):
if scaune[i] > maxim:
maxim = scaune[i]

rez = (nr_opriri - 1) // nr_statii + 1
if maxim:
rez += (maxim - nr_opriri % nr_statii - 1) // nr_statii + 1

print(cost, rez)

</syntaxhighlight>

1054 - Galbeni

2023-05-06T11:49:37Z

Ardelean Alexandru:

==Cerința==
După ce au descoperit ascunzătoarea piratului Spânu, marinarii de pe corabia “Speranţa” au hotărât să ofere sătenilor o parte din comoara acestuia. Întrucât comoara avea un număr nelimitat de bani din aur, numiţi galbeni, singura problemă a marinarilor a fost regula după care să împartă banii.

După îndelungi discuţii au procedat astfel: i-au rugat pe săteni să se aşeze în ordine la coadă şi să vină, pe rând, unul câte unul pentru a-şi ridica galbenii cuveniţi. Primul sătean a fost rugat să îşi aleagă numărul de galbeni, cu condiţia ca acest număr să fie format din exact <code>K</code> cifre. Al doilea sătean va primi un număr de galbeni calculat astfel: se înmulţeşte numărul de galbeni ai primului sătean cu toate cifrele nenule ale acelui număr, rezultatul se înmulţeşte cu <code>8</code> şi apoi se împarte la <code>9</code> păstrându-se doar ultimele <code>K</code> cifre ale câtului împărţirii. Dacă numărul obţinut are mai puţin de <code>K</code> cifre, atunci acestuia i se adaugă la final cifra <code>9</code>, până când se completează <code>K</code> cifre.

Pentru a stabili câţi galbeni primeşte al treilea sătean, se aplică aceeaşi regulă, dar pornind de la numărul de galbeni ai celui de-al doilea sătean. Regula se aplică în continuare fiecărui sătean, plecând de la numărul de galbeni primiţi de săteanul care a stat la coadă exact în faţa lui.

Cunoscând numărul de galbeni aleşi de primul sătean, determinaţi numărul de galbeni pe care îl va primi al <code>N</code>-lea sătean.

==Date de intrare==
Fișierul de intrare <code>galbeni.in</code> conține pe prima linie cele <code>3</code> numere naturale nenule <code>S</code>, <code>K</code>, <code>N</code> separate prin câte un spaţiu, unde <code>S</code> reprezintă numărul de galbeni ales de primul sătean, <code>K</code> este numărul de cifre ale numărului <code>S</code>, iar <code>N</code> reprezintă numărul de ordine al săteanului pentru care se cere să determinaţi numărul de galbeni primiţi.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa un număr natural reprezentând rezultatul determinat.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>2 ≤ N ≤ 1 000 000 000</code>
* <code>1 ≤ K ≤ 3</code>

* Se garantează că <code>S</code> are exact <code>K</code> cifre.

==Exemplu 1==
;Intrare
:51 2 3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:77

===Explicație===
Primul sătean a luat <code>51</code> de galbeni. Cel de al doilea sătean va primi <code>26</code> de galbeni

(<code>51</code> se înmulţeşte cu cifrele nenule <code>51*5*1=255</code>, <code>255</code> se înmulţeşte cu <code>8 =2040</code>. Câtul împărţirii lui <code>2040</code> la <code>9</code> este <code>226</code>, ultimele două cifre fiind <code>26</code>).

Cel de al treilea sătean va primi <code>77</code> de galbeni (<code>26</code> se înmulţeşte cu cifrele nenule <code>26*2*6=312</code>, <code>312</code> se înmulţeşte cu <code>8</code> şi obţinem numărul <code>2496</code>. Câtul împărţirii dintre <code>2469</code> şi <code>9</code> este <code>277</code>, ultimele două cifre fiind <code>77</code>)

==Exemplu 2==
;Intrare
:10 2 3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:96

===Explicație===
Primul sătean primeşte <code>10</code> galbeni. Pentru a calcula câţi galbeni primeşte al doilea sătean procedăm astfel: înmulţim <code>10</code> cu cifele sale nenule: <code>10*1 = 10</code>, apoi cu <code>8</code>,

<code>10*8 = 80</code>. Câtul împărţirii lui <code>80</code> la <code>9</code> este <code>8</code>. Acest număr având mai puţin de <code>K=2</code> cifre, se adaugă la finalul său cifra <code>9</code> şi se obţine <code>89</code>.

Pentru al treilea sătean se pleacă de la <code>89</code> (<code>89*8*9=6408</code>, <code>6408*8=51264</code>, câtul împărţirii lui <code>51264</code> la <code>9</code> este <code>5696</code>, ultimele două cifre sunt <code>96</code>)

==Exemplu 3==
;Intrare
:1234 4 4
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1054 Galbeni

def conditii(prim_satean, cifre_prim_satean, nth_satean):
restrictii = (
len(str(prim_satean)) == cifre_prim_satean,
1 <= cifre_prim_satean <= 3,
2 <= nth_satean <= 1_000_000_000
)

return all(restrictii)

def calcul_galbeni(s, cifre_s):
# Extragem din s toate cifrele nenule
cifre_nenule = [int(x) for x in list(str(s)) if int(x) > 0]
# Le înmulțim cu s și apoi cu 8, după care le împărțim la 9, conform enunțului
produs = s
for cif in cifre_nenule:
produs *= cif
produs *= 8
cat = produs // 9
# Adăugăm suficienți "9" la finalul variabile 'cat' până când acesta are cifre_s cifre
while len(str(cat)) < cifre_s:
cat = str(cat)+"9"
# Secționăm string-ul și returnăm ultimele cifre_s cifre
return int(str(cat)[-cifre_s:])

def galbeni(prim_satean, cifre_prim_satean, nth_satean):
suma = prim_satean
# Pentru fiecare sătean (până la al n-lea sătean), calculăm suma galbenilor
for i in range(nth_satean - 1):
suma = calcul_galbeni(suma, cifre_prim_satean)

# Ultima sumă calculată (la ieșirea din for loop) este suma de galbeni pe care am vrut să o determinăm
print(suma)

if __name__ == "__main__":
prim_satean, cifre_prim_satean, nth_satean = [int(x) for x in input().split()]

if not conditii(prim_satean, cifre_prim_satean, nth_satean):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
galbeni(prim_satean, cifre_prim_satean, nth_satean)

</syntaxhighlight>

1833 - N Consecutive

2023-05-06T11:41:03Z

Ardelean Alexandru:

==Cerința==
Într-o zi frumoasă de vara, Gigel la auzit pe fratele mai mare spunând că ştie să scrie numărul <code>600</code> ca sumă de numere consecutive în <code>5</code> moduri distincte. Deoarece Gigel este ambiţios, doreşte să poată să facă şi el astfel de afirmaţii. Mai exact, el îşi doreşte să poată să spună care este cel mai mic număr natural care poate fi descompus ca sumă de două sau mai multe numere naturale consecutive în exact <code>N</code> moduri şi care sunt acele moduri.

Să se determine cel mai mic număr natural care respectă condițiile lui Gigel.

==Date de intrare==
Fișierul de intrare <code>consecutive.in</code> conține pe prima linie numărul <code>N</code>, reprezentând numărul de moduri în care numărul găsit de Gigel să poată fi scris ca suma de numere consecutive
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa numărul <code>x</code>, reprezentând numărul găsit de Gigel, iar pe următoarele <code>N</code> rânduri va fi afișat câte un număr, reprezentând lungimea secvenţei.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 100</code>

* Se garantează că soluţia e mai mică decât <code>1.000.000</code>

==Exemplu 1==
;Intrare
:2
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:9
:2
:3

===Explicație===
<code>9 = 4 + 5</code> (secventa de lungime <code>2</code> care incepe de la <code>4</code>)

<code>9 = 2 + 3 + 4</code> (secventa de lungime <code>3</code> care incepe de la <code>2</code>)

==Exemplu 2==
;Intrare
:500
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1833 N Consecutive
from math import sqrt

def cerinte(nr):
return 1 <= nr <= 100

def suma_aritmetic(a, b):
# Formula sumei aritmetice
return (b * (b + 1)) // 2 - ((a - 1) * a) // 2

def n_consecutive(nr):
val_max = 1_000_000
sume = [0] * (val_max + 1)

# Iterăm peste toate secvențele consecutive posibile (adică punctele de început și de sfârșit)
for i in range(2, val_max):
for stanga in range(1, val_max):
dreapta = stanga + i - 1
# Dacă suma acestei secvențe este mai mare decât val_max, nu mai iterăm peste punctele de început
if suma_aritmetic(stanga, dreapta) > val_max:
break
# Incrementăm numărul de apariții ale sumei acestei secvențe în lista sume
sume[suma_aritmetic(stanga, dreapta)] += 1

# Căutăm prima sumă a unei secvențe consecutive care apare de nr ori în lista sume
for i in range(3, val_max):
if sume[i] == nr:
print(i)

# Căutăm o secvență consecutivă care se adună la i iterând peste toate punctele de început posibile
# și rezolvând o ecuație de gradul 2 pentru a găsi punctul de sfârșit
for stanga in range(i // 2, 0, -1):
ec_patrata = 1 - 4 * (stanga - stanga * stanga - 2 * i)
dreapta = (-1 + sqrt(ec_patrata)) / 2
# Dacă punctul de sfârșit este un număr întreg, afișăm lungimea secvenței consecutive
if dreapta == int(dreapta):
print(int(dreapta - stanga + 1))
break

if __name__ == "__main__":
nr = int(input())

if not cerinte(nr):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
n_consecutive(nr)

</syntaxhighlight>

0271 - S Sume

2023-05-05T15:28:09Z

Ardelean Alexandru:

==Cerința==
Se dă un tablou unidimensional cu <code>n</code> elemente, numere naturale nenule cu cel mult <code>8</code> cifre fiecare. Determinaţi câte dintre elementele tabloului se pot scrie ca sumă a altor două elemente aflate pe poziţii distincte din tablou.

==Date de intrare==
Fişierul de intrare <code>ssume.in</code> conţine pe prima linie numărul <code>n</code>; urmează cele <code>n</code> elemente ale tabloului, dispuse pe mai multe linii şi separate prin spaţii.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa numărul <code>C</code>, numărul de elemente ale tabloului care se pot scrie ca sumă a altor două elemente aflate pe poziţii distincte din tablou.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 100</code>

==Exemplu 1==
;Intrare
:7
:1 10 25 6 2 15 3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:2

===Explicație===
<code>25=10+15</code>, <code>3=1+2</code>.

==Exemplu 2==
;Intrare
:101
:1 2 3 4 5
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0271 S Sume

def conditii(n, tablou):
restrictii = (
1 <= n <= 10,
len(tablou) == n
)

return all(restrictii)

def ssume(n, tablou):
nr_sume = 0
# Pentru fiecare număr din tablou, verificăm dacă există alte două numere distincte a căror sumă este egală cu el
for i in range(n):
for j in range(n):
for h in range(j + 1, n):
# Ne asigurăm că verificăm indici diferiți (adică numere distincte)
# Dacă există două numere diferite care se adună la numărul curent...
if i != j and i != h and tablou[j] + tablou[h] == tablou[i]:
# ...incrementăm nr_sume
nr_sume += 1

print(nr_sume)

if __name__ == "__main__":
n = int(input())
tablou = [int(x) for x in input().split()]

if not conditii(n, tablou):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
ssume(n, tablou)

</syntaxhighlight>

0801 - Eliminare Spatii

2023-05-05T15:23:39Z

Ardelean Alexandru:

==Cerința==
Se dă un şir de caractere ce conţine cuvinte formate din litere mici ale alfabetului englez, separate prin unul sau mai multe spații.

Să se afişeze şirul obţinut după eliminarea din șir unor spații, astfel încât între cuvinte să fie un singur spațiu și să nu nu existe spații înainte de primul cuvânt și nici după ultimul.

==Date de intrare==
Programul va citi de la tastatură şirul dat.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa şirul transformat corespunzător.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* șirul dat va conține cel mult <code>255</code> caractere, litere mici ale alfabetului englez și spații

==Exemplu 1==
;Intrare<syntaxhighlight>
in vacanta plec la mare
</syntaxhighlight>Ieșire
:Datele de intrare corespund restricțiilor impuse.
:in vacanta plec la mare

==Exemplu 2==
;Intrare<syntaxhighlight>
în v4c4nță pl3c l4 m4r3
</syntaxhighlight>Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0801 Eliminare Spatii
import re

def conditii(sir):
# Regex care acceptă doar litere din alfabetul englez, caracterul spațiu și are lungimea maximă de 255 de caractere
return re.match(r"^[a-z ]{0,255}$", sir)

def eliminare_spatii(sir):
# Funcția strip() elimină spațiile de la începutul și sfârșitul unui șir de caractere.
# Funcția split() împarte un șir de caractere în funcție de un parametru dat. Dacă nu este dat niciun parametru,
# șirul este împărțit după caracterul spațiu.
# Dacă există mai multe spații consecutive, funcția split() le va considera ca un singur spațiu.
# Funcția join() îmbină elementele unei liste într-un șir de caractere, folosind un parametru dat. În acest caz,
# parametru dat este spațiu.
print(" ".join(sir.strip().split()))

if __name__ == "__main__":
sir = input()

if not conditii(sir):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
eliminare_spatii(sir)

</syntaxhighlight>

1159 - Smen

2023-05-05T15:17:24Z

Ardelean Alexandru:

==Cerința==
Se dă un șir <code>V</code>. Știind <code>V0 = 3</code> și regula de formare a șirului:

<code>Vi = ([Vi-1*Vi-1 / (i + 2)] + Vi-1 * i + i + 1) % 666013</code>.

să se determine al <code>n</code>-lea termen al șirului. (unde <code>[x]</code> reprezintă partea întreagă a numărului <code>x</code>)

==Date de intrare==
Fișierul de intrare <code>smen.in</code> conține numărul <code>n</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa al <code>n</code>-lea termen al șirului.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 20.000.000</code>

==Exemplu 1==
;Intrare
:10000000
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:22230

==Exemplu 2==
;Intrare
:21345670
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1159 Smen

def conditii(n):
return 1 <= n <= 20_000_000

def smen(n):
# v_n = valoarea de la pasul n
# v_i = valoarea de la pasul i
# Primul termen al șirului este 3
v_n, v_i = 3, 0
for i in range(n + 1):
# Formula de recurență, conform cerinței
v_i = ((v_n * v_n // (i + 2)) + v_n * i + i + 1) % 666013
# Înlocuim v_n cu v_i pentru a putea calcula următorul termen
v_n = v_i

# Afisăm al n-lea termen
print(v_i)

if __name__ == "__main__":
n = int(input())

if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
smen(n)

</syntaxhighlight>

2129 - Prime 1

2023-05-05T15:13:06Z

Ardelean Alexandru:

==Cerința==
Eu sunt fascinată de numerele prime. Consider că numerele prime sunt “scheletul” tuturor numerelor sau “atomii” acestora, pentru că orice număr natural mai mare decât <code>1</code> poate fi scris ca un produs de numere prime. Recent am aflat şi alte proprietăţi interesante legate de numerele prime, de exemplu:

#În şirul Fibonacci există o infinitate de numere prime. Vă mai amintiţi şirul Fibonacci? <code>0</code>, <code>1</code>, <code>1</code>, <code>2</code>, <code>3</code>, <code>5</code>, <code>8</code>, <code>13</code>, <code>...</code> Este şirul în care fiecare termen, exceptând primii doi, se obţine ca suma celor doi termeni care îl precedă.
#Există numere naturale denumite „economice”. Un număr natural este economic dacă numărul de cifre necesare pentru scrierea sa este mai mare decât numărul de cifre necesare pentru scrierea descompunerii sale în factori primi (adică decât numărul de cifre necesare pentru scrierea factorilor primi şi a puterilor acestora). De exemplu <code>128</code> este economic pentru că <code>128</code> se scrie cu <code>3</code> cifre, iar descompunerea sa în factori primi se scrie cu două cifre (<code>2^7</code>); <code>4374</code> este economic pentru că se scrie cu <code>4</code> cifre, în timp ce descompunerea sa în factori primi se scrie cu <code>3</code> cifre (<code>2*3^7</code>). Observaţi că atunci când un factor prim apare la puterea <code>1</code>, aceasta nu este necesar să fie scrisă.
#Multe numere naturale pot fi scrise ca sumă de două numere prime. Dar nu toate. De exemplu, <code>121</code> nu poate fi scris ca sumă de două numere prime.
Scrieţi un program care citeşte numărul natural <code>n</code> şi o secvenţă de n numere naturale, apoi rezolvă următoarele cerinţe:

#determină şi afişează câte dintre numerele din secvenţa dată sunt numere prime din şirul Fibonacci;
#determină şi afişează câte dintre numerele din secvenţa dată sunt numere economice;
#determină şi afişează câte dintre numerele din secvenţa dată nu pot fi scrise ca sumă de două numere prime.

==Date de intrare==
Fișierul de intrare <code>prime1.in</code> conține pe prima linie un număr natural <code>c</code> care reprezintă cerinţa (<code>1</code> , <code>2</code> sau <code>3</code>). Pe a doua linie se află numărul natural <code>n</code>. Pe a treia linie se află o secvenţă de <code>n</code> numere naturale separate prin spaţii.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa răspunsul la cerinţa din fişierul de intrare.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

*<code>1 < n ≤ 50</code>
*Dacă <code>c=1</code> sau <code>c=3</code> numerele naturale din şir sunt mai mari decât <code>1</code> şi mai mici decât <code>10^7</code>.
*Dacă <code>c=2</code> numerele naturale din şir sunt mai mari decât <code>1</code> şi mai mici decât <code>10^14</code>. Pentru rezolvarea corectă a cerinţei 1 se acordă 20 de puncte; pentru rezolvarea corectă a cerinţei 2 se acordă 50 de puncte, iar pentru rezolvarea corectă a cerinţei 3 se acordă 30 de puncte.

==Exemplu 1==
;Intrare
:1
:5
:2 10 13 997 233
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:3

===Explicație===
Cerinţa este 1. Cele <code>3</code> numere prime din şirul Fibonacci existente în secvenţă sunt <code>2</code>, <code>13</code> şi <code>233</code>.

==Exemplu 2==
;Intrare
:2
:4
:128 25 4374 720
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:2

=== Explicație ===
Cerinţa este 2. Succesiunea conţine două numere economice (<code>128</code> şi <code>4374</code>).

==Exemplu 3==
;Intrare
:3
:5
:57 30 121 11 3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:4

===Explicație===
Cerinţa este 3. Sunt <code>4</code> numere naturale din secvenţă care nu pot fi scrise ca sumă de două numere prime: <code>57</code>, <code>121</code>, <code>11</code>, <code>3</code>.

== Exemplu 4 ==

;Intrare
:3
:5
:57 -30 -121 -11 3
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2129 Prime 1
def cerinte(c, n, numere):
if not n == len(numere):
return False
if not 1 < n <= 50:
return False

if c == 1 or c == 3:
for nr in numere:
if not 1 < nr < 10**7:
return False

return True

def prim(nr):
# Dace nr <= 1, atunci nr nu este prim.
if nr < 2:
return False
# Dacă de la 2 până la rădăcina pătrată a lui nr există un divizor a lui nr, atunci nr nu este prim.
for i in range(2, int(nr**0.5) + 1):
if nr % i == 0:
return False

return True

def suma_cifre(nr):
# Transformăm numărul într-o listă de cifre, după care returnăm suma cifrelor
cifre = [int(x) for x in list(str(nr))]
return sum(cifre)

def suma_factori_cifre(nr):
suma = 0
# Primul factor prim este 2
factor = 2

while nr > 1:
exponent = 0

# Dacă numărul este divizibil cu factorul curent...
if nr % factor == 0:
# ...îl împărțim la factorul curent și numărăm de câte ori apare factorul curent în număr
while nr % factor == 0:
nr //= factor
exponent += 1
# Adăugăm la sumă suma cifrelor factorului și a exponentului, dacă exponentul este mai mare decât 1
suma += suma_cifre(factor)
if exponent > 1:
suma += suma_cifre(exponent)
# Trecem la următorul factor prim
factor += 1

# Dacă factorul prim la pătrat este mai mare decât numărul, atunci numărul este prim
if factor ** 2 > nr:
factor = nr

return suma

def prime_suma(nr):
# Dacă nr este par sau nr-2 este prim, atunci nr nu este sumă de două numere prime.
if nr % 2 == 0:
return False
elif prim(nr - 2):
return False

return True

def c_prim_fibonacii(numere):
nr = 0
fibonacii = {0}
a, b = 1, 1

# Generăm numere Fibonacii până ajungem la 10^7
while a < 10 ** 7:
# Algoritm pentru a genera numerele din șirul lui Fibonacci
fibonacii.add(a)
temp = a
a = b
b += temp

# Pentru fiecare număr din numere...
for numar in numere:
# ...dacă numărul se află în șirul lui Fibonacci și este prim...
if numar in fibonacii and prim(numar):
# ...îl numărăm
nr += 1

return nr

def c_economice(numere):
nr = 0
for numar in numere:
nr_suma_cifre = suma_cifre(numar)
nde = suma_factori_cifre(numar)

if nr_suma_cifre > nde:
nr += 1

return nr

def c_not_suma(numere):
nr = 0
for numar in numere:
if prime_suma(numar):
nr += 1

return nr

def prime1(c, numere):
# c este numărul cerinței
if c == 1:
print(c_prim_fibonacii(numere))

elif c == 2:
print(c_economice(numere))

elif c == 3:
print(c_not_suma(numere))

if __name__ == "__main__":
c = int(input())
n = int(input())
numere = [int(x) for x in input().split()]

if not cerinte(c, n, numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
prime1(c, numere)
</syntaxhighlight>

2135 - Roua

2023-05-05T14:41:31Z

Ardelean Alexandru:

==Cerința==
Un copil dorește să vopsească ouăle de Paște, având la dispoziție vopsele de culoare roșie, galbenă, verde și albastră. Fiecare culoare va fi reprezentată printr-un singur caracter astfel: <code>'r'</code> pentru culoarea roșie, <code>'g'</code> pentru galben, <code>'v'</code> pentru verde, <code>'a'</code> pentru albastru. Pentru a vopsi ouăle, le așază în rând, unul după altul. Astfel, o colorare va fi o succesiune de <code>N</code> caractere din mulţimea <code>{'r' , 'g' , 'v','a'}</code>, reprezentând, în ordinea aşezării, culorile celor <code>N</code> ouă.

Numim “roua” o secvență de <code>R</code> caractere cu proprietatea că dintre acestea exact <code>R-1</code> caractere reprezintă culoarea roșie, iar un caracter reprezintă una dintre celelalte <code>3</code> culori. De exemplu secvenţele roua de lungime <code>3</code> sunt <code>"grr"</code>, <code>"rgr"</code>, <code>"rrg"</code>, <code>"vrr"</code>, <code>"rvr"</code>, <code>"rrv"</code>, <code>"arr"</code>, <code>"rar"</code>, <code>"rra"</code> .

Copilul consideră că o colorare este R-frumoasă, dacă oricare <code>R</code> caractere consecutive din colorare formează o secvență roua. De exemplu, pentru <code>N=11</code> ouă, şirul <code>"arrrvrrrarr"</code> reprezintă o colorare 4-frumoasă.
Cunoscând <code>N</code>, numărul de ouă vopsite, și numărul natural <code>R</code>, scrieți un program care determină și afișează:

# numărul de secvențe “roua” de lungime <code>R</code> existente în colorarea celor <code>N</code> ouă;
# numărul total al colorărilor <code>R</code>-frumoase pentru cele <code>N</code> ouă.

==Date de intrare==
Fișierul de intrare <code>roua.in</code> conține pe prima linie un număr natural <code>C</code> reprezentând cerința din problemă care trebuie rezolvată (<code>1</code> sau <code>2</code>). A doua linie din fișier conține numerele naturale <code>N</code> și <code>R</code>, separate prin spaţiu, reprezentând numărul de ouă și lungimea unei secvențe “roua”. Dacă <code>C=1</code>, fișierul va conţine şi o a treia linie pe care se află colorarea celor <code>N</code> ouă.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa un număr natural, reprezentând răspunsul la cerinţa specificată în fişierul de intrare

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>3 ≤ N ≤ 10000</code>
* <code>2 ≤ R < N</code>
* Rezultatul la cerința 2 poate avea cel mult <code>2400</code> de cifre.

==Exemplu 1==
;Intrare
:1
:7 3
:vrrrgrr
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:4

===Explicație===
Cerinţa este 1. Există <code>N=7</code> ouă. Secvențele ''roua'' de lungime <code>3</code> existente în colorare sunt <code>"vrr"</code>, <code>"rrg"</code>, <code>"rgr"</code>, <code>"grr"</code>.

==Exemplu 2==
;Intrare
:2
:4 3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:15

===Explicație===
Cerinţa este 2. Există <code>4</code> ouă. Colorările <code>3</code>-frumoase ale celor <code>4</code> ouă sunt <code>"grrg"</code>, <code>"grrv"</code>, <code>"grra"</code>, <code>"vrrg"</code>,

<code>"vrrv"</code>, <code>"vrra"</code>, <code>"arrg"</code>, <code>"arrv"</code>, <code>"arra"</code>, <code>"rgrr"</code>, <code>"rvrr"</code>, <code>"rarr"</code>, <code>"rrgr"</code>, <code>"rrvr"</code>, <code>"rrar"</code>.

==Exemplu 3==
;Intrare
:2
:3 5
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2135 Roua

def conditii(n, r, colorare=None):
restrictii = (
3 <= n <= 10_000,
2 <= r < n,
len(colorare) == n if colorare else True
)

return all(restrictii)

def nr_secvente_roua(colorare, r):
nr = 0
# Secționăm treptat șirul 'colorare' (colorare[0:r], colorare[1:r], colorare[2:r] ...)
for i in range(len(colorare)-r+1):
secventa = colorare[i:i+r]
# Dacă secvența conține exact r-1 litere 'r'...
if secventa.count("r") == r-1:
# ... înseamnă că avem o secvență "rouă"
nr += 1

return nr

def nr_colorari_r_frumoase(nr_oua, lungime_secventa_roua):
# Numărul de subsecvențe complete (succesiuni de "r")
modulo = nr_oua % lungime_secventa_roua
# Elementele rămase (diferite de "r")
cat = nr_oua / lungime_secventa_roua

# Cu excepția culorii "r", există alte 3 culori: "g", "v", "a"
produs = (cat*3) * (modulo+lungime_secventa_roua)

return int(produs) - 1

def roua(c, nr_oua, lungime_secventa_roua, colorare=None):
# c este numărul cerinței
if c == 1:
print(nr_secvente_roua(colorare, lungime_secventa_roua))
elif c == 2:
print(nr_colorari_r_frumoase(nr_oua, lungime_secventa_roua))

if __name__ == '__main__':
c = int(input())
nr_oua, lungime_secventa_roua = [int(x) for x in input().split()]
colorare = None
if c == 1:
colorare = input()

if not conditii(nr_oua, lungime_secventa_roua, colorare):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
roua(c, nr_oua, lungime_secventa_roua, colorare)

</syntaxhighlight>

2051 - PP

2023-05-05T11:14:35Z

Ardelean Alexandru:

==Cerința==
Se consideră un șir de <code>N</code> numere naturale nenule ordonate crescător <code>a[1]≤a[2]≤...≤a[N]</code>. În legătură cu acest șir de numere ne interesează perechile de poziții <code>(i,j)</code> cu <code>1≤i<j≤N</code> și <code>a[i]≠a[j]</code> sau ne interesează suma elementelor anumitor secvențe.

Se cere să se scrie un program care să citească un număr <code>C</code> reprezentând tipul cerinței, un șir de <code>N</code> numere naturale nenule ordonate crescător <code>a[1]≤a[2]≤...≤a[N]</code> și <code>T</code> perechi de numere naturale <code>(p[k],q[k])</code> cu <code>1≤p[k]<q[k]≤N</code> și <code>1≤k≤T</code> și apoi:

(1) Dacă <code>C=1</code>, atunci trebuie să se determine pentru fiecare pereche dată de numere naturale <code>(p,q)</code> suma <code>a[p]+a[p+1]+...+a[q]</code>.

(2) Dacă <code>C=2</code>, atunci trebuie să se determine pentru fiecare pereche dată de numere naturale <code>(p,q)</code> numărul de perechi <code>(i,j)</code> care respectă simultan condițiile <code>p≤i<j≤q</code> și <code>a[i]≠a[j]</code>.

==Date de intrare==
Fișierul de intrare <code>pp.in</code> conține pe prima linie numărul natural <code>C</code>. Pe al doilea rând se află numărul <code>N</code>. Pe al treilea rând sunt scrise <code>N</code> numere naturale ordonate crescător și separate prin câte un spațiu. Pe al patrulea rând este scris numărul natural <code>T</code>, iar pe fiecare dintre următoarele <code>T</code> rânduri câte două numere naturale separate prin câte un spațiu.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Dacă <code>C=1</code>, atunci pe fiecare din următoarele <code>T</code> rânduri va fi afișat câte un număr natural. Al <code>k</code>-lea număr va reprezenta suma elementelor cuprinse între pozițiile <code>p[k]</code> și <code>q[k]</code> inclusiv.

Dacă <code>C=2</code>, atunci pe fiecare din următoarele <code>T</code> rânduri va fi afișat câte un număr natural. Al <code>k</code>-lea număr va reprezenta numărul cerut de perechi de indici cuprinși între poziţiile <code>p[k]</code> şi <code>q[k]</code> inclusiv.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

*<code>1 ≤ p[i] < q[i] ≤ N ≤ 100 000</code>
*<code>1 ≤ a[1] ≤ a[2] ≤ ... ≤ a[N] ≤ 100 000</code>
*<code>1 ≤ T ≤ 1000</code>

==Exemplu 1==
;Intrare
:1
:5
:1 2 3 3 3
:2
:1 4
:2 5
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:9
:11

===Explicație===
Suntem în cazul <code>C=1</code>. Prima pereche <code>(p,q)</code> este <code>(1,4)</code>. Suma valorilor din secvență este <code>1+2+3+3=9</code>. A doua pereche <code>(p,q)</code> este <code>(2,5)</code>. Suma valorilor din secvență este <code>2+3+3+3=11</code>.

==Exemplu 2==
;Intrare
:2
:5
:1 2 3 3 3
:2
:1 4
:2 5
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:5
:3

===Explicație===
Suntem în cazul <code>C=2</code>. Prima pereche <code>(p,q)</code> este <code>(1,4)</code>. Perechile de poziții care conțin numere diferite între ele sunt <code>(1,2)</code>, <code>(1,3)</code>, <code>(1,4)</code>, <code>(2,3)</code>, <code>(2,4)</code>. Deci sunt <code>5</code> perechi.

A doua pereche <code>(p,q)</code> este <code>(2,5)</code>. Perechile de poziții care conțin numere diferite sunt <code>(2,3)</code>, <code>(2,4)</code>, <code>(2,5)</code>. Deci sunt <code>3</code> perechi.

==Exemplu 3==
;Intrare
:1 5
:1 2 3 3 3
:2
:1 4
:5 2
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2051 PP
def conditii_perechi(n, perechi):
for pereche in perechi:
if not 1 <= pereche[0] < pereche[1] <= n <= 100_000:
return False

return True

def conditii(n, numere, perechi):
restrictii = (
n == len(numere),
1 <= len(perechi) <= 1000,
sorted(numere) == numere,
1 <= numere[0] <= numere[-1] <= 100_000,
conditii_perechi(n, perechi)
)

return all(restrictii)

def pp(c, numere, perechi):
if c == 1:
# A și B fiind elementele din pereche, se îmsumează elementele din intervalul [A, B]
for pereche in perechi:
print(sum(numere[pereche[0] - 1:pereche[1]]))
# Scădem 1 din A pentru că indexarea în Python începe de la 0
elif c == 2:
for pereche in perechi:
nr = 0
# Pentru elementele din intervalul [A, B], verificăm dacă există elemente egale
for i in range(pereche[0] - 1, pereche[1]):
for j in range(i + 1, pereche[1]):
if numere[i] != numere[j]:
nr += 1
print(nr)

if __name__ == '__main__':
c = int(input())
n = int(input())
numere = [int(x) for x in input().split()]
t = int(input())
perechi = []
for i in range(t):
perechi.append([int(x) for x in input().split(" ")])

if not conditii(n, numere, perechi):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
pp(c, numere, perechi)

</syntaxhighlight>

1503 - Puteri 5

2023-05-05T09:54:03Z

Ardelean Alexandru:

==Cerința==
Deoarece Ionel nu a înţeles bine ordinea de efectuare a operaţiilor de ridicare la putere, doamna învăţătoare îi dă o tema care să îl ajute să aprofundeze această problemă. Astfel, îi dă mai multe exerciţii de următorul tip: pentru trei cifre nenule <code>a</code>, <code>b</code>, <code>c</code>, el va trebui să calculeze valoarea următoarei expresii:

<code>ab^c+ac^b+ba^c+bc^a+ca^b+cb^a</code>

Cunoscând cifrele <code>a</code>, <code>b</code>, <code>c</code>, determinaţi valoarea obţinută în urma efectuării calculelor de mai sus.

==Date de intrare==
Fișierul de intrare <code>puteri5.in</code> conține pe prima linie trei cifre <code>a b c</code>, separate prin câte un spaţiu.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa un număr natural ce reprezintă valoarea obţinută pentru expresia precizată anterior.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ a,b,c ≤ 5</code>

==Exemplu 1==
;Intrare
:2 1 3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:24

===Explicație===
Suntem în cazul <code>21^3+23^1+12^3+13^2+32^1+31^2=21+23+18+19+32+31=2+8+1+1+9+3=24</code>

==Exemplu 2==
;Intrare
:2 3 2
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1698

==Exemplu 3==
;Intrare
:4, 0, 6
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1503 Puteri 5
def conditii(a, b, c):
return 1 <= min(a, b, c) <= max(a, b, c) <= 5

def puteri5(a, b, c):
# sum() este o funcție built-in care returnează suma elementelor dintr-o listă
# ** este operatorul de ridicare la putere
# ex: (a**(b**c)) este echivalent cu a^(b^c)
print(sum([
(a ** (b ** c)),
(a ** (c ** b)),
(b ** (a ** c)),
(b ** (c ** a)),
(c ** (a ** b)),
(c ** (b ** a))
]))

if __name__ == "__main__":
a, b, c = [int(x) for x in input().split()]

if not conditii(a, b, c):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
puteri5(a, b, c)

</syntaxhighlight>

2348 - Caracterul mediu 1

2023-05-05T08:55:22Z

Ardelean Alexandru:

==Cerința==
Caracterul mediu a două sau al mai multor caractere este caracterul care are codul ASCII egal cu partea întreagă a mediei aritmetice a codurilor ASCII ale caracterelor date.

Un caracter se numeste ''bun'' daca nu este spatiu, nu este litera mare si nu este vocala .

Se citeste un sir de caractere (care poate contine si spatii). Să se determine caracterul mediu al caracterelor bune din sir .

==Date de intrare==
Programul citește de la tastatură un sir de caractere.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa caracterul mediu al caracterelor bune din sir.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>2 ≤ numărul de caractere citite ≤ 200</code>
* Caracterul mediu poate fi spatiu, litera mare sau vocala.
* Cel putin un caracter va fi bun

==Exemplu 1==
;Intrare
:fz
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:p

==Exemplu 2==
;Intrare
:FaZ QWaaP
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2348 Caracterul Mediu 1
import re

def caractere_bune(sir):
bune = []

for caracter in sir:
# Regex care acceptă doar literele din alfabetul englez și spațiu
if not re.match(r"([aeiouA-Z ])", caracter):
bune.append(caracter)

return bune

def conditii(sir):
return all((
2 <= len(sir) <= 200,
len(caractere_bune(sir)) > 0
))

def caracterul_mediu(sir):
# ord() este o funcție built-in care returnează codul ASCII al unui caracter
caractere = [ord(c) for c in caractere_bune(sir)]
medie = sum(caractere) // len(caractere)
# chr() este o funcție built-in care returnează caracterul corespunzător unui cod ASCII
print(chr(medie))

if __name__ == "__main__":
sir = input()

if not conditii(sir):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
caracterul_mediu(sir)

</syntaxhighlight>

0997 - Reuniune

2023-05-05T08:50:42Z

Ardelean Alexandru:

==Cerința==
Se dau două mulțimi de numere naturale. Să se afișeze reuniunea lor.

==Date de intrare==
Fişierul de intrare <code>reuniune.in</code> conţine pe prima linie numerele <code>n m</code>, reprezentând numărul de elemente din fiecare mulţime.

Linia a doua conţine <code>n</code> numere naturale diferite, ordonate crescător, reprezentând elementele primei mulțimi.

Linia a treia conţine <code>m</code> numere naturale diferite, ordonate crescător, reprezentând elementele celei de-a doua mulțimi.

==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa elementele reuniunii celor două mulțimi, în ordine crescătoare, separate prin exact un spațiu.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n , m ≤ 1000</code>

* elementele celor două mulțimi vor fi mai mici decât <code>1 000 000 000</code>

==Exemplu 1==
;Intrare
:6 4
:1 3 4 7 10 43
:3 5 10 37
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1 3 4 5 7 10 37 43

==Exemplu 2==
;Intrare
:6 4
:7 10 43 1 3 4
:3 37 10 5
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0997 Reuniune

def conditii(n, m, multimea_n, multimea_m):
if not all((
1 <= n <= 1_000,
1 <= m <= 1_000,
len(multimea_m) == m,
multimea_m == sorted(multimea_m),
len(multimea_n) == n,
multimea_n == sorted(multimea_n),
)):
return False

for i in multimea_n:
if not i < 1_000_000_000:
return False
for i in multimea_m:
if not i < 1_000_000_000:
return False

return True

def reuniune(multimea_n, multimea_m):
# sorted() este o funcție built-in care sortează (implicit crescător) o listă de elemente (în acest caz, numere)
# set() este o funcție built-in care combină elemente mai multor liste, ignorând orice duplicate
rezultat = sorted(set(multimea_n + multimea_m))
print(" ".join([str(x) for x in rezultat]))

if __name__ == "__main__":
n, m = [int(x) for x in input().split()]

multimea_n = [int(x) for x in input().split()]
multimea_m = [int(x) for x in input().split()]

if not conditii(n, m, multimea_n, multimea_m):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
reuniune(multimea_n, multimea_m)

</syntaxhighlight>

2857 - LOL

2023-05-05T07:54:29Z

Ardelean Alexandru:

==Cerința==
În jocul League of Legends participă două echipe a câte <code>5</code> jucători notați <code>a,b,c,d,e</code>, respectiv <code>A,B,C,D,E</code>. Fiecare jucător are o valoare, inițial <code>300</code>, și un câștig, inițial <code>0</code>. În joc au loc lupte între perechi de jucători din echipe diferite, în urma fiecărei lupte fiind un învingător și un învins.

După luptă, câștigul învingătorului crește cu valoarea învinsului, valoarea sa crește cu <code>50</code> de bani, fără să depășească <code>1000</code> de bani, iar valoarea învinsului scade cu <code>50</code> de bani, neputând deveni mai mică decât <code>0</code>.

Dându-se lista luptelor, să se determine câți bani va avea fiecare jucător la finalul meciului.

==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>, reprezentând numărul de lupte, iar pe linii separate vor fi perechi <code>x y</code>, însemnând <code>x</code> îl învinge pe <code>y</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarele rânduri vor fi afișate câștigul fiecărui jucător la finalul meciului. Afișarea va fi de forma: <code>L x</code> (<code>x</code> este câștigul jucătorului <code>L</code>).

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 200.000</code>

==Exemplu 1==
;Intrare
:6
:A b
:A c
:A a
:d A
:e C
:e C
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:A 900
:B 0
:C 0
:D 0
:E 0
:a 0
:b 0
:c 0
:d 450
:e 550

===Explicație===
<code>A</code> învinge 3 inamici, <code>d</code> îl învinge pe <code>A</code>, câștigând <code>450</code> de bani, iar <code>e</code> îl învinge pe <code>C</code> de <code>2</code> ori, prima oară câștigând <code>300</code> apoi <code>250</code> de bani.

==Exemplu 2==
;Intrare
:5000000
:A a
:A b
:A c
:B a
:B b
:B c
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2857 LOL

def conditii(n):
return 1 <= n <= 200_000

def lol(n):
# Câștigul inițial al fiecărui jucător este 0
castig = dict.fromkeys(["A", "B", "C", "D", "E", "a", "b", "c", "d", "e"], 0)
# Valoarea inițială al fiecărui jucător este 300
valoare = dict.fromkeys(["A", "B", "C", "D", "E", "a", "b", "c", "d", "e"], 300)

for i in range(n):
castigator, invins = [i for i in input().split()]

# La câștigul jucătorului câștigător se adaugă valoarea jucătorului învins
castig[castigator] += valoare[invins]

# Valoarea maximă a unui jucător este 1000
if valoare[castigator] <= 950:
valoare[castigator] += 50
# Valoarea minimă a unui jucător este 0
if valoare[invins] >= 50:
valoare[invins] -= 50

# Se afișează câștigul fiecărui jucător
for membru in castig:
print(membru, castig[membru])

if __name__ == "__main__":
n = int(input())

if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
lol(n)

</syntaxhighlight>

3328 - Balaur

2023-05-05T07:50:05Z

Ardelean Alexandru:

==Cerința==
A fost o dată un balaur cu <code>6</code> capete. Într-o zi Făt-Frumos s-a supărat şi i-a tăiat un cap. Peste noapte i-au crescut alte <code>6</code> capete în loc. Pe acelaşi gât! A doua zi, Făt-Frumos iar i-a tăiat un cap, dar peste noapte balaurului i-au crescut în loc alte <code>6</code> capete … şi tot aşa timp de <code>n</code> zile. În cea de a ( <code>n+1</code> )-a zi, Făt-Frumos s-a plictisit şi a plecat acasă!

Scrieţi un program care citeşte de la tastatură <code>n</code> , numărul de zile, şi care afişează pe ecran câte capete avea balaurul după <code>n</code> zile.

==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa numărul <code>S</code> reprezentând numărul de capete pe care le va avea balaurul după <code>n</code> zile.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 1.000.000.000</code>

==Exemplu 1==
;Intrare
:3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:15

===Explicație===
Iniţial balaurul avea <code>6</code> capete. În prima zi Făt-Frumos i-a tăiat un cap şi i-au rămas <code>5</code> .

Peste noapte i-au crescut alte <code>6</code> , deci a doua zi dimineaţa balaurul avea <code>11</code> capete. În cea de a doua zi Făt-Frumos îi mai taie balaurului un cap, deci balaurul rămâne cu <code>10</code> capete. Peste noapte îi mai cresc <code>6</code> , astfel că a treia zi dimineaţă balaurul avea <code>16</code> capete. Dar în cea de a treia zi Făt-Frumos îi mai taie balaurului un cap, deci după cea de a treia zi balaurul a rămas cu <code>15</code> capete.

==Exemplu 2==
;Intrare
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#3328 Balaur

def conditii(n):
return 1 <= n <= 1_000_000_000

def balaur(n):
# Înmulțim cu 5 și nu cu 6 pentru că la finalul oricărei zi, balaurului i se va tăia un cap.
# După n zile, balaurul va avea 5*n capete.
print(5 * n)

if __name__ == "__main__":
n = int(input())

if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
balaur(n)

</syntaxhighlight>

1435 - Biti

2023-04-30T16:08:06Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Zoli a primit de la doamna profesoară un șir cu <code>n</code> elemente, numere naturale. Lui Zoli i se cere să răspundă corect la întrebarea: “Câte numere din șir au în reprezentarea binară doar biți setați – adică au toți biții <code>1</code>? ==Date de intrare== Fișierul de intrare <code>biti.in</code> conține pe prima linie numărul <code>n</code>, iar pe a doua linie <code>n</code> numere naturale separate prin spații, reprezentând el...

==Cerința==
Zoli a primit de la doamna profesoară un șir cu <code>n</code> elemente, numere naturale. Lui Zoli i se cere să răspundă corect la întrebarea: “Câte numere din șir au în reprezentarea binară doar biți setați – adică au toți biții <code>1</code>?

==Date de intrare==
Fișierul de intrare <code>biti.in</code> conține pe prima linie numărul <code>n</code>, iar pe a doua linie <code>n</code> numere naturale separate prin spații, reprezentând elementele șirului.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa numărul <code>nr</code>, reprezentând numărul de elemente ale șirului formate doar din biți setați.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 3.000.000</code>

* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât <code>2.000.000.000</code>

==Exemplu 1==
;Intrare
:7
:24 19 15 81 7 63 100
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:3
===Explicație===
Numerele care respectă condiția sunt <code>15</code>, <code>7</code>, <code>63</code>.
==Exemplu 2==
;Intrare
:-5
:24 19 15 81 7 63 100
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1435 Biti
def conditii(n, numere):
return len(numere) == n and \
1 <= n <= 3_000_000 and \
all(nr < 2_000_000_000 for nr in numere)

def biti(numere):
setati = 0
for nr in numere:
# Dacă toate caracterele din reprezentarea binară a lui 'nr' sunt egale cu 1 ...
if all(c == '1' for c in bin(nr)[2:]):
# ... se incrementează valoarea variabilei 'setati'
setati += 1
print(setati)

if __name__ == "__main__":
n = int(input())
numere = [int(x) for x in input().split()]
if not conditii(n, numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
biti(numere)

</syntaxhighlight>

1922 - N Mod 25

2023-04-30T15:32:20Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se dau numerele naturale <code>N</code> și <code>X</code>. Aflați dacă <code>N</code> este divizibil cu <code>2X</code> și dacă <code>N</code> este divizibil cu <code>5X</code>. ==Date de intrare== Fișierul de intrare <code>nmod25.in</code> conține numărul <code>X</code> și numărul <code>N</code>. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse." Pe următoarea linie se va afi...

==Cerința==
Se dau numerele naturale <code>N</code> și <code>X</code>. Aflați dacă <code>N</code> este divizibil cu <code>2X</code> și dacă <code>N</code> este divizibil cu <code>5X</code>.

==Date de intrare==
Fișierul de intrare <code>nmod25.in</code> conține numărul <code>X</code> și numărul <code>N</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa mesajul <code>DA</code> dacă numărul este divizibil cu <code>2X</code> sau <code>NU</code> dacă nu este divizibil, pe a treia linie mesajul <code>DA</code> dacă numărul este divizibil cu <code>5X</code> sau <code>NU</code> dacă nu este divizibil.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>N</code> are cel mult <code>100.001</code> cifre

* <code>0 < X < 5</code>

==Exemplu 1==
;Intrare
:3
:50008
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:DA
:NU
===Explicație===
<code>50008</code> este divizibil cu <code>2</code> la puterea <code>3</code> dar nu si cu <code>5</code> la puterea <code>3</code>.
==Exemplu 2==
;Intrare
:10
:800055
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1922 - N Mod 25
def conditii(x, n):
return 0 < x < 5 and\
0 < n <= 100_001

def nmod25(x, n):
# orice numar A este divizibil cu B daca A % B == 0 (citit A modulo B)
# În Python, ** este operatorul de ridicare la putere
print("DA" if n % (2 ** x) == 0 else "NU")
print("DA" if n % (5 ** x) == 0 else "NU")

if __name__ == "__main__":
x = int(input())
n = int(input())
if not conditii(x, n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
nmod25(x, n)

</syntaxhighlight>

3017 - Decimal Converter

2023-04-30T15:09:38Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se dă <code>n</code> un număr natural și un caracter <code>c</code>, care poate fi <code>b</code>, <code>o</code> sau <code>h</code>. Transformați numărul în baza dată de <code>c</code>, astfel: {| class="wikitable" !c !Baza |- |b |Bin |- |o |Oct |- |h |Hex |} ==Date de intrare== Programul citește de la tastatură numărul caracterul <code>c</code>, iar apoi numărul <code>n</code>. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de intrare co...

==Cerința==
Se dă <code>n</code> un număr natural și un caracter <code>c</code>, care poate fi <code>b</code>, <code>o</code> sau <code>h</code>. Transformați numărul în baza dată de <code>c</code>, astfel:
{| class="wikitable"
!c
!Baza
|-
|b
|Bin
|-
|o
|Oct
|-
|h
|Hex
|}

==Date de intrare==
Programul citește de la tastatură numărul caracterul <code>c</code>, iar apoi numărul <code>n</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se va afișa valoarea cerută.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

*<code>1 ≤ n < 2<big>64</big></code>

* Cifrele cu valori mai mari decât <code>9</code> se vor scrie cu litere mari.

==Exemplu 1==
;Intrare
:b
:5
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:101
===Explicație===
Numărul <code>5</code> în baza doi este scris <code>101</code>.
==Exemplu 2==
;Intrare
:h
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#3017 - DecimalConverter
def conditii(n):
return 1 <= n < 2 ** 64

def decimal_converter(n, c):
# bin(), oct() și hex() sunt funcții predefinite in Python
if c == "b":
print(bin(n)[2:])
elif c == "o":
print(oct(n)[2:])
elif c == "h":
print(hex(n)[2:].upper())

if __name__ == "__main__":
c = input()
n = int(input())

if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
decimal_converter(n, c)

</syntaxhighlight>

0515 - Sort SD

2023-04-30T14:20:27Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se dau <code>n</code> numere naturale. Afișați aceste numere ordonate crescător după suma divizorilor. Dacă două numere au aceeași sumă a divizorilor, se va afișa mai întâi cel mai mic. ==Date de intrare== Programul citește de la tastatură numărul <code>n</code>, iar apoi <code>n</code> numere naturale. ==Date de ieșire== Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse." Pe următoarea linie se vor afișa cele <c...

==Cerința==
Se dau <code>n</code> numere naturale. Afișați aceste numere ordonate crescător după suma divizorilor. Dacă două numere au aceeași sumă a divizorilor, se va afișa mai întâi cel mai mic.

==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>, iar apoi <code>n</code> numere naturale.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se vor afișa cele <code>n</code> numere în ordinea cerută.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

*<code>1 ≤ n ≤ 1000</code>

* cele <code>n</code> numere citite vor fi mai mici decât <code>100.000.000</code>

==Exemplu 1==
;Intrare
:10
:24 46 11 36 48 35 27 28 49 6
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:6 11 27 35 28 49 24 46 36 48

==Exemplu 2==
;Intrare
:-2
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0515 - SortSD
def conditii(n, numere):
return len(numere) == n and \
1 <= n <= 1_000 and \
all(nr < 100_000_000 for nr in numere)

def sort_sd(numere):
rezultat = sorted(numere, key=lambda x: (sum([i for i in range(1, x + 1) if x % i == 0]), x))
# cheia de sortare returneaza un tuplu de 2 elemente:
# 1) suma divizorilor unui număr, SD(x) -> sum([i for i in range(1, x + 1) if x % i == 0]
# 2) numărul în sine, x
# Numerele sunt sortate după SD(x). Dacă două numere au aceeași SD, atunci sunt sortate după valoarea lor.
print(" ".join([str(x) for x in rezultat]))

if __name__ == "__main__":
n = int(input())
numere = [int(x) for x in input().split()]
if not conditii(n, numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
sort_sd(numere)

</syntaxhighlight>

0240 - Max N

2023-04-30T14:04:27Z

Ardelean Alexandru: Pagină nouă: ==Cerința== Se dă un şir cu <code>n</code> numere naturale. Să se determine un alt şir de numere, cu proprietatea că valoarea elementului de pe poziţia <code>i</code> (<code>1≤i≤n</code>) din acest şir este egală cu cea mai mare dintre valorile primelor <code>i</code> elemente din primul şir. ==Date de intrare== Fişierul de intrare <code>maxn.in</code> conţine pe prima linie numărul <code>n</code>, iar pe a următoarele linii <code>n</code> numere naturale s...

==Cerința==
Se dă un şir cu <code>n</code> numere naturale. Să se determine un alt şir de numere, cu proprietatea că valoarea elementului de pe poziţia <code>i</code> (<code>1≤i≤n</code>) din acest şir este egală cu cea mai mare dintre valorile primelor <code>i</code> elemente din primul şir.

==Date de intrare==
Fişierul de intrare <code>maxn.in</code> conţine pe prima linie numărul <code>n</code>, iar pe a următoarele linii <code>n</code> numere naturale separate prin spaţii.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarea linie se vor afișa '''n''' numere, separate prin câte un spaţiu, reprezentând elementele şirului determinat.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 100000</code>

* numerele de pe a doua linie a fişierului de intrare vor avea cel mult <code>9</code> cifre

==Exemplu 1==
;Intrare
:12
:4 6 3 7 8 1 6 2 7 9 10 8
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:4 6 6 7 8 8 8 8 8 9 10 10

==Exemplu 2==
;Intrare
:-10
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0240 - Max N
def conditii(n, numere):
return len(numere) == n and \
1 <= n <= 100_000 and \
all(nr <= 999_999_999 for nr in numere)

def max_n(numere):
rezultat = []

# Incepand cu primul element pana la ultimul...
for i in range(len(numere)):
# ...adaugam in rezultat maximul dintre primele i+1 elemente
rezultat.append(max(numere[:i + 1]))

print(" ".join([str(x) for x in rezultat]))

if __name__ == "__main__":
n = int(input())
numere = [int(x) for x in input().split()]
if not conditii(n, numere):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
max_n(numere)

</syntaxhighlight>

3328 - Balaur

2023-04-29T14:11:03Z

Ardelean Alexandru:

==Cerința==
A fost o dată un balaur cu <code>6</code> capete. Într-o zi Făt-Frumos s-a supărat şi i-a tăiat un cap. Peste noapte i-au crescut alte <code>6</code> capete în loc. Pe acelaşi gât! A doua zi, Făt-Frumos iar i-a tăiat un cap, dar peste noapte balaurului i-au crescut în loc alte <code>6</code> capete … şi tot aşa timp de <code>n</code> zile. În cea de a ( <code>n+1</code> )-a zi, Făt-Frumos s-a plictisit şi a plecat acasă!

Scrieţi un program care citeşte de la tastatură <code>n</code> , numărul de zile, şi care afişează pe ecran câte capete avea balaurul după <code>n</code> zile.

==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa numărul <code>S</code> reprezentând numărul de capete pe care le va avea balaurul după <code>n</code> zile.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 1.000.000.000</code>

==Exemplu 1==
;Intrare
:3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:15

===Explicație===
Iniţial balaurul avea <code>6</code> capete. În prima zi Făt-Frumos i-a tăiat un cap şi i-au rămas <code>5</code> .

Peste noapte i-au crescut alte <code>6</code> , deci a doua zi dimineaţa balaurul avea <code>11</code> capete. În cea de a doua zi Făt-Frumos îi mai taie balaurului un cap, deci balaurul rămâne cu <code>10</code> capete. Peste noapte îi mai cresc <code>6</code> , astfel că a treia zi dimineaţă balaurul avea <code>16</code> capete. Dar în cea de a treia zi Făt-Frumos îi mai taie balaurului un cap, deci după cea de a treia zi balaurul a rămas cu <code>15</code> capete.

==Exemplu 2==
;Intrare
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#3328 Balaur

def conditii(n):
return 1 <= n <= 1_000_000_000

def balaur(n):
print(5 * n)

if __name__ == "__main__":
n = int(input())

if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
balaur(n)

</syntaxhighlight>

2857 - LOL

2023-04-29T14:10:51Z

Ardelean Alexandru:

==Cerința==
În jocul League of Legends participă două echipe a câte <code>5</code> jucători notați <code>a,b,c,d,e</code>, respectiv <code>A,B,C,D,E</code>. Fiecare jucător are o valoare, inițial <code>300</code>, și un câștig, inițial <code>0</code>. În joc au loc lupte între perechi de jucători din echipe diferite, în urma fiecărei lupte fiind un învingător și un învins.

După luptă, câștigul învingătorului crește cu valoarea învinsului, valoarea sa crește cu <code>50</code> de bani, fără să depășească <code>1000</code> de bani, iar valoarea învinsului scade cu <code>50</code> de bani, neputând deveni mai mică decât <code>0</code>.

Dându-se lista luptelor, să se determine câți bani va avea fiecare jucător la finalul meciului.

==Date de intrare==
Programul citește de la tastatură numărul <code>n</code>, reprezentând numărul de lupte, iar pe linii separate vor fi perechi <code>x y</code>, însemnând <code>x</code> îl învinge pe <code>y</code>.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următoarele rânduri vor fi afișate câștigul fiecărui jucător la finalul meciului. Afișarea va fi de forma: <code>L x</code> (<code>x</code> este câștigul jucătorului <code>L</code>).

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 200.000</code>

==Exemplu 1==
;Intrare
:6
:A b
:A c
:A a
:d A
:e C
:e C
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:A 900
:B 0
:C 0
:D 0
:E 0
:a 0
:b 0
:c 0
:d 450
:e 550

===Explicație===
<code>A</code> învinge 3 inamici, <code>d</code> îl învinge pe <code>A</code>, câștigând <code>450</code> de bani, iar <code>e</code> îl învinge pe <code>C</code> de <code>2</code> ori, prima oară câștigând <code>300</code> apoi <code>250</code> de bani.

==Exemplu 2==
;Intrare
:5000000
:A a
:A b
:A c
:B a
:B b
:B c
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2857 LOL

def conditii(n):
return 1 <= n <= 200_000

def lol(n):
castig = dict.fromkeys(["A", "B", "C", "D", "E", "a", "b", "c", "d", "e"], 0)
valoare = dict.fromkeys(["A", "B", "C", "D", "E", "a", "b", "c", "d", "e"], 300)

for i in range(n):
castigator, invins = [i for i in input().split()]

castig[castigator] += valoare[invins]

if valoare[castigator] <= 950:
valoare[castigator] += 50
if valoare[invins] >= 50:
valoare[invins] -= 50

for membru in castig:
print(membru, castig[membru])

if __name__ == "__main__":
n = int(input())

if not conditii(n):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
lol(n)

</syntaxhighlight>

0747 - Turism

2023-04-29T14:10:25Z

Ardelean Alexandru:

==Cerința==
În oraşul Z sunt un număr de <code>n</code> obiective turistice, numerotate de la <code>1</code> la <code>n</code>. Pentru a ajuta turiştii să viziteze oraşul, primăria a cumpărat un autobuz special ce are <code>k</code> locuri şi care va parcurge cele <code>n</code> puncte de atracţie turistică începând cu obiectivul numerotat cu <code>1</code>, apoi obiectivul numerotat cu <code>2</code>, …, până la obiectivul numerotat cu <code>n</code> şi apoi revine la obiectivul <code>1</code>, traseul având formă circulară. În fiecare staţie aşteaptă un anumit număr de călători; pentru fiecare călător se ştie numărul de staţii pe care doreşte să le parcurgă. Călătorii au acces în autobuz numai dacă sunt locuri libere, în ordinea în care așteaptă în stație, iar cei care nu pot urca părăsesc staţia; la următoarea oprire în staţia respectivă vor aştepta alţi călători. Pentru fiecare staţie parcursă costul unui bilet este <code>1</code> leu. Autobuzul va face pentru ultima urcare a călătorilor şi un ultim tur în care doar coboară călători şi nu urcă nimeni. Se cere numărul de curse complete realizate şi suma încasată pentru cursele realizate.

Determinarea valorilor ce reprezintă suma încasată şi numărul de curse complete realizate.

==Date de intrare==
Fișierul de intrare <code>turism.in</code> conține pe prima linie trei numere naturale: <code>n</code>(numărul de staţii), <code>k</code>(numărul de locuri) şi <code>m</code>(numărul de opriri) separate printr-un spaţiu. Pe următoarele <code>m</code> linii secvenţe de valori ce reprezintă numărul de călători din stația respectivă şi pentru fiecare călător numărul staţiilor pe care le parcurge dacă are loc în mijlocul de transport, cu un spaţiu între ele.
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa numărul ce reprezintă suma încasată şi numărul de curse realizate, separate prin exact un spațiu.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

*<code>0 < n ≤ 200,n ≤ m ≤ 10000, 2 < k ≤ 100</code>

*<code>0 <</code> numărul de staţii parcurse de un călător <code>≤ n</code>

*<code>autobuzul opreşte în fiecare staţie</code>
*<code>în fiecare staţie sunt cel mult k călători</code>

==Exemplu 1==
;Intrare
:10 8 16
:9 4 2 6 8 1 1 1 3 2
:2 1 3
:2 1 1
:2 1 2
:2 10 7
:2 10 1
:2 2 2
:2 2 2
:2 2 6
:2 4 1
:2 4 1
:4 3 1 1 1
:3 1 1 1
:8 5 7 4 10 2 3 2 5
:4 1 10 1 1
:4 1 1 1 10
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:138 3

===Explicație===
În prima staţie urcă primii <code>8</code> în autobuz, în a doua coboara <code>3</code>(cei <code>3</code> care au ales sa parcurga numai <code>1</code> staţie) şi urca <code>2</code>, şi aşa mai departe până se parcurg toate cele <code>16</code> opriri alea autobuzului. Suma încasată este : <code>138</code>.

==Exemplu 2==
;Intrare
:16 8 9
:9 4 2 6 8 1 1 20 3 2
:2 1 3
:2 20 1
:2 1 2
:2 10 7
:2 50 1
:3 2 2
:4 2 2
:2 2 6
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0747 Turism
def conditii(nr_statii, nr_locuri, nr_opriri):
restrictii = (
0 < nr_statii <= 200,
nr_statii <= nr_opriri <= 10_000,
2 < nr_locuri <= 100
)

return all(restrictii)

def conditii_calatori(nr_statii, nr_calatori, calatori):
if not nr_calatori == len(calatori):
return False

for c in calatori:
if not 0 < c <= nr_statii:
return False

return True

if __name__ == "__main__":
scaune = [0] * 110
cost = 0

nr_statii, nr_locuri, nr_opriri = [int(x) for x in input().split()]

if not conditii(nr_statii, nr_locuri, nr_opriri):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
for i in range(1, nr_opriri+1):
for j in range(1, nr_locuri+1):
if scaune[j]:
scaune[j] -= 1
poz = 1

rand_input = [int(x) for x in input().split()]
nr_calatori = rand_input[0]
calatori = rand_input[1:]

if not conditii_calatori(nr_statii, nr_calatori, calatori):
print("Datele de intrare nu corespund restricțiilor impuse.")
exit(0)

for cal in calatori:
while poz <= nr_locuri and scaune[poz]:
poz += 1
if poz <= nr_locuri:
scaune[poz] = cal
cost += cal

print("Datele de intrare corespund restricțiilor impuse.")

maxim = scaune[0]
for i in range(1, nr_locuri):
if scaune[i] > maxim:
maxim = scaune[i]

rez = (nr_opriri - 1) // nr_statii + 1
if maxim:
rez += (maxim - nr_opriri % nr_statii - 1) // nr_statii + 1

print(cost, rez)

</syntaxhighlight>

1833 - N Consecutive

2023-04-29T14:10:17Z

Ardelean Alexandru:

==Cerința==
Într-o zi frumoasă de vara, Gigel la auzit pe fratele mai mare spunând că ştie să scrie numărul <code>600</code> ca sumă de numere consecutive în <code>5</code> moduri distincte. Deoarece Gigel este ambiţios, doreşte să poată să facă şi el astfel de afirmaţii. Mai exact, el îşi doreşte să poată să spună care este cel mai mic număr natural care poate fi descompus ca sumă de două sau mai multe numere naturale consecutive în exact <code>N</code> moduri şi care sunt acele moduri.

Să se determine cel mai mic număr natural care respectă condițiile lui Gigel.

==Date de intrare==
Fișierul de intrare <code>consecutive.in</code> conține pe prima linie numărul <code>N</code>, reprezentând numărul de moduri în care numărul găsit de Gigel să poată fi scris ca suma de numere consecutive
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa numărul <code>x</code>, reprezentând numărul găsit de Gigel, iar pe următoarele <code>N</code> rânduri va fi afișat câte un număr, reprezentând lungimea secvenţei.

În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse."

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

* <code>1 ≤ n ≤ 100</code>

* Se garantează că soluţia e mai mică decât <code>1.000.000</code>

==Exemplu 1==
;Intrare
:2
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:9
:2
:3

===Explicație===
<code>9 = 4 + 5</code> (secventa de lungime <code>2</code> care incepe de la <code>4</code>)

<code>9 = 2 + 3 + 4</code> (secventa de lungime <code>3</code> care incepe de la <code>2</code>)

==Exemplu 2==
;Intrare
:500
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1833 N Consecutive
from math import sqrt

def cerinte(nr):
return 1 <= nr <= 100

def suma_aritmetic(a, b):
return (b * (b + 1)) // 2 - ((a - 1) * a) // 2

def n_consecutive(nr):
val_max = 1_000_000
sume = [0] * (val_max + 1)

for i in range(2, val_max):
for stanga in range(1, val_max):
dreapta = stanga + i - 1
if suma_aritmetic(stanga, dreapta) > val_max:
break
sume[suma_aritmetic(stanga, dreapta)] += 1

for i in range(3, val_max):
if sume[i] == nr:
print(i)

for stanga in range(i // 2, 0, -1):
ec_patrata = 1 - 4 * (stanga - stanga * stanga - 2 * i)
dreapta = (-1 + sqrt(ec_patrata)) / 2
if dreapta == int(dreapta):
print(int(dreapta - stanga + 1))
break

if __name__ == "__main__":
nr = int(input())

if not cerinte(nr):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
n_consecutive(nr)

</syntaxhighlight>