Bitnami MediaWiki - User contributions [en]

S:E15313

2024-12-10T12:25:15Z

Cristina94: Created page with "'''S:E15313 (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)''' ''Determinați cifra <math>a</math> pentru care fracția <math>\frac{a^2 \cdot \overline{aa} + a^2(a^2+1)}{\overline{202a}}</math> este echiunitară.'' '''Soluție:''' ''Fracția este echiunitară dacă <math>a^2 \cdot \overline{aa} + a^2(a^2+1) = \overline{202a}</math> sau <math>a^4 + 11a^3 + a^2 = \overline{202a}</math>. Avem <math> 2020 \leq \overline{202a} \leq 2029 </math>. Dacă <math> a \leq 4 <..."

'''S:E15313 (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)'''

''Determinați cifra <math>a</math> pentru care fracția <math>\frac{a^2 \cdot \overline{aa} + a^2(a^2+1)}{\overline{202a}}</math> este echiunitară.''

'''Soluție:'''

''Fracția este echiunitară dacă <math>a^2 \cdot \overline{aa} + a^2(a^2+1) = \overline{202a}</math> sau <math>a^4 + 11a^3 + a^2 = \overline{202a}</math>. Avem <math> 2020 \leq \overline{202a} \leq 2029 </math>. Dacă <math> a \leq 4 </math>, atunci <math> a^4 + 11a^3 + a^2 \leq 976 < 2020 </math>, iar dacă <math>a \geq 6</math>, atunci <math>a^4 + 11a^3 + a^2 \geq 3708 > 2029 </math>. Pentru <math>a = 5 </math>, avem <math>5^4 + 11 \cdot 5^3 + 5^2 = 2025 </math>. ''

S:E15310

2024-12-10T12:10:42Z

Cristina94: Created page with "'''S:E15310 (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)''' ''Arătați că nu există numere naturale <math>p</math> și <math>q</math> astfel încât să fie adevărată relația <math>p^2 - 2018 = 2^q</math>.'' '''Soluție:''' ''Putem scrie <math>p^2 = 2^q + 2018</math>. Pentru <math>q = 0</math> obținem <math>p^2 = 2019</math>, iar pentru <math>q = 1</math> obținem <math>p^2 = 2020</math> care nu sunt pătrate de numere naturale. Pentru <math>q \geq 2</ma..."

'''S:E15310 (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)'''

''Arătați că nu există numere naturale <math>p</math> și <math>q</math> astfel încât să fie adevărată relația <math>p^2 - 2018 = 2^q</math>.''

'''Soluție:'''

''Putem scrie <math>p^2 = 2^q + 2018</math>. Pentru <math>q = 0</math> obținem <math>p^2 = 2019</math>, iar pentru <math>q = 1</math> obținem <math>p^2 = 2020</math> care nu sunt pătrate de numere naturale. Pentru <math>q \geq 2</math> trebuie să avem <math>p</math> număr par. Atunci <math>p^2 = M4</math>, <math>2^q = M4</math>, ar <math>2018 = M4 + 2</math>. Prin urmare relația dată nu este posibilă pentru <math>p</math> și <math>q</math> numere naturale. ''

Gazeta matematică 2018

2024-12-10T11:54:19Z

Cristina94: /* Gazeta Matematică 2/2018 */

== Gazeta Matematică 2/2018 ==

'''[[S:E15.314|E:15314]] (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Determinați numerele naturale <math>m</math> și <math>n</math> pentru care este adevărată relația <math>2018^{m}=8^{n}+2010</math>.''

'''[[S:E15.316|E:15316]] (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Determinați numărul prim <math>p</math> și numărul natural <math>q</math> astfel încât <math>p^{2} + 5^{p} + 31 = 3181^{q}.</math>''

'''[[S:E15.325|E:15325]] (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)'''
''Determinați numerele naturale <math>\overline{abcd}</math> pentru care:''
<math display="block">\frac{\sqrt{d+2 \cdot \overline{abc}}}{\overline{d0}} = \frac{\sqrt{3 \cdot \overline{abc}}}{\overline{abc}}</math>

'''[[S:E15310]] (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)'''

''Arătați că nu există numere naturale <math>p</math> și <math>q</math> astfel încât să fie adevărată relația <math>p^2 - 2018 = 2^q</math>.''

'''[[S:E15313]] (Cristina Vijdeluc și Mihai Vijdeluc, Baia Mare)'''

''Determinați cifra <math>a</math> pentru care fracția <math>\frac{a^2 \cdot \overline{aa} + a^2(a^2+1)}{\overline{202a}}</math> este echiunitară.''

== Gazeta Matematică 4/2018 ==

'''S:E18.127 (Nicolae Mușuroia)'''

''Un copil se joacă. În prima etapă, scrie un număr pe tablă. La fiecare dintre etapele următoare, înlocuiește numărul de pe tablă cu un altul, obținut după una dintre următoarele reguli: sau scrie dublul numărului, sau scrie numărul obținut prin înlocuirea ultimei cifre a numărului cu ultima cifră a cubului acestuia. Știind că se pornește de la numărul <math>18</math>, stabiliți dacă''

a) s''e poate ajunge la numărul'' <math>78</math>;

b) ''se poate ajunge la numărul'' <math>2018</math>.

'''[[S:E18.128]] (Vasile Ienuțaș)'''

''Scrieți numărul <math>2018^{2017}</math> ca sumă de patru pătrate perfecte nenule distincte.''

'''S:E18.129 (Ioan-Iulian Bunu)'''

''Determinați numerele prime <math>a, b, c</math> din egalitatea <math>5a^6+13b^2+5^c=2018</math>''.

'''S:E18.130 (Traian Covaciu)'''

a) ''Determinați numerele prime <math>x,y,z</math> astfel încât'' <math>8x+9y+60z=1918</math>.

b) ''Aflați numerele naturale <math>x,y,z</math> astfel încât'' <math>20x+208y+209z=2018</math>.

'''[[S:E18.131]] (Nicolae Mușuroia)'''

''Determinați cel mai mic număr natural pătrat perfect care se poate scrie ca sumă de 2018 numere naturale consecutive.''

'''[[S:E18.154]] (Nicolae Mușuroia)'''

''Fie <math>a,b,c \in \mathbb{Z}</math> cu <math>b^{2}+c^{2}=a^{2}</math>. Arătați că pentru orice <math>n\in \mathbb{N}^{*}</math>, ecuația <math>x^{2}+2a^{n}x+b^{2n}+c^{2n}=0</math> are soluții reale.''

1476 – Fsortare

2024-05-13T13:10:53Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct nod{ int info; nod *urm; }; în care câmpul info memorează un număr întreg, iar câmpul urm memorează adresa următorului element al listei. ==Cerința== Să se scrie o funcție C++ cu următorul prototip: void sortareCrescator(nod *&prim) care sortează crescător elementele listei al cărei prim elemen...

==Enunţ==
Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos:

struct nod{
int info;
nod *urm;
};

în care câmpul info memorează un număr întreg, iar câmpul urm memorează adresa următorului element al listei.

==Cerința==
Să se scrie o funcție C++ cu următorul prototip:

void sortareCrescator(nod *&prim)

care sortează crescător elementele listei al cărei prim element are adresa memorată în prim.

==Restricții și precizări==
*numele funcției va fi sortareCrescator
*lista va conține cel puțin 3 elemente
*rezolvarea se va face in python

==Exemplu==
Dacă lista este formată din valorile (5, 3, 9, 4, 2, 12), după apelul funcţiei ea va conţine elementele (2, 3, 4, 5, 9, 12).

==Rezolvare==
<syntaxhighlight lang="python" line>
#1476 FSortare

class Node:
def __init__(self, info):
self.info = info
self.next = None

def create_linked_list(values):
head = None
tail = None
for value in values:
new_node = Node(value)
if head is None:
head = new_node
tail = new_node
else:
tail.next = new_node
tail = new_node
return head

def sortareCrescator(prim):
# Funcție pentru inserarea unui nod într-o listă sortată
def insert_sorted(head, new_node):
if head is None or head.info >= new_node.info:
new_node.next = head
return new_node

current = head
while current.next is not None and current.next.info < new_node.info:
current = current.next

new_node.next = current.next
current.next = new_node
return head

# Inițializăm lista sortată ca fiind lista vidă
sorted_list = None
current = prim

# Parcurgem lista inițială și inserăm fiecare nod în lista sortată
while current is not None:
sorted_list = insert_sorted(sorted_list, Node(current.info))
current = current.next

# Copiem lista sortată înapoi în lista inițială
current = prim
sorted_current = sorted_list
while sorted_current is not None:
current.info = sorted_current.info
current = current.next
sorted_current = sorted_current.next

# Funcție pentru citirea datelor de intrare de la tastatură
def read_input():
values = input("Introduceți valorile separate prin virgulă: ").split(',')
return [int(value) for value in values if value.strip()] # eliminăm spațiile și convertim în int

# Testăm funcția
def print_list(head):
current = head
while current is not None:
print(current.info, end=" ")
current = current.next
print()

# Citim datele de intrare de la tastatură
values = read_input()

# Cream lista liniară simplu înlănțuită folosind funcția create_linked_list
l = create_linked_list(values)

print("Lista inițială:")
print_list(l)

# Sortăm lista
sortareCrescator(l)

print("Lista sortată:")
print_list(l)

</syntaxhighlight>

1181 – FListă Interclasare2

2024-05-13T13:05:04Z

Cristina94:

1171 – FȘterge Primul Din Listă

2024-05-13T13:00:51Z

Cristina94:

==Enunţ==
Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos:

struct nod{
int info;
nod * urm;
};

în care câmpul info memorează un număr întreg, iar câmpul urm memorează adresa următorului element al listei.

==Cerinţa==
Să se scrie o funcție C++ cu următorul prototip:

void stergePrimul(nod * & p);

care șterge primul element al unei liste; pointerul p are ca valoarea adresa primului element din listă – cel care va fi șters.

==Restricţii şi precizări==
numele funcției va fi stergePrimul
dacă lista nu conține niciun element, pointerul p va avea valoarea NULL
în toate cazurile, la ieșirea din apel p va memora adresa primului element al listei; dacă elementul șters este ultimul, p va avea valoarea NULL

==Important==
Se va rezolva în python.

Soluţia propusă va conţine definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line>
#1171 FStergePrimulDinLista
class Nod:
def __init__(self, info):
self.info = info
self.urm = None

def stergePrimul(p):
if p is None:
return

p = p.urm
return p

def main():
# Citirea datelor de intrare de la tastatura
N = int(input("Introduceti numarul de noduri: "))
vals = [int(input(f"Introduceti valoarea pentru nodul {i + 1}: ")) for i in range(N)]

# Crearea unei liste liniare simplu inlantuite
noduri = [Nod(val) for val in vals]
for i in range(N - 1):
noduri[i].urm = noduri[i + 1]

# Afisarea listei inainte de stergerea primului element
print("Lista inainte de stergerea primului element:")
current = noduri[0]
while current is not None:
print(current.info)
current = current.urm

# Stergerea primului element
noduri[0] = stergePrimul(noduri[0])

# Afisarea listei dupa stergerea primului element
print("Lista dupa stergerea primului element:")
current = noduri[0]
while current is not None:
print(current.info)
current = current.urm

if __name__ == "__main__":
main()

</syntaxhighlight>

1000 - CNP

2024-05-13T12:40:12Z

Cristina94:

==Cerința==
Se consideră un fişier care conţine informaţii despre mai multe persoane, sub o formă nestructurată. Informaţiile sunt dispuse pe linii de maxim 200 de caractere şi pot conţine CNP-uri valide. Ştiind că CNP-ul unei persoane este un şir de exact 13 cifre consecutive, scrieţi un program care determină şi scrie în fişierul de ieșire, pe linii distincte, toate CNP-urile extrase din text. Dacă în fișierul de intrare nu se află niciun CNP, în fișierul de ieșire se va afișa numai valoarea 0.

==Date de intrare==
Fișierul de intrare cnp.in conține informațiile date.

==Date de ieșire==
Fișierul de ieșire cnp.out va conține CNP-urile determinate, câte unul pe o linie, sau valoarea 0 dacă în fișierul de intrare nu există CNP-uri.

==Exemplul 1==
;cnp.in
:Popescu Grigore, 14 ani, 1991212122334;
:Gigel Banu - 1031102453435, Bujorului 7;
:Dana Marin: 2690405358687, fara viza, 2450609987654 -
:Jane Doe

;cnp.out
:1991212122334
:1031102453435
:2690405358687
:2450609987654

==Exemplul 2==
;cnp.in
:Popescu Grigore, 14 ani, 1991212134;
:Gigel Banu - 103110245Bujorului 7;
:Dana Marin: 269-04-05-358687, fara viza, 2+450609+987654 -
:Jane Doe

;cnp.out
:0

==Rezolvare==
<syntaxhighlight lang="python" line>
#1000 CNP
import re
import os

def extrage_cnp(text):
regex = r'\b\d{13}\b' # căutăm grupuri de exact 13 cifre
return re.findall(regex, text)

def verifica_date_intrare(nume_fisier):
if not os.path.exists(nume_fisier):
return False
if not os.path.isfile(nume_fisier):
return False
if not os.access(nume_fisier, os.R_OK):
return False
return True

def main():
nume_fisier_intrare = 'cnp.in'
nume_fisier_iesire = 'cnp.out'

if not verifica_date_intrare(nume_fisier_intrare):
with open(nume_fisier_iesire, 'w') as fout:
fout.write("Date invalide: Fisierul de intrare nu poate fi citit.")
return

# Verificare dacă fișierul de intrare este gol
if os.path.getsize(nume_fisier_intrare) == 0:
with open(nume_fisier_iesire, 'w') as fout:
fout.write("Date invalide: Fisierul de intrare este gol.")
return

with open(nume_fisier_intrare, 'r') as fin:
text = fin.read()

cnp_list = extrage_cnp(text)

if cnp_list:
with open(nume_fisier_iesire, 'w') as fout:
for cnp in cnp_list:
fout.write(cnp + '\n')
else:
with open(nume_fisier_iesire, 'w') as fout:
fout.write("0")

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

1970 - secventa xor

2024-04-01T14:10:56Z

Cristina94: Pagină nouă: ==Enunţ== Fie secvența S(x) care se construiește astfel: S(1)=x S(n+1)=S(n) XOR [S(n)/2], unde [x] se definește ca parte întreagă din x, iar XOR este operația clasică „sau exclusiv”. ==Cerința== Dându-se un număr natural k, aflați numărul de numere naturale x pentru care S(k+1)=S(1)=x este adevărat. Deoarece numărul poate fi foarte mare, afișați rezultatul modulo 1000000007. ==Date de intrare== Fișierul de intrare secventa.in se găsește un singur nu...

==Enunţ==
Fie secvența S(x) care se construiește astfel:

S(1)=x
S(n+1)=S(n) XOR [S(n)/2], unde [x] se definește ca parte întreagă din x, iar XOR este operația clasică „sau exclusiv”.

==Cerința==
Dându-se un număr natural k, aflați numărul de numere naturale x pentru care S(k+1)=S(1)=x este adevărat. Deoarece numărul poate fi foarte mare, afișați rezultatul modulo 1000000007.

==Date de intrare==
Fișierul de intrare secventa.in se găsește un singur număr natural k.

==Date de ieșire==
Fișierul de ieșire secventa.out va conține pe prima linie un singur număr – răspunsul problemei modulo 1000000007.

Dacă pentru un număr k există o infinitate de numere x care respectă cerința, se va afișa numărul -1.

==Restricții și precizări==
*1 ≤ k ≤ 10^19

==Exemplul 1==
;secventa.in
:260

;secventa.out
:15

==Exemplul 2==
;secventa.in
:100000000000000000000

;secventa.out
:Date de intrare invalide!

==Rezolvare==
<syntaxhighlight lang="python" line>
#1970 secventa xor
MOD = 1000000007

def calculate_sequence_term(k, x):
while k > 0:
x = x ^ (x // 2)
k -= 1
return x

def count_matching_numbers(k):
count = 0
for x in range(1, k + 1):
if calculate_sequence_term(k, x) == x:
count += 1
return count % MOD

def verify_input_data(k):
if not (1 <= k <= 10 ** 19):
with open("secventa.out", "w") as fout:
fout.write("Date de intrare invalide!")
return False
return True

def main():
with open("secventa.in", "r") as fin:
k = int(fin.readline().strip())

if not verify_input_data(k):
return

matching_numbers = count_matching_numbers(k)

with open("secventa.out", "w") as fout:
fout.write(str(matching_numbers))

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

3650 - Perechi3

2024-04-01T14:00:07Z

Cristina94: Pagină nouă: ==Enunţ== Se dă un șir de numere hexazecimale, adică numere în care cele 16 cifre sunt din mulțimea {0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F}. Spunem că două numere se potrivesc dacă nu au cifre hexazecimale comune și împreună conțin toate cifrele în baza 16, cel puțin o dată. De exemplu, 24FFA032 și EDCB1998765 sunt numere care se potrivesc. ==Cerința== Să se determine numărul perechilor de numere hexazecimale care se potrivesc. ==Date de intrare== Fișierul de...

==Enunţ==
Se dă un șir de numere hexazecimale, adică numere în care cele 16 cifre sunt din mulțimea {0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F}. Spunem că două numere se potrivesc dacă nu au cifre hexazecimale comune și împreună conțin toate cifrele în baza 16, cel puțin o dată. De exemplu, 24FFA032 și EDCB1998765 sunt numere care se potrivesc.

==Cerința==
Să se determine numărul perechilor de numere hexazecimale care se potrivesc.

==Date de intrare==
Fișierul de intrare perechi.in conține pe mai multe linii șirul de numere hexazecimale, deci numerele sunt separate prin spații sau enter.

==Date de ieșire==
Fișierul de ieșire perechi.out va conține un singur număr natural reprezentând numărul perechilor de numere care se potrivesc.

==Restricții și precizări==
*În șir sunt cel puțin două numere și cel mult 200.000 de numere
*Numerele conțin cel puțin o cifră și cel mult 30 de cifre
*Cifrele hexazecimale de la 10 la 15 se scriu cu ajutorul literelor mari A, B, C, D, E, F.

==Exemplul 1==
;perechi.in
:24FFA032 EDCB1998765
:24FA03 24FFA032 0
:123456789ABCDEF12

;perechi.out
:4

==Explicație==
Cele patru perechi sunt: (24FFA032, EDCB1998765), (EDCB1998765, 24FA03), (EDCB1998765, 24FFA032) și (0, 123456789ABCDEF12).

==Exemplul 2==
;perechi.in
:G123 24FFA032 EDCB1998765

;perechi.out
:Date de intrare invalide!

==Rezolvare==
<syntaxhighlight lang="python" line>
#3650 perechi3
def citeste_numere_hexazecimale(fisier):
numere = []
for linie in fisier:
numere.extend(linie.split())
return numere

def se_potrivesc(numar1, numar2):
cifre1 = set(numar1)
cifre2 = set(numar2)
if any(cifra in cifre2 for cifra in cifre1):
return False
cifre_unite = cifre1.union(cifre2)
return len(cifre_unite) == 16

def numara_perechi_potrivite(numere):
count = 0
for i in range(len(numere)):
for j in range(i + 1, len(numere)):
if se_potrivesc(numere[i], numere[j]):
count += 1
return count

def verifica_date_intrare(numere):
if len(numere) < 2 or len(numere) > 200000:
return False
for numar in numere:
if not all(caracter.isdigit() or caracter.upper() in "ABCDEF" for caracter in numar):
return False
return True

def main():
with open("perechi.in", "r") as fin:
numere_hexazecimale = citeste_numere_hexazecimale(fin)

if not verifica_date_intrare(numere_hexazecimale):
with open("perechi.out", "w") as fout:
fout.write("Date de intrare invalide!")
return

numar_perechi_potrivite = numara_perechi_potrivite(numere_hexazecimale)

with open("perechi.out", "w") as fout:
fout.write(str(numar_perechi_potrivite))

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

2107 - Pomi

2024-04-01T13:48:04Z

Cristina94: Pagină nouă: ==Enunţ== În livada sa, Vasile are pomi fructiferi, organizaţi în parcele în funcţie de soi. În fiecare an, scoate la vânzare doar o parte dintre pomii adulţi dintr-o singură parcelă. Ca să asigure spaţiu de dezvoltare pentru pomii rămaşi, Vasile s-a decis să fie scoşi la vînzare numai acei pomi din parcelă al căror număr de ordine este divizibil cu o cifră k, numită cifra anului. ==Cerința== Cunoscând valorile a şi b, reprezentând numerele de ordi...

==Enunţ==
În livada sa, Vasile are pomi fructiferi, organizaţi în parcele în funcţie de soi. În fiecare an, scoate la vânzare doar o parte dintre pomii adulţi dintr-o singură parcelă. Ca să asigure spaţiu de dezvoltare pentru pomii rămaşi, Vasile s-a decis să fie scoşi la vînzare numai acei pomi din parcelă al căror număr de ordine este divizibil cu o cifră k, numită cifra anului.

==Cerința==
Cunoscând valorile a şi b, reprezentând numerele de ordine ale primului, respectiv ultimului pom din parcela din care se face vânzarea, precum şi k – cifra anului, se cere să se determine numărul de pomi scoşi la vânzare de Vasile în acest an.

==Date de intrare==
Fişierul de intrare pomi.in conţine trei numere naturale a, b, k, fiecare pe câte o linie, ce reprezintă: numerele de ordine ale primului, respectiv ultimului pom din parcela din care se face vânzarea şi cifra anului.

==Date de ieșire==
Fişierul de ieşire pomi.out va conţine pe prima linie, un număr natural ce reprezintă numărul de pomi scoşi la vânzare de către Vasile.

==Restricții și precizări==
*1 < k ≤ 9
*1 < a < b
*a şi b sunt numere naturale cu cel mult 80 de cifre fiecare.

==Exemplul 1==
;pomi.in
:23
:41
:3

;pomi.out
:6

==Explicație==
Sunt 6 pomi scoşi la vânzare în acest an.
În cadrul parcelei, ei au avut numerele de ordine: 24, 27, 30, 33, 36, 39 (toate numerele dintre a şi b, care sunt divizibile cu cifra anului, k).

==Exemplul 2==
;pomi.in
:41
:23
:3

;pomi.out
:Date de intrare invalide!

==Rezolvare==
<syntaxhighlight lang="python" line>
#2107 Pomi
def verifica_date_intrare(a, b, k):
if not (1 < k <= 9):
return False
if not (1 < a < b):
return False
return True

def numar_pomi_scoasi_la_vanzare(a, b, k):
count = 0
for i in range(a, b + 1):
if i % k == 0:
count += 1
return count

def main():
# Citire date de intrare
try:
with open("pomi.in", "r") as fin:
a = int(fin.readline().strip())
b = int(fin.readline().strip())
k = int(fin.readline().strip())
except (ValueError, FileNotFoundError):
# Date de intrare invalide sau lipsa fisierului
with open("pomi.out", "w") as fout:
fout.write("Date de intrare invalide!")
return

# Verificare date de intrare
if not verifica_date_intrare(a, b, k):
with open("pomi.out", "w") as fout:
fout.write("Date de intrare invalide!")
return

# Calcul numar de pomi scoși la vânzare
numar_pomi = numar_pomi_scoasi_la_vanzare(a, b, k)

# Scriere rezultat in fisierul de ieșire
with open("pomi.out", "w") as fout:
fout.write(str(numar_pomi))

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

1182 – FListă Interclasare3

2024-04-01T13:23:36Z

Cristina94: /* Important */

1181 – FListă Interclasare2

2024-04-01T13:23:20Z

Cristina94: /* Important */

1171 – FȘterge Primul Din Listă

2024-04-01T13:23:03Z

Cristina94: /* Important */

3789 – FListă Oglindire

2024-04-01T13:22:41Z

Cristina94:

1172 – FListă Numărare

2024-04-01T13:21:43Z

Cristina94:

1173 – FListă Numărare1

2024-04-01T13:21:10Z

Cristina94: /* Important */

4164 – FadaugăÎnainte

2024-04-01T13:20:22Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct Nod{ int info; Nod *leg; }; în care câmpul info memorează un număr întreg, iar câmpul leg memorează adresa următorului element al listei. ==Cerinţa== Să se scrie o funcție C++ cu următorul prototip: void FAdaugaInainte(Nod * &head); care, în lista pentru care primul element are adresa memorată...

==Enunţ==
Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos:

struct Nod{
int info;
Nod *leg;
};

în care câmpul info memorează un număr întreg, iar câmpul leg memorează adresa următorului element al listei.

==Cerinţa==
Să se scrie o funcție C++ cu următorul prototip:

void FAdaugaInainte(Nod * &head);

care, în lista pentru care primul element are adresa memorată în pointerul head, inserează inainte de fiecare nod cu informația impară dublul său. Lista are inițial cel puțin un element. Dacă lista nu are noduri cu informația impară, lista rămâne neschimbată. De exemplu, dacă lista conține inițial informațiile 1,7,3,4,13, atunci la final lista va fi: 2,1,14,7,6,3,4,26,13.

==Important==
Se va rezolva în python.
Soluţia propusă va conţine definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line>
#4164 FAdaugaInainte
class Nod:
def __init__(self, info):
self.info = info
self.leg = None

def FAdaugaInainte(head):
nod_curent = head
while nod_curent is not None:
if nod_curent.info % 2 != 0:
nod_nou = Nod(nod_curent.info * 2)
nod_nou.leg = nod_curent
if nod_curent == head:
head = nod_nou
else:
nod_anterior.leg = nod_nou
nod_anterior = nod_curent
nod_curent = nod_curent.leg

return head

def afisare(head):
nod_curent = head
while nod_curent is not None:
print(nod_curent.info, end=" ")
nod_curent = nod_curent.leg
print()

# Exemplu de utilizare
def main():
# Construim lista liniară simplu înlănțuită de test
head = Nod(1)
head.leg = Nod(7)
head.leg.leg = Nod(3)
head.leg.leg.leg = Nod(4)
head.leg.leg.leg.leg = Nod(13)

print("Lista initiala:")
afisare(head)

# Apelam functia FAdaugaInainte pentru a insera dublul valorilor impare inaintea fiecarei valori impare
head = FAdaugaInainte(head)

print("Lista dupa inserare:")
afisare(head)

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

1173 – FListă Numărare1

2024-04-01T13:12:10Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct nod{ int info; nod * urm; }; în care câmpul info memorează un număr întreg, iar câmpul urm memorează adresa următorului element al listei. ==Cerinţa== Să se scrie o funcție C++ cu următorul prototip: int numarare(nod * p); care determina și returnează numărul perechi de elemente consecutive e...

1126 - Betisoare

2024-04-01T12:51:11Z

Cristina94: Pagină nouă: ==Enunţ== Se presupune că unele dintre primele instrumente de calcul au fost beţişoarele de socotit. În problema noastră vom considera un număr ca fiind o succesiune de unul sau mai multe beţişoare, un beţişor fiind reprezentat de litera I. Într-o expresie, între oricare două numere există semnul + sau semnul *. Exemple: ;Numere I III IIIIIIIIIII ;Expresii III II*III I+I*III+IIIIIII ==Cerinţă== Scrieţi un program care evaluează ast...

==Enunţ==
Se presupune că unele dintre primele instrumente de calcul au fost beţişoarele de socotit. În problema noastră vom considera un număr ca fiind o succesiune de unul sau mai multe beţişoare, un beţişor fiind reprezentat de litera I. Într-o expresie, între oricare două numere există semnul + sau semnul *.

Exemple:
;Numere
I
III
IIIIIIIIIII
;Expresii
III
II*III
I+I*III+IIIIIII

==Cerinţă==
Scrieţi un program care evaluează astfel de expresii.

==Date de intrare==
Fișierul de intrare betisoare.in conține pe prima linie o valoare naturală n, care indică numărul de expresii care trebuie evaluate. Fiecare dintre următoarele n linii conţine un şir de maximum 1.000.000 caractere care reprezintă expresia ce trebuie evaluată.

==Date de ieșire==
Fișierul de ieșire betisoare.out va conține pe fiecare linie i dintre primele n linii câte un număr întreg care reprezintă rezultatul evaluării expresiei de pe linia i+1 din fişierul de intrare.

==Restricții și precizări==
*1 ≤ n ≤ 10
*O expresie poate avea cel puţin 1 caracter şi cel mult 1.000.010 de caractere.
*Valorile calculate pe parcurs şi valoarea finală au maximum 18 cifre.
*Dintre teste, 26% conţin numai operaţii de adunare, 22% numai operaţii de înmulţire, iar restul de 52% conţin ambele operaţii.

==Exemplul 1==
;betisoare.in
:1
:I+I*III+IIIIIII

;betisoare.out
:11

==Exemplul 2==
;betisoare.in
:1
:I+I*III+IIIIIII

;betisoare.out
:4
:2

==Exemplul 3==
;betisoare.in
:II2+3*II

;betisoare.out
:Date de intrare invalide!

==Rezolvare==
<syntaxhighlight lang="python" line>
#1126 Betisoare
def verificare_date_intrare(expresie):
caractere_permise = {'I', '+', '*'}
for caracter in expresie:
if caracter not in caractere_permise and not caracter.isdigit():
return False
return True

def evaluare_expresie(expresie):
stiva = []
numar = 0
for caracter in expresie:
if caracter == 'I':
numar += 1
elif caracter == '+':
stiva.append(numar)
stiva.append('+')
numar = 0
elif caracter == '*':
stiva.append(numar)
stiva.append('*')
numar = 0
elif caracter.isdigit():
numar = numar * 10 + int(caracter)

# Adăugăm ultimul număr la stivă
stiva.append(numar)

rezultat = 0
operatie = '+'
while stiva:
element = stiva.pop()
if isinstance(element, int):
if operatie == '+':
rezultat += element
elif operatie == '*':
rezultat *= element
else:
operatie = element

return rezultat

def main():
with open("betisoare.in", "r") as f:
n = f.readline().strip()
try:
n = int(n)
except ValueError:
with open("betisoare.out", "w") as fout:
fout.write("Date de intrare invalide!\n")
return

expresii = [f.readline().strip() for _ in range(n)]

rezultate = []
for expresie in expresii:
if not verificare_date_intrare(expresie):
rezultate.append("Date invalide")
continue
rezultat = evaluare_expresie(expresie)
rezultate.append(rezultat)

with open("betisoare.out", "w") as f:
for rezultat in rezultate:
f.write(str(rezultat) + "\n")

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

3543 - StringPushPop

2024-04-01T12:06:20Z

Cristina94: Pagină nouă: ==Cerința== Se dă un string s. Asupra acestuia, se aplică 5 tipuri de operații: *(1, c) – se adaugă caracterul c la începutul string-ului *(2, c) – se adaugă caracterul c la finalul string-ului *(3) – se șterge primul caracter al string-ului *(4) – se șterge ultimul caracter al string-ului *(5) – string-ul se va transforma în răsturnatul său Să se afișeze string-ul rezultat după cele q operații. ==Date de intrare== Programul citește de la tastatur...

==Cerința==
Se dă un string s. Asupra acestuia, se aplică 5 tipuri de operații:
*(1, c) – se adaugă caracterul c la începutul string-ului
*(2, c) – se adaugă caracterul c la finalul string-ului
*(3) – se șterge primul caracter al string-ului
*(4) – se șterge ultimul caracter al string-ului
*(5) – string-ul se va transforma în răsturnatul său
Să se afișeze string-ul rezultat după cele q operații.

==Date de intrare==
Programul citește de la tastatură string-ul s, numărul natural q si cele q query-uri.

==Date de ieșire==
Programul va afișa pe ecran string-ul rezultat.

==Restricții și precizări==
*q si lungimea inițială a lui s sunt mai mici sau egale decat 100.000

==Exemplul 1==
;Intrare
:fnic
:7
:1 a
:3
:4
:1 o
:2 b
:5
:1 p

;Ieșire
:pbinfo

==Exemplul 1==
;Intrare
:abc
:-3

;Ieșire
:Date invalide: lungimea string-ului sau numărul de operații sunt invalide.

==Rezolvare==
<syntaxhighlight lang="python" line>
#3543 StringPushPop
def verifica_date_intrare(s, q):
if len(s) > 100000 or q <= 0:
return False
return True

def main():
s = input("Introduceți string-ul s: ").strip() # citim string-ul s de la tastatură și afișăm un mesaj de prompt
q = input("Introduceți numărul de operații q: ").strip() # citim numărul de operații q de la tastatură și îl convertim la întreg

# Verificăm datele de intrare
if not verifica_date_intrare(s, int(q)):
print("Date invalide: lungimea string-ului sau numărul de operații sunt invalide.")
return

for _ in range(int(q)):
op = input("Introduceți operația și caracterul asociat (exemplu: '1 a'): ").strip().split() # citim operația și caracterul asociat
cod = int(op[0])
if cod == 1:
c = op[1]
s = c + s # adăugăm caracterul la începutul string-ului
elif cod == 2:
c = op[1]
s = s + c # adăugăm caracterul la finalul string-ului
elif cod == 3:
s = s[1:] # ștergem primul caracter al string-ului
elif cod == 4:
s = s[:-1] # ștergem ultimul caracter al string-ului
elif cod == 5:
s = s[::-1] # inversăm string-ul

print(s) # afișăm string-ul rezultat

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

1000 - CNP

2024-04-01T11:51:04Z

Cristina94: Pagină nouă: ==Cerința== Se consideră un fişier care conţine informaţii despre mai multe persoane, sub o formă nestructurată. Informaţiile sunt dispuse pe linii de maxim 200 de caractere şi pot conţine CNP-uri valide. Ştiind că CNP-ul unei persoane este un şir de exact 13 cifre consecutive, scrieţi un program care determină şi scrie în fişierul de ieșire, pe linii distincte, toate CNP-urile extrase din text. Dacă în fișierul de intrare nu se află niciun CNP, în fi...

==Cerința==
Se consideră un fişier care conţine informaţii despre mai multe persoane, sub o formă nestructurată. Informaţiile sunt dispuse pe linii de maxim 200 de caractere şi pot conţine CNP-uri valide. Ştiind că CNP-ul unei persoane este un şir de exact 13 cifre consecutive, scrieţi un program care determină şi scrie în fişierul de ieșire, pe linii distincte, toate CNP-urile extrase din text. Dacă în fișierul de intrare nu se află niciun CNP, în fișierul de ieșire se va afișa numai valoarea 0.

==Date de intrare==
Fișierul de intrare cnp.in conține informațiile date.

==Date de ieșire==
Fișierul de ieșire cnp.out va conține CNP-urile determinate, câte unul pe o linie, sau valoarea 0 dacă în fișierul de intrare nu există CNP-uri.

==Exemplul 1==
;cnp.in
:Popescu Grigore, 14 ani, 1991212122334;
:Gigel Banu - 1031102453435, Bujorului 7;
:Dana Marin: 2690405358687, fara viza, 2450609987654 -
:Jane Doe

;cnp.out
:1991212122334
:1031102453435
:2690405358687
:2450609987654

==Exemplul 2==
;cnp.in
:Popescu Grigore, 14 ani, 1991212134;
:Gigel Banu - 103110245Bujorului 7;
:Dana Marin: 269-04-05-358687, fara viza, 2+450609+987654 -
:Jane Doe

;cnp.out
:Date invalide: Nu exista CNP-uri valide in fisierul de intrare.

==Rezolvare==
<syntaxhighlight lang="python" line>
#1000 CNP
import re
import os

def extrage_cnp(text):
regex = r'\b\d{13}\b' # căutăm grupuri de exact 13 cifre
return re.findall(regex, text)

def verifica_date_intrare(nume_fisier):
if not os.path.exists(nume_fisier):
return False
if not os.path.isfile(nume_fisier):
return False
if not os.access(nume_fisier, os.R_OK):
return False
return True

def main():
nume_fisier_intrare = 'cnp.in'
nume_fisier_iesire = 'cnp.out'

if not verifica_date_intrare(nume_fisier_intrare):
with open(nume_fisier_iesire, 'w') as fout:
fout.write("Date invalide: Fisierul de intrare nu poate fi citit.")
return

# Verificare dacă fișierul de intrare este gol
if os.path.getsize(nume_fisier_intrare) == 0:
with open(nume_fisier_iesire, 'w') as fout:
fout.write("Date invalide: Fisierul de intrare este gol.")
return

with open(nume_fisier_intrare, 'r') as fin:
text = fin.read()

cnp_list = extrage_cnp(text)

if cnp_list:
with open(nume_fisier_iesire, 'w') as fout:
for cnp in cnp_list:
fout.write(cnp + '\n')
else:
with open(nume_fisier_iesire, 'w') as fout:
fout.write("Date invalide: Nu exista CNP-uri valide in fisierul de intrare.")

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

3345 - Divimax

2024-04-01T11:40:36Z

Cristina94: Pagină nouă: ==Enunț== Având note mici la matematică, Gicuţa primeşte spre rezolvare următoarea problemă (uşoară pentru clasa a X-a) pentru a-şi mări nota: “Dându-se un şir X cu N numere naturale nenule: X 1 , X 2,…., X N, să se determine cel mai mare divizor prim dintre toti divizorii tuturor numerelor din şirul X“. Însă, pentru a obţine nota 10, el mai are de rezolvat o cerinţă a problemei: să determine cel mai mare număr care se poate forma din concatenarea...

==Enunț==
Având note mici la matematică, Gicuţa primeşte spre rezolvare următoarea problemă (uşoară pentru clasa a X-a) pentru a-şi mări nota: “Dându-se un şir X cu N numere naturale nenule: X 1 , X 2,…., X N, să se determine cel mai mare divizor prim dintre toti divizorii tuturor numerelor din şirul X“.
Însă, pentru a obţine nota 10, el mai are de rezolvat o cerinţă a problemei: să determine cel mai mare număr care se poate forma din concatenarea divizorilor primi maximi ai fiecărui număr din şirul X.

==Cerința==
Scrieţi un program care să citească numărul natural N şi cele N numere naturale din şirul X şi care să determine:
1. numărul natural P reprezentând cel mai mare divizor prim dintre toţi divizorii tuturor numerelor din şirul X
2. cel mai mare număr natural K ce se poate forma din concatenarea divizorilor primi maximi ai fiecărui număr din şirul X.

==Date de intrare==
Fișierul de intrare divimax.in conține conţine N+1 linii. Pe prima linie sunt scrise doua numere naturale C și N, separate printr-un spațiu. Pe fiecare dintre următoarele N linii este scris câte un număr din şirului X, astfel încât pe linia i+1 din fişier este scris numărul Xi (1≤i≤N).

==Date de ieșire==
Fișierul de ieșire divimax.out va conține o linie.
- Dacă C=1, atunci se va rezolva doar cerința 1 a problemei, iar pe prima linie se va scrie numărul natural P reprezentând raspunsul la cerința 1.
- Dacă C=2, atunci se va rezolva doar cerința 2 a problemei, iar pe prima linie a fişierului se va scrie numărul natural K, reprezentând răspunsul la cerința 2.

==Restricții și precizări==
*0 ≤ N ≤ 3030, N număr natural
*C=1 sau C=2
*2 ≤ Xi ≤ 3500, unde 1 ≤ i ≤N
*Concatenarea a două numere inseamnă lipirea lor. (exemplu: Prin concatenarea numerelor 325 şi 684 rezultă numărul 325684, iar concatenându-le invers, obţinem 684325)
*Numărul determinat la cerinţa 2 poate avea cel mult 8000 de cifre
*Pentru rezolvarea corectă a cerinţei 1 se acordă 30% din punctaj, iar pentru rezolvarea corectă a cerinţei 2 se acordă 70% din punctaj.

==Exemplul 1==
;divimax.in
:1 5
:2
:36
:15
:12
:33

;divimax.out
:11

==Explicație==
C=1, se va rezolva doar cerinta 1.
Cel mai mare divizor prim al lui 2 este 2, cel mai mare divizor prim al lui 36 este 3, cel mai mare divizor prim al lui 15 este 5, cel mai mare divizor prim al lui 12 este 3, cel mai mare divizor al lui 33 este 11.

==Exemplul 2==
;divimax.in
:3 3
:8
:8
:4000

;divimax.out
:Date de intrare invalide!

==Rezolvare==
<syntaxhighlight lang="python" line>
#3345 divimax
def este_prim(numar):
if numar < 2:
return False
for i in range(2, int(numar ** 0.5) + 1):
if numar % i == 0:
return False
return True

def determina_divizori(numar):
divizori = []
for i in range(1, numar + 1):
if numar % i == 0:
divizori.append(i)
return divizori

def determina_cel_mai_mare_divizor_prim(lista_numere):
divizori_prim = []
for numar in lista_numere:
divizori = determina_divizori(numar)
for divizor in divizori:
if este_prim(divizor):
divizori_prim.append(divizor)
return max(divizori_prim)

def determina_cel_mai_mare_numar_concatenare(lista_numere):
divizori_prim = []
for numar in lista_numere:
divizori = determina_divizori(numar)
for divizor in divizori:
if este_prim(divizor):
divizori_prim.append(divizor)
divizori_prim.sort(reverse=True)
return int(''.join(map(str, divizori_prim)))

def verifica_date_intrare(C, N, numere):
if C not in [1, 2]:
return False
if not (0 <= N <= 3030):
return False
for numar in numere:
if not (2 <= numar <= 3500):
return False
return True

def main():
# Citire date de intrare
with open('divimax.in', 'r') as f:
C, N = map(int, f.readline().split())
numere = [int(f.readline()) for _ in range(N)]

# Verificare date de intrare
if not verifica_date_intrare(C, N, numere):
# Scriere mesaj de date invalide in fisierul de iesire
with open('divimax.out', 'w') as fout:
fout.write("Date de intrare invalide!")
return

# Calculare rezultat in functie de C
if C == 1:
P = determina_cel_mai_mare_divizor_prim(numere)
rezultat = P
elif C == 2:
K = determina_cel_mai_mare_numar_concatenare(numere)
rezultat = K

# Scriere rezultat in fisierul de iesire
with open('divimax.out', 'w') as f:
f.write(str(rezultat) + '\n')

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

4165 – FinserareKX

2024-04-01T10:47:44Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct Nod { int info; Nod *leg; }; în care câmpul info memorează un număr întreg, iar câmpul leg memorează adresa următorului element al listei. ==Cerinţa== Să se scrie o funcție C++ cu următorul prototip: void FInserareKX(Nod * &head, int k, int x); care, în lista pentru care primul element are...

==Enunţ==
Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos:

struct Nod
{
int info;
Nod *leg;
};

în care câmpul info memorează un număr întreg, iar câmpul leg memorează adresa următorului element al listei.

==Cerinţa==
Să se scrie o funcție C++ cu următorul prototip:

void FInserareKX(Nod * &head, int k, int x);

care, în lista pentru care primul element are adresa memorată în pointerul head, inserează pe poziția k un nou nod cu informația x. Dacă lista are mai puțin de k noduri, inserarea se face la sfârșitul listei, iar dacă k ≤ 1, atunci inserarea se va face la începutul listei. Lista poate fi inițial și vidă, caz în care head = NULL. De exemplu, dacă lista conține inițial informațiile 1, 2, 3, 4, 5, k = 3 și x = 100, atunci lista devine: 1, 2, 100, 3, 4, 5.

==Important==
Rezolvarea se va face în python.
Soluţia propusă va conţine definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line>
#4165 FInserareKX
class Node:
def __init__(self, info):
self.info = info
self.next = None

def FInserareKX(head, k, x):
new_node = Node(x)

# Cazul în care lista este inițial vidă sau inserăm la începutul listei
if head is None or k <= 1:
new_node.next = head
head = new_node
return head

# Cazul în care lista are cel puțin un nod și inserăm pe poziția k sau la sfârșitul listei
current = head
prev = None
count = 1

while current and count < k:
prev = current
current = current.next
count += 1

if current is None: # Inserare la sfârșitul listei
prev.next = new_node
else: # Inserare pe poziția k
new_node.next = current
prev.next = new_node

return head

# Funcție pentru afișarea listei
def afisare_lista(head):
current = head
while current:
print(current.info, end=" ")
current = current.next
print()

# Exemplu de utilizare
if __name__ == "__main__":
# Inițializare lista cu câteva noduri
head = Node(1)
head.next = Node(2)
head.next.next = Node(3)
head.next.next.next = Node(4)
head.next.next.next.next = Node(5)

# Inserare pe poziția k = 3 a valorii x = 100
head = FInserareKX(head, 3, 100)

# Afișare lista rezultată
afisare_lista(head)
</syntaxhighlight>

3676 - ABK1K2

2024-04-01T10:42:31Z

Cristina94: Pagină nouă: ==Cerința== Se dau patru numere naturale a, b, k1, k2. Determinați numărul de submulțimi formate din două elemente numere naturale x și y, cu x și y cuprinse între a și b, astfel încât cel mai mare divizor comun al lui x și y să fie multiplu de k1 sau multiplu de k2. ==Date de intrare== Fișierul de intrare conține patru numere, câte unul pe rând, în ordine: a, b, k1, k2 cu semnificația de mai sus. ==Date de ieșire== În fișierul de ieșire se va scrie p...

==Cerința==
Se dau patru numere naturale a, b, k1, k2. Determinați numărul de submulțimi formate din două elemente
numere naturale x și y, cu x și y cuprinse între a și b, astfel încât cel mai mare divizor comun al lui x și y să fie multiplu de k1 sau multiplu de k2.

==Date de intrare==
Fișierul de intrare conține patru numere, câte unul pe rând, în ordine: a, b, k1, k2 cu semnificația de mai sus.

==Date de ieșire==
În fișierul de ieșire se va scrie pe prima linie valoarea cerută.

==Restricții și precizări==
*a și b sunt cuprinse între 1 și inclusiv 109, a ≤ b.
*k1 și k2 sunt cuprinse între 2 și 109 inclusiv.
*perechile pentru care avem x = y nu se numără.

==Exemplul 1==
;abk1k2.in
:4
:10
:2
:4

;abk1k2.out
:6

==Explicație==
Submulțimile care se numără sunt: 4, 6 4, 8 4, 10 6, 8 6, 10 8, 10.

==Exemplul 2==
;abk1k2.in
:10
:20
:3

;abk1k2.out
:Date invalide: Nu sunt suficiente date in fisierul de intrare

==Rezolvare==
<syntaxhighlight lang="python" line>
#3676 abk1k2
from math import gcd

def verificare_date_intrare(a, b, k1, k2):
# Verificăm dacă a și b sunt în intervalul specificat
if not (1 <= a <= b <= 10**9):
return False

# Verificăm dacă k1 și k2 sunt în intervalul specificat
if not (2 <= k1 <= 10**9 and 2 <= k2 <= 10**9):
return False

return True

def numar_submultimi(a, b, k1, k2):
if not verificare_date_intrare(a, b, k1, k2):
return "Date invalide: Parametrii introdusi sunt incorecti."

count = 0
for x in range(a, b + 1):
for y in range(x + 1, b + 1):
if gcd(x, y) % k1 == 0 or gcd(x, y) % k2 == 0:
count += 1
return count

def main():
# Citim datele de intrare
with open("abk1k2.in", "r") as f:
linii = f.readlines()

# Eliminăm liniile goale și spațiile suplimentare
linii = [linie.strip() for linie in linii if linie.strip()]

# Verificăm dacă avem suficiente linii pentru a extrage datele
if len(linii) != 4:
# Scriem mesaj de date invalide în fișierul de ieșire
with open("abk1k2.out", "w") as f:
f.write("Date invalide: Nu sunt suficiente date in fisierul de intrare")
return

# Extragem datele de intrare
a = int(linii[0])
b = int(linii[1])
k1 = int(linii[2])
k2 = int(linii[3])

# Calculăm numărul de submulțimi dorit
rezultat = numar_submultimi(a, b, k1, k2)

# Scriem rezultatul în fișierul de ieșire
with open("abk1k2.out", "w") as f:
f.write(str(rezultat))

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

3540 - Ambuscada

2024-04-01T10:32:12Z

Cristina94: Pagină nouă: ==Cerința== N soldați, numerotați de la 1 la N, sunt prinși într-o ambuscadă. Asupra lor se execută M atacuri de tun. Atacurile afectează nu doar un soldat, ci un interval de soldați, provocând fiecăruia dintre aceștia o anumită pierdere (damage). De exemplu, atacul (3,7,5) afectează soldații 3,4,5,6,7 cu 5 damage. La început, toți soldații au V vieți. Câți soldați rămân în viață după cele M atacuri? ==Date de intrare== Fișierul de intrare ambusc...

==Cerința==
N soldați, numerotați de la 1 la N, sunt prinși într-o ambuscadă. Asupra lor se execută M atacuri de tun. Atacurile afectează nu doar un soldat, ci un interval de soldați, provocând fiecăruia dintre aceștia o anumită pierdere (damage). De exemplu, atacul (3,7,5) afectează soldații 3,4,5,6,7 cu 5 damage. La început, toți soldații au V vieți. Câți soldați rămân în viață după cele M atacuri?

==Date de intrare==
Fișierul de intrare ambuscada.in conține pe prima linie numerele naturale N, M și V separate prin spații. Pe următoarele M linii se află câte 3 numere naturale i j k separate cu un spațiu, cu semnificația de mai sus.

==Date de ieșire==
Fișierul de ieșire ambuscada.out va conține un singur număr natural reprezentând numărul de soldați rămași în viață.

==Restricții și precizări==
*2 ≤ N ≤ 1.000.000.000, 1 ≤ M ≤ 100.000, 1 ≤ V ≤ 1.000.000.000
*In toate testele, 1 ≤ i ≤ j ≤ N, 1 ≤ k ≤ V
*Pentru teste în valoare de 30 de puncte, N<=100.000 și M<=50

==Exemplul 1==
;ambuscada.in
:6 4 10
:2 5 2
:1 3 7
:2 6 3
:3 5 6

;ambuscada.out
:2

==Explicație==
Inițial toți soldații aveau 10 vieți.
După prima tragere: 10 8 8 8 8 10
După a doua tragere: 3 1 1 8 8 10
După a treia tragere: 3 0 0 5 5 7
După a patra tragere: 3 0 0 0 0 7
In final, 2 soldați au rămas în viață: primul și ultimul.

==Exemplul 2==
;ambuscada.in
:5 2
:2 7 8
:1

;ambuscada.out
:Date invalide: Linia 1 nu contine suficiente valori

==Rezolvare==
<syntaxhighlight lang="python" line>
#3540 Ambuscada
def verificare_date_intrare(N, M, V, atacuri):
# Verificăm dacă N, M și V sunt în intervalul specificat
if not (2 <= N <= 1000000000 and 1 <= M <= 100000 and 1 <= V <= 1000000000):
return False

# Verificăm fiecare atac
for atac in atacuri:
i, j, k = atac
# Verificăm dacă i, j și k sunt în intervalul specificat
if not (1 <= i <= j <= N and 1 <= k <= V):
return False

return True

def soldati_ramasii(N, M, V, atacuri):
# Inițializăm un vector cu viețile soldaților
soldati = [V] * N

# Parcurgem fiecare atac și actualizăm starea soldaților afectați
for atac in atacuri:
i, j, k = atac
for index in range(i-1, j):
soldati[index] -= k

# Numărăm câți soldați au vieți pozitive și returnăm rezultatul
soldati_ramas = sum(1 for viata in soldati if viata > 0)
return soldati_ramas

def main():
# Citim datele de intrare din fișier
with open('ambuscada.in', 'r') as f:
linii = f.readlines()

# Verificăm dacă există suficiente linii în fișierul de intrare
if len(linii) < 2:
# Scriem mesaj de date invalide în fișierul de ieșire
with open('ambuscada.out', 'w') as f:
f.write("Date invalide: Nu sunt suficiente date in fisierul de intrare")
return

# Extragem N, M și V din prima linie
try:
N, M, V = map(int, linii[0].split())
except ValueError:
# Scriem mesaj de date invalide în fișierul de ieșire
with open('ambuscada.out', 'w') as f:
f.write("Date invalide: Linia 1 nu contine suficiente valori")
return

# Verificăm dacă există suficiente atacuri în fișierul de intrare
if len(linii) - 1 < M:
# Scriem mesaj de date invalide în fișierul de ieșire
with open('ambuscada.out', 'w') as f:
f.write("Date invalide: Nu sunt suficiente atacuri in fisierul de intrare")
return

# Citim atacurile
atacuri = [tuple(map(int, line.split())) for line in linii[1:M+1]]

# Verificăm datele de intrare
if not verificare_date_intrare(N, M, V, atacuri):
# Scriem mesaj de date invalide în fișierul de ieșire
with open('ambuscada.out', 'w') as f:
f.write("Datele de intrare sunt invalide")
return

# Calculăm numărul de soldați rămași în viață
soldati_ramas = soldati_ramasii(N, M, V, atacuri)

# Scriem rezultatul în fișierul de ieșire
with open('ambuscada.out', 'w') as f:
f.write(str(soldati_ramas))

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

2957 - Nests

2024-04-01T09:35:17Z

Cristina94: Pagină nouă: ==Enunţ== Pe vârfurile unui poligon regulat și-au făcut cuibul 𝑁 păsări. Cele 𝑁 vârfuri ale poligonului sunt numerotate cu numere de la 0 la 𝑁−1 în ordine sens trigonometric. Fiecare pasăre se găsește în câte un cuib. La un moment dat păsările își schimbe cuiburile. Se obține astfel o permutare (𝑐0 ,𝑐1 ,𝑐2 ,..., 𝑐𝑁−1) unde 𝑐𝑖 reprezintă cuibul în care s-a mutat pasărea care locuia inițial în cuibul 𝑖. Pentru ca toate...

==Enunţ==
Pe vârfurile unui poligon regulat și-au făcut cuibul 𝑁 păsări. Cele 𝑁 vârfuri ale poligonului sunt numerotate cu numere de la 0 la 𝑁−1 în ordine sens trigonometric. Fiecare pasăre se găsește în câte un cuib. La un moment dat păsările își schimbe cuiburile. Se obține astfel o permutare (𝑐0 ,𝑐1 ,𝑐2 ,..., 𝑐𝑁−1) unde 𝑐𝑖 reprezintă cuibul în care s-a mutat pasărea care locuia inițial în cuibul 𝑖. Pentru ca toate păsările sa depună același efort cuiburile vor fi alese astfel încât distanța între cuibul inițial 𝑖 și cel final 𝑐𝑖 să fie aceeași pentru toate cele 𝑁 păsări. Se consideră toate permutările (𝑐0 ,𝑐1 ,𝑐2 ,..., 𝑐𝑁−1) obținute după mutarea păsărilor și se ordonează lexicografic.

==Cerința==
Scrieți un program citește două numere naturale 𝑁 și 𝐾 și care afișează permutarea situată pe poziția 𝐾 în ordine lexicografică după ordonarea permutărilor obținute prin mutarea păsărilor. ATENȚIE: numărul K va fi dat în baza 2.

==Date de intrare==
De la intrarea standard se va citi de pe prima linie numărul 𝑁 și de pe a doua linie un șir de valori 0 sau 1 neseparate prin spatii reprezentând cifrele numărului K scris în baza 2.

==Date de ieșire==
La ieșirea standard vor fi afișate N numere întregi distincte, separate prin câte un spațiu, cu valori între 0 și 𝑁−1, reprezentând permutarea situată pe poziția 𝐾 în ordine lexicografică între toate permutările posibile obținute după mutarea păsărilor.

==Restricții și precizări==
*1 ≤ N ≤ 1.000.000
*Se asigură că pentru N dat există cel puțin K posibilități pentru mutarea păsărilor.

==Exemplul 1==
;Intrare
:4
:101

;Ieșire
:0 3 2 1

==Exemplul 2==
;Intrare
:-5
:101

;Ieșire
:Date invalide: N trebuie să fie un număr natural între 1 și 1.000.000

==Rezolvare==
<syntaxhighlight lang="python" line>
#2957 nests
def nth_lexicographic_permutation(N, K):
# Convertim numărul K din baza 2 în baza 10
K_base10 = int(K, 2)

# Inițializăm permutarea cu cifrele de la 0 la N-1
permutation = list(range(N))

# Algoritmul lui Narayana pentru generarea permutărilor lexicografice
for _ in range(K_base10):
i = N - 2
while i >= 0 and permutation[i] > permutation[i + 1]:
i -= 1

j = N - 1
while permutation[j] < permutation[i]:
j -= 1

permutation[i], permutation[j] = permutation[j], permutation[i]
permutation[i + 1:] = reversed(permutation[i + 1:])

return permutation

def validate_input(N, K):
try:
N = int(N)
if not 1 <= N <= 1000000:
raise ValueError("N trebuie să fie între 1 și 1.000.000")
except ValueError:
return False, "N trebuie să fie un număr natural între 1 și 1.000.000"

if not K.isdigit() or set(K) - {'0', '1'}:
return False, "K trebuie să fie un număr în baza 2"

return True, ""

def main():
# Citirea datelor de intrare
N = input("Introduceți numărul N: ")
K = input("Introduceți numărul K în baza 2: ").strip()

# Validarea datelor de intrare
is_valid, error_message = validate_input(N, K)
if not is_valid:
print("Date invalide:", error_message)
return

# Generarea permutării și afișarea ei
result = nth_lexicographic_permutation(int(N), K)
print("Permutarea lexicografică corespunzătoare poziției K:", ' '.join(map(str, result)))

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

2556 - HN

2024-04-01T09:18:52Z

Cristina94: Pagină nouă: ==Enunţ== Fie N un număr natural și expresia HN=1+1/2+1/3+…+1/N. ==Cerința== Determinați numerele naturale P și Q ce reprezintă numărătorul respectiv numitorul fracției ireductibile HN=P/Q. ==Date de intrare== Fișierul de intrare hn.in conţine pe prima linie numărul natural N. ==Date de ieșire== Fișierul de ieșire hn.out va conţine pe prima linie numărul P și pe a doua linie numărul Q. ==Restricții și precizări== *2 ≤ N ≤ 10000 ==Exemplul 1==...

==Enunţ==
Fie N un număr natural și expresia HN=1+1/2+1/3+…+1/N.

==Cerința==
Determinați numerele naturale P și Q ce reprezintă numărătorul respectiv numitorul fracției ireductibile HN=P/Q.

==Date de intrare==
Fișierul de intrare hn.in conţine pe prima linie numărul natural N.

==Date de ieșire==
Fișierul de ieșire hn.out va conţine pe prima linie numărul P și pe a doua linie numărul Q.

==Restricții și precizări==
*2 ≤ N ≤ 10000

==Exemplul 1==
;hn.in
:6

;hn.out
:49
:20

==Exemplul 2==
;hn.in
:20

;hn.out
:55835135
:15519504

==Exemplul 3==
;hn.in
:-10

;hn.out
:Date de intrare invalide!

==Rezolvare==
<syntaxhighlight lang="python" line>
#2556 hn
def gcd(a, b):
while b:
a, b = b, a % b
return a

def simplify_fraction(num, denom):
divisor = gcd(num, denom)
return num // divisor, denom // divisor

def calculate_harmonic_fraction(N):
numerator = 0
denominator = 1
for i in range(1, N + 1):
numerator = numerator * i + denominator
denominator *= i
return numerator, denominator

def validate_input(N):
if not (isinstance(N, int) and 2 <= N <= 10000):
with open('hn.out', 'w') as f:
f.write("Date de intrare invalide!")
return False
return True

def main():
try:
# Citirea datelor din fișierul de intrare
with open('hn.in', 'r') as f:
N = int(f.readline().strip())
except FileNotFoundError:
with open('hn.out', 'w') as f:
f.write("Fisierul de intrare nu a fost gasit.")
return
except ValueError:
with open('hn.out', 'w') as f:
f.write("Date de intrare invalide!")
return

# Validarea datelor de intrare
if not validate_input(N):
return

# Calcularea fractiei armonice si simplificarea ei
numerator, denominator = calculate_harmonic_fraction(N)
numerator, denominator = simplify_fraction(numerator, denominator)

# Scrierea rezultatului in fisierul de iesire
with open('hn.out', 'w') as f:
f.write(str(numerator) + '\n')
f.write(str(denominator))

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

2100 - Prod Nr

2024-04-01T07:00:56Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o succesiune de numere naturale a[1] a[2] ... a[N]. Cu aceste numere se construieşte un şir de caractere astfel: pentru fiecare număr a[i] din şir (i=1, 2, ..., N) se scrie mai întâi numărul de cifre ale lui a[i], apoi cifrele lui a[i]. ==Cerința== Scrieţi un program care pe baza şirului de caractere să determine câte numere sunt în succesiune, precum şi descompunerea în factori primi a produsului numerelor din succesiune. ==Date de i...

==Enunţ==
Se consideră o succesiune de numere naturale a[1] a[2] ... a[N]. Cu aceste numere se construieşte un şir de caractere astfel: pentru fiecare număr a[i] din şir (i=1, 2, ..., N) se scrie mai întâi numărul de cifre ale lui a[i], apoi cifrele lui a[i].

==Cerința==
Scrieţi un program care pe baza şirului de caractere să determine câte numere sunt în succesiune, precum şi descompunerea în factori primi a produsului numerelor din succesiune.

==Date de intrare==
Fişierul de intrare prodnr.in conţine pe prima linie şirul de caractere.

==Date de ieșire==
Fişierul de ieşire prodnr.out va conţine pe prima linie numărul natural N, reprezentând numărul de numere din succesiune. Pe următoarele linii va fi scrisă descompunerea în factori primi a produsului celor N numere din succesiune. Pe fiecare linie vor fi scrise două numere naturale separate printr-un singur spaţiu f m, unde f reprezintă factorul prim, iar m multiplicitatea acestuia în produs. Factorii primi vor fi afişaţi în fişier în ordine strict crescătoare.

==Restricții și precizări==
*Lungimea şirului este de cel mult 30.000;
*Numerele din succesiune sunt nenule şi au cel mult 5 cifre.
*Produsul numerelor este strict mai mare decât 1.

==Exemplu 1==
;prodnr.in
:410242253100213235

;prodnr.out
:5
:2 12
:5 5
:7 1
:13 1

==Explicație==
Numerele sunt: 1024 25 100 13 35

==Exemplu 2==
;prodnr.in
:12a34b

;prodnr.out
:Date de intrare invalide!

==Rezolvare==
<syntaxhighlight lang="python" line>
#2100 ProdNr
def descompunere_in_factori_primi(n):
factori = {}
divizor = 2
while n > 1:
if n % divizor == 0:
if divizor not in factori:
factori[divizor] = 1
else:
factori[divizor] += 1
n //= divizor
else:
divizor += 1
return factori

def verifica_date_intrare(sir):
if not sir:
return False
for caracter in sir:
if not caracter.isdigit():
return False
return True

def main():
# Citirea şirului de caractere
with open("prodnr.in", "r") as fin:
sir = fin.readline().strip()

# Verificarea datelor de intrare
if not verifica_date_intrare(sir):
# Scrierea mesajului de date invalide în fișierul de ieșire
with open("prodnr.out", "w") as fout:
fout.write("Date de intrare invalide!")
return

# Extrage numerele din şir
numere = []
i = 0
while i < len(sir):
lungime_numar = int(sir[i])
numar = int(sir[i + 1:i + 1 + lungime_numar])
numere.append(numar)
i += 1 + lungime_numar

# Calculul numărului de numere din succesiune
N = len(numere)

# Calculul produsului numerelor din succesiune
produs = 1
for numar in numere:
produs *= numar

# Calculul descompunerii în factori primi a produsului
descompunere = descompunere_in_factori_primi(produs)

# Scrierea rezultatelor în fișierul de ieșire
with open("prodnr.out", "w") as fout:
# Scrierea numărului de numere din succesiune
fout.write(str(N) + "\n")
# Scrierea descompunerii în factori primi
for factor, multiplicitate in descompunere.items():
fout.write(f"{factor} {multiplicitate}\n")

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

1172 – FListă Numărare

2024-04-01T06:52:52Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct nod{ int info; nod * urm; }; în care câmpul info memorează un număr întreg, iar câmpul urm memorează adresa următorului element al listei. ==Cerinţa== Să se scrie o funcție C++ cu următorul prototip: int numarare(nod * p); care determina și returnează numărul de elemente memorate în lista pe...

1789 - 3 Secv

2024-04-01T05:58:06Z

Cristina94: Pagină nouă: ==Cerința== Se consideră un șir de n elemente numere naturale. O subsecvență se definește ca o succesiune de elemente ale șirului luate de pe poziții consecutive. De exemplu şirul 1 4 3 5 are 10 subsecvenţe: *4 subsecvențe de lungime 1 **1 **4 **3 **5 *3 subsecvențe de lungime 2 **1 4 **4 3 **3 5 *2 subsecvențe de lungime 3 **1 4 3 **4 3 5 *1 subsecvenţă de lungime 4 **1 4 3 5 Să se scrie un program care pentru un şir cunoscut determină pentru câte subsec...

==Cerința==
Se consideră un șir de n elemente numere naturale. O subsecvență se definește ca o succesiune de elemente ale șirului luate de pe poziții consecutive.

De exemplu şirul 1 4 3 5 are 10 subsecvenţe:

*4 subsecvențe de lungime 1
**1
**4
**3
**5
*3 subsecvențe de lungime 2
**1 4
**4 3
**3 5
*2 subsecvențe de lungime 3
**1 4 3
**4 3 5
*1 subsecvenţă de lungime 4
**1 4 3 5
Să se scrie un program care pentru un şir cunoscut determină pentru câte subsecvenţe ale şirului suma elementelor care le alcătuiesc are un anumit rest dat la împărţirea cu 3.

==Date de intrare==
Fișierul de intrare 3secv.in conține pe prima linie două numere naturale n şi r, separate prin spaţiu, n reprezentând numărul de elemente din şirul dat, iar r reprezentând restul pentru care trebuie rezolvată cerinţa. Pe linia a doua vor fi n numere naturale separate prin câte un spaţiu, reprezentând elementele şirului dat.

==Date de ieșire==
Fișierul de ieșire 3secv.out va conține pe prima linie un număr natural reprezentând numărul de subsecvențe ale șirului pentru care suma elementelor dă restul r la împărțirea cu 3.

==Restricții și precizări==
*1 ≤ n ≤ 1.000.000
*r ∈ {0,1,2}
*Elementele șirului sunt numere naturale mai mici sau egale cu 32767

==Exemplul 1==
;3secv.in
:4 0
:1 4 3 5

;3secv.out
:2

==Exemplul 2==
;3secv.in
:4 1
:1 4 3 5

;3secv.out
:4

==Exemplul 3==
;3secv.in
:4 2
:1 4 3 5

;3secv.out
:4

==Exemplul 4==
;3secv.in
:1000001 1
:1 2 3 4 5 6 1000001

;3secv.out
:Date de intrare invalide.

==Rezolvare==
<syntaxhighlight lang="python" line>
#1789 3secv
def is_valid_input(n, r, arr):
# Verificăm dacă n și r sunt în limitele impuse
if not (1 <= n <= 1000000 and r in {0, 1, 2}):
return False
# Verificăm dacă toate elementele din șir sunt numere naturale mai mici sau egale cu 32767
if any(not (1 <= x <= 32767) for x in arr):
return False
return True

def count_subsequences(n, arr, r):
count = 0
for i in range(n):
for j in range(i, n):
subsequence_sum = sum(arr[i:j+1])
if subsequence_sum % 3 == r:
count += 1
return count

def main():
# Citirea datelor de intrare
with open("3secv.in", "r") as fin:
n, r = map(int, fin.readline().split())
arr = list(map(int, fin.readline().split()))

# Verificarea datelor de intrare
if not is_valid_input(n, r, arr):
# Scrierea mesajului de date invalide în fișierul de ieșire
with open("3secv.out", "w") as fout:
fout.write("Date de intrare invalide.\n")
return

# Calculul numărului de subsecvențe cu suma dată prin restul r la împărțirea cu 3
result = count_subsequences(n, arr, r)

# Scrierea rezultatului în fișierul de ieșire
with open("3secv.out", "w") as fout:
fout.write(str(result) + "\n")

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

3789 – FListă Oglindire

2024-04-01T05:05:29Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct nod{ int info; nod * urm; }; în care câmpul info memorează un număr întreg, iar câmpul urm memorează adresa următorului element al listei. ==Cerinţa== Să se scrie o funcție C++ cu următorul prototip: void oglindire(nod * & p); care oglindește nodurile din lista pentru care primul element are ad...

1226 - Nebuni

2024-04-01T04:55:55Z

Cristina94: Pagină nouă: ==Enunţ== Pe o tablă de şah cu N linii şi N coloane sunt plasaţi M nebuni. După cum se ştie de la jocul de şah, nebunii atacă doar în diagonală. O poziţie de pe tabla de şah este considerată sigură dacă nu este atacată de niciun nebun aflat pe tablă. ==Cerinţă== Scrieţi un program care să determine numărul de poziţii sigure de pe tabla de şah. ==Date de intrare== Fișierul de intrare nebuni.in conține pe prima linie numerele naturale N M, separate...

==Enunţ==
Pe o tablă de şah cu N linii şi N coloane sunt plasaţi M nebuni. După cum se ştie de la jocul de şah, nebunii atacă doar în diagonală.

O poziţie de pe tabla de şah este considerată sigură dacă nu este atacată de niciun nebun aflat pe tablă.

==Cerinţă==
Scrieţi un program care să determine numărul de poziţii sigure de pe tabla de şah.

==Date de intrare==
Fișierul de intrare nebuni.in conține pe prima linie numerele naturale N M, separate prin spaţiu, cu semnificaţia din enunţ. Pe următoarele M linii sunt descrise poziţiile (linia şi coloana, separate prin spaţiu) celor M nebuni, câte un nebun pe o linie a fişierului.

==Date de ieșire==
Fișierul de ieșire nebuni.out va conține o singură linie pe care va fi scris un număr natural reprezentând numărul de poziţii sigure de pe tabla de şah.

==Restricții și precizări==
1 ≤ N ≤ 1 000 000
1 ≤ M < 16 500
Liniile şi coloanele sunt numerotate de la 1 la N.
Pentru 50% dintre teste N ≤ 300.
Pentru 60% dintre teste M ≤ 1000.

==Exemplu 1==
;nebuni.in
:5 4
:2 1
:1 3
:4 2
:5 2

;nebuni.out
:6

==Exemplu 2==
;nebuni.in
:10 3
:1 1
:15 8
:5 12

;nebuni.out
:Date de intrare invalide.

==Rezolvare==
<syntaxhighlight lang="python" line>
#1226 Nebuni
def verificare_date_intrare(N, M, nebuni):
if not (1 <= N <= 1000000):
return False
if not (1 <= M < 16500):
return False
for x, y in nebuni:
if not (1 <= x <= N and 1 <= y <= N):
return False
return True

def numar_pozitii_sigure(N, M, nebuni):
# Inițializăm o matrice pentru tabla de șah și o marcam pe toate pozițiile atacate de nebuni
tabla = [[False] * N for _ in range(N)]
for x, y in nebuni:
for i in range(N):
for j in range(N):
if abs(x - i) == abs(y - j):
tabla[i][j] = True

# Numărăm pozițiile sigure care nu sunt atacate de niciun nebun
numar_pozitii_sigure = 0
for i in range(N):
for j in range(N):
if not tabla[i][j]:
numar_pozitii_sigure += 1

return numar_pozitii_sigure

def main():
# Citim datele de intrare
try:
with open("nebuni.in", "r") as fin:
N, M = map(int, fin.readline().split())
nebuni = [tuple(map(int, line.split())) for line in fin]
except ValueError:
# Date invalide
with open("nebuni.out", "w") as fout:
fout.write("Date invalide\n")
return

# Verificăm datele de intrare
if not verificare_date_intrare(N, M, nebuni):
with open("nebuni.out", "w") as fout:
fout.write("Date de intrare invalide.\n")
return

# Determinăm numărul de poziții sigure
rezultat = numar_pozitii_sigure(N, M, nebuni)

# Scriem rezultatul în fișierul de ieșire
with open("nebuni.out", "w") as fout:
fout.write(str(rezultat) + "\n")

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

2449 - PM

2024-04-01T04:29:36Z

Cristina94: Pagină nouă: ==Enunţ== Vom numi secvenţă PM o succesiune formată din plus şi minus, care NU conţine două semne minus alăturate. De exemplu, există 5 secvenţe PM de lungime 3: + + + , + + - , + - + , - + + , - + -. ==Cerința== Să se determine numărul de secvenţe PM care conţin x semne plus şi y semne minus. ==Date de intrare== Fişierul de intrare pm.in conţine pe prima linie două numere naturale separate prin spaţiu x, y, cu semnificaţia din enunţ. ==Date de ieșir...

==Enunţ==
Vom numi secvenţă PM o succesiune formată din plus şi minus, care NU conţine două semne minus alăturate.
De exemplu, există 5 secvenţe PM de lungime 3: + + + , + + - , + - + , - + + , - + -.

==Cerința==
Să se determine numărul de secvenţe PM care conţin x semne plus şi y semne minus.

==Date de intrare==
Fişierul de intrare pm.in conţine pe prima linie două numere naturale separate prin spaţiu x, y, cu semnificaţia din enunţ.

==Date de ieșire==
Fişierul de ieşire pm.out va conţine o singură linie pe care va fi scris un singur număr natural, reprezentând numărul de secvenţe PM care conţin x semne plus şi y semne minus.

==Restricții și precizări==
*0 ≤ y ≤ x ≤ 250
*Rezultatul va avea maxim 100 cifre.
*Pentru 50% din testele de evaluare, x < 32.
*10% din punctaj se va acorda pe exemple.

==Exemplu 1==
;pm.in
:2 1

;pm.out
:3

==Exemplu 2==
;pm.in
:300 200

;pm.out
:Date de intrare invalide.

==Rezolvare==
<syntaxhighlight lang="python" line>
#2449 PM
def verificare_date_intrare(x, y):
if not (0 <= y <= x <= 250):
return False
return True

def numar_secvente_PM(x, y):
if not verificare_date_intrare(x, y):
return "Date de intrare invalide."

dp = [[0] * (y + 1) for _ in range(x + 1)]
dp[0][0] = 1

for i in range(1, x + 1):
for j in range(min(i, y) + 1):
if j == 0:
dp[i][j] = dp[i - 1][j]
else:
dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1]

numar_total = sum(dp[x])

return numar_total

def main():
with open("pm.in", "r") as fin:
x, y = map(int, fin.readline().split())

rezultat = numar_secvente_PM(x, y)

with open("pm.out", "w") as fout:
fout.write(str(rezultat) + "\n")

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

1686 - Leduri

2024-04-01T04:14:16Z

Cristina94: Pagină nouă: ==Enunţ== Am un cablu cu N leduri (numerotate de la 1 la N) aşezate echidistant. Inițial, unele leduri sunt aprinse, iar altele sunt stinse. Ledurile sunt legate între ele astfel încât atingerea fiecărui led produce modificarea atât a stării lui, cât şi a ledurilor vecine lui. Deci, dacă se atinge ledul i (2≤i≤N-1) atunci se modifică stările ledurilor i-1, i și i+1. Dacă se atinge ledul 1, atunci se modifică stările ledurilor 1 și 2, iar dacă se atinge...

==Enunţ==
Am un cablu cu N leduri (numerotate de la 1 la N) aşezate echidistant. Inițial, unele leduri sunt aprinse, iar altele sunt stinse. Ledurile sunt legate între ele astfel încât atingerea fiecărui led produce modificarea atât a stării lui, cât şi a ledurilor vecine lui. Deci, dacă se atinge ledul i (2≤i≤N-1) atunci se modifică stările ledurilor i-1, i și i+1. Dacă se atinge ledul 1, atunci se modifică stările ledurilor 1 și 2, iar dacă se atinge ledul N, atunci se modifică stările ledurilor N-1 și N. Vreau să modific starea ledurilor astfel încât să semene cu cablul cu N leduri pe care îl are Ionuț, prietenul meu (două cabluri seamănă dacă pentru orice i=1..N stările ledurilor de pe poziția i sunt identice).

==Cerința==
Cunoscând cum arată cablul lui Ionuț, ajutați-mă să determin numărul minim de atingeri ale unor leduri astfel încât cablul meu să arate ca și cablul lui Ionuț.

==Date de intrare==
Fișierul de intrare leduri.in conține pe prima linie numărul natural N. Pe a doua linie sunt N cifre binare separate prin câte un spațiu reprezentând stările ledurilor de pe cablul meu. Cifra de pe poziția i este 0 dacă ledul i este stins, respectiv este 1 dacă ledul i este aprins (i=1..N). Pe a treia linie sunt N cifre binare separate prin câte un spațiu, reprezentând stările ledurilor de pe cablul lui Ionuț.

==Date de ieșire==
Fișierul de ieșire leduri.out va conține pe prima linie un singur număr natural reprezentând numărul minim de atingeri ale unor leduri astfel încât cablul meu să arate ca și cablul lui Ionuț.

==Restricții și precizări==
*1 ≤ N ≤ 100000
*Se garantează că pentru toate testele există soluție.
*Pentru teste valorând 30 de puncte, N va fi cel mult 20

==Exemplu1==
;leduri.in
:4
:1 0 1 0
:0 1 1 1

;leduri.out
:2

==Exemplu2==
;leduri.in
:5
:1 0 1 1
:1 0 1 1

;leduri.out
:Date de intrare invalide.

==Rezolvare==
<syntaxhighlight lang="python" line>
#1686 Leduri
def verificare_date_intrare(N, starea_mea, starea_ionut):
if not (1 <= N <= 100000):
return False
if len(starea_mea) != N or len(starea_ionut) != N:
return False
for bit in starea_mea:
if bit not in {0, 1}:
return False
for bit in starea_ionut:
if bit not in {0, 1}:
return False
return True

def numar_minim_atingeri(N, starea_mea, starea_ionut):
atingeri = 0
for i in range(N):
if starea_mea[i] != starea_ionut[i]:
atingeri += 1
if i > 0:
starea_mea[i - 1] = 1 - starea_mea[i - 1]
if i < N - 1:
starea_mea[i + 1] = 1 - starea_mea[i + 1]
return atingeri

def main():
with open("leduri.in", "r") as fin:
N = int(fin.readline())
starea_mea = list(map(int, fin.readline().split()))
starea_ionut = list(map(int, fin.readline().split()))

if not verificare_date_intrare(N, starea_mea, starea_ionut):
with open("leduri.out", "w") as fout:
fout.write("Date de intrare invalide.\n")
return

numar_atingeri = numar_minim_atingeri(N, starea_mea, starea_ionut)

with open("leduri.out", "w") as fout:
fout.write(str(numar_atingeri) + "\n")

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

1171 – FȘterge Primul Din Listă

2024-04-01T04:00:22Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct nod{ int info; nod * urm; }; în care câmpul info memorează un număr întreg, iar câmpul urm memorează adresa următorului element al listei. ==Cerinţa== Să se scrie o funcție C++ cu următorul prototip: void stergePrimul(nod * & p); care șterge primul element al unei liste; pointerul p are ca valo...

1181 – FListă Interclasare2

2024-04-01T03:35:03Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct nod{ int info; nod * urm; }; în care câmpul info memorează un număr natural, iar câmpul urm memorează adresa următorului element al listei. ==Cerinţa== Să se scrie o funcție C++ cu următorul prototip: void inserare(nod * p); care inserează după fiecare element par al unei liste pentru care prim...

1182 – FListă Interclasare3

2024-03-29T05:13:32Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct nod{ int info; nod * urm; }; în care câmpul info memorează un număr natural, iar câmpul urm memorează adresa următorului element al listei. ==Cerinţa== Să se scrie o funcție C++ cu următorul prototip: void inserare(nod * & p); care inserează înaintea fiecărui element par al unei liste pentru...

2563 – FAdCresc

2024-03-29T04:47:45Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct nod{ int info; nod * urm; }; în care câmpul info memorează un număr întreg, iar câmpul urm memorează adresa următorului element al listei. Informațiile din listă sunt ordonate crescător. ==Cerința== Să se scrie o funcție C++ cu următorul prototip: void ins_cresc(nod *&p, int x); care ins...

==Enunţ==
Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos:

struct nod{
int info;
nod * urm;
};

în care câmpul info memorează un număr întreg, iar câmpul urm memorează adresa următorului element al listei.

Informațiile din listă sunt ordonate crescător.

==Cerința==
Să se scrie o funcție C++ cu următorul prototip:

void ins_cresc(nod *&p, int x);

care inserează în listă un nou nod care memorează valoarea x astfel încât informațiile din lista să fie în continuare ordonate crescător; pointerul p are ca valoarea adresa primului element din listă.

==Restricții și precizări==
*numele funcției va fi ins_cresc.
*lista conține inițial cel puțin un nod.
*rezolvarea problemei se va face în ptyhon

==Important==
Soluţia propusă va conţine definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line>
#2563 FAdCresc
class Node:
def __init__(self, info):
self.info = info
self.next = None

def ins_cresc(p, x):
new_node = Node(x)

# Dacă lista este goală sau noul nod trebuie inserat înaintea primului nod
if p is None or x < p.info:
new_node.next = p
p = new_node
return p

# Parcurgem lista până găsim locul corect pentru inserare
current = p
while current.next is not None and current.next.info < x:
current = current.next

# Inserăm noul nod între current și current.next
new_node.next = current.next
current.next = new_node

return p

# Funcție pentru afișarea listei
def print_list(p):
current = p
while current is not None:
print(current.info, end=" ")
current = current.next
print()

# Funcție pentru crearea listei inițiale
def create_list(values):
if not values:
return None

p = Node(values[0])
current = p
for val in values[1:]:
current.next = Node(val)
current = current.next

return p

# Funcție pentru afișarea listei în ordine crescătoare
def print_list_sorted(p):
# Creează o listă pentru a stoca valorile din listă
values = []
current = p
while current is not None:
values.append(current.info)
current = current.next

# Sortează valorile
values.sort()

# Afișează valorile sortate
for val in values:
print(val, end=" ")
print()

if __name__ == "__main__":
# Cream lista de test
values = [2, 4, 8, 6, 1, 0]
p = create_list(values)

# Afisam lista in ordine crescatoare
print("Lista creata:")
print_list_sorted(p)
</syntaxhighlight>

1476 – FSortare

2024-03-29T04:35:34Z

==Enunţ==
Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos:

struct nod{
int info;
nod *urm;
};

în care câmpul info memorează un număr întreg, iar câmpul urm memorează adresa următorului element al listei.

==Cerința==
Să se scrie o funcție C++ cu următorul prototip:

void sortareCrescator(nod *&prim)

care sortează crescător elementele listei al cărei prim element are adresa memorată în prim.

==Restricții și precizări==
*numele funcției va fi sortareCrescator
*lista va conține cel puțin 3 elemente
*rezolvarea se va face in python

==Exemplu==
Dacă lista este formată din valorile (5, 3, 9, 4, 2, 12), după apelul funcţiei ea va conţine elementele (2, 3, 4, 5, 9, 12).

==Rezolvare==
<syntaxhighlight lang="python" line>
#1476 FSortare
class Node:
def __init__(self, info):
self.info = info
self.next = None

def create_linked_list(values):
head = None
tail = None
for value in values:
new_node = Node(value)
if head is None:
head = new_node
tail = new_node
else:
tail.next = new_node
tail = new_node
return head

def sortareCrescator(prim):
# Funcție pentru inserarea unui nod într-o listă sortată
def insert_sorted(head, new_node):
if head is None or head.info >= new_node.info:
new_node.next = head
return new_node

current = head
while current.next is not None and current.next.info < new_node.info:
current = current.next

new_node.next = current.next
current.next = new_node
return head

# Inițializăm lista sortată ca fiind lista vidă
sorted_list = None
current = prim

# Parcurgem lista inițială și inserăm fiecare nod în lista sortată
while current is not None:
sorted_list = insert_sorted(sorted_list, Node(current.info))
current = current.next

# Copiem lista sortată înapoi în lista inițială
current = prim
sorted_current = sorted_list
while sorted_current is not None:
current.info = sorted_current.info
current = current.next
sorted_current = sorted_current.next

# Testăm funcția
def print_list(head):
current = head
while current is not None:
print(current.info, end=" ")
current = current.next
print()

# Cream lista de test folosind funcția create_linked_list
values = [5, 3, 9, 4, 2, 12]
l = create_linked_list(values)

print("Lista initiala:")
print_list(l)

# Sortam lista
sortareCrescator(l)

print("Lista sortata:")
print_list(l)
</syntaxhighlight>

3527 – FȘterge Duplicate

2024-03-29T04:23:07Z

Cristina94: /* Rezolvare */

==Enunţ==
Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos:

struct Nod{
int val;
Nod *next;
};

în care câmpul val memorează un număr întreg, iar câmpul next memorează adresa următorului element al listei.

Valorile din listă sunt ordonate crescător.

==Cerința==
Să se scrie o funcție C++ cu următorul prototip:

void FStergeDuplicate(Nod *&L);
Funcția primește ca parametru un pointer L la o listă simplu înlănțuită care are valorile din noduri în ordine crescătoare. Funcția trebuie să elimine nodurile care conțin valori duplicate. De exemplu, dacă lista conține valorile 3,3,3,5,6,7,7,7,7,20, atunci după eliminarea duplicatelor, lista va conține 3,5,6,7,20.

==Restricții și precizări==
*numele funcției va fi FStergeDuplicate.

==Important==
Soluţia propusă va conţine definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.
Rezolvarea se va face în python.

==Enunţ==
Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos:

struct Nod{
int val;
Nod *next;
};

în care câmpul val memorează un număr întreg, iar câmpul next memorează adresa următorului element al listei.

Valorile din listă sunt ordonate crescător.

==Cerința==
Să se scrie o funcție C++ cu următorul prototip:

void FStergeDuplicate(Nod *&L);
Funcția primește ca parametru un pointer L la o listă simplu înlănțuită care are valorile din noduri în ordine crescătoare. Funcția trebuie să elimine nodurile care conțin valori duplicate. De exemplu, dacă lista conține valorile 3,3,3,5,6,7,7,7,7,20, atunci după eliminarea duplicatelor, lista va conține 3,5,6,7,20.

==Restricții și precizări==
*numele funcției va fi FStergeDuplicate.

==Important==
Soluţia propusă va conţine definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.
Rezolvarea se va face în python.

==Rezolvare==
<syntaxhighlight lang="python" line>
#3527 FStergeDuplicate
# Definim clasa pentru nodul unei liste liniare simplu înlănțuite
class Nod:
def __init__(self, val=0, next=None):
self.val = val
self.next = next

# Funcția care elimină duplicatele din lista
def FStergeDuplicate(L):
if L is None:
return

current = L
while current.next is not None:
if current.val == current.next.val:
next_next = current.next.next
current.next = None
current.next = next_next
else:
current = current.next

# Funcția care creează o listă liniară simplu înlănțuită pe baza unei liste de valori
def createLinkedList(values):
if not values:
return None

# Creăm primul nod al listei
head = Nod(values[0])
current = head

# Iterăm prin valorile date și le adăugăm ca noduri în listă
for val in values[1:]:
current.next = Nod(val)
current = current.next

return head

# Exemplu de utilizare
if __name__ == "__main__":
# Lista de valori din exemplu
values = [3, 3, 3, 5, 6, 7, 7, 7, 7, 20]

# Creăm lista liniară simplu înlănțuită
L = createLinkedList(values)

# Eliminăm duplicatele din lista
FStergeDuplicate(L)

# Afisam lista rezultata
current = L
while current is not None:
print(current.val, end=" ")
current = current.next
</syntaxhighlight>

3527 – FȘterge Duplicate

2024-03-29T04:21:58Z

Cristina94: Pagină nouă: ==Enunţ== Se consideră o listă liniară simplu înlănțuită, alocată dinamic, în care elementele sunt de tipul declarat mai jos: struct Nod{ int val; Nod *next; }; în care câmpul val memorează un număr întreg, iar câmpul next memorează adresa următorului element al listei. Valorile din listă sunt ordonate crescător. ==Cerința== Să se scrie o funcție C++ cu următorul prototip: void FStergeDuplicate(Nod *&L); Funcția primește ca p...

4094 - oneout

2024-03-28T11:05:43Z

Cristina94: Pagină nouă: ==Enunţ== Definim un număr liber de pătrate ca fiind un număr natural care nu are ca divizor niciun pătrat perfect mai mare ca 1. Prin convenție, 1 este considerat liber de pătrate. Așadar, șirul numerelor libere de pătrate este: 1,2,3,5,6,7,10,11,13,14,15,17, ... Se consideră un șir de N numere naturale X[i], 1 ≤ i ≤ N, unde N este un număr natural. O secvență este un subșir format din numere aflate pe poziții consecutive în șirul dat. Definim o bise...

==Enunţ==
Definim un număr liber de pătrate ca fiind un număr natural care nu are ca divizor niciun pătrat perfect mai mare ca 1. Prin convenție, 1 este considerat liber de pătrate.

Așadar, șirul numerelor libere de pătrate este: 1,2,3,5,6,7,10,11,13,14,15,17, ...

Se consideră un șir de N numere naturale X[i], 1 ≤ i ≤ N, unde N este un număr natural. O secvență este un subșir format din numere aflate pe poziții consecutive în șirul dat. Definim o bisecvență ca un subșir nevid obținut prin eliminarea dintr-o secvență a unui număr care nu este la începutul sau la sfârșitul secvenței.

==Cerința==
*1) Să se determine câte numere libere de pătrate conține șirul dat.
*2) Să se determine cea mai lungă bisecvență din șir formată din numere libere de pătrate, obținută prin eliminarea unui număr care nu este liber de pătrate.

==Date de intrare==
Fișierul de intrare oneout.in conține pe primul rând un număr natural C, care poate fi doar 1 sau 2, reprezentând cerința, pe a doua linie numărul natural N iar pe a treia linie N numere naturale, separate prin câte un spațiu, cu semnificația de mai sus.

==Date de ieșire==
Dacă C = 1, în fișierul de ieșire oneout.out se va scrie numărul de numere libere de pătrate din șir. Dacă C = 2:
:- pe prima linie a fișierului de ieșire oneout.out se vor scrie două numere L și K despărțite printr-un spațiu, unde L reprezintă lungimea maximă a unei bisecvențe cu proprietățile cerute, iar K reprezintă numărul de bisecvențe de lungime maximă existente în șir
:- pe următoarele K linii se vor scrie indicii de început și de sfârșit ai fiecărei bisecvențe de lungime maximă găsite, în ordinea crescătoare a indicelui de start, despărțite printr-un spațiu
:- dacă șirul nu conține nicio bisecvență cu proprietățile cerute, în fișierul de ieșire se va scrie -1.

==Restricții și precizări==
*3 ≤ N ≤ 1.000.000
*2 ≤ X[i] ≤ 1.000.000, 1 ≤ i ≤ N
*Lungimea unei bisecvențe reprezintă numărul de numere din aceasta.
*Datorită dimensiunilor prea mari ale testelor, s-au adăugat doar o parte din ele

==Exemplul 1==
;oneout.in
:1
:6
:10 2 12 7 8 15

;oneout.out
:4

==Exemplul 2==
;oneout.in
:0
:5
:10 20 30 40 50

;oneout.out
:Date de intrare invalide.

==Rezolvare==
<syntaxhighlight lang="python" line>
#4094 oneout
def is_square_free(num):
i = 2
while i * i <= num:
if num % (i * i) == 0:
return False
i += 1
return True

def count_square_free_numbers(numbers):
count = 0
for num in numbers:
if is_square_free(num):
count += 1
return count

def longest_square_free_bisect(numbers):
longest_length = 0
current_length = 0
max_length_count = 0
max_length_start = -1
max_length_end = -1
current_start = -1

for i, num in enumerate(numbers):
if is_square_free(num):
current_length += 1
if current_start == -1:
current_start = i
else:
if current_length > longest_length:
longest_length = current_length
max_length_count = 1
max_length_start = current_start
max_length_end = i - 1
elif current_length == longest_length:
max_length_count += 1
current_length = 0
current_start = -1

if current_length > longest_length:
longest_length = current_length
max_length_count = 1
max_length_start = current_start
max_length_end = len(numbers) - 1
elif current_length == longest_length:
max_length_count += 1

if longest_length == 0:
return -1
else:
return longest_length, max_length_count, max_length_start, max_length_end

def validate_input(C, N, numbers):
if C not in [1, 2]:
return False
if N < 3 or N > 1000000:
return False
if any(num < 2 or num > 1000000 for num in numbers):
return False
return True

def main():
with open("oneout.in", "r") as f_in:
C = int(f_in.readline().strip())
N = int(f_in.readline().strip())
numbers = list(map(int, f_in.readline().split()))

if not validate_input(C, N, numbers):
with open("oneout.out", "w") as f_out:
f_out.write("Date de intrare invalide.\n")
return

with open("oneout.out", "w") as f_out:
if C == 1:
result = count_square_free_numbers(numbers)
f_out.write(str(result) + "\n")
elif C == 2:
result = longest_square_free_bisect(numbers)
if result == -1:
f_out.write("-1\n")
else:
length, count, start, end = result
f_out.write(f"{length} {count}\n")
for i in range(count):
f_out.write(f"{start} {end}\n")
else:
f_out.write("Cerința introdusă nu este validă.\n")

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

3560 - Stampile

2024-03-28T10:50:45Z

Cristina94: Pagină nouă: ==Cerința== Pe fiecare din porțile celor n (n <= 100) case dintr-un sat se scrie câte un număr, prin aplicarea unor ștampile cu cifre. Exemplu: pentru a scrie numărul 3404 se vor aplica ștampilele 3 și 0 câte o dată și ștampila 4 de două ori. Se citesc n numere naturale (cele ce se scriu pe porți) și se cer următoarele: a) Care este ștampila cea mai puțin folosită? b) Care este ordinea celor 10 ștampile (cu cele 10 cifre), începând cu cea mai uzată ș...

==Cerința==
Pe fiecare din porțile celor n (n <= 100) case dintr-un sat se scrie câte un număr, prin aplicarea unor ștampile cu cifre. Exemplu: pentru a scrie numărul 3404 se vor aplica ștampilele 3 și 0 câte o dată și ștampila 4 de două ori.

Se citesc n numere naturale (cele ce se scriu pe porți) și se cer următoarele:

a) Care este ștampila cea mai puțin folosită?
b) Care este ordinea celor 10 ștampile (cu cele 10 cifre), începând cu cea mai uzată și terminând cu cea mai puțin folosită?
c) Care numere au folosit exact două ștampile?

==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații.

==Date de ieșire==
Programul va afișa pe prima linie cea mai puțin uzată ștampilă, cu numărul cel mai mic. Pe a doua linie ordinea celor 10 ștampile, începând cu cea mai uzată și terminând cu cea mai puțin folosită. Pe treia linie se vor numerele care au folosit exact doua ștampile, în ordine crescătoare sau numărul -1, dacă nu există.

==Restricții și precizări==
1 ≤ n ≤ 100
Pentru a doua cerintă, dacă există mai multe ștampile care sunt la fel de uzate, atunci ele se vor afișa în ordinea descrescătoare a numărului lor.
Cele n numere citite vor fi cuprinse între 1 și 99999

==Exemplu1==
;Intrare
:7
:36411 78978 7824 33 6200 200 5

;Ieșire
:9
:0 2 3 7 8 1 4 6 5 9
:200

==Exemplu2==
;Intrare
:101
:36411 78978 7824 33 6200 200 5

;Ieșire
:Date de intrare invalide!

==Rezolvare==
<syntaxhighlight lang="python" line>
#3560 Stampile
def least_used_stamp(numbers):
stamps_freq = {}
for num in numbers:
for digit in str(num):
stamps_freq[digit] = stamps_freq.get(digit, 0) + 1

least_used = min(stamps_freq, key=stamps_freq.get)
return least_used

def stamps_order(numbers):
stamps_freq = {}
for num in numbers:
for digit in str(num):
stamps_freq[digit] = stamps_freq.get(digit, 0) + 1

sorted_stamps = sorted(stamps_freq, key=lambda x: (-stamps_freq[x], int(x)))
return sorted_stamps

def numbers_with_two_stamps(numbers):
result = []
for num in numbers:
distinct_digits = set(str(num))
if len(distinct_digits) == 2:
result.append(num)
return result if result else -1

def validate_input(numbers):
if not numbers:
return False

for num in numbers:
if not (isinstance(num, int) and 0 <= num <= 99999):
return False

return True

def main():
n = int(input("Introduceți numărul de numere: "))
numbers = list(map(int, input("Introduceți numerele separate prin spațiu: ").split()))

if not (1 <= n <= 100 and validate_input(numbers)):
print("Date de intrare invalide!")
return

least_used = least_used_stamp(numbers)
print(least_used)

sorted_stamps = stamps_order(numbers)
print(" ".join(sorted_stamps))

numbers_with_two = numbers_with_two_stamps(numbers)
if numbers_with_two != -1:
print(" ".join(map(str, numbers_with_two)))
else:
print(-1)

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

4139 - triprime

2024-03-28T10:06:26Z

Cristina94: Pagină nouă: ==Enunţ== Un număr se numește triprim dacă este produsul a trei numere prime distincte. Exemple de numere triprime: 30 = 2 × 3 × 5, 42 = 2 × 3 × 7, 231 = 3 × 7 × 11. Exemple de numere care nu sunt triprime: 77 = 7 × 11 (prea puține numere prime în produs), 3003 = 3 × 7 × 11 × 13 (prea multe numere prime în produs), 18 = 2 × 3 × 3 (numerele prime nu sunt distincte), 10241 = 7 × 7 × 11 × 19 (prea multe numere prime în produs). ==Cerința== Date fiind num...

==Enunţ==
Un număr se numește triprim dacă este produsul a trei numere prime distincte. Exemple de numere triprime: 30 = 2 × 3 × 5, 42 = 2 × 3 × 7, 231 = 3 × 7 × 11. Exemple de numere care nu sunt triprime: 77 = 7 × 11 (prea puține numere prime în produs), 3003 = 3 × 7 × 11 × 13 (prea multe numere prime în produs), 18 = 2 × 3 × 3 (numerele prime nu sunt distincte), 10241 = 7 × 7 × 11 × 19 (prea multe numere prime în produs).

==Cerința==
Date fiind numerele A și B, să se afișeze numărul de numere triprime din intervalul [A, B] (inclusiv A și B).

==Date de intrare==
Fișierul de intrare triprime.in conține pe prima linie două numere naturale A și B, despărțite printr-un
singur spațiu.

==Date de ieșire==
Fișierul de ieșire triprime.out va conține numărul de numere triprime din intervalul [A, B].

==Restricții și precizări==
*1 ≤ A ≤ B ≤ 390.000.000
*Pentru 18 puncte, 1 ≤ B ≤ 1.500.000
*Pentru 6 puncte, 1.500.000 < B ≤ 2.500.000
*Pentru 20 puncte, 2.500.000 < B ≤ 4.500.000
*Pentru 31 puncte, 4.500.000 < B ≤ 35.000.000
*Pentru 25 puncte, nu există alte restricții

==Exemplul 1==
;triprime.in
:1 50

;triprime.out
:2

==Explicație==
Sunt două numere triprime de la 1 la 50: 30 = 2 × 3 × 5 și 42 = 2 × 3 × 7.

==Exemplul 2==
;triprime.in
:10 5

;triprime.out
:Datele sunt invalide

==Rezolvare==
<syntaxhighlight lang="python" line>
#4139 triprime
def sieve_of_eratosthenes(n):
primes = [True] * (n + 1)
primes[0], primes[1] = False, False
p = 2
while p * p <= n:
if primes[p] == True:
for i in range(p * p, n + 1, p):
primes[i] = False
p += 1
return [i for i in range(n + 1) if primes[i]]

def count_triprimes_in_interval(A, B):
primes = sieve_of_eratosthenes(B)
count = 0
for num in range(A, B + 1):
prime_factors = [p for p in primes if num % p == 0]
if len(prime_factors) == 3:
count += 1
return count

def is_valid_input(A, B):
if not (1 <= A <= B <= 390_000_000):
return False
return True

def main():
with open("triprime.in", "r") as f:
A, B = map(int, f.readline().split())

if not is_valid_input(A, B):
with open("triprime.out", "w") as f:
f.write("Datele sunt invalide")
return

triprime_count = count_triprimes_in_interval(A, B)

with open("triprime.out", "w") as f:
f.write(str(triprime_count))

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

4140 - bug

2024-03-28T09:50:44Z

Cristina94: Pagină nouă: ==Enunţ== Dacă vrei să-ți schimbi buletinul trebuie să mergi la Serviciul de Evidență a Populației. Acolo trebuie să iei un număr de ordine și să aștepți să-ți vină rândul. Numerele de ordine sunt emise de un robot, în ordinea 1,2,3,... Programatorul Vasile, care a elaborat soft-ul pentru robot și care asigură (contra cost) întreținerea sistemului, a creat intenționat un bug în sistem. Vasile are un număr natural preferat N. Un număr de ordine x va...

==Enunţ==
Dacă vrei să-ți schimbi buletinul trebuie să mergi la Serviciul de Evidență a Populației. Acolo trebuie să iei un număr de ordine și să aștepți să-ți vină rândul. Numerele de ordine sunt emise de un robot, în ordinea 1,2,3,... Programatorul Vasile, care a elaborat soft-ul pentru robot și care asigură (contra cost) întreținerea sistemului, a creat intenționat un bug în sistem. Vasile are un număr natural preferat N. Un număr de ordine x va fi emis dacă și numai dacă x este un subșir al lui N (adică toate cifrele lui x apar în N în ordinea din x, nu neapărat pe poziții consecutive). Dacă numărul de ordine curent x nu îndeplinește această condiție, robotul se blochează și nu mai emite numere de ordine.

==Cerința==
Scrieți un program care, cunoscând valoarea lui N, numărul natural preferat de Vasile, rezolvă următoarele două cerințe:
1. determină câte cifre are numărul de ordine x care conduce la blocarea robotului;
2. determină numărul de ordine x care conduce la blocarea robotului.

==Date de intrare==
Fișierul de intrare bug.in conține pe prima linie cerința C care trebuie să fie rezolvată (1 sau 2). Pe cea de-a doua linie se află numărul natural N.

==Date de ieșire==
Fișierul de ieșire bug.out va conține o singură linie pe care va fi scris răspunsul la cerința C.

==Restricții și precizări==
*N este un număr natural nenul având cel mult 100.000 de cifre.
*Pentru 23 de puncte, C = 1
*Pentru 10 de puncte, C = 2 și N are cel mult 18 cifre.
*Pentru 10 de puncte, C = 2, N are cel puțin 20 de cifre și rezultatul are cel mult 7 cifre.
*Pentru 30 de puncte, C = 2, N are cel puțin 101 și cel mult 10.000 de cifre.
*Pentru 27 de puncte, C = 2 și nu există alte restricții.

==Exemplul 1==
;bug.in
:1
:1032

;bug.out
:1

==Explicație==
Cel mai mic număr natural nenul care nu este subșir al lui 1032 are o singură cifră.

==Exemplul 2==
;bug.in
:2
:1032

;bug.out
:4

==Explicație==
Cel mai mic număr natural nenul care nu este subșir al lui 1032 este 4.

==Exemplul 3==
;bug.in
:1
:-1032

;bug.out
:Eroare: Numărul preferat trebuie să fie un număr natural nenul.

==Exemplul 4==
;bug.in
:3
:-1032

;bug.out
:Eroare: Query-ul trebuie să fie 1 sau 2.

==Rezolvare==
<syntaxhighlight lang="python" line>
#4140 bug
def check_input(query, preferred_number):
# Verificăm dacă query-ul este valid
if query != 1 and query != 2:
return "Eroare: Query-ul trebuie să fie 1 sau 2."

# Verificăm dacă preferred_number este un număr natural nenul
if preferred_number <= 0:
return "Eroare: Numărul preferat trebuie să fie un număr natural nenul."

return None

def is_subsequence(number, preferred_number):
number_str = str(number)
preferred_str = str(preferred_number)
i = 0

for digit in preferred_str:
if digit == number_str[i]:
i += 1
if i == len(number_str):
return True
return False

def find_smallest_non_subsequence(preferred_number):
i = 1
while True:
if not is_subsequence(i, preferred_number):
return i
i += 1

def main():
# Citim datele de intrare
with open("bug.in", "r") as f:
query = int(f.readline())
preferred_number = int(f.readline())

# Verificăm datele de intrare
error_message = check_input(query, preferred_number)
if error_message:
with open("bug.out", "w", encoding='utf-8') as f:
f.write(error_message)
return

# Rezolvăm cerința
if query == 1:
smallest_non_subsequence = find_smallest_non_subsequence(preferred_number)
with open("bug.out", "w", encoding='utf-8') as f:
f.write(str(len(str(smallest_non_subsequence))))
else:
smallest_non_subsequence = find_smallest_non_subsequence(preferred_number)
with open("bug.out", "w", encoding='utf-8') as f:
f.write(str(smallest_non_subsequence))

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

1161 - Big Number

2024-03-28T08:53:39Z

Cristina94: Pagină nouă: ==Enunţ== Algorel tocmai a avut un interviu la AlgoTech. Fiind isteţ din fire, el a reuşit să rezolve toate problemele, mai puţin una de care nu reuşeşte nicicum să se prindă cum se face. Aflând că la Iaşi are loc Concursul Urmaşii lui Moisil, s-a gândit să propună această problemă şi să ofere 100 de puncte ca recompensă celor care o rezolvă corect. Fie un şir cu N cifre asupra căruia se poate efectua operaţia swap de maxim X ori. Prin swap se înţe...

==Enunţ==
Algorel tocmai a avut un interviu la AlgoTech. Fiind isteţ din fire, el a reuşit să rezolve toate problemele, mai puţin una de care nu reuşeşte nicicum să se prindă cum se face. Aflând că la Iaşi are loc Concursul Urmaşii lui Moisil, s-a gândit să propună această problemă şi să ofere 100 de puncte ca recompensă celor care o rezolvă corect.

Fie un şir cu N cifre asupra căruia se poate efectua operaţia swap de maxim X ori. Prin swap se înţelege interschimbarea a două elemente din şir aflate pe poziţii vecine.

==Cerința==
Să se determine numărul maxim care se poate obţine din şirul cu N cifre, după efectuarea a maxim X operaţii swap.

==Date de intrare==
Fișierul de intrare bignumber.in conține pe prima linie numerele naturale N şi X separate prin exact un spaţiu, iar pe următoarea linie se află N cifre fără spaţiu.

==Date de ieșire==
Fișierul de ieșire bignumber.out va conține pe prima linie numărul maxim care se poate obţine conform cerinţei din enunţ.

==Restricții și precizări==
*1 ≤ N ≤ 1.000.000
*0 ≤ X ≤ 1.000.000.000
*Pentru 30% din teste N ≤ 5.000
*Pentru alte 20% din teste X ≤ 25.000.000

==Exemplu1==
;bignumber.in
:5 3
:14325

;bignumber.out
:41532

==Exemplu2==
;bignumber.in
:1000001 3
:12345

;bignumber.out
:Date invalide.

==Rezolvare==
<syntaxhighlight lang="python" line>
#1161 BigNumber
def maximum_number(N, X, digits):
result = list(digits)

for i in range(N):
max_index = i
for j in range(i + 1, min(N, i + X + 1)):
if digits[j] > digits[max_index]:
max_index = j

for j in range(max_index, i, -1):
if X <= 0:
break
result[j], result[j - 1] = result[j - 1], result[j]
X -= 1

return ''.join(result)

def is_valid_input(N, X, digits):
if not (1 <= N <= 1000000):
return False
if not (0 <= X <= 1000000000):
return False
if len(digits) != N:
return False
for digit in digits:
if not ('0' <= digit <= '9'):
return False
return True

def main():
with open("bignumber.in", "r") as f:
N, X = map(int, f.readline().split())
digits = f.readline().strip()

if not is_valid_input(N, X, digits):
with open("bignumber.out", "w") as f_out:
f_out.write("Date invalide.")

else:
max_number = maximum_number(N, X, digits)
with open("bignumber.out", "w") as f_out:
f_out.write(max_number)

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

1505 - B 210

2024-03-28T08:21:28Z

Cristina94: Pagină nouă: ==Enunţ== Vasilică tocmai a învăţat la şcoală despre sistemul de numeraţie cu baza 2. I se pare interesant şi a inventat jocul b210, pe care vrea să îl joace cu prietenul său Gigel. Vasilică îi spune lui Gigel un număr natural nenul n, scris în baza 10. Gigel trebuie să scrie numărul în baza 2, obţinând astfel o secvenţă de cifre binare, care începe cu 1. Asupra scrierii în baza 2 a numărului n Gigel poate aplica una sau mai multe permutări circular...

==Enunţ==
Vasilică tocmai a învăţat la şcoală despre sistemul de numeraţie cu baza 2. I se pare interesant şi a inventat jocul b210, pe care vrea să îl joace cu prietenul său Gigel. Vasilică îi spune lui Gigel un număr natural nenul n, scris în baza 10. Gigel trebuie să scrie numărul în baza 2, obţinând astfel o secvenţă de cifre binare, care începe cu 1. Asupra scrierii în baza 2 a numărului n Gigel poate aplica una sau mai multe permutări circulare. Printr-o permutare circulară, toate cifrele secvenţei date, exceptând ultima, sunt mutate cu o poziţie spre dreapta, iar ultima cifră devine prima.

De exemplu, dacă n=107, scrierea sa în baza 2 este 1101011. Prin permutări circulare succesive putem obţine, în ordine, secvenţele:

:1110101
:1111010
:0111101
:1011110
:...

Fiecare astfel de secvenţă este scrierea în baza 2 a unui număr natural, pe care Gigel îl transformă în baza 10. Gigel trebuie să afle care este cel mai mare număr natural m, scris în baza 10, a cărui scriere în baza 2 se poate obţine prin una sau mai multe permutări circulare ale scrierii în baza 2 a numărului n. Lui Gigel jocul nu i se pare aşa interesant şi ar prefera să aibă un program care să determine în locul lui numărul natural m.

==Cerința==
Scrieţi un program care citeşte numărul natural nenul n şi care determină cel mai mare număr natural m, scris în baza 10, care poate fi obţinut prin una sau mai multe permutări circulare ale scrierii în baza 2 a numărului natural n.

==Date de intrare==
Fișierul de intrare b210.in conține pe prima linie numărul natural nenul n.

==Date de ieșire==
Fișierul de ieșire b210.out va conține pe prima linie numărul natural m, cu semnificaţia din enunţ.

==Restricții și precizări==
0 < n ≤ 1.000.000.000

==Exemplu1==
;b210.in
:13

;b210.out
:14

==Explicație==
Scrierea în baza 2 a lui 13 este 1101.

Numărul maxim scris în baza 10 a cărui scriere în baza 2 se poate obţine din permutări circulare ale scrierii în baza 2 a lui 13 este 14, a cărui scriere în baza 2 este 1110.

==Exemplu2==
;b210.in
:-10

;b210.out
:Date invalide in fisierul de intrare.

==Rezolvare==
<syntaxhighlight lang="python" line>
#1505 B210
def decimal_to_binary(n):
# Convertim numărul din baza 10 în baza 2
return bin(n)[2:]

def rotate_left(s):
# Rotim cifrele la stânga
return s[1:] + s[0]

def find_largest_permuted_number(n):
binary = decimal_to_binary(n)
largest_number = n

# Generăm toate permutările circulare
for _ in range(len(binary) - 1):
binary = rotate_left(binary)
# Convertim înapoi în baza 10
num = int(binary, 2)
# Actualizăm cel mai mare număr
largest_number = max(largest_number, num)

return largest_number

def is_valid_input(n):
# Verificăm dacă numărul este nenul și se încadrează în limitele impuse
return 0 < n <= 1000000000

def main():
with open("b210.in", "r") as f_in:
n = int(f_in.readline().strip())

if not is_valid_input(n):
with open("b210.out", "w") as f_out:
f_out.write("Date invalide in fisierul de intrare.")
return

# Determinăm cel mai mare număr permis
largest_number = find_largest_permuted_number(n)

# Scriem rezultatul în fișierul de ieșire
with open("b210.out", "w") as f:
f.write(str(largest_number))

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

2120 - Concurs 4

2024-03-28T07:26:12Z

Cristina94: Pagină nouă: ==Enunţ== La concursul de patinaj artistic din acest an s-au înscris n concurenţi. După înscriere, participanţilor li se asociază coduri numerice distincte aparţinând mulţimii primelor n numere prime. Pentru a stabili ordinea intrării în concurs, concurenţii sunt aşezaţi în cerc, după care se procedează astfel: primul participant în concurs este cel situat pe poziţia 1 pentru alegerea celorlalţi, se parcurge circular lista de concurenţi, alegând din k...

==Enunţ==
La concursul de patinaj artistic din acest an s-au înscris n concurenţi. După înscriere, participanţilor li se asociază coduri numerice distincte aparţinând mulţimii primelor n numere prime.

Pentru a stabili ordinea intrării în concurs, concurenţii sunt aşezaţi în cerc, după care se procedează astfel:

primul participant în concurs este cel situat pe poziţia 1
pentru alegerea celorlalţi, se parcurge circular lista de concurenţi, alegând din k în k, câte un unul, până la repartizarea tuturor.
Regulamentul prevede ca participanţii să intre în concurs în ordinea crescătoare a codurilor lor.

==Cerința==
Cunoscând numărul n de concurenţi precum şi numărul k folosit la repartizarea concurenţilor în concurs, se cere să se determine şirul codurilor asociate concurenţilor, astfel încât intrarea lor în concurs să se facă conform regulamentului.

==Date de intrare==
Fişierul concurs4.in conţine pe prima linie numerele naturale n şi k cu semnificaţiile din enunţ.

==Date de ieșire==
Fişierul concurs4.out va conţine n numere naturale separate prin câte un spaţiu, reprezentând şirul codurilor asociate concurenţilor, astfel încât intrarea lor în concurs să se facă conform regulamentului.

==Restricții și precizări==
• 2 ≤ k ≤ n ≤ 30000

==Exemplu 1==
;concurs4.in
:10 4

;concurs4.out
:2 29 23 7 3 17 13 19 5 11

==Explicație==
Distribuirea codurilor se face astfel:
2 29 23 7 3 17 13 19 5 11 Numărând din 4 în 4, începând cu primul cod, se obţine următoarea listă:
2 3 5 7 11 13 17 19 23 29 reprezentând primele 10 numere prime.

==Exemplu 2==
;concurs4.in
:1 1

;concurs4.out
Valorile pentru n si k trebuie sa fie in intervalul [2, 30000].

==Rezolvare==
<syntaxhighlight lang="python" line>
#2120 Concurs4
def este_prim(numar):
if numar < 2:
return False
for i in range(2, int(numar ** 0.5) + 1):
if numar % i == 0:
return False
return True

def genereaza_prime(n):
prime = []
numar = 2
while len(prime) < n:
if este_prim(numar):
prime.append(numar)
numar += 1
return prime

def alege_concurenti(n, k):
prime = genereaza_prime(n)
concurenti = []

index = 0
while len(concurenti) < n:
index = (index + k - 1) % len(prime)
concurenti.append(prime.pop(index))
return concurenti

def verifica_date_intrare(n, k):
if not (2 <= k <= n <= 30000):
with open("concurs4.out", "w") as f:
f.write("Valorile pentru n si k trebuie sa fie in intervalul [2, 30000].")
exit()

def main():
with open("concurs4.in", "r") as f:
n, k = map(int, f.readline().split())
verifica_date_intrare(n, k)

coduri_concurenti = alege_concurenti(n, k)

with open("concurs4.out", "w") as f:
f.write(" ".join(map(str, coduri_concurenti)))

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

3680 - Numere X

2024-03-28T06:31:34Z

Cristina94:

==Enunţ==
Pentru un număr natural nenul X, se numește divizor propriu al lui X, un divizor natural al lui X, diferit de 1 și X. De exemplu, pentru numărul 20 divizorii proprii sunt 2, 4, 5, 10, iar numărul 20 are 4 divizori proprii.

==Cerința==
1. Se dă un număr natural N. Determinați cel mai mic număr din intervalul închis [1,N] care are număr maxim de divizori proprii.
2. Se dau trei numere N, M și T. Determinați câte intervale de forma [a,b] au proprietatea că există exact M numere naturale care au T divizori proprii.

==Date de intrare==
Fișierul de intrare numere.in conține pe prima linie un număr natural P reprezentând cerința din problemă care trebuie rezolvată.

Dacă P = 1 atunci pe a doua linie se găsește un număr natural N, reprezentând extremitatea din dreapta a intervalului.

Dacă P = 2 atunci pe a doua linie se găsesc trei numere: un număr natural N, un număr natural M și un număr natural T cu semnificațiile din enunț.

==Date de ieșire==
Dacă P = 1 atunci fișierul de ieșire numere.out conține pe o singură linie numărul cel mai mic determinat care are număr maxim de divizori.

Dacă P = 2 atunci fișierul de ieșire numere.out conține pe o singură linie numărul de intervale determinate care au proprietatea cerută.

==Restricții și precizări==
*1 ≤ N ≤ 100000
*1 ≤ M ≤ 100000
*1 ≤ T ≤ 100000
*1 ≤ a ≤ b ≤ N

==Exemplul 1==
;numere.in
:1
:20

;numere.out
:12

==Explicație==
12 are 4 divizori proprii și este cel mai mic număr cu 4 divizori proprii din [1,20].

==Exemplul 2==
;numere.in
:2
:10 3 2

;numere.out
:6

==Explicație==
[1,10], [2,10], [3,10], [4,10], [5,10], [6,10] sunt cele 6 intervale în care se găsesc exact 3 numere cu 2 divizori proprii(6, 8, 10 sunt numerele cu 3 divizori proprii).

==Exemplul 3==
;numere.in
:1
:0

;numere.out
:Datele introduse sunt invalide

==Rezolvare==
<syntaxhighlight lang="python" line>
#3680 - Numere X
def numar_divizori(n):
divizori = 0
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
if n // i == i:
divizori += 1
else:
divizori += 2
return divizori

def cel_mai_mic_numar_cu_max_divizori(N):
maxim_divizori = 0
numar = 0
for i in range(1, N + 1):
divizori = numar_divizori(i)
if divizori > maxim_divizori:
maxim_divizori = divizori
numar = i
return numar

def numar_intervale_cu_M_numere_T_divizori(N, M, T):
numar_intervale = 0
for a in range(1, N + 1):
for b in range(a, N + 1):
numere_cu_T_divizori = sum(1 for x in range(a, b + 1) if numar_divizori(x) == T)
if numere_cu_T_divizori == M:
numar_intervale += 1
return numar_intervale

def verifica_date_intrare(P, N, M, T):
if P not in [1, 2]:
return False
if P == 1:
if not isinstance(N, int) or N < 1 or N > 100000:
return False
elif P == 2:
if not (isinstance(N, int) and isinstance(M, int) and isinstance(T, int)):
return False
if not (1 <= N <= 100000 and 1 <= M <= 100000 and 1 <= T <= 100000):
return False
return True

def main():
N = None
with open("numere.in", "r") as fin:
P = int(fin.readline().strip())
if P == 1:
N = int(fin.readline().strip())
elif P == 2:
N, M, T = map(int, fin.readline().strip().split())

if not verifica_date_intrare(P, N, M if P == 2 else None, T if P == 2 else None):
with open("numere.out", "w") as fout:
fout.write("Datele introduse sunt invalide\n")
return

if P == 1:
rezultat = cel_mai_mic_numar_cu_max_divizori(N)
else:
rezultat = numar_intervale_cu_M_numere_T_divizori(N, M, T)

with open("numere.out", "w") as fout:
fout.write(str(rezultat) + "\n")

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

3680 - Numere X

2024-03-28T06:30:25Z

Cristina94: Pagină nouă: ==Enunţ== Pentru un număr natural nenul X, se numește divizor propriu al lui X, un divizor natural al lui X, diferit de 1 și X. De exemplu, pentru numărul 20 divizorii proprii sunt 2, 4, 5, 10, iar numărul 20 are 4 divizori proprii. ==Cerința== 1. Se dă un număr natural N. Determinați cel mai mic număr din intervalul închis [1,N] care are număr maxim de divizori proprii. 2. Se dau trei numere N, M și T. Determinați câte intervale de forma [a,b] au proprietate...

==Enunţ==
Pentru un număr natural nenul X, se numește divizor propriu al lui X, un divizor natural al lui X, diferit de 1 și X. De exemplu, pentru numărul 20 divizorii proprii sunt 2, 4, 5, 10, iar numărul 20 are 4 divizori proprii.

==Cerința==
1. Se dă un număr natural N. Determinați cel mai mic număr din intervalul închis [1,N] care are număr maxim de divizori proprii.
2. Se dau trei numere N, M și T. Determinați câte intervale de forma [a,b] au proprietatea că există exact M numere naturale care au T divizori proprii.

==Date de intrare==
Fișierul de intrare numere.in conține pe prima linie un număr natural P reprezentând cerința din problemă care trebuie rezolvată.

Dacă P = 1 atunci pe a doua linie se găsește un număr natural N, reprezentând extremitatea din dreapta a intervalului.

Dacă P = 2 atunci pe a doua linie se găsesc trei numere: un număr natural N, un număr natural M și un număr natural T cu semnificațiile din enunț.

==Date de ieșire==
Dacă P = 1 atunci fișierul de ieșire numere.out conține pe o singură linie numărul cel mai mic determinat care are număr maxim de divizori.

Dacă P = 2 atunci fișierul de ieșire numere.out conține pe o singură linie numărul de intervale determinate care au proprietatea cerută.

==Restricții și precizări==
*1 ≤ N ≤ 100000
*1 ≤ M ≤ 100000
*1 ≤ T ≤ 100000
*1 ≤ a ≤ b ≤ N

==Exemplul 1==
;numere.in
:1
:20

;numere.out
:12

==Explicație==
12 are 4 divizori proprii și este cel mai mic număr cu 4 divizori proprii din [1,20].

==Exemplul 2==
;numere.in
:2
:10 3 2

;numere.out
:6

==Explicație==
[1,10], [2,10], [3,10], [4,10], [5,10], [6,10] sunt cele 6 intervale în care se găsesc exact 3 numere cu 2 divizori proprii(6, 8, 10 sunt numerele cu 3 divizori proprii).

==Exemplul 3==
;numere.in
:1
:0

;numere.out
:Datele introduse sunt invalide

==Rezolvare==
<syntaxhighlight lang="python" line>
def numar_divizori(n):
divizori = 0
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
if n // i == i:
divizori += 1
else:
divizori += 2
return divizori

def cel_mai_mic_numar_cu_max_divizori(N):
maxim_divizori = 0
numar = 0
for i in range(1, N + 1):
divizori = numar_divizori(i)
if divizori > maxim_divizori:
maxim_divizori = divizori
numar = i
return numar

def numar_intervale_cu_M_numere_T_divizori(N, M, T):
numar_intervale = 0
for a in range(1, N + 1):
for b in range(a, N + 1):
numere_cu_T_divizori = sum(1 for x in range(a, b + 1) if numar_divizori(x) == T)
if numere_cu_T_divizori == M:
numar_intervale += 1
return numar_intervale

def verifica_date_intrare(P, N, M, T):
if P not in [1, 2]:
return False
if P == 1:
if not isinstance(N, int) or N < 1 or N > 100000:
return False
elif P == 2:
if not (isinstance(N, int) and isinstance(M, int) and isinstance(T, int)):
return False
if not (1 <= N <= 100000 and 1 <= M <= 100000 and 1 <= T <= 100000):
return False
return True

def main():
N = None
with open("numere.in", "r") as fin:
P = int(fin.readline().strip())
if P == 1:
N = int(fin.readline().strip())
elif P == 2:
N, M, T = map(int, fin.readline().strip().split())

if not verifica_date_intrare(P, N, M if P == 2 else None, T if P == 2 else None):
with open("numere.out", "w") as fout:
fout.write("Datele introduse sunt invalide\n")
return

if P == 1:
rezultat = cel_mai_mic_numar_cu_max_divizori(N)
else:
rezultat = numar_intervale_cu_M_numere_T_divizori(N, M, T)

with open("numere.out", "w") as fout:
fout.write(str(rezultat) + "\n")

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