Bitnami MediaWiki - User contributions [en]

3813 - Unghiuri

2023-05-07T20:18:21Z

Cuceu Andrei: Pagină nouă: ==Cerință== Se dau lungimile laturilor unui triunghi '''ABC'''. Aflati masurile unghiurilor '''A, B, C'''. ==Date de intrare== Programul citește de la tastatură lungimile laturilor '''AB, BC, AC'''. ==Date de ieșire== Programul va afișa pe ecran masura unghiurilor '''A, B, C''' cu '''2''' zecimale exacte daca triunghiul este valid, altfel se afiseaza mesajul '''Imposibil'''. ==Restricții și precizări== *'''1 ≤ AB,BC,AC ≤ 1000''' ==Exemplul 1== ;'''Intr...

==Cerință==

Se dau lungimile laturilor unui triunghi '''ABC'''. Aflati masurile unghiurilor '''A, B, C'''.

==Date de intrare==

Programul citește de la tastatură lungimile laturilor '''AB, BC, AC'''.

==Date de ieșire==

Programul va afișa pe ecran masura unghiurilor '''A, B, C''' cu '''2''' zecimale exacte daca triunghiul este valid, altfel se afiseaza mesajul '''Imposibil'''.

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

*'''1 ≤ AB,BC,AC ≤ 1000'''

==Exemplul 1==
;'''Intrare '''
:7 8 6

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:57.91 75.52 46.57

==Exemplul 2==
;'''Intrare '''
:4 5 10

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:Imposibil

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

import math

def validate_triangle(a, b, c):
"""
Verifica daca triunghiul cu laturile a, b si c este valid.
Returneaza True daca triunghiul este valid, altfel False.
"""
if a + b <= c or a + c <= b or b + c <= a:
return False
return True

def calculate_angles(a, b, c):
"""
Calculeaza masurile unghiurilor triunghiului cu laturile a, b si c.
Returneaza un tuple cu valorile ungiurilor in ordinea A, B, C.
"""
if not validate_triangle(a, b, c):
return "Imposibil"

angle_a = round(math.degrees(math.acos((b**2 + c**2 - a**2)/(2*b*c))), 2)
angle_b = round(math.degrees(math.acos((a**2 + c**2 - b**2)/(2*a*c))), 2)
angle_c = round(math.degrees(math.acos((a**2 + b**2 - c**2)/(2*a*b))), 2)

return (angle_a, angle_b, angle_c)

def main():
a, b, c = map(float, input().split())
angles = calculate_angles(a, b, c)
if angles == "Imposibil":
print("Imposibil")
else:
print(*angles)

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicație==
Funcția validate_triangle verifică dacă triunghiul este valid, returnând True dacă este valid și False altfel. Aceasta verifică dacă suma a două laturi este mai mare decât lungimea celei de-a treia laturi, ceea ce este condiția necesară pentru a forma un triunghi valid.

Funcția calculate_angles primește lungimile laturilor triunghiului și calculează masurile unghiurilor acestuia folosind legea cosinusului. Rezultatele sunt rotunjite la 2 zecimale cu funcția round. Dacă triunghiul nu este valid, funcția returnează mesajul "Imposibil".

Funcția main citește de la tastatură lungimile laturilor triunghiului și apelează funcția calculate_angles. Dacă triunghiul nu este valid, afișează mesajul "Imposibil", altfel afișează masurile unghiurilor folosind print(*angles), unde angles este un tuple cu valorile ungiurilor.

3812 - Înălțimi2

2023-05-07T20:10:08Z

Cuceu Andrei:

==Cerință==

Se dau lungimile laturilor unui triunghi '''ABC'''. Calculati lungimile inaltimilor duse din '''A, B, C'''.

==Date de intrare==

Programul citește de la tastatură numerele '''a, b, c''' reprezentand lungimile laturilor '''AB, BC, AC'''.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran lungimile inaltimilor triunghiului cu '''2''' zecimale exacte daca acesta este valid, altfel se afiseaza mesajul Imposibil. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

*'''1 ≤ a, b, c ≤ 1000'''

==Exemplul 1==
;'''Intrare '''
:3 4 5

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:4.00 3.00 2.40

==Exemplul 2==
;'''Intrare '''
:4 5 10

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:Imposibil

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validate_triangle(a, b, c):
if a + b > c and a + c > b and b + c > a:
return True
return False

def validare(a, b, c):
return 1 <= int(a) <= 1000 and 1 <= int(b) <= 1000 and 1 <= int(c) <= 1000

def calculate_altitudes(a, b, c):
if validate_triangle(a, b, c):
p = (a + b + c) / 2
area = (p * (p - a) * (p - b) * (p - c)) ** 0.5
ha = 2 * area / a
hb = 2 * area / b
hc = 2 * area / c
return round(ha, 2), round(hb, 2), round(hc, 2)
else:
return "Imposibil"

if __name__ == '__main__':
a, b, c = map(str, input().split())
if validare(a, b, c):
print("Datele de intrare corespund restrictiilor impuse.")
a, b, c = int(a), int(b), int(c)
altitudes = calculate_altitudes(a, b, c)
if isinstance(altitudes, tuple):
ha, hb, hc = altitudes
print(round(ha, 2), round(hb, 2), round(hc, 2))
else:
print(altitudes)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație==

Acest cod reprezintă un program Python care calculează înălțimile unui triunghi, având date cele trei laturi ale sale.

Funcția validate_triangle verifică dacă cele trei laturi date pot forma un triunghi valid, utilizând proprietatea că suma oricăror două laturi trebuie să fie mai mare decât cea de-a treia latură.

Funcția validare verifică dacă valorile laturilor sunt între 1 și 1000.

Funcția calculate_altitudes calculează înălțimile triunghiului utilizând formula standard care folosește aria triunghiului și lungimile laturilor. În cazul în care laturile nu formează un triunghi valid, funcția returnează o valoare specială "Imposibil".

În cadrul blocului principal de cod, valorile laturilor triunghiului sunt citite de la tastatură și apoi verificate prin intermediul funcției validare. Dacă valorile sunt valide, se calculează înălțimile triunghiului prin apelarea funcției calculate_altitudes. Dacă aceasta returnează o tuplă, valorile înălțimilor sunt afișate pe ecran rotunjite la două zecimale. Dacă funcția calculate_altitudes returnează valoarea specială "Imposibil", se afișează acest mesaj pe ecran. În caz contrar, se afișează un mesaj care indică că datele de intrare sunt valide.

3806 - Mediane

2023-05-07T19:55:29Z

Cuceu Andrei: Pagină nouă: ==Cerință== Se dau lungimile laturilor unui triunghi '''ABC'''. Aflați lungimile medianelor duse din '''A,B si C'''. ==Date de intrare== Programul citește de la tastatură numerele a,b,c, reprezentând lungimile laturilor AB,BC,AC. ==Date de ieșire== Programul va afișa pe ecran trei numere, reprezentând lungimile celor 3 mediane, fiecare cu 2 zecimale exacte, fără rotunjire, daca triunghiul este valid, altfel se afiseaza mesajul Imposibil. ==Restricții și...

==Cerință==

Se dau lungimile laturilor unui triunghi '''ABC'''. Aflați lungimile medianelor duse din '''A,B si C'''.

==Date de intrare==

Programul citește de la tastatură numerele a,b,c, reprezentând lungimile laturilor AB,BC,AC.

==Date de ieșire==

Programul va afișa pe ecran trei numere, reprezentând lungimile celor 3 mediane, fiecare cu 2 zecimale exacte, fără rotunjire, daca triunghiul este valid, altfel se afiseaza mesajul Imposibil.

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

*'''1 ≤ a,b,c ≤ 1000'''

==Exemplul 1==
;'''Intrare '''
3 4 5

;'''Ieșire '''

4.27 3.61 2.50

==Exemplul 2==
;'''Intrare '''
4 5 10

;'''Ieșire '''

Imposibil

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

import math

def validare(a, b, c):
return a + b > c and a + c > b and b + c > a

def medianele_triunghiului(a, b, c):
if not validare(a, b, c):
print("Imposibil")
else:
med_a = math.sqrt(2 * b**2 + 2 * c**2 - a**2) / 2
med_b = math.sqrt(2 * a**2 + 2 * c**2 - b**2) / 2
med_c = math.sqrt(2 * a**2 + 2 * b**2 - c**2) / 2
print("{:.2f} {:.2f} {:.2f}".format(med_a, med_b, med_c))

def main():
a, b, c = map(float, input().split())
medianele_triunghiului(a, b, c)

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatie==

Functia validare verifica daca triunghiul exista, iar functia medianele_triunghiului calculeaza medianele si le afiseaza daca triunghiul exista, sau mesajul "Imposibil" in caz contrar.

In functia main, valorile a, b, c sunt citite de la tastatura cu ajutorul functiei map si sunt transmise functiei medianele_triunghiului pentru a calcula si afisa media.

0970 - Gen

2023-05-07T19:45:45Z

Cuceu Andrei:

==Enunț==
Pe planeta Marte, marţienii folosesc în calculele aritmetice doar cifrele '''0''', '''1''', '''2''' şi '''3'''. Ei au inventat un nou sistem binar de numeraţie. Pornind de la numărul '''23''', ei generează numere binare speciale aplicând de un număr finit de ori regulile din tabelul de mai jos:

*Cifra '''2''' se poate înlocui cu succesiunea: '''12'''
*Cifra '''3''' se poate înlocui cu succesiunea: '''03'''
*Cifra '''2''' se poate înlocui cu succesiunea: '''01'''
*Cifra '''3''' se poate înlocui cu succesiunea: '''10'''

Marţienii au început să genereze un astfel de număr, aplicând succesiv (în această ordine): de n ori regula 1); de k ori regula 2); o singură dată regula 3) şi o singură dată regula 4). Nefiind atenţi, ei nu au reuşit să ducă la capăt generarea şi au nevoie de ajutor. Ajutaţi-i să genereze numărul binar dorit.

==Cerință==

Scrieţi un program care citeşte numerele naturale nenule n şi k şi care afişează numărul binar obţinut în urma aplicării succesive a regulilor cerute de marţieni.

==Date de intrare==

Programul citește de la tastatură numerele '''n k'''.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran numărul cerut.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

*'''0<n,k<=1000000, numere naturale'''

==Exemplul 1==
;'''Intrare '''
:5 4

;'''Iesire '''
:Datele de intrare corespund restrictiilor impuse.
:1111101000010

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(n, k):
if n <= 0 or k <= 0 or n > 1000000 or k > 1000000:
print("Datele de intrare nu corespund restricțiilor impuse.")
return False
print("Datele de intrare corespund restricțiilor impuse.")
return True

def generate_binary(n, k):
binary = "23"
for i in range(n):
binary = binary.replace("2", "12").replace("3", "03")
for i in range(k):
binary = binary.replace("2", "01").replace("3", "10")
binary = binary.replace("2", "01")
binary = binary.replace("3", "10")
return binary

if __name__ == '__main__':
n, k = map(int, input().split())
if validate_input(n, k):
print(generate_binary(n, k))

</syntaxhighlight>

==Explicatie==

In acest cod, am definit functia aplicare_reguli care primeste ca parametri numerele n si k, si returneaza numarul binar obtinut in urma aplicarii regulilor cerute de martieni. In functia aplicare_reguli am definit un string numar initializat cu valoarea "23", si apoi am aplicat regulile in ordinea specificata in problema, folosind functia replace() pentru inlocuirea cifrelor 2 si 3 cu succesiunile corespunzatoare. La final, am convertit numarul in format binar cu ajutorul functiei bin() si am afisat rezultatul.

In main, am citit de la tastatura valorile pentru n si k, am validat datele de intrare folosind functia validare, si apoi am apelat functia aplicare_reguli si am afisat rezultatul.

3812 - Înălțimi2

2023-05-07T19:38:53Z

Cuceu Andrei: Pagină nouă: ==Cerință== Se dau lungimile laturilor unui triunghi '''ABC'''. Calculati lungimile inaltimilor duse din '''A, B, C'''. ==Date de intrare== Programul citește de la tastatură numerele '''a, b, c''' reprezentand lungimile laturilor '''AB, BC, AC'''. ==Date de ieșire== Programul va afișa pe ecran lungimile inaltimilor triunghiului cu '''2''' zecimale exacte daca acesta este valid, altfel se afiseaza mesajul Imposibil. ==Restricții și precizări== *'''1 ≤ a,...

0970 - Gen

2023-05-07T19:29:54Z

Cuceu Andrei: Pagină nouă: ==Enunt== Pe planeta Marte, marţienii folosesc în calculele aritmetice doar cifrele '''0''', '''1''', '''2''' şi '''3'''. Ei au inventat un nou sistem binar de numeraţie. Pornind de la numărul '''23''', ei generează numere binare speciale aplicând de un număr finit de ori regulile din tabelul de mai jos: *Cifra '''2''' se poate înlocui cu succesiunea: '''12''' *Cifra '''3''' se poate înlocui cu succesiunea: '''03''' *Cifra '''2''' se poate înlocui cu succesiunea:...

==Enunt==
Pe planeta Marte, marţienii folosesc în calculele aritmetice doar cifrele '''0''', '''1''', '''2''' şi '''3'''. Ei au inventat un nou sistem binar de numeraţie. Pornind de la numărul '''23''', ei generează numere binare speciale aplicând de un număr finit de ori regulile din tabelul de mai jos:

*Cifra '''2''' se poate înlocui cu succesiunea: '''12'''
*Cifra '''3''' se poate înlocui cu succesiunea: '''03'''
*Cifra '''2''' se poate înlocui cu succesiunea: '''01'''
*Cifra '''3''' se poate înlocui cu succesiunea: '''10'''

Marţienii au început să genereze un astfel de număr, aplicând succesiv (în această ordine): de n ori regula 1); de k ori regula 2); o singură dată regula 3) şi o singură dată regula 4). Nefiind atenţi, ei nu au reuşit să ducă la capăt generarea şi au nevoie de ajutor. Ajutaţi-i să genereze numărul binar dorit.

==Cerință==

Scrieţi un program care citeşte numerele naturale nenule n şi k şi care afişează numărul binar obţinut în urma aplicării succesive a regulilor cerute de marţieni.

==Date de intrare==

Programul citește de la tastatură numerele '''n k'''.

==Date de ieșire==

Programul va afișa pe ecran numărul cerut.

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

*'''0<n,k<=1000000, numere naturale'''

==Exemplul 1==
;'''Intrare '''
5 4

;'''Iesire '''

1111101000010

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validare(n, k):
if not(1 <= n <= 1000000) or not(1 <= k <= 1000000):
return False
return True

def aplicare_reguli(n, k):
# incepem cu numarul 23
numar = '23'
# aplicam regula 1 de n ori
for i in range(n):
numar = numar.replace('2', '12').replace('3', '03')
# aplicam regula 2 de k ori
for i in range(k):
numar = numar.replace('2', '01').replace('3', '10')
# aplicam regula 3 o singura data
numar = numar.replace('2', '01')
# aplicam regula 4 o singura data
numar = numar.replace('3', '10')
# afisam numarul final in format binar
return bin(int(numar))[2:].zfill(13)

if __name__ == '__main__':
# citim n si k de la tastatura
n, k = map(int, input().split())
# validam datele de intrare
if validare(n, k):
# aplicam regulile si afisam rezultatul
print(aplicare_reguli(n, k))
else:
print("Date de intrare invalide!")

</syntaxhighlight>

==Explicatie==

In acest cod, am definit functia aplicare_reguli care primeste ca parametri numerele n si k, si returneaza numarul binar obtinut in urma aplicarii regulilor cerute de martieni. In functia aplicare_reguli am definit un string numar initializat cu valoarea "23", si apoi am aplicat regulile in ordinea specificata in problema, folosind functia replace() pentru inlocuirea cifrelor 2 si 3 cu succesiunile corespunzatoare. La final, am convertit numarul in format binar cu ajutorul functiei bin() si am afisat rezultatul.

In main, am citit de la tastatura valorile pentru n si k, am validat datele de intrare folosind functia validare, si apoi am apelat functia aplicare_reguli si am afisat rezultatul.

2579 - Putere 2 Interval

2023-05-07T19:10:02Z

Cuceu Andrei: Pagină nouă: ==Cerință== Se citesc 3 numere naturale '''n''', '''a''' și '''b'''. Afișați primele '''n''' puteri ale lui '''2''', în ordine crescătoare, din intervalul '''[a,b]'''. Dacă nu există cel puțin n puteri ale lui '''2''' în interval, atunci se vor afișa cele care există. ==Date de intrare== Programul citește de la tastatură numărul '''n''', '''a''' și '''b''', separate prin spații. ==Date de ieșire== Programul va afișa pe ecran puterile lui '''2''' d...

==Cerință==

Se citesc 3 numere naturale '''n''', '''a''' și '''b'''. Afișați primele '''n''' puteri ale lui '''2''', în ordine crescătoare, din intervalul '''[a,b]'''. Dacă nu există cel puțin n puteri ale lui '''2''' în interval, atunci se vor afișa cele care există.

==Date de intrare==
Programul citește de la tastatură numărul '''n''', '''a''' și '''b''', separate prin spații.

==Date de ieșire==

Programul va afișa pe ecran puterile lui '''2''' din intervalul '''[a,b]'''.

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

*'''1 ≤ n ≤ 60'''
*'''1 ≤ a ≤ b < 2^64'''

==Exemplul 1==
;'''Intrare '''
2 6 35

;'''Ieșire '''

8 16

==Explicatie==

În interval există '''3''' puteri ale lui '''2''', dar s-au afișat doar '''n''' dintre ele.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(n: int, a: int, b: int) -> bool:
if not (1 <= n <= 60):
print("Numărul n trebuie să fie între 1 și 60.")
return False
if not (1 <= a <= b < 2**64):
print("Numerele a și b trebuie să fie între 1 și 2^64 - 1, și a trebuie să fie mai mic sau egal cu b.")
return False
return True

def main():
n, a, b = map(int, input().split())
if not validate_input(n, a, b):
return

powers_of_2 = []
for i in range(64):
power_of_2 = 2**i
if a <= power_of_2 <= b:
powers_of_2.append(power_of_2)

powers_of_2.sort()
for i in range(min(n, len(powers_of_2))):
print(powers_of_2[i], end=' ')

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==

==Explicatie==
Funcția validate_input este folosită pentru a valida inputul citit de la tastatură. Aceasta verifică dacă valorile citite pentru n, a, și b respectă restricțiile date. Dacă inputul nu este valid, se va afișa un mesaj de eroare și funcția va returna False. Altfel, funcția va returna True.

În funcția main, citim inputul de la tastatură folosind input() și îl procesăm folosind funcția map() și split() pentru a separa valorile citite. Apoi, verificăm dacă inputul este valid folosind funcția validate_input. Dacă inputul nu este valid, funcția se va încheia.

În continuare, parcurgem toate puterile lui 2 din intervalul [a, b], și le stocăm în lista powers_of_2. După ce am stocat toate puterile lui 2 din interval, sortăm lista și afișăm primele n elemente folosind un for loop.

0326 - Ultimul Par

2023-05-07T18:49:15Z

Cuceu Andrei: Pagină nouă: ==Cerință== Se dau '''n''' numere naturale. Să se determine ultimul număr par dintre cele date. ==Date de intrare== Programul citeşte de la tastatură numărul '''n''', apoi n numere naturale, dispuse pe mai multe linii. ==Date de ieșire== Programul afişează pe ecran ultimul număr par dintre cele date. Dacă nu au fost citite numere pare, se va afişa doar mesajul '''IMPOSIBIL'''. ==Restricții și precizări== *'''0< n <= 100''' *cele n numere citite vo...

==Cerință==

Se dau '''n''' numere naturale. Să se determine ultimul număr par dintre cele date.

==Date de intrare==

Programul citeşte de la tastatură numărul '''n''', apoi n numere naturale, dispuse pe mai multe linii.

==Date de ieșire==

Programul afişează pe ecran ultimul număr par dintre cele date. Dacă nu au fost citite numere pare, se va afişa doar mesajul '''IMPOSIBIL'''.

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

*'''0< n <= 100'''
*cele n numere citite vor avea cel mult '''9''' cifre

==Exemplul 1==
;'''Date de intrare '''
8
12 15 68 13 17
90 31 43

;'''Date de ieşire '''

90

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def ultimul_numar_par(n, numere):
ultimul_par = None
for numar in numere:
if numar % 2 == 0:
ultimul_par = numar
if ultimul_par is None:
print("IMPOSIBIL")
else:
print(ultimul_par)

def main():
n = int(input("Introduceti numarul de numere: "))
numere = []
for i in range(n):
numere += [int(x) for x in input().split()]
ultimul_numar_par(n, numere)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==

Funcția ultimul_numar_par primește numărul total de numere n și o listă de numere numere, și determină ultimul număr par din lista.
Funcția main primește de la utilizator numărul total de numere n și o listă de n numere separate prin spații pe mai multe linii. Apoi, apelează funcția ultimul_numar_par cu aceste date.
Restricțiile sunt îndeplinite prin verificarea că n este între 1 și 100, iar numerele citite au cel mult 9 cifre.
În cazul în care nu există numere pare în lista, se afișează mesajul "IMPOSIBIL".

2276 - Cb

2023-05-07T18:23:48Z

Cuceu Andrei:

==Enunt==

Se consideră un șir '''a[1], a[2], …, a[n]''' de numere naturale. Se dau și '''T''' intervale închise de forma '''[x, y], cu x ≤ y.'''

==Cerință==

Pentru fiecare din cele '''T''' intervale de forma '''[x, y]''' trebuie să răspundeți la întrebarea: câte numere din șir aparțin intervalului''' [x, y]'''?

==Date de intrare==

Programul citește de la tastatură numerele '''n''' și '''T''', apoi '''n''' numere naturale, separate prin spații, '''a[1], a[2], …, a[n]'''. Pe următoarele '''T''' linii se află câte două numere naturale '''x''' și''' y''' reprezentând un interval '''[x, y]'''.

==Date de ieșire==

Programul va afișa pe ecran '''T''' linii. Pe fiecare linie '''i (i=1..T)''' se va afla un singur număr natural reprezentând răspunsul la a '''i'''-a întrebare.

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

*'''1 ≤ n, T ≤ 200 000'''
*'''0 ≤ a[i] ≤ 2 000 000 000'''
*'''0 ≤ x ≤ y ≤ 2 000 000 000'''

==Exemplul 1==
;'''Intrare '''
9 7
6 1 3 5 3 3 9 20 9
4 10
0 100
0 1
500 506
3 3
10 18
3 9

;'''Ieșire '''

4
9
1
0
3
0
7

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(n, T, a, intervals):
if len(a) != n:
return False
for x, y in intervals:
if x > y:
return False
return True

def count_numbers_in_intervals(n, T, a, intervals):
if not validate_input(n, T, a, intervals):
return []

counts = []
for x, y in intervals:
count = 0
for num in a:
if x <= num <= y:
count += 1
counts.append(count)

return counts

if __name__ == '__main__':
n, T = map(int, input().split())
a = list(map(int, input().split()))

intervals = []
for i in range(T):
x, y = map(int, input().split())
intervals.append((x, y))

counts = count_numbers_in_intervals(n, T, a, intervals)

for count in counts:
print(count)

</syntaxhighlight>

==Explicatie==
Acest program citește întâi valorile n și T de la intrare folosind map(int, input().split()), care face conversia valorilor citite de la tastatură în lista de întregi. Acestea reprezintă, respectiv, numărul de elemente din lista a și numărul de intervale pe care trebuie să le verificăm.

Următoarea linie citește lista a de n elemente de la intrare, folosind list(map(int, input().split())). Această linie citește o singură linie de intrare, separă elementele în funcție de spațiu (split()), le converteste în lista de întregi (map(int, ...)) și creează lista finală (list(...)).

În continuare, linia for i in range(T): iterăm prin fiecare interval și adăugăm intervalele la lista de intervale folosind linia intervals.append((x, y)), unde (x, y) este o tuplă care conține cele două valori ale intervalului.

Apelăm funcția count_numbers_in_intervals cu argumentele necesare și apoi afișăm rezultatele într-un format specificat.

Funcția count_numbers_in_intervals primește numărul de elemente din lista a, numărul de intervale, lista de numere a și o listă de intervale și returnează o listă cu numărul de elemente din fiecare interval.

Funcția validate_input verifică dacă datele de intrare sunt valide și returnează True dacă sunt și False în caz contrar. De asemenea, verifică dacă intervalul dat este valid, adică x este mai mic sau egal cu y.

Pentru a verifica dacă un număr se află într-un interval dat, iterăm prin lista a și verificăm dacă fiecare element este mai mare sau egal cu limita inferioară x și mai mic sau egal cu limita superioară y. Dacă acest lucru este adevărat, incrementăm count și continuăm până când am verificat toate elementele din lista. La final, adăugăm valoarea count la lista counts și returnăm lista de numere.

2276 - Cb

2023-05-07T18:23:04Z

Cuceu Andrei: Pagină nouă: ==Enunt== Se consideră un șir '''a[1], a[2], …, a[n]''' de numere naturale. Se dau și '''T''' intervale închise de forma '''[x, y], cu x ≤ y.''' ==Cerință== Pentru fiecare din cele '''T''' intervale de forma '''[x, y]''' trebuie să răspundeți la întrebarea: câte numere din șir aparțin intervalului''' [x, y]'''? ==Date de intrare== Programul citește de la tastatură numerele '''n''' și '''T''', apoi '''n''' numere naturale, separate prin spații, '''...

2644 - Clase

2023-05-07T18:15:16Z

Cuceu Andrei:

==Cerință==

Într-o școală sunt n clase, fiecare având un număr diferit de elevi. Școală primește m pachete cu cărți, fiecare cu un număr diferit de cărți. Pentru ca o clasa să primească un pachet, numărul elevilor din acea clasa trebuie să fie egal cu numărul cărților din pachet. Să se determine câte clase primesc un pachet de cărți.

==Date de intrare==

Fișierul de intrare '''clase.in''' va avea pe prima linie numărul '''n''', iar pe următoarea linie '''n''' numere naturale ordonate crescător, separate prin spații, reprezentând numărul de elevi din fiecare clasa. Pe următoarea linie numărul '''m''', și pe următoarea linie '''m '''numere, reprezentând numărul de cărți din fiecare pachet.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Fișierul de ieșire clase.out va conține pe prima linie numărul de clase care primesc pachete cu cărți. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

*'''1 ≤ n, m ≤ 10.000'''
*într-un pachet sunt maximum '''1.000.000.000.000''' cărți.
*într-o clasă sunt maximum '''1.000.000.000.000''' elevi.

==Exemplul 1==
;'''clase.in '''
:5
:16 17 20 24 30
:4
:78 20 17 74

;'''clase.out '''
:2

;Ieșire
:Datele de intrare corespund restricțiilor impuse.

==Explicație==

Doar clasa cu '''20''' de elevi și cea cu '''17''' elevi vor primi pachete cu cărți.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input():
# Citim datele de intrare
n = int(input().strip())
classes = list(map(int, input().strip().split()))
m = int(input().strip())
packages = list(map(int, input().strip().split()))

# Validam inputul
assert 1 <= n <= 10000, "Numarul de clase trebuie sa fie intre 1 si 10000"
assert 1 <= m <= 10000, "Numarul de pachete trebuie sa fie intre 1 si 10000"
for c in classes:
assert 1 <= c <= 10**12, "Numarul de elevi trebuie sa fie intre 1 si 10^12"
for p in packages:
assert 1 <= p <= 10**12, "Numarul de carti trebuie sa fie intre 1 si 10^12"

def count_classes_with_packages(n, classes, m, packages):
# Initializam un set cu clasele care primesc pachete cu carti
classes_with_packages = set()

# Parcurgem toate pachetele cu carti
for package in packages:
# Parcurgem toate clasele si verificam daca numarul de elevi
# dintr-o clasa este egal cu numarul de carti din pachet
for i in range(n):
if classes[i] == package:
classes_with_packages.add(i+1)

# Returnam numarul de clase care primesc pachete cu carti
return len(classes_with_packages)

def main():
# Validam inputul
validate_input()

# Citim datele de intrare
n = int(input().strip())
classes = list(map(int, input().strip().split()))
m = int(input().strip())
packages = list(map(int, input().strip().split()))

# Determinam numarul de clase care primesc pachete cu carti
num_classes_with_packages = count_classes_with_packages(n, classes, m, packages)

# Afisam rezultatul in consola si in fisierul de iesire
with open("clase.out", "w") as fout:
fout.write(str(num_classes_with_packages) + "\n")
print(num_classes_with_packages)

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicație==

Mai exact, codul verifică dacă datele de intrare sunt valide prin intermediul funcției validate_input(), care verifică ca numerele de clase și pachete să fie întregi pozitive între 1 și 10000, iar numărul de elevi și cărți să fie între 1 și 10^12.

Apoi, funcția count_classes_with_packages() primește numărul de clase, lista cu numărul de elevi pentru fiecare clasă, numărul de pachete și lista cu numărul de cărți pentru fiecare pachet. Aceasta determină numărul de clase care primesc pachete cu cărți prin parcurgerea tuturor pachetelor și a tuturor claselor și verificarea dacă numărul de elevi dintr-o clasă este egal cu numărul de cărți dintr-un pachet.

În final, codul scrie rezultatul în fișierul de ieșire clase.out și ar trebui să afișeze numărul corect de clase care primesc pachete cu cărți în consolă.

2014 - Canguri

2023-05-07T18:11:55Z

Cuceu Andrei: Pagină nouă: ==Enunt== La proba de atletism s-au calificat trei canguri care trebuie să efectueze sărituri pe o pistă de 800 metri. Fiecare cangur se aliniază la linia de start, îşi lipeşte pe marsupiu eticheta cu numărul său de concurs iar apoi când se dă stratul efectuează săritură după săritură până trece linia de sosire. Cunoscând lungimea săriturii fiecărui cangur (exprimată în metri) şi faptul că nu există doi canguri cu sărituri de aceeaşi lungime, sc...

==Enunt==

La proba de atletism s-au calificat trei canguri care trebuie să efectueze sărituri pe o pistă de 800 metri.
Fiecare cangur se aliniază la linia de start, îşi lipeşte pe marsupiu eticheta cu numărul său de concurs iar apoi când se dă stratul efectuează săritură după săritură până trece linia de sosire.

Cunoscând lungimea săriturii fiecărui cangur (exprimată în metri) şi faptul că nu există doi canguri cu sărituri de aceeaşi lungime, scrieți un program care să determine:

==Cerință==

a) Numărul de concurs al cangurului care ajunge primul la linia de sosire;
b) Numărul săriturilor efectuate de cangurul care a trecut primul linia de sosire.

==Date de intrare==

Din fişierul de intrare canguri.in se citesc:

*de pe primele trei linii, câte două numere naturale despărțite prin câte un spațiu, ce reprezintă numărul de concurs respectiv lungimea săriturii fiecărui cangur.

==Date de ieșire==

În fişierul canguri.out se va scrie:

*pe prima linie, numărul de concurs al cangurului care trece primul linia de sosire;
*pe cea de-a doua linie, un număr natural ce reprezintă numărul săriturilor efectuate de cangurul care a trecut primul linia de sosire.

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

Numerele scrise pe etichetele de concurs sunt numere naturale cu maximum trei cifre
pentru determinarea corectă a numărului de concurs se acordă 60% din punctaj; pentru determinarea corectă a numărului de sărituri se acordă 40% din punctaj

==Exemplul 1==
;'''canguri.in '''
769 2
354 6
129 4

;'''canguri.out '''

354
134

==Explicatie==

Primul cangur are numărul de concurs '''769''' şi lungimea săriturii egală cu '''2''' metri.
Cel de-al doilea cangur are numărul de concurs '''354''' şi lungimea săriturii de '''6''' metri.
Cel de-al treilea cangur are numărul de concurs '''129''' și lungimea săriturii de '''4''' metri.
Primul va trece linia de sosire cangurul cu numărul de concurs '''354.'''
El va efectua '''134''' de sărituri pentru a trece linia de sosire.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(n, data):
if n != 3:
return False
for i in range(n):
if len(data[i]) != 2:
return False
if not data[i][0].isdigit() or not data[i][1].isdigit():
return False
return True

def main():
# Citim datele de intrare din fisierul "canguri.in"
with open("canguri.in", "r") as f:
n = 3
data = [tuple(line.strip().split()) for line in f.readlines()]

# Validam datele de intrare
if not validate_input(n, data):
print("Date de intrare invalide!")
return

# Sortam lista de canguri in functie de lungimea sariturii
sorted_canguri = sorted(data, key=lambda x: int(x[1]))

# Aflam numarul de concurs al cangurului care trece primul linia de sosire
numar_cangur = sorted_canguri[0][0]
print(numar_cangur)

# Aflam numarul de sarituri efectuate de cangurul care a trecut primul linia de sosire
nr_sarituri = 800 // int(sorted_canguri[0][1])
print(nr_sarituri)

# Scriem rezultatele in fisierul "canguri.out"
with open("canguri.out", "w") as f:
f.write(str(numar_cangur) + "\n")
f.write(str(nr_sarituri) + "\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatie==

Pentru validarea datelor de intrare, am definit funcția validate_input, care primește numărul de linii n și datele propriu-zise data și verifică dacă avem exact 3 linii de date, iar fiecare linie conține două numere naturale separate prin spațiu.

În funcția main, citim datele de intrare din fișierul "canguri.in" și le validăm folosind funcția validate_input. Apoi, sortăm lista de canguri în funcție de lungimea săriturii

3644 - Joc12

2023-05-07T18:05:39Z

Cuceu Andrei: Pagină nouă: ==Enunt== Ioana și Maria tocmai au învățat la matematică despre multiplii unui număr natural. Pentru a exersa lucrul cu noua noțiune, își propun să joace următorul joc: fiecare își alege câte un număr natural nenul și pentru câte un interval închis dat (la intervalele închise capetele fac parte din interval), calculează câți multipli are numărul ales în acel interval. Câștigă cea care a ales numărul care are mai mulți multipli în intervalul prim...

==Enunt==

Ioana și Maria tocmai au învățat la matematică despre multiplii unui număr natural. Pentru a exersa lucrul cu noua noțiune, își propun să joace următorul joc: fiecare își alege câte un număr natural nenul și pentru câte un interval închis dat (la intervalele închise capetele fac parte din interval), calculează câți multipli are numărul ales în acel interval. Câștigă cea care a ales numărul care are mai mulți multipli în intervalul primit, sau este egalitate în cazul în care numărul multiplilor este acelaşi.

==Cerință==

Cunoscând numerele alese de cele două fete precum și numerele care determină intervalele date, să se determine cine câștigă jocul și care este numărul care conduce la câștigarea jocului.

==Date de intrare==

De la tastatură se citesc șase valori: '''x a b y c d''', care reprezintă, în ordine, numărul ales de Ioana și capetele intervalului primit de aceasta, numărul ales de Maria și capetele intervalului primit de ea.

==Date de ieșire==

Pe ecran se va afișa numele fetei care câștigă și o valoare P ce reprezintă numărul care conduce la câștigarea jocului, separate printr-un spațiu. În caz de egalitate se va afișa '''Egalitate''' urmat de un spaţiu şi de numărul egal al multiplilor.

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

*'''1 ≤ x, y ≤ 1.000.000'''
*'''1 ≤ a, b ≤ 1.000.000.000'''
*'''1 ≤ c, d ≤ 1.000.000.000'''

==Exemplul 1==
;'''Intrare '''
7
9
30
9
60
20

;'''Ieșire '''

Maria 4

==Explicatie==

'''7''' are în intervalul '''[9, 30]''' trei multipli '''{14, 21, 28}'''. '''9 '''are în intervalul '''[20, 60]''' patru multipli '''{27, 36, 45, 54}.''' Prin urmare numărul ales de Maria este cel câștigător, având '''4''' multipli în intervalul dat.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(x, a, b, y, c, d):
if not(1 <= x <= 1000000 and 1 <= y <= 1000000):
return False
if not(1 <= a <= 1000000000 and 1 <= b <= 1000000000 and 1 <= c <= 1000000000 and 1 <= d <= 1000000000):
return False
if not(b <= a or d <= c):
return False
return True

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

def find_winner(x, a, b, y, c, d):
if calculate_multiples(x, a, b) > calculate_multiples(y, c, d):
return "Ioana", x
elif calculate_multiples(x, a, b) < calculate_multiples(y, c, d):
return "Maria", y
else:
return "Egalitate", calculate_multiples(x, a, b)

if __name__ == '__main__':
x = int(input())
a = int(input())
b = int(input())
y = int(input())
c = int(input())
d = int(input())

if validate_input(x, a, b, y, c, d):
winner, num = find_winner(x, a, b, y, c, d)
print(winner, num)
else:
print("Input invalid")

</syntaxhighlight>

==Explicatie==

În acest exemplu, am introdus numărul 7 pentru Ioana, intervalul [9, 30], numărul 30 pentru Maria și intervalul [20, 60]. Funcția de validare verifică dacă valorile sunt valide, ceea ce este cazul aici. Apoi, funcția find_winner calculează numărul de multipli pentru fiecare număr în intervalul dat și compară rezultatele pentru a determina câștigătorul. În cazul nostru, Maria are mai mulți multipli, deci câștigă.

2644 - Clase

2023-05-07T17:48:29Z

Cuceu Andrei: Pagină nouă: ==Cerință== Într-o școală sunt n clase, fiecare având un număr diferit de elevi. Școală primește m pachete cu cărți, fiecare cu un număr diferit de cărți. Pentru ca o clasa să primească un pachet, numărul elevilor din acea clasa trebuie să fie egal cu numărul cărților din pachet. Să se determine câte clase primesc un pachet de cărți. ==Date de intrare== Fișierul de intrare '''clase.in''' va avea pe prima linie numărul '''n''', iar pe următoar...

==Cerință==

Într-o școală sunt n clase, fiecare având un număr diferit de elevi. Școală primește m pachete cu cărți, fiecare cu un număr diferit de cărți. Pentru ca o clasa să primească un pachet, numărul elevilor din acea clasa trebuie să fie egal cu numărul cărților din pachet. Să se determine câte clase primesc un pachet de cărți.

==Date de intrare==

Fișierul de intrare '''clase.in''' va avea pe prima linie numărul '''n''', iar pe următoarea linie '''n''' numere naturale ordonate crescător, separate prin spații, reprezentând numărul de elevi din fiecare clasa. Pe următoarea linie numărul '''m''', și pe următoarea linie '''m '''numere, reprezentând numărul de cărți din fiecare pachet.

==Date de ieșire==

Fișierul de ieșire clase.out va conține pe prima linie numărul de clase care primesc pachete cu cărți.

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

*'''1 ≤ n, m ≤ 10.000'''
*într-un pachet sunt maximum '''1.000.000.000.000''' cărți.
*într-o clasă sunt maximum '''1.000.000.000.000''' elevi.

==Exemplul 1==
;'''clase.in '''

5
16 17 20 24 30
4
78 20 17 74

;'''clase.out '''

2

==Explicatie==

Doar clasa cu '''20''' de elevi și cea cu '''17''' elevi vor primi pachete cu cărți.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(n, m, classes, packages):
# Verificăm ca n și m să fie numere întregi pozitive mai mici sau egale cu 10000
if not(1 <= n <= 10000) or not(1 <= m <= 10000):
return False

# Verificăm ca toate clasele să aibă între 1 și 10^12 elevi
for num_students in classes:
if not(1 <= num_students <= 10**12):
return False

# Verificăm ca toate pachetele să aibă între 1 și 10^12 cărți
for num_books in packages:
if not(1 <= num_books <= 10**12):
return False

return True

def count_classes_with_packages(n, classes, m, packages):
classes_with_packages = 0

for package in packages:
for num_students in classes:
if num_students == package:
classes_with_packages += 1
break

return classes_with_packages

if __name__ == '__main__':
# Citim numărul de clase și lista cu numărul de elevi pentru fiecare clasă
with open('clase.in', 'r') as f:
n = int(f.readline())
classes = list(map(int, f.readline().split()))

# Citim numărul de pachete și lista cu numărul de cărți pentru fiecare pachet
with open('clase.in', 'r') as f:
m = int(f.readline())
packages = list(map(int, f.readline().split()))

# Validăm datele de intrare
if not validate_input(n, m, classes, packages):
print('Date de intrare invalide!')
exit()

# Determinăm numărul de clase care primesc pachete cu cărți
classes_with_packages = count_classes_with_packages(n, classes, m, packages)

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

</syntaxhighlight>

==Explicatie==

Mai exact, codul verifică dacă datele de intrare sunt valide prin intermediul funcției validate_input(), care verifică ca numerele de clase și pachete să fie întregi pozitive între 1 și 10000, iar numărul de elevi și cărți să fie între 1 și 10^12.

Apoi, funcția count_classes_with_packages() primește numărul de clase, lista cu numărul de elevi pentru fiecare clasă, numărul de pachete și lista cu numărul de cărți pentru fiecare pachet. Aceasta determină numărul de clase care primesc pachete cu cărți prin parcurgerea tuturor pachetelor și a tuturor claselor și verificarea dacă numărul de elevi dintr-o clasă este egal cu numărul de cărți dintr-un pachet.

În final, codul scrie rezultatul în fișierul de ieșire clase.out și ar trebui să afișeze numărul corect de clase care primesc pachete cu cărți în consolă.

2560 - Bits

2023-05-07T17:43:01Z

Cuceu Andrei: Pagină nouă: ==Enunt== Se dă un număr natural '''N'''. ==Cerință== Determinați valoarea unor anumiți biți din reprezentarea sa în baza 2. ==Date de intrare== Fișierul de intrare '''bits.in''' conține pe prima linie două numere naturale''' N''' și '''Q''' separate prin spațiu. Pe linia a doua se află '''Q''' numere naturale separate prin câte un spațiu. ==Date de ieșire== Fișierul de ieșire '''bits.out''' conține pe prima linie '''Q''' valori, neseparate prin s...

==Enunt==
Se dă un număr natural '''N'''.

==Cerință==

Determinați valoarea unor anumiți biți din reprezentarea sa în baza 2.

==Date de intrare==

Fișierul de intrare '''bits.in''' conține pe prima linie două numere naturale''' N''' și '''Q''' separate prin spațiu. Pe linia a doua se află '''Q''' numere naturale separate prin câte un spațiu.

==Date de ieșire==

Fișierul de ieșire '''bits.out''' conține pe prima linie '''Q''' valori, neseparate prin spațiu, reprezentând, în ordine, răspunsurile la întrebări.

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

*'''0 ≤ N ≤ 2^63-1'''
*'''1 ≤ Q ≤ 63'''
*valorile de pe a doua linie a fișierului de intrare sunt distincte și cuprinse între '''0''' și '''62''' (inclusiv)
*biții se numerotează începând cu poziția''' 0 '''(cel mai puțin semnificativ)
*numărul '''N''' este reprezentat pe '''64''' de biți

==Exemplul 1==
;'''bits.in '''
12 4
2 0 3 20

;'''bits.out '''

1010

==Explicatie==

Reprezentarea internă a valorii '''12''' este '''000...0001100.''' Biții de pe pozițiile '''0''' și '''20''' au valoarea '''0''' iar cei de pe pozițiile '''2 '''și '''3''' au valoarea '''1'''.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(n, q, queries):
"""
Verifică dacă datele de intrare respectă condițiile problemei.
"""
if not 0 <= n <= 2**63 - 1:
return False
if not 1 <= q <= 63:
return False
if len(queries) != q:
return False
if any(query < 0 or query > 62 for query in queries):
return False
return True

def get_bits(n, queries):
"""
Returnează valorile biților specificați din reprezentarea în baza 2 a lui n.
"""
binary_n = bin(n)[2:].zfill(64)
results = []
for query in queries:
bit_value = binary_n[-query-1]
results.append(bit_value)
return ''.join(results)

if __name__ == '__main__':
with open('bits.in', 'r') as f_in, open('bits.out', 'w') as f_out:
n, q = map(int, f_in.readline().split())
queries = list(map(int, f_in.readline().split()))
if not validate_input(n, q, queries):
f_out.write('Invalid input')
else:
result = get_bits(n, queries)
f_out.write(result)

</syntaxhighlight>

==Explicatie==

Funcția validate_input verifică dacă datele de intrare respectă restricțiile problemei. Dacă nu sunt respectate, se returnează False. Altfel, se returnează True.

Funcția get_bits primește numărul n și lista de întrebări queries. Transformă n în reprezentarea sa în baza 2 sub formă de șir de caractere și extrage biții specificați din listă. Rezultatul este returnat sub formă de șir de caractere.

Blocul main începe prin deschiderea fișierelor de intrare și de ieșire. Pe prima linie din fișierul de intrare se citesc valorile n și q, iar pe a doua linie se citesc întrebările. Se validează datele de intrare prin apelul funcției validate_input. Dacă datele nu sunt valide, se afișează în fișierul de ieșire mesajul "Invalid input". Altfel, se apelează funcția get_bits și se scrie rezultatul în fișierul de ieșire.

1300 - Hex

2023-05-07T16:52:40Z

Cuceu Andrei: Pagină nouă: ==Enunt== Andino este un elev pasionat de informatică. Din păcate, profesoara de matematică l-a prins rezolvând probleme de informatică în ora ei. Totuşi, ştiind că el este un elev bun, a decis să-i dea o provocare. Ea i-a dat o foaie pe care era scris un număr '''b''' în baza '''2''' şi i-a cerut să îl transforme în baza '''16''' într-un timp cât mai scurt. Andino, fiind în criză de timp, vă roagă să-l ajutaţi! ==Cerință== Să se transforme num...

==Enunt==

Andino este un elev pasionat de informatică. Din păcate, profesoara de matematică l-a prins rezolvând probleme de informatică în ora ei. Totuşi, ştiind că el este un elev bun, a decis să-i dea o provocare.

Ea i-a dat o foaie pe care era scris un număr '''b''' în baza '''2''' şi i-a cerut să îl transforme în baza '''16''' într-un timp cât mai scurt.

Andino, fiind în criză de timp, vă roagă să-l ajutaţi!

==Cerință==

Să se transforme numărul dat de profesoară în baza '''16'''.

==Date de intrare==

Fișierul de intrare hex.in conține pe prima linie numărul''' b''', scris în baza''' 2'''.

==Date de ieșire==

Fișierul de ieșire hex.out va conține pe prima linie numărul '''x''', reprezentând numărul''' b''' scris în baza '''16'''.

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

*'''1 ≤''' lungimea numărului dat '''≤ 10000'''
*Cifrele în baza '''16''' sunt '''0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F'''
*Pentru '''40%''' din teste, '''1 ≤''' lungimea numărului '''≤ 20'''
*Dacă îl ajutaţi pe Andino să rezolve problema, el vă va răsplăti cu '''100''' de puncte

==Exemplul 1==
;'''hex.in '''
1001010

;'''hex.out '''

4A

==Explicatie==

Numărul '''1001010(2)''' este scrierea în baza '''2''' a numărului '''74(10)'''. Scrierea în sistemul hexazecimal a numărului '''74''' este '''4A(16)'''.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_binary_number(binary_number):
for digit in binary_number:
if digit not in ['0', '1']:
return False
return True

def binary_to_decimal(binary_number):
decimal_number = 0
for digit in binary_number:
decimal_number = decimal_number * 2 + int(digit)
return decimal_number

def decimal_to_hex(decimal_number):
hex_digits = "0123456789ABCDEF"
hex_number = ""
while decimal_number > 0:
remainder = decimal_number % 16
hex_number = hex_digits[remainder] + hex_number
decimal_number //= 16
return hex_number

if __name__ == '__main__':
with open('hex.in', 'r') as fin:
binary_number = fin.readline().strip()

if not validate_binary_number(binary_number):
print('Invalid input!')
else:
decimal_number = binary_to_decimal(binary_number)
hex_number = decimal_to_hex(decimal_number)

with open('hex.out', 'w') as fout:
fout.write(hex_number)

</syntaxhighlight>

==Explicatie==

Funcția validate_binary_number verifică dacă numărul dat este valid, adică este scris în baza 2.

Funcția binary_to_decimal convertește numărul dat din baza 2 în baza 10, prin parcurgerea cifrelor numărului și adunarea puterilor de 2 corespunzătoare cifrelor de 1.

Funcția decimal_to_hex convertește numărul dat din baza 10 în baza 16, prin împărțirea repetată a numărului la 16 și adăugarea cifrei corespunzătoare rămășiței în șirul rezultat.

În blocul if __name__ == '__main__':, citim numărul dat din fișierul de intrare hex.in, verificăm dacă este valid, apoi convertim numărul din baza 2 în baza 10 și din baza 10 în baza 16. La final, scriem rezultatul în fișierul de ieșire hex.out.

3009 - ZTS

2023-05-07T16:44:15Z

Cuceu Andrei: Pagină nouă: ==Cerință== Fie '''Z''' un număr natural în baza '''10'''. Considerăm '''rkrk-1 … r1r0''' scrierea numărului '''Z''' în baza '''3'''. Fie '''T = rkrk−1…r1r0''' numărul în baza 10 format cu cifrele rk, rk-1, … r1, r0. Notăm cu '''S''' restul împărțirii numărului '''T '''la''' 7'''. Se dau '''N''' numere naturale '''Z1, Z2, … , ZN'''. Pentru fiecare dintre numerele '''Z1, Z2, … , ZN''' se cere să se calculeze '''S1, S2, … , SN'''. ('''Si '''reprezi...

==Cerință==

Fie '''Z''' un număr natural în baza '''10'''. Considerăm '''rkrk-1 … r1r0''' scrierea numărului '''Z''' în baza '''3'''.
Fie '''T = rkrk−1…r1r0''' numărul în baza 10 format cu cifrele rk, rk-1, … r1, r0.
Notăm cu '''S''' restul împărțirii numărului '''T '''la''' 7'''.
Se dau '''N''' numere naturale '''Z1, Z2, … , ZN'''.
Pentru fiecare dintre numerele '''Z1, Z2, … , ZN''' se cere să se calculeze '''S1, S2, … , SN'''. ('''Si '''reprezintă restul împărțirii la '''7''' a numărului '''Ti '''iar''' Ti'''reprezintă numărul format cu cifrele scrierii în baza '''3''' a numărului '''Zi''').

==Date de intrare==

Programul citește de la tastatură numărul '''N''', iar apoi '''N''' numere naturale '''Z1, Z2, … , ZN''', separate prin spații.

==Date de ieșire==

Programul va afișa pe ecran, pe câte o linie, numerele '''S1, S2, … , SN'''.

==Restricții și precizări==
*'''1 ≤ N ≤ 40000'''
*'''Z1, Z2, … , ZN''' vor fi mai mici decât '''2^64'''

==Exemplul 1==
;''' Intrare '''
2
19 30

;'''Ieșire '''

5
2

==Explicatie==

S-au citit '''2''' numere:''' 19''' și '''30'''.
Numărul '''19''' în baza '''3''' se scrie: '''201.''' Restul împărțirii numărului '''201''' la '''7''' este '''5'''.
Numărul '''30''' în baza '''3''' se scrie: '''1010.''' Restul împărțirii numărului '''1010''' la '''7''' este '''2'''.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(N, Z):
if N < 1 or N > 40000:
print("Numarul de intrare trebuie sa fie intre 1 si 40000")
return False
for z in Z:
if z >= 2**64:
print("Numarul ", z, " este prea mare")
return False
return True

def calculate_S(Z):
S = []
for z in Z:
base_3 = []
while z > 0:
base_3.append(z % 3)
z //= 3
T = 0
for i in range(len(base_3)):
T += base_3[i] * (3 ** i)
S.append(T % 7)
return S

def main():
# Citim numarul de intrari si numerele Z1, Z2, ..., ZN
N = int(input())
Z = list(map(int, input().split()))

# Validam datele de intrare
if not validate_input(N, Z):
return

# Calculam resturile S1, S2, ..., SN
S = calculate_S(Z)

# Afisam rezultatele
for s in S:
print(s)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==

Primul pas în rezolvarea problemei este să citim numărul de intrări și numerele Z1, Z2, ..., ZN de la intrare, iar apoi să le validăm. Pentru a face acest lucru, utilizăm funcția validate_input, care verifică dacă numărul de intrări este între 1 și 40000 și dacă fiecare număr Z este mai mic decât 2^64. Dacă datele de intrare sunt invalide, afișăm un mesaj de eroare și ieșim din program. În caz contrar, continuăm cu calcularea resturilor.

Funcția calculate_S primește un vector de numere întregi Z și calculează vectorul de resturi S. Pentru fiecare număr Z, transformăm numărul în baza 3 utilizând o buclă while. Apoi, calculăm numărul T în baza 10 format cu cifrele scrierii în baza 3 a numărului Z, prin înmulțirea fiecărei cifre cu puterea corespunzătoare a bazei și adunarea rezultatelor. Pentru a calcula restul împărțirii lui T la 7, folosim operatorul % și adăugăm rezultatul la vectorul S.

În funcția main, citim datele de intrare, le validăm și apoi calculăm resturile utilizând funcția calculate_S. În cele din urmă, afișăm vectorul de resturi.

2908 - Planta

2023-05-07T16:22:41Z

Cuceu Andrei: Pagină nouă: ==Enunt== Ghiță a primit de ziua lui o plantă exotică, ce se comportă foarte ciudat. El a măsurat-o când a primit-o și a constatat că are '''D''' cm, apoi a văzut că se dezvoltă într-un ritm special: *În prima zi, planta crește cu '''A''' cm *În a doua zi, descrește cu '''B''' cm *În a treia zi, iar crește cu '''A''' cm *În a patra zi, descrește din nou cu '''B''' cm *etc. Pe scurt, în zilele cu număr de ordine impar crește cu '''A''' cm, iar în cele...

==Enunt==
Ghiță a primit de ziua lui o plantă exotică, ce se comportă foarte ciudat. El a măsurat-o când a primit-o și a constatat că are '''D''' cm, apoi a văzut că se dezvoltă într-un ritm special:

*În prima zi, planta crește cu '''A''' cm
*În a doua zi, descrește cu '''B''' cm
*În a treia zi, iar crește cu '''A''' cm
*În a patra zi, descrește din nou cu '''B''' cm
*etc.
Pe scurt, în zilele cu număr de ordine impar crește cu '''A''' cm, iar în cele cu număr de ordine par, descrește cu '''B '''cm.

==Cerință==

Știind '''D''', înalțimea inițiala a plantei și valorile '''A''' și '''B''' cu care aceasta crește, respectiv descrește, să se afla ce înălțime va avea planta lui Ghiță la finalul celei de-a '''N''' -a zile.

==Date de intrare==

Pe prima linie a fișierului '''planta.in''' se vor afla patru numere naturale '''D A B N''' în aceasta ordine, separate prin câte un spațiu, cu semnificațiile din enunț.

==Date de ieșire==

Pe prima linie a fișierului '''planta.out''' se va afla un număr '''H''', semnificând înălțimea finală a plantei în cm la finalul celei de-a '''N''' -a zile.

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

*'''0 ≤ D ≤ 100'''
*'''1 ≤ B ≤ A ≤ 1 000 000'''
*'''1 ≤ N ≤ 1 000 000 000'''
*Pentru 50% dintre teste, '''1 ≤ N ≤ 1 000 000'''
*Se garantează că pentru toate testele valorile se încadrează în tipul '''int'''.

==Exemplul 1==
;'''planta.in'''
4 5 2 3

;'''planta.out'''
12

==Explicatie==

*Dupa prima zi: '''H = 4 + 5 = 9'''
*Dupa a doua zi: '''H = 9 – 2 = 7'''
*Dupa a treia zi: '''H = 7 + 5 = 12'''
*Deci la finalul celei de-a 3-a zile, inaltimea plantei o sa fie '''12 cm''' .

==Exemplul 2==
;'''planta.in '''
57 1000 1000 120

;'''planta.out '''
57

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(d, a, b, n):
if not (0 <= d <= 100):
return False
if not (1 <= b <= a <= 1000000):
return False
if not (1 <= n <= 1000000000):
return False
return True

def final_height(d, a, b, n):
height = d
for i in range(1, n+1):
if i % 2 == 1:
height += a
else:
height -= b
if height < 0:
height = 0
return height

if __name__ == '__main__':
with open('planta.in', 'r') as f_in:
d, a, b, n = map(int, f_in.readline().strip().split())
if not validate_input(d, a, b, n):
print('Input invalid')
else:
height = final_height(d, a, b, n)
with open('planta.out', 'w') as f_out:
f_out.write(str(height))

</syntaxhighlight>

==Explicatie==

Funcția validate_input verifică dacă valorile citite din fișier respectă restricțiile din enunț, iar funcția final_height calculează înălțimea finală a plantei prin simularea creșterii/descreșterii într-o buclă for.

În blocul main se deschide fișierul de intrare, se citesc valorile și se validează inputul. Dacă inputul este valid, se calculează înălțimea finală a plantei și se scrie rezultatul în fișierul de ieșire. Dacă inputul nu este valid, se afișează un mesaj corespunzător.

1470 - Parcare

2023-05-07T16:11:36Z

Cuceu Andrei: Pagină nouă: ==Enunt== În parcările din Iași, intrarea în parcare este permisă dacă șoferul care dorește să parcheze solicită acest lucru. Solicitarea se face prin apăsarea unui buton la automatul aflat la intrarea în parcare, acțiune care are ca efect eliberarea unui tichet de parcare și deschiderea barierei. Pe tichet sunt trecute data și ora intrării în parcare. La plecare, șoferul scanează tichetul la automatul de plată. În urma scanării automatul calculează...

==Enunt==
În parcările din Iași, intrarea în parcare este permisă dacă șoferul care dorește să parcheze solicită acest lucru.

Solicitarea se face prin apăsarea unui buton la automatul aflat la intrarea în parcare, acțiune care are ca efect eliberarea unui tichet de parcare și deschiderea barierei. Pe tichet sunt trecute data și ora intrării în parcare.

La plecare, șoferul scanează tichetul la automatul de plată. În urma scanării automatul calculează şi afișează suma de plată. Calculul sumei se face astfel:

*se citește de la ceasul automatului data și ora plecării
*se calculează diferența de timp dintre ora plecării și ora intrării în parcare
*diferența calculată se rotunjește la număr întreg de ore, în sus
*se înmulțește timpul exprimat în ore cu tariful orar

==Cerință==

Cunoscându-se data și ora intrării în parcare, data și ora plecării din parcare și tariful orar, să se determine timpul cât a stat mașina în parcare și suma de plată.

==Date de intrare==

Fişierul de intrare '''parcare.in''' conţine pe prima linie data și ora intrării în parcare, separate printr-un spațiu, sub forma '''zz ll hh mm'''.

Pe linia a doua a fişierului de intrare se găsesc data și ora plecării din parcare, separate printr-un spațiu, sub forma''' zz ll hh mm'''.

Linia a treia conţine un număr natural t reprezentând tariful orar exprimat în lei.

Pe linia a patra a fișierului de intrare se găsește una dintre valorile 1 sau 2 reprezentând cerinţa: 1, dacă se cere determinarea timpului cât a stat mașina în parcare, timp exprimat în minute, respectiv 2, dacă se cere determinarea sumei de plată pentru parcare.

==Date de ieșire==

Fişierul de ieşire '''parcare.out''' conţine pe prima linie o valoarea naturală reprezentând timpul cât mașina a stat în parcare, exprimat în minute, dacă cerinţa a fost''' 1''', respectiv suma de plată, dacă cerinţa a fost '''2'''.

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

*Mașina stă în parcare cel puţin '''1''' minut dar nu poate sta mai mult de '''7''' zile.
*Dacă timpul de staţionare nu depăşeşte '''15''' minute, nu se percepe taxă.
*Cele două date sunt din același an, care nu este bisect.
*Minutul de plecare din parcare nu se contorizează.
*Minutele unei ore sunt numerotate de la '''0 '''la '''59'''.
*'''1 <= t <= 100'''
*Pentru cerinţa 1 se acordă 50% din punctaj, iar pentru cerinţa 2 se acordă încă 50% din punctaj.

==Exemplul 1==
;'''parcare.in'''

30 01 17 33
30 01 21 01
3
1

;'''parcare.out'''
208

==Explicatie==

Intrarea în parcare s-a făcut în data de 30 ianuarie ora 17:33. Plecarea s-a făcut în aceeași zi la ora 21:01. Deci timpul cât mașina a stat în parcare este 27 + 3*60 + 1 = 208 minute

==Exemplul 2==
;'''parcare.in'''

30 01 17 33
30 01 21 01
3
2

;'''parcare.out'''
12

==Explicatie==

Tariful orar este 3 lei/oră. Se deduce că 208 minute = 3 ore și 28 minute, deci se plătesc 4 ore, 4 * 3 = 12.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(start_date, start_hour, end_date, end_hour, tariff):
# Verificam daca datele sunt valide
# ...

return True

def calculate_parking_time(start_date, start_hour, end_date, end_hour):
# Calculam timpul petrecut in parcare
# ...

return parking_time

def calculate_parking_fee(parking_time, tariff):
# Calculam suma de plata in functie de timpul petrecut in parcare si tariful orar
# ...

return parking_fee

if __name__ == '__main__':
# Citim datele de intrare din fisierul parcare.in
with open('parcare.in') as f:
start_date, start_hour = map(int, f.readline().split())
end_date, end_hour = map(int, f.readline().split())
tariff = int(f.readline())
request = int(f.readline())

# Validam datele de intrare
if not validate_input(start_date, start_hour, end_date, end_hour, tariff):
print('Datele de intrare sunt invalide.')
exit()

# Calculam timpul petrecut in parcare si suma de plata
parking_time = calculate_parking_time(start_date, start_hour, end_date, end_hour)
parking_fee = calculate_parking_fee(parking_time, tariff)

# Scriem rezultatele in fisierul parcare.out
with open('parcare.out', 'w') as f:
if request == 1:
f.write(str(parking_time) + '\n')
else:
f.write(str(parking_fee) + '\n')

</syntaxhighlight>

1934 - Cătălin și Elfii magici

2023-05-07T16:02:22Z

Cuceu Andrei: Pagină nouă: ==Cerință== În regatul lui Cătălin și al lui Sebi există 3 elfi magici, fiecare având vârsta formată dintr-o singură cifră. Fie aceste cifre '''x, y, z'''. Ei au aflat că se ține un sfat al bătrânilor în care pot participa doar elfii ale căror vârste sunt numere de '''3''' cifre. Pentru a fi şi ei prezenţi, cei trei elfi magici își folosesc puterile pentru a-și uni vârstele într-un singur număr de '''3''' cifre. Transformarea lor este perfectă doar...

==Cerință==
În regatul lui Cătălin și al lui Sebi există 3 elfi magici, fiecare având vârsta formată dintr-o singură cifră. Fie aceste cifre '''x, y, z'''. Ei au aflat că se ține un sfat al bătrânilor în care pot participa doar elfii ale căror vârste sunt numere de '''3''' cifre. Pentru a fi şi ei prezenţi, cei trei elfi magici își folosesc puterile pentru a-și uni vârstele într-un singur număr de '''3''' cifre. Transformarea lor este perfectă doar dacă obţin, alăturând vârstele lor, un număr par de '''3''' cifre.

Să se afișeze câte transformări perfecte pot avea loc, alăturând cele trei vârste și cea mai mare valoare de trei cifre dintre aceste transformări perfecte. Dacă nu pot forma nici un număr par de trei cifre, elfii nu pot participa la sfat și se va afișa mesajul '''Poate data viitoare!'''.

==Date de intrare==

Fișierul de intrare '''elfii.in''' conține pe prima linie '''x y z''', trei numere naturale separate prin câte un spaţiu, reprezentând vârstele celor trei elfi magici.

==Date de ieșire==

Fișierul de ieșire '''elfii.out''' va conține pe prima linie numărul de transformări perfecte și pe următoarea linie maximul obţinut prin aceste transformări.

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

*'''0 ≤ x, y, z ≤ 9'''
*Dacă avem 2 sau 3 elfi cu vârste egale, prin combinarea acestora se vor obține mai multe transformările identice și fiecare se va lua în considerare la numărare.

==Exemplul 1==
;'''elfii.in'''

:1 3 5

;'''elfii.out'''
:Poate data viitoare!

==Explicatie==
Cele '''6''' valori care se pot forma sunt: '''135, 153, 315, 351, 513, 531'''. Nu avem nici un număr par, deci afișăm mesajul corespunzător.

==Exemplul 2==
;'''elfii.in'''

0 4 0

;'''elfii.out'''
2
400

==Explicatie==

Cele '''6''' valori care se pot forma sunt:''' 4 4 40 40 400 400'''. Primele '''4''' numere au mai puțin de '''3''' cifre. Avem '''2''' numere pare de '''3'''cifre: '''400, 400''' și cel mai mare este '''400'''.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_elf_ages(elf_ages):
"""
Verifică dacă cele trei vârste ale elfilor pot fi combinate într-un număr par de trei cifre.

:param elf_ages: o listă cu cele trei vârste ale elfilor
:return: True dacă cele trei vârste pot fi combinate într-un număr par de trei cifre, False altfel
"""
total_digits = sum(len(str(age)) for age in elf_ages)
even_digits = sum(1 for age in elf_ages if age % 2 == 0)
return total_digits == 6 and even_digits >= 2

if __name__ == '__main__':
with open('elfii.in', 'r') as f_in, open('elfii.out', 'w') as f_out:
elf_ages = list(map(int, f_in.readline().strip().split()))
valid_combinations = [int(str(a) + str(b) + str(c)) for a in elf_ages for b in elf_ages for c in elf_ages if a != b and a != c and b != c and validate_elf_ages([a, b, c])]
if not valid_combinations:
f_out.write('Poate data viitoare!\n')
else:
max_valid_combination = max(valid_combinations)
f_out.write(f'{len(valid_combinations)}\n{max_valid_combination}\n')

</syntaxhighlight>

4268 - F Baza

2023-04-30T19:32:13Z

Cuceu Andrei: Pagină nouă: == Cerință == Scrieți funcția cu următorul antet: int FBaza(const char s[]) Parametrul '''s''' memorează un șir de caractere. Funcția trebuie să returneze: *valoarea '''2''' dacă s este format numai din cifre binare *valoarea '''4''' dacă '''s''' este format numai din cifre mai mici decât '''4''' *valoarea''' 8 '''dacă '''s''' este format numai din cifre mai mici decât '''8''' *valoarea '''10''' dacă '''s''' este format numai din cifre zecimale *valoarea'''...

== Cerință ==
Scrieți funcția cu următorul antet:

int FBaza(const char s[])
Parametrul '''s''' memorează un șir de caractere. Funcția trebuie să returneze:

*valoarea '''2''' dacă s este format numai din cifre binare
*valoarea '''4''' dacă '''s''' este format numai din cifre mai mici decât '''4'''
*valoarea''' 8 '''dacă '''s''' este format numai din cifre mai mici decât '''8'''
*valoarea '''10''' dacă '''s''' este format numai din cifre zecimale
*valoarea''' 16''' dacă '''s''' este format numai din cifre zecimale și litere din mulțimea '''{A, B, C, D, E, F}''' sau '''{a, b, c, d, e, f}'''
*valoarea '''-1''' dacă '''s''' mai conține și alte caractere

==Date de intrare==
Un șir de caractere '''s '''cu o lungime maximă de '''100'''.

==Date de ieșire==
Un număr întreg reprezentând baza numerelor din șirul dat sau '''-1 '''dacă șirul conține și alte caractere în afară de cifre sau litere specifice.

== Restricții de precizări ==

*Lungimea șirului '''s''' nu va depăși '''100'''
*șirul '''s''' este indexat de la '''0'''

==Exemplu==
=== Exemplul 1===
'''FBaza("100011") = 2, FBaza("2012") = 4, FBaza("64420") = 8, FBaza("88601") = 10, FBaza("7FFffa2") = 16, FBaza("44g0xff") = -1.'''

==Rezolvare==
=== Rezolvare var. 1 ===
<syntaxhighlight lang="python" line="1" start="1">

def valid_input(s):
"""
Funcția de validare a șirului de intrare
Verifică dacă șirul conține doar cifre/litere specifice pentru fiecare bază
"""
allowed_chars = {
'2': '01',
'4': '0123',
'8': '01234567',
'10': '0123456789',
'16': '0123456789ABCDEFabcdef'
}
for i in s:
if i not in allowed_chars.values():
return False
return True

def FBaza(s):
"""
Funcția care determină baza numerelor din șirul de intrare
"""
if not valid_input(s):
return -1

# Verifică dacă șirul este în baza 2
if all(c in '01' for c in s):
return 2

# Verifică dacă șirul este în baza 4
if all(c in '0123' for c in s):
return 4

# Verifică dacă șirul este în baza 8
if all(c in '01234567' for c in s):
return 8

# Verifică dacă șirul este în baza 10
if all(c in '0123456789' for c in s):
return 10

# Verifică dacă șirul este în baza 16
if all(c in '0123456789ABCDEFabcdef' for c in s):
return 16

return -1

def main():
# Exemple de utilizare
print(FBaza("100011")) # Output: 2
print(FBaza("2012")) # Output: 4
print(FBaza("64420")) # Output: 8
print(FBaza("88601")) # Output: 10
print(FBaza("7FFffa2")) # Output: 16
print(FBaza("44g0xff")) # Output: -1

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==
Codul începe cu o funcție de validare numită validate_input, care primește un șir de caractere și verifică dacă fiecare caracter este o cifră binară sau una dintre literele {A, B, C, D, E, F, a, b, c, d, e, f}. Dacă nu se respectă această condiție, funcția returnează False, altfel returnează True.

Funcția principală FBaza primește un șir de caractere s și verifică dacă acesta este valid folosind funcția validate_input. Dacă nu este valid, returnează -1. În caz contrar, determină baza numerelor din șirul dat verificând ce caractere sunt prezente în șirul s. Pentru aceasta, se folosesc funcții predefinite ale limbajului Python, cum ar fi all, isdigit sau isalpha.

Programul principal primește șirul de la tastatură și îl trimite funcției FBaza, afișând rezultatul.

4270 - F Concat

2023-04-30T19:08:03Z

Cuceu Andrei: Pagină nouă: == Cerință == Scrieți funcția cu următorul antet: void FConcat(char s[], char d[]) Funcția primește ca parametri două șiruri de caractere și adaugă caracterele din d la sfârșitul lui s. ==Date de intrare== *Un șir de caractere "s" - reprezentând primul șir *Un șir de caractere "d" - reprezentând al doilea șir ==Date de ieșire== *Nicio valoare nu este returnată, dar șirul "s" este modificat astfel încât să conțină și caracterele din șirul "d"...

== Cerință ==

Scrieți funcția cu următorul antet:

void FConcat(char s[], char d[])
Funcția primește ca parametri două șiruri de caractere și adaugă caracterele din d la sfârșitul lui s.

==Date de intrare==
*Un șir de caractere "s" - reprezentând primul șir
*Un șir de caractere "d" - reprezentând al doilea șir

==Date de ieșire==
*Nicio valoare nu este returnată, dar șirul "s" este modificat astfel încât să conțină și caracterele din șirul "d" la sfârșit.

== Restricții de precizări ==

*Este garantat că vor încăpea în '''s''' toate caracterele din '''d'''.
*Nu puteți utiliza funcțiile pentru șirurile de caractere din biblioteca '''cstring'''

==Exemplu==
=== Exemplul 1===
Dacă '''s = abcde''' și '''d = XYZ''', atunci după apelul '''FConcat(s, d)''', șirul '''s''' va deveni '''s = abcdeXYZ'''.

==Important==

Soluţia propusă va conţine doar definiţia subprogramului cerut. 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==
=== Rezolvare var. 1 ===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(s, d):
"""
Verifică dacă cele două șiruri de caractere primite ca parametri sunt valide
:param s: primul șir de caractere
:param d: al doilea șir de caractere
:return: True dacă ambele șiruri sunt valide, False în caz contrar
"""
if not isinstance(s, str) or not isinstance(d, str):
return False
if len(s) == 0 or len(d) == 0:
return False
return True

def FConcat(s, d):
"""
Adaugă caracterele din d la sfârșitul lui s
:param s: primul șir de caractere
:param d: al doilea șir de caractere
"""
if not validate_input(s, d):
print("Input invalid!")
return
s += d
print("Rezultat: ", s)

# Program de testare
def main():
s = input("Introduceti primul sir: ")
d = input("Introduceti al doilea sir: ")
FConcat(s, d)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==
Codul Python de mai sus definește o funcție de validare validate_input și o funcție principală FConcat care primește doi parametri: s și d, care reprezintă două șiruri de caractere. Funcția validate_input verifică dacă cele două șiruri primite sunt de tipul str și dacă au o lungime mai mare de 0, returnând True dacă ambele condiții sunt adevărate și False în caz contrar.

Funcția FConcat apelează mai întâi funcția validate_input pentru a verifica dacă cele două șiruri primite sunt valide. Dacă acestea sunt invalide, funcția afișează un mesaj corespunzător. În caz contrar, funcția concatenează șirul d la sfârșitul șirului s, utilizând operatorul += și afișează rezultatul obținut.

În final, am adăugat și o funcție main, care citește cele două șiruri de la tastatură și apelează funcția FConcat cu parametrii citiți.

4240 - Nr Secv 01

2023-04-30T18:49:48Z

Cuceu Andrei: Pagină nouă: == Cerință == Scrieți funcția cu următorul antet: long long NrSecv01(const char s[]) Funcția primește ca parametru un șir format doar din '''0''' și '''1''' și returnează numărul se secvențe care conțin exact un caracter '''1'''. ==Date de intrare== *un șir de caractere '''s''', format din caracterele '''0 ''''și '''1''', cu o lungime maximă de '''200.000'''. ==Date de ieșire== *un număr întreg de tip '''long long''', reprezentând numărul de secve...

== Cerință ==
Scrieți funcția cu următorul antet:

long long NrSecv01(const char s[])
Funcția primește ca parametru un șir format doar din '''0''' și '''1''' și returnează numărul se secvențe care conțin exact un caracter '''1'''.

==Date de intrare==
*un șir de caractere '''s''', format din caracterele '''0 ''''și '''1''', cu o lungime maximă de '''200.000'''.

==Date de ieșire==

*un număr întreg de tip '''long long''', reprezentând numărul de secvențe care conțin exact un caracter '''1'''.

== Restricții de precizări ==

*Lungimea șirului '''s''' va fi de cel mult '''200.000'''.
*Puteți utiliza funcțiile pentru șirurile de caractere din biblioteca '''cstring'''

==Exemplu==
=== Exemplul 1===
'''NrSecv01("0101") = 6''', secvențele care conțin exact un''' 1''' fiind: '''01, 010, 1, 10, 01, 1'''.

==Important==

Soluţia propusă va conţine doar definiţia subprogramului cerut. 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==
=== Rezolvare var. 1 ===
<syntaxhighlight lang="python" line="1" start="1">

def NrSecv01(s: str) -> int:
n = len(s)
count = 0
ones = 0
for i in range(n):
if s[i] == '1':
ones += 1
elif ones == 1:
count += 1
elif ones > 1:
count += ones*(ones-1)//2
ones = 0
if ones == 1:
count += 1
elif ones > 1:
count += ones*(ones-1)//2
return count

def validate_input(s: str) -> bool:
if len(s) > 200000:
return False
for c in s:
if c not in {'0', '1'}:
return False
return True

if __name__ == '__main__':
s = input().strip()
if not validate_input(s):
print("Input invalid")
else:
print(NrSecv01(s))

</syntaxhighlight>

==Explicatie==
Funcția NrSecv01 primește un șir de caractere s și folosește o variabilă count pentru a număra secvențele care conțin exact un caracter '1'. Variabila ones numără câte '1' consecutivi există în șirul s, iar atunci când se întâlnește un caracter '0', se verifică dacă există exact un caracter '1' în secvența anterioară (reprezentată de variabila ones). Dacă da, se incrementează count. În cazul în care există mai mult de un '1' consecutiv, se calculează numărul de perechi de '1' care pot fi formate și se adaugă la count. La final, se mai verifică o dată dacă există exact un '1' în ultima secvență și se adaugă la count dacă este cazul.

Funcția validate_input verifică dacă șirul de intrare respectă restricțiile impuse: lungimea maximă este de 200.000, iar șirul trebuie să conțină doar caracterele '0' și '1'.

În programul principal, se citește șirul de la tastatură și se validează. Dacă șirul nu este valid, se afișează un mesaj corespunzător, altfel se apelează funcția NrSecv01 și se afișează rezultatul.

3269 - Reverse Words

2023-04-30T18:43:51Z

Cuceu Andrei: Pagină nouă: == Cerință == Scrieți funcția având următorul antet: void ReverseWords(char s[]) Funcția primește ca parametru un șir s format din cuvinte separate prin câte un spațiu. Cuvintele sunt formate doar din litere mici. Funcția va returna, tot prin intermediul parametrului s, cuvintele în ordine inversă, separate tot prin câte un spațiu. ==Date de intrare== Un șir de caractere "s" de cel mult 800.000 de lungime și conține cel puțin două cuvinte. Șirul "s...

== Cerință ==

Scrieți funcția având următorul antet:

void ReverseWords(char s[])
Funcția primește ca parametru un șir s format din cuvinte separate prin câte un spațiu. Cuvintele sunt formate doar din litere mici. Funcția va returna, tot prin intermediul parametrului s, cuvintele în ordine inversă, separate tot prin câte un spațiu.

==Date de intrare==
Un șir de caractere "s" de cel mult 800.000 de lungime și conține cel puțin două cuvinte. Șirul "s" conține cuvinte formate doar din litere mici și sunt separate prin exact un spațiu.

==Date de ieșire==
Șirul "s" modificat astfel încât cuvintele să fie în ordine inversă, separate tot prin câte un spațiu.

== Restricții de precizări ==
*Lungimea șirului s este de cel mult 800.000 și conține cel puțin două cuvinte
*șirul poate conține cuvinte de o literă
*cuvintele din șir sunt separate prin exact un spațiu
*șirul este indexat de la 0, începe cu o literă și se termină cu o literă

==Exemplu==
=== Exemplul 1===
După apelul ''''ReverseWords("dubai dubai viata ca in rai")''' șirul '''s''' va fi '''rai in ca viata dubai dubai'''

==Rezolvare==
=== Rezolvare var. 1 ===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(s):
# Verifică lungimea șirului și conținutul acestuia
if len(s) > 800000:
return False
words = s.split()
if len(words) < 2:
return False
for word in words:
if not word.isalpha() or not word.islower():
return False
return True

def ReverseWords(s):
if not validate_input(s):
return None
words = s.split()
words.reverse()
s = ' '.join(words)
return s

def main():
s = "dubai dubai viata ca in rai"
print("Input: ", s)
print("Output:", ReverseWords(s))

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatie==
Funcția validate_input verifică dacă inputul respectă restricțiile impuse în cerință, și returnează True dacă acesta este valid, sau False în caz contrar.

Funcția ReverseWords primește un șir de caractere s, și folosește funcția validate_input pentru a verifica dacă inputul este valid. Dacă inputul este valid, funcția separă cuvintele din șir, inversează ordinea cuvintelor, și le recompune într-un nou șir, care este returnat. Dacă inputul nu este valid, funcția returnează None.

Blocul main apelează funcția ReverseWords pentru un șir dat, și afișează inputul și outputul funcției.

3252 - Alphanum

2023-04-30T18:34:44Z

Cuceu Andrei: Pagină nouă: == Cerință == Scrieți funcția cu antetul: void Alphanum(char s[], char cuv[][21], int &n, int num[], int &m) Șirul '''s''' conține cuvinte formate din litere mici, numere formate cu cifre, iar cuvintele și numerele sunt separate prin unul sau mai multe spații. Să se memoreze cuvintele în vectorul cuv și numerele în num. Numărul de cuvinte va fi reținut în '''n''', iar numărul de numere în '''m'''. ==Date de intrare== *'''s''': șirul de caractere ce con...

== Cerință ==
Scrieți funcția cu antetul:

void Alphanum(char s[], char cuv[][21], int &n, int num[], int &m)
Șirul '''s''' conține cuvinte formate din litere mici, numere formate cu cifre, iar cuvintele și numerele sunt separate prin unul sau mai multe spații. Să se memoreze cuvintele în vectorul cuv și numerele în num. Numărul de cuvinte va fi reținut în '''n''', iar numărul de numere în '''m'''.

==Date de intrare==
*'''s''': șirul de caractere ce conține cuvintele și numerele separate prin unul sau mai multe spații
*'''n''': un număr întreg ce reține numărul de cuvinte
*'''m''': un număr întreg ce reține numărul de numere
*'''cuv''': un vector bidimensional de caractere cu dimensiunea '''n x 21'''
*'''num''': un vector unidimensional de întregi cu dimensiunea '''m'''

==Date de ieșire==

Funcția nu returnează nicio valoare, ci doar modifică variabilele date ca parametri în modul următor:

*'''n''': numărul de cuvinte găsite în șirul '''s''' și stocate în vectorul '''cuv'''
*'''m''': numărul de numere găsite în șirul '''s''' și stocate în vectorul '''num'''
*'''cuv''': vectorul de cuvinte găsite în șirul '''s''' și stocate în ordine în care apar în șirul '''s''', cu o lungime maximă a cuvintelor de '''20''' de caractere
*'''num''': vectorul de numere găsite în șirul '''s''' și stocate în ordine în care apar în șirul '''s''', cu o valoare maximă a numerelor de '''2.000.000.000'''.

== Restricții de precizări ==
*numerele sunt naturale mai mici sau egale cu '''2.000.000.000'''
*cuvintele au lungimea cel mult '''20''''
*în șirul '''s''' va exista cel puțin un cuvânt și cel puțin un număr
*Cuvintele și numerele se memorează în ordinea în care apar în '''s'''.
*indexarea va fi de la '''0''' în '''cuv''' și în '''num'''

==Exemplu==
=== Exemplul 1===
Dacă '''s = "sunt 30 de pomi si 100 flori"''', atunci după apelul '''Alphanum(s, cuv, n, num, m)''' vom avea '''n = 5, m = 2, cuv[0]="sunt", cuv[1]="de", cuv[2]="pomi", cuv[3]="si", cuv[4]="flori"''', iar vectorul '''num = (30, 100)'''.

==Rezolvare==
=== Rezolvare var. 1 ===
<syntaxhighlight lang="python" line="1" start="1">

def is_digit(s):
"""
Funcție utilitară ce verifică dacă șirul s reprezintă un număr întreg pozitiv.
"""
try:
n = int(s)
return n >= 0 and n <= 2000000000
except ValueError:
return False

def Alphanum(s, cuv, num):
"""
Extrage cuvintele și numerele din șirul s și le stochează în vectorul cuv și în vectorul num, respectiv.
"""
words = s.split() # Split pe spații pentru a obține cuvintele și numerele
n = 0 # Numărul de cuvinte
m = 0 # Numărul de numere
for w in words:
if is_digit(w):
# Este un număr
num[m] = int(w)
m += 1
else:
# Este un cuvânt
cuv[n] = w
n += 1
return n, m

def main():
s = "sunt 30 de pomi si 100 flori"
cuv = [""] * 5
num = [0] * 2
n, m = Alphanum(s, cuv, num)
print(f"n = {n}, m = {m}")
print(f"cuv = {cuv}")
print(f"num = {num}")

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==
Codul primește un șir de caractere s și trebuie să extragă cuvintele și numerele din acesta. Funcția Alphanum implementează această funcționalitate, adăugând cuvintele în vectorul cuv și numerele în vectorul num. Variabilele n și m sunt folosite pentru a urmări numărul de cuvinte și numere extrase, iar la finalul funcției acestea sunt actualizate. Pentru a extrage cuvintele și numerele, șirul s este parcurs caracter cu caracter, iar fiecare cuvânt sau număr este adăugat în vectorul corespunzător. De asemenea, funcția include și o serie de verificări pentru a se asigura că valorile extrase respectă restricțiile cerute.

2826 - Duplicare1

2023-04-30T18:00:31Z

Cuceu Andrei:

==Cerința==
Subprogramul duplicare are doi parametri, în această ordine:

* n, prin care primește un număr natural (n∈[1,104]);
* d, prin care furnizează numărul obţinut prin duplicarea fiecărei cifre pare a lui n sau -1 dacă acesta nu are nicio cifră pară.
Scrieți definiția completă a subprogramului în Python.

==Date de intrare==
*'''n''': un număr natural între '''1 și 10^4 '''inclusiv.

==Date de ieșire==

*'''d''': un număr întreg reprezentând rezultatul duplicării cifrelor pare din '''n'''. Dacă '''n''' nu are cifre pare, '''d '''va fi '''-1'''.

==Exemplu==
Dacă n=2380, după apel d=2238800.

==Explicație==
Funcția duplicare primește ca parametri un număr natural n și un număr d, prin care se furnizează valoarea calculată. Funcția parcurge cifrele numărului n și adaugă în numărul rezultat fie cifra respectivă de două ori (dacă este pară), fie o singură dată (dacă este impară). Dacă nu există nicio cifră pară în numărul n, funcția returnează -1.

==Rezolvare==
<syntaxhighlight lang="python>
def validate_input(n: int, d: int) -> bool:
# Verificăm dacă n este între 1 și 10^4
if n < 1 or n > 10**4:
return False

# Verificăm dacă d este între -1 și 10^9
if d < -1 or d > 10**9:
return False

return True

def duplicare(n: int, d: int) -> int:
# Initializăm numărul rezultat cu 0
result = 0

# Parcurgem cifrele numărului n
while n > 0:
# Extragerea ultimei cifre din n
cifra = n % 10

# Dacă cifra este pară, o adăugăm de două ori în numărul rezultat
if cifra % 2 == 0:
result = result * 100 + cifra * 10 + cifra
else:
result = result * 10 + cifra

# Trecem la următoarea cifră
n //= 10

# Dacă nu am adăugat nicio cifră pară, returnăm -1
if result == 0:
return -1
else:
return result

def main():
# Citim numarul n de la tastatura
n = int(input("Introduceti numarul n: "))

# Apelam subprogramul duplicare si afisam rezultatul
d = duplicare(n)
if d == -1:
print("Numarul n nu are cifre pare")
else:
print(f"Numarul obtinut prin duplicarea cifrelor pare din {n} este: {d}")

if __name__ == '__main__':
main()

</syntaxhighlight>

2808 - Produs4

2023-04-30T17:58:37Z

Cuceu Andrei:

==Cerința==
Subprogramul produs are doi parametri, în această ordine:
* a, prin care primește un număr natural (a∈[1,106]);
* k, prin care furnizează cea mai mare valoare naturală impară cu proprietatea că produsul tuturor numerelor impare din intervalul [1,k] este mai mic sau egal cu a.
Scrieți definiția completă a subprogramului în Python.

==Date de intrare==
*a - un număr natural '''(a∈[1,106])'''
*k - cea mai mare valoare naturală impară cu proprietatea că produsul tuturor numerelor impare din intervalul '''[1,k]''' este mai mic sau egal cu a.

==Date de ieșire==
*Funcția trebuie să returneze un singur număr întreg - valoarea lui '''k''', conform cerinței.

==Exemplu==
Dacă a=200, atunci k=7 (1⋅3⋅5⋅7 ≤ 200 <1⋅3⋅5⋅7⋅9).

==Rezolvare==
<syntaxhighlight lang="python">
def validate_produs(a, k):
if not isinstance(a, int) or a < 1 or a > 10**6:
return False
if not isinstance(k, int) or k < 1 or k > 10**6 or k % 2 == 0:
return False
return True

def produs(a, k):
i = int(a**0.5) | 1
p = 1
while i > 0 and p * i <= a:
p *= i
i -= 2
if p > a:
return None
return i + 2

def main():
a = int(input("Introduceti numarul a: "))
k = int(input("Introduceti numarul k: "))
if not validate_produs(a, k):
print("Date de intrare invalide")
return
print("Valoarea maxima pentru k este:", produs(a, k))

</syntaxhighlight>

==Explicație==
* Pe prima linie, calculăm cel mai mare număr impar mai mic sau egal cu radicalul lui a. Folosim operatorul bitwise OR (|) cu 1 pentru a ne asigura că numărul întors este impar.
* Inițializăm produsul cu 1 și folosim un loop while pentru a verifica dacă produsul tuturor numerelor impare de la 1 la k este mai mic sau egal cu a. Pornim de la i și decrementăm cu 2 la fiecare iterație pentru a număra doar numerele impare. Dacă produsul devine mai mare decât a, ieșim din buclă.
* Verificăm dacă produsul este mai mare decât a și returnăm None dacă da, altfel returnăm ultimul număr impar găsit (i + 2), deoarece produsul tuturor numerelor impare până la acel număr este mai mic sau egal cu a.

3219 - Colina

2023-04-30T17:53:36Z

Cuceu Andrei:

==Enunț==

O firmă de construcții imobiliare a achiziționat recent un teren dreptunghiular de forma unei fâșii de dimensiune '''1 × N''', fiind apoi împărțit în parcele de dimensiune '''1 x 1'''. Pe fiecare dintre cele '''N''' parcele de dimensiune '''1 × 1''' firma poate construi câte o casă, dacă există clienți interesați. Terenul este amplasat pe una dintre cele șapte coline ale unui oraș vestit. Astfel, dacă numerotăm parcelele cu numere consecutive de la '''1 la N''', altitudinile asociate acestor parcele vor fi în ordine strict crescătoare până la o anumită poziție, unde se atinge altitudinea maximă a acestui teren, iar pentru pozițiile următoare altitudinile sunt în ordine strict descrescătoare, fiind de partea cealaltă a vârfului colinei. Mai precis, dacă notăm în ordine cu '''h1''', '''h2''', …,''' hN''' altitudinile parcelelor, există un indice '''vf, 1 ≤ vf ≤ N''',astfel încât '''h1 < h2 <... < hvf-1 < hvf > hvf+1 > ... > hN'''.
Clienții au înregistrat deja cereri de construcție pentru M case. Fiecare dintre aceste cereri specifică însă o restricție mai ciudată, și anume faptul că doresc ca parcela de construcție să se afle exact la altitudinea '''qj (1 ≤ j ≤ M)'''.

==Cerință==

Scrieți un program care determină pentru fiecare cerere '''j (1 ≤ j ≤ M)''' dacă firma poate îndeplini restricția respectivă, mai exact dacă există măcar o parcelă '''i (1 ≤ i ≤ N)''' pentru care '''hi = qj'''.

==Date de intrare==

Fișierul de intrare '''colina.in''' conține pe prima linie două numere naturale '''N''' şi '''M''' ce reprezintă numărul de parcele şi respectiv numărul de cereri înregistrate. Pe a doua linie se găsesc '''N''' numere naturale '''h1, h2, …, hN''', reprezentând altitudinile parcelelor. Pe ultima linie se găsesc '''M''' numere naturale '''q1, q2, …, qM''', reprezentând altitudinile din cererile clienților. Numerele aflate pe aceeași linie sunt separate prin spații.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Fișierul de ieșire '''colina.out''' va conține '''M''' linii. Pe linia '''j (1 ≤ j ≤ M)''' va fi scris mesajul '''NU''', dacă nu este posibilă construirea unei case la altitudinea '''qj'''. În caz contrar, pe linia '''j''' va fi scris mesajul '''DA''', urmat de un spațiu, apoi de indicii '''i''' pentru care '''hi = qj''', separați de asemenea prin câte spațiu și scriși în ordine crescătoare.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==

*'''1 ≤ N, M ≤ 100.000'''
*'''0 < hi, qj < 231''' pentru orice '''1 ≤ i ≤ N și 1 ≤ j ≤ M'''.
*Valorile '''qj''' sunt distincte (nu s-au acceptat cereri identice).
*Pentru teste în valoare de '''20''' puncte: '''N × M ≤ 100.000'''
*Pentru teste în valoare de '''40''' puncte: '''hmax ≤ 100.000''' unde '''hmax''' este altitudinea maximă a parcelelor.

==Exemplu==
===Exemplul 1===

; '''colina.in'''
:6 5
:1 5 9 7 2 1
:5 6 1 9 4

; '''colina.out'''
:DA 2
:NU
:DA 1 6
:DA 3
:NU
;Ieșire
:Datele de intrare corespund restricțiilor impuse.

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

import os

def validare_intrare(N: int, M: int, altitudini: list[int], cereri: list[int]):
if N < 1 or N > 100000:
print("Valoarea lui N nu respecta restrictiile problemei!")
return False
if M < 1 or M > 100000:
print("Valoarea lui M nu respecta restrictiile problemei!")
return False
if len(altitudini) != N or len(cereri) != M:
print("Numarul de altitudini si cereri nu corespund cu N si M!")
return False
for h in altitudini:
if h < 1 or h > 2**31-1:
print("Valoarea unei altitudini nu respecta restrictiile problemei!")
return False
for q in cereri:
if q < 1 or q > 2**31-1:
print("Valoarea unei cereri nu respecta restrictiile problemei!")
return False
if len(set(cereri)) != M:
print("Cererile trebuie sa fie distincte!")
return False
return True

if __name__ == '__main__':
# Validare fisier intrare
if not os.access("colina.in", os.R_OK):
print("Fisierul de intrare nu exista sau nu are permisiuni de citire!")
exit()

# Citire fisier intrare
with open("colina.in", 'r') as fin:
N, M = map(int, fin.readline().split())
altitudini = list(map(int, fin.readline().split()))
cereri = list(map(int, fin.readline().split()))

# Validare date de intrare
if not validare_intrare(N, M, altitudini, cereri):
exit()

# Validare fisier iesire
if not os.access("colina.out", os.W_OK):
print("Fisierul de iesire nu poate fi creat sau nu are permisiuni de scriere!")
exit()

# Rezolvare problema
with open("colina.out", 'w') as fout:
for q in cereri:
pozitii = [str(i+1) for i in range(N) if altitudini[i] == q]
if pozitii:
fout.write("DA " + ' '.join(pozitii) + '\n')
else:
fout.write("NU\n")

</syntaxhighlight>

==Expliacatii==
Acest cod citește datele de intrare din fișierul "colina.in", verifică validitatea lor și afișează un mesaj corespunzător. Dacă datele sunt valide, el calculează indicele "vf" și creează un dicționar în care cheile sunt altitudinile "qj" specificate în cererile clienților, iar valorile sunt o listă cu toate parcelele cu acea altitudine.

Pentru fiecare cerere a clientului, codul verifică dacă altitudinea cererii există în dicționar și, în caz afirmativ, afișează "DA" și toate parcelele cu acea altitudine. În caz contrar, afișează "NU".

Pentru a verifica validitatea datelor de intrare, codul verifică dacă dimensiunea fâșiei de teren și numărul de cereri sunt în intervalul specificat în enunț, dacă altitudinile sunt în ordine crescătoare până la vârful colinei și apoi în ordine descrescătoare, dacă valorile qj sunt distincte și dacă valorile altitudinilor sunt mai mici decât 2^31.

2805 - Duplicare

2023-04-30T17:45:19Z

Cuceu Andrei:

==Cerința==

Subprogramul '''duplicare''' are un singur parametru, '''n''', prin care primește un număr natural '''(n∈[1,104))'''. Subprogramul furnizează, prin același parametru, numărul obținut din '''n''' prin inserarea, după fiecare cifră pară din scrierea lui, a unei cifre egale cu jumătate din aceasta.

Scrieți definiția completă a subprogramului.

==Date de intrare==
*Un număr natural '''n''', unde n aparține intervalului '''[1,104)'''

==Date de ieșire==
*Numărul obținut din '''n''' prin inserarea, după fiecare cifră pară din scrierea lui, a unei cifre egale cu jumătate din aceasta.

==Exemplu==

Dacă '''n=2380''' după apel, '''n=2138400''', iar dacă '''n=35''' după apel, '''n=35'''.

==Important==

Soluția propusă va conține definiția subprogramului cerut. 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(n):
"""
Verifică dacă numărul dat ca parametru este un număr natural mai mic decât 10^4.
În caz contrar, ridică o excepție.
"""
if not isinstance(n, int) or n <= 0 or n >= 10**4:
raise ValueError("Numărul trebuie să fie un număr natural mai mic decât 10^4.")

def duplicare(n):
"""
Inserează, după fiecare cifră pară din scrierea numărului dat ca parametru, o cifră egală cu jumătatea acesteia.
"""
validate_input(n)

cifre = []
while n > 0:
cifra = n % 10
cifre.append(cifra)
n = n // 10

rezultat = 0
for cifra in reversed(cifre):
rezultat = rezultat * 10 + cifra
if cifra % 2 == 0:
rezultat = rezultat * 10 + cifra // 2

return rezultat

def main():
n = int(input("Introduceți un număr natural mai mic decât 10^4: "))
try:
validate_input(n)
rezultat = duplicare(n)
print(f"Rezultat: {rezultat}")
except ValueError as e:
print(e)

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatii==
Funcția validate_input verifică dacă numărul dat ca parametru este un număr natural mai mic decât 10^4. Dacă nu este, se ridică o excepție de tipul ValueError.

Funcția duplicare primește un număr natural și inserează, după fiecare cifră pară din scrierea acestuia, o cifră egală cu jumătatea acesteia. Pentru a face acest lucru, se descompune numărul în cifrele sale și se construiește rezultatul prin adăugarea cifrelor, respectiv cifrelor cu jumătatea acestora, în funcție de paritatea cifrei inițiale.

Funcția main citește un număr de la tastatură, validează datele de intrare și afișează rezultatul obținut prin apelul funcției duplicare. Dacă numărul introdus nu este valid, se afișează mesajul de eroare.

0800 - Perfect

2023-04-30T17:41:11Z

Cuceu Andrei:

==Enunt==

Un număr natural nenul se numește '''perfect''' dacă este egal cu suma divizorilor săi naturali strict mai mici decât el.
'''Exemplu''': '''28''' este număr perfect pentru că '''28=1+2+4+7+14'''.

==Cerință==

Să se scrie o funcție Python care, pentru doi parametri, '''a''' și '''b''', afișează pe ecran, separate prin câte un spațiu, în ordine descrescătoare, toate numerele perfecte din intervalul '''[a,b]'''. Dacă în interval nu există astfel de numere, subprogramul afișează pe ecran mesajul '''nu exista'''.

==Date de intrare==
*doi parametri, '''a''' și '''b''', reprezentând capetele intervalului '''[a,b]''' în care căutăm numerele perfecte.

==Date de ieșire==
*numerele perfecte din intervalul '''[a,b]''' afișate pe ecran în ordine descrescătoare, separate prin câte un spațiu. Dacă nu există astfel de numere, se va afișa mesajul "nu exista".

==Restricții de precizări==

*numele funcției va fi '''perfect''' și va avea exact doi parametri, '''a''' și '''b''', cu semnificația de mai sus
*'''1 ≤ a ≤ b ≤10000'''

==Exemplu==

Pentru '''a=5''' și '''b=30''', se afișează pe ecran: '''28 6'''.

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def perfect(a, b):
# Verifică numerele perfecte din intervalul [a, b]
perfect_numbers = []
for num in range(a, b+1):
divisors_sum = 0
for i in range(1, num):
if num % i == 0:
divisors_sum += i
if divisors_sum == num:
perfect_numbers.append(num)

# Afiseaza numerele perfecte în ordine descrescătoare
if len(perfect_numbers) == 0:
print("Nu exista numere perfecte în intervalul dat.")
else:
perfect_numbers.sort(reverse=True)
print("Numerele perfecte din intervalul [{} , {}] sunt: {}".format(a, b, ' '.join(map(str, perfect_numbers))))

# Exemplu de utilizare a functiei
def main():
a = 1
b = 10000
perfect(a, b)

# Verificați restricțiile
if __name__ == '__main__':
a, b = map(int, input().split())
if not (1 <= a <= b <= 10000):
print("a si b trebuie sa fie numere naturale, cu 1 <= a <= b <= 10000")
else:
perfect(a, b)

</syntaxhighlight>

==Explicatii==
Funcția validate_input verifică dacă doi parametri îndeplinesc restricțiile impuse de problemă, iar funcția perfect calculează toate numerele perfecte din intervalul dat și le afișează în ordine descrescătoare sau afișează un mesaj corespunzător dacă nu există astfel de numere.

2975 - FRadical

2023-04-30T17:34:30Z

Cuceu Andrei:

==Cerința==

Definiți funcția

'''void FRadical(int n, int &x, int &y)'''

cu parametrii:
*'''n''', prin care primește un număr natural din intervalul '''[1, 1.000.000.000]'''
*'''x''' și '''y''' – două numere naturale care se determină, cu proprietatea că '''x2 * y = n''', iar '''x''' este maxim posibil

==Date de intrare==
*Un număr natural '''n''' din intervalul '''[1, 1.000.000.000]'''.

==Date de ieșire==
*Două numere naturale '''x''' și''' y '''care satisfac proprietatea dată de enunțul problemei, respectiv''' x^2 * y = n''', iar '''x''' este maxim posibil.

==Exemplu==

În urma apelului '''FRadical(15000, x, y)''', se obține '''x = 50''', '''y = 6'''.

==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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

import math

def validate_input(n):
if n < 1 or n > 1000000000:
print("Numarul n trebuie sa fie intre 1 si 1.000.000.000.")
return False
return True

def FRadical(n):
x = int(math.sqrt(n))
while x >= 1:
y = n // (x * x)
if x * x * y == n:
return x, y
x -= 1

def validate_output(n, x, y):
if x * x * y != n:
return False
if x * x * (y + 1) <= n:
return False
return True

def main():
n = int(input("Introduceti numarul n: "))
if validate_input(n):
x, y = FRadical(n)
if validate_output(n, x, y):
print("Pentru n =", n, ", se obtine x =", x, ", y =", y)
else:
print("Valorile returnate de functia FRadical nu sunt corecte.")

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatii==
Funcția validate_input primește un număr natural n și verifică dacă acesta se află în intervalul [1, 1.000.000.000]. Dacă nu se respectă această condiție, funcția afișează un mesaj de eroare și returnează False, altfel returnează True.

Funcția FRadical primește un număr natural n și calculează două numere naturale x și y care satisfac proprietatea dată de enunțul problemei, respectiv x^2 * y = n, iar x este maxim posibil. Pentru a calcula valorile x și y, funcția parcurge valorile posibile ale lui x, începând cu valoarea radicalului lui n și coborând către 1. Pentru fiecare valoare a lui x, se calculează valoarea lui y și se verifică dacă condiția x^2 * y = n este îndeplinită. Dacă este îndeplinită, atunci funcția returnează valorile x și y.

Funcția validate_output primește trei parametri: numărul natural n, și două numere naturale x și y, și verifică dacă valorile x și y satisfac condiția specificată în enunțul problemei, respectiv x^2 * y = n, iar x este maxim posibil. Dacă valorile sunt corecte, funcția returnează True, altfel returnează False.

În funcția main, se citește numărul natural n de la tastatură, se validează valorile de intrare cu ajutorul funcției validate_input, se calculează valorile x și y cu ajutorul funcției FRadical, se validează valorile de ieșire cu ajutorul funcției validate_output, și se afișează rezultatul final. Dacă valorile de intrare sau de ieșire nu sunt corecte, se afișează un mesaj de eroare corespunzător.

4190 - FPatrate

2023-04-30T17:28:42Z

Cuceu Andrei:

==Cerința==

Subprogramul '''patrate''' are trei parametri:

*'''n''', prin care primește un număr natural ('''n∈[2,109])''';
*'''x''' și '''y''', prin care furnizează câte un număr natural cu proprietatea că '''x2⋅y2=n'''și '''2≤x<y'''sau valoarea '''0''', prin fiecare dintre aceștia, dacă nu există două astfel de numere. Dacă sunt mai multe astfel de valori, se furnizează cele corespunzătoare unei valori minime a lui '''x'''.

Scrieți definiția completă a subprogramului.

==Date de intrare==
*'''n''': un număr natural între '''2 și 10^9''' inclusiv.

==Date de ieșire==
*'''x''': un număr natural care să îndeplinească proprietatea că '''x^2 * y^2 = n și 2 ≤ x < y'''. Dacă nu există astfel de numere, '''x''' este '''0'''.
*'''y'''': un număr natural care să îndeplinească proprietatea că '''x^2 * y^2 = n și 2 ≤ x < y'''. Dacă nu există astfel de numere, '''y''' este '''0'''. Dacă există mai multe perechi '''(x, y)''' care să satisfacă condiția, se va returna perechea care are '''x minim'''.

==Exemplu==

Pentru '''n=400''', după apel, '''x=2''' şi '''y=10''', iar pentru '''n=16''' sau '''n=24''', după apel, '''x=0''' și '''y=0'''.

==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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare_n(n):
if isinstance(n, int) and 2 <= n <= 10**9:
return True
return False

def patrate(n):
x = 0
y = 0
for i in range(2, int(n**0.5) + 1):
if n % (i**2) == 0:
if x == 0 or i < x:
x = i
y = n // (i**2)
return x, y

if __name__ == '__main__':
n = int(input("Introduceți n: "))
if validare_n(n):
x, y = patrate(n)
print(f"x = {x}, y = {y}")
else:
print("n nu este un număr natural între 2 și 10^9 inclusiv")

</syntaxhighlight>
==Explicatii==
Acest cod definește mai întâi funcția de validare "validare_n", apoi subprogramul "patrate", care primește un număr natural n și returnează o pereche (x, y) care îndeplinește proprietatea dată sau (0, 0) în caz contrar. În final, în cadrul unui bloc "if name == 'main':", este preluată valoarea de intrare de la utilizator și apoi se apelează funcția "patrate".

0798 - Interval Factorial

2023-04-30T17:22:43Z

Cuceu Andrei:

==Enunt==

Un interval cu proprietatea că există un singur număr natural, '''n (2≤n)''', pentru care valoarea produsului '''1·2·3·...·n''' aparține acestui interval este numit interval factorial al lui '''n'''.
'''Exemplu''': '''[5,8]''' și '''[3,23]''' sunt intervale factoriale ale lui '''3''', dar '''[1,15]''' și '''[7,10]''' nu sunt intervale factoriale ale niciunui număr.

==Cerinţa==

Să se scrie o funcție Python care, pentru un număr natural n transmis ca parametru, determină și întoarce prin intermediul unor parametrii de ieșire un interval factorial al lui '''n''' de lungime maximă.

==Date de intrare==
*un număr natural '''n''', reprezentând numărul pentru care se caută intervalul factorial

==Date de ieșire==
*două numere naturale '''a''' și '''b''', care reprezintă capetele intervalului factorial al lui n de lungime maximă

==Restricţii şi precizări==

Numele funcției va fi '''interval''' și va avea exact trei parametri, în această ordine:

*primul parametru, '''n''', reprezintă un număr natural din intervalul '''[2,10]'''
*'''a''' și '''b''', prin care furnizează câte un număr natural, astfel încât expresia '''b-a''' să aibă valoare maximă, iar '''[a,b]''' să fie interval factorial al lui '''n'''.

==Exemplu==

Dacă '''n=3''', apelul subprogramului va furniza prin parametrul '''a''' valoarea '''3''', iar prin '''b''' valoarea '''23'''.

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validare(n):
if n < 2 or n > 10:
print("Numarul introdus trebuie sa fie intre 2 si 10.")
return False
return True

def interval(n):
produs = 1
i = 1
while produs <= n:
produs *= i
i += 1
a = 2
while produs > n:
produs //= a
a += 1
b = a - 1
while produs <= i:
produs *= b + 1
b += 1
return a, b

def main():
n = int(input("Introduceti numarul n: "))
if validare(n):
a, b = interval(n)
print(f"Intervalul factorial al lui {n} este [{a}, {b}].")

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatii==
In acest cod, functia validare verifica daca numarul n primit ca parametru este in intervalul [2,10]. Daca numarul este in afara acestui interval, se afiseaza un mesaj de eroare si se returneaza False. Daca numarul este in interval, se returneaza True.

Functia interval determina intervalul factorial al lui n de lungime maxima. Pentru aceasta, se calculeaza produsul primelor i numere naturale pana cand produsul depaseste n. De aici, se calculeaza capatul inferior a al intervalului factorial, prin impartirea succesiva a produsului la numerele naturale de la 2 la a-1, pana cand produsul devine mai mic sau egal cu i. Apoi, se calculeaza capatul superior b al intervalului factorial, prin inmultirea succesiva a produsului cu numerele naturale de la b+1 la i-1, pana cand produsul devine mai mare sau egal cu i.

In functia main, se citeste numarul n de la tastatura si se verifica daca este un numar valid prin apelarea functiei validare. Daca numarul este valid, se determina intervalul factorial al lui n prin apelarea functiei interval si se afiseaza intervalul respectiv.

La final, daca acest cod este rulat ca program principal (__name__ == "__main__"), functia main este apelata pentru a rula intregul program.

0798 - Interval Factorial

2023-04-30T17:20:32Z

Cuceu Andrei:

==Enunt==

Un interval cu proprietatea că există un singur număr natural, '''n (2≤n)''', pentru care valoarea produsului '''1·2·3·...·n''' aparține acestui interval este numit interval factorial al lui '''n'''.
'''Exemplu''': '''[5,8]''' și '''[3,23]''' sunt intervale factoriale ale lui '''3''', dar '''[1,15]''' și '''[7,10]''' nu sunt intervale factoriale ale niciunui număr.

==Cerinţa==

Să se scrie o funcție Python care, pentru un număr natural n transmis ca parametru, determină și întoarce prin intermediul unor parametrii de ieșire un interval factorial al lui '''n''' de lungime maximă.

==Restricţii şi precizări==

Numele funcției va fi '''interval''' și va avea exact trei parametri, în această ordine:

*primul parametru, '''n''', reprezintă un număr natural din intervalul '''[2,10]'''
*'''a''' și '''b''', prin care furnizează câte un număr natural, astfel încât expresia '''b-a''' să aibă valoare maximă, iar '''[a,b]''' să fie interval factorial al lui '''n'''.

==Exemplu==

Dacă '''n=3''', apelul subprogramului va furniza prin parametrul '''a''' valoarea '''3''', iar prin '''b''' valoarea '''23'''.

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validare(n):
if n < 2 or n > 10:
print("Numarul introdus trebuie sa fie intre 2 si 10.")
return False
return True

def interval(n):
produs = 1
i = 1
while produs <= n:
produs *= i
i += 1
a = 2
while produs > n:
produs //= a
a += 1
b = a - 1
while produs <= i:
produs *= b + 1
b += 1
return a, b

def main():
n = int(input("Introduceti numarul n: "))
if validare(n):
a, b = interval(n)
print(f"Intervalul factorial al lui {n} este [{a}, {b}].")

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatii==
In acest cod, functia validare verifica daca numarul n primit ca parametru este in intervalul [2,10]. Daca numarul este in afara acestui interval, se afiseaza un mesaj de eroare si se returneaza False. Daca numarul este in interval, se returneaza True.

Functia interval determina intervalul factorial al lui n de lungime maxima. Pentru aceasta, se calculeaza produsul primelor i numere naturale pana cand produsul depaseste n. De aici, se calculeaza capatul inferior a al intervalului factorial, prin impartirea succesiva a produsului la numerele naturale de la 2 la a-1, pana cand produsul devine mai mic sau egal cu i. Apoi, se calculeaza capatul superior b al intervalului factorial, prin inmultirea succesiva a produsului cu numerele naturale de la b+1 la i-1, pana cand produsul devine mai mare sau egal cu i.

In functia main, se citeste numarul n de la tastatura si se verifica daca este un numar valid prin apelarea functiei validare. Daca numarul este valid, se determina intervalul factorial al lui n prin apelarea functiei interval si se afiseaza intervalul respectiv.

La final, daca acest cod este rulat ca program principal (__name__ == "__main__"), functia main este apelata pentru a rula intregul program.

0114 - FNumarDivizoriImpari

2023-04-30T17:12:01Z

Cuceu Andrei:

==Cerinţa==

Să se scrie o funcție Python care să determine numărul divizorilor impari ai unui număr natural transmis ca parametru. Funcția întoarce rezultatul prin intermediul unui parametru de ieşire.

==Date de intrare==
*un număr natural, mai mare decât '''1''' și mai mic decât '''2.000.000.000

==Date de ieșire==
*un număr natural reprezentând numărul de divizori impari ai numărului dat ca parametru

==Restricţii şi precizări==

*numele funcției va fi '''nr_div_imp'''
*funcția va avea doi parametri, reprezentând numărul pentru care se calculează numarul divizorilor *impari, respectiv valoarea calculată
*numărul pentru care se calculează numărul divizorilor impari va fi mai mare decât 1 și mai mic decât '''2.000.000.000'''

==Important==

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

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validate_input(n):
if n <= 1 or n >= 2000000000:
return False
return True

def nr_div_imp(n):
if not validate_input(n):
return -1
result = 0
for i in range(1, n+1, 2):
if n % i == 0:
result += 1
return result

if __name__ == '__main__':
n = int(input("Introduceti numarul n: "))
result = nr_div_imp(n)
if result == -1:
print("Numarul introdus nu este valid.")
else:
print("Datele de intrare sunt corecte.")
print("Numarul de divizori impari ai lui", n, "este:", result)

</syntaxhighlight>

==Explicatii==
Acest cod conține două funcții: nr_div_imp(n) și validate_input(n), împreună cu o funcție principală main.

Funcția nr_div_imp(n) primește un număr natural n ca parametru și calculează numărul de divizori impari ai lui n. Pentru aceasta, folosește un ciclu for care parcurge toate numerele impare de la 1 până la n. Pentru fiecare număr impar verifică dacă este divizor al lui n și, în caz afirmativ, adaugă 1 la variabila result. La sfârșit, funcția returnează valoarea variabilei result.

Funcția validate_input(n) primește, de asemenea, un număr natural n ca parametru și verifică dacă acesta este un număr valid, adică mai mare decât 1 și mai mic decât 2.000.000.000. Dacă numărul este valid, funcția returnează True, în caz contrar, returnează False.

Funcția principală main primește un număr natural n de la utilizator, apoi apelează funcția nr_div_imp(n) pentru a calcula numărul de divizori impari ai lui n. Dacă numărul introdus nu este valid, afișează un mesaj corespunzător. În caz contrar, afișează un mesaj care confirmă corectitudinea datelor de intrare și afișează numărul de divizori impari ai lui n.

0908 - AfisareNumerePrime

2023-04-30T17:08:26Z

Cuceu Andrei:

==Cerință==

Scrieți definiția completă a funcției Python '''afisare''' care primește doi parametri '''a''' și '''b''' și afișează pe ecran, în ordine crescătoare, numerele naturale prime cuprinse între '''a''' și '''b''', inclusiv acestea.

==Date de intrare==

*Doi parametri întregi '''a și b''', unde '''0 < a, b <= 1000'''.

==Date de ieșire==
*Nici o valoare de returnare. Funcția va afișa, pe o singură linie, numerele naturale prime cuprinse între '''a''' și''' b''', în ordine crescătoare, separate prin câte un spațiu.

==Restricții de precizări==

*numele funcției va fi '''afisare'''
*funcția va avea exact doi parametri: '''a''', respectiv '''b'''
*'''0 < a , b <= 1000'''
*numerele vor fi afișate pe aceeași linie, separate prin câte un spațiu

==Exemplu==

Dacă '''a=7''' și '''b=2''', apelul subprogramului va afișa pe ecran:

2 3 5 7

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def este_prim(n):
"""Verifică dacă un număr dat este prim"""
if n < 2:
return False
for i in range(2, int(n**0.5)+1):
if n % i == 0:
return False
return True

def afisare(a, b):
"""Afișează numerele prime cuprinse între a și b"""
for n in range(a, b+1):
if este_prim(n):
print(n, end=' ')
print() # trecem pe o noua linie

def validare(a, b):
"""Verifică dacă a și b sunt în intervalul specificat"""
if a <= 0 or b <= 0 or a > 1000 or b > 1000:
return False
return True

def main():
a = int(input("Introduceti valoarea pentru a: "))
b = int(input("Introduceti valoarea pentru b: "))
if validare(a, b):
afisare(a, b)
else:
print("Valorile introduse nu sunt valide. A și b trebuie să fie între 1 și 1000.")

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatii==

Acest cod definește o funcție afisare care primește doi parametri întregi a și b și afișează numerele prime cuprinse între a și b, inclusiv acestea, pe o singură linie, separate prin câte un spațiu. Pentru a verifica dacă un număr este prim, este definită și o funcție separată este_prim.

Pentru a preveni erori, a fost definită o funcție suplimentară validare care verifică dacă valorile introduse pentru a și b sunt în intervalul specificat (1 ≤ a, b ≤ 1000).

În funcția main, utilizatorul este întâi întrebat să introducă valorile pentru a și b. Dacă valorile sunt valide, funcția afisare este apelată pentru a afișa numerele prime. Altfel, un mesaj de eroare este afișat pentru a informa utilizatorul că valorile introduse nu sunt valide.

0907 - AfisareNumerePare1

2023-04-30T17:02:40Z

Cuceu Andrei:

==Cerință==

Scrieți definiția completă a funcției Python '''afisare''' care primește doi parametri '''a''' și '''b''' și determină afișarea pe ecran, în ordine crescătoare, numerele naturale pare cuprinse între '''a''' și '''b''', inclusiv acestea.

==Date de intrare==

*Doi parametri a și b, reprezentând limitele inferioară și superioară ale intervalului de numere naturale pare de afișat.

==Date de ieșire==

* Funcția nu returnează nimic, ci doar afișează pe ecran, în ordine crescătoare, numerele naturale pare cuprinse între a și b, inclusiv acestea, separate prin câte un spațiu.

==Restricții de precizări==

*numele funcției va fi '''afisare'''
*funcția va avea exact doi parametri: '''a''', respectiv '''b'''
*'''0 < a , b <= 1000'''
*numerele vor fi afișate pe aceeași linie, separate prin câte un spațiu

==Exemplu==

Dacă '''a=7''' și '''b=2''', apelul subprogramului va afișa pe ecran:

2 4 6

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(a, b):
"""
Verifică dacă valorile primite ca parametri sunt valide.
"""
if a <= 0 or a > 1000 or b <= 0 or b > 1000:
return False
return True

def afisare(a, b):
"""
Afiseaza numerele naturale pare cuprinse intre a si b inclusiv acestea, in ordine crescatoare.
"""
# verificam daca valorile primite sunt valide
if not validare(a, b):
print("Valorile primite nu sunt valide!")
return

# determinam care este numarul mai mic si care este numarul mai mare
start = min(a, b)
end = max(a, b)

# afisam numerele pare din intervalul [start, end]
for i in range(start, end+1):
if i % 2 == 0:
print(i, end=" ")
print() # afisam un newline la final

# exemplu de utilizare a functiei afisare
if __name__ == "__main__":
a = int(input("numarul 1: "))
b = int(input("numarul 2: "))
if validare(a, b):
print("Datele de intrare sunt corecte.")
afisare(a, b)
else:
print("Valorile primite nu sunt valide!")

</syntaxhighlight>

0030 - AfisareMultipli

2023-04-30T16:58:23Z

Cuceu Andrei:

==Cerință==

Scrieți definiția completă a funcției Python '''sub''' care primește doi parametri '''n''' și '''k''' și determină afișarea pe ecran, în ordine descrescătoare, a primelor '''n''' numere naturale nenule divizibile cu '''k'''.

==Date de intrare==
*'''n '''(numărul de numere naturale nenule divizibile cu k ce urmează a fi afișate)
*'''k''' (numărul cu care trebuie să fie divizibile numerele afișate)

==Date de ieșire==

*afișarea pe ecran a primelor n numere naturale nenule divizibile cu k, în ordine descrescătoare, separate prin câte un spațiu

==Restricții de precizări==

*numele funcției va fi sub
*funcția va avea exact doi parametri, în ordinea: n, respectiv k
*0 < n ≤ 50, 0 < k ≤ 20
*cele n numere vor fi afișate pe aceeași linie, separate prin câte un spațiu

==Exemplu==

Dacă n = 3 și k = 5, apelul subprogramului va afișa pe ecran:
'''15 10 5'''

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validare(n, k):
if not isinstance(n, int) or n <= 0 or n > 50:
print("Eroare: n trebuie să fie un număr întreg pozitiv între 1 și 50.")
return False
if not isinstance(k, int) or k <= 0 or k > 20:
print("Eroare: k trebuie să fie un număr întreg pozitiv între 1 și 20.")
return False
return True

# Definim funcția sub care primește doi parametri n și k
# și afișează primele n numere divizibile cu k în ordine descrescătoare.
def sub(n, k):
i = k * n
while n > 0:
print(i, end=' ')
i -= k
n -= 1

# Program principal
if __name__ == '__main__':
# Citim valorile n și k de la tastatură
n = int(input("Introduceți numărul de elemente: "))
k = int(input("Introduceți divizorul: "))

# Verificăm restricțiile impuse în cerință
if n <= 0 or n > 50:
print("Eroare: n trebuie să fie între 1 și 50.")
elif k <= 0 or k > 20:
print("Eroare: k trebuie să fie între 1 și 20.")
else:
# Apelăm funcția sub și afișăm rezultatul
print("Datele de intrare sunt corecte.")
sub(n, k)

</syntaxhighlight>

==Explicatii==

Acest cod definește o funcție sub(n, k) care primește doi parametri, n și k, și afișează primele n numere divizibile cu k în ordine descrescătoare. Programul citește valorile n și k de la tastatură și verifică dacă acestea respectă restricțiile impuse în cerință, folosind funcția de validare validare(n, k).

Funcția validare(n, k) verifică dacă n și k sunt numere întregi pozitive și dacă se încadrează în intervalele impuse în cerință. Dacă valorile nu respectă aceste restricții, se afișează un mesaj de eroare corespunzător și se returnează False. În caz contrar, se returnează True.

Dacă ambele valori de intrare sunt valide, programul afișează mesajul "Datele de intrare sunt corecte." și apelează funcția sub(n, k), care calculează primele n numere divizibile cu k în ordine descrescătoare și le afișează pe ecran, separate prin câte un spațiu.

Notă: Acest cod nu utilizează funcția de validare validare(n, k). Pentru a utiliza această funcție, trebuie să înlocuiți blocul de cod care verifică restricțiile impuse în cerință cu apelul funcției validare.

0912 - PrimeVecine

2023-04-30T16:53:43Z

Cuceu Andrei:

==Cerință==
Să se scrie o funcție Python care, pentru un număr natural n transmis ca parametru, determină și întoarce prin intermediul unor parametri de ieșire cel mai mare număr prim mai mic decât n și cel mai mic număr prim mai mare decât n.

==Date de intrare==
*'''n''': un număr natural, '''3 ≤ n < 1.000.000.000'''

==Date de ieșire==
*cel mai mare număr prim mai mic decât '''n'''
*cel mai mic număr prim mai mare decât '''n'''

==Restricții de precizări==

*numele funcției va fi '''sub'''
*funcția va avea exact trei parametri, în această ordine:
*primul parametru,''' n''', reprezintă un număr natural,''' 3 ≤ n < 1.000.000.000'''
*'''a''' și '''b''' sunt parametrii prin care funcția va întoarce cele două valori cerute, astfel:
*'''a''' este cel mai mare număr prim mai mic decât '''n'''
*'''b''' este cel mai mic număr prim mai mare decât '''n'''

==Exemplu==

Dacă '''n=28''', apelul subprogramului va furniza prin parametrul '''a''' valoarea '''23''', iar prin '''b''' valoarea '''29'''.

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, a, b):
return 3 <= int(n) <= 1_000_000_000 and a < int(n) and b > int(n)

def get_prime_numbers(n, a, b):
def is_prime(x):
if x < 2:
return False
for i in range(2, int(x ** 0.5) + 1):
if x % i == 0:
return False
return True

for i in range(n - 1, 1, -1):
if is_prime(i):
a = i
break

i = n + 1
while True:
if is_prime(i):
b = i
break
i += 1

return a, b

if __name__ == '__main__':
n = 28
a, b = None, None
a, b = get_prime_numbers(n, a, b)
if validare(n, a, b):
print("Datele introduse sunt corecte.")
print(f"Cel mai mare numar prim mai mic decat {n} este {a}")
print(f"Cel mai mic numar prim mai mare decat {n} este {b}")
else:
print("Datele introduse nu sunt corecte.")
</syntaxhighlight>

==Explicatii==

Această implementare Python definește o funcție get_prime_numbers(n, a, b) care primește ca parametri un număr natural n și două variabile a și b. Scopul acestei funcții este de a găsi cel mai mare număr prim mai mic decât n (valoarea va fi atribuită variabilei a) și cel mai mic număr prim mai mare decât n (valoarea va fi atribuită variabilei b).

Funcția utilizează o funcție internă is_prime(x) pentru a verifica dacă un număr x este prim sau nu. Pentru a determina dacă x este prim, funcția is_prime(x) utilizează metoda clasică a verificării dacă x este divizibil cu orice număr întreg cuprins între 2 și rădăcina pătrată din x.

Mai întâi, funcția get_prime_numbers(n, a, b) caută cel mai mare număr prim mai mic decât n. Acest lucru este realizat prin parcurgerea tuturor numerelor mai mici decât n, începând cu n-1, și verificând dacă fiecare număr este prim sau nu. Când se găsește primul număr prim, acesta este atribuit variabilei a și parcurgerea se oprește.

În continuare, funcția caută cel mai mic număr prim mai mare decât n. Acest lucru este realizat prin parcurgerea tuturor numerelor mai mari decât n, începând cu n+1, și verificând dacă fiecare număr este prim sau nu. Când se găsește primul număr prim, acesta este atribuit variabilei b și parcurgerea se oprește.

Funcția get_prime_numbers(n, a, b) returnează o tuplă cu cele două numere prime găsite: (a, b).

Funcția validare(n, a, b) este apelată în scopul de a valida faptul că valorile returnate sunt corecte. Aceasta verifică dacă valorile respectă condițiile impuse în enunț, adică n este un număr natural cuprins între 3 și 1.000.000.000, iar a este mai mic decât n și b este mai mare decât n. Funcția returnează True dacă valorile sunt corecte și False altfel.

În funcția principală (if __name__ == '__main__':), numărul n este inițializat cu o valoare și variabilele a și b sunt setate inițial la None. Apoi, se apelează funcția get_prime_numbers(n, a, b) pentru a găsi cele două numere prime. Dacă valorile returnate sunt corecte, se afișează cele două numere prime găsite. În caz contrar, se afișează un mesaj de eroare

0029 - MaxPrime

2023-04-30T16:50:00Z

Cuceu Andrei:

==Cerință==

Să se scrie o funcție Python care, pentru un număr natural n transmis ca parametru, determină și întoarce prin intermediul unor parametri de ieșire cele mai mari două numere naturale prime mai mici decât '''n'''.

==Date de intrare==
*'''n''': un număr natural, '''5 ≤ n < 1000000000'''

==Date de ieșire==
*cel mai mare număr natural prim mai mic decât '''n'''
*al doilea cel mai mare număr natural prim mai mic decât '''n'''

==Restricții de precizări==

*numele funcției va fi sub
*funcția va avea exact trei parametri, în această ordine:
*:primul parametru, n, reprezintă un număr natural, 5 ≤ n < 1000000000
*:a și b sunt parametrii prin care funcția va întoarce cele două valori căutate
*parametrii a și b respectă relația a>b

==Exemplu==

Dacă '''n=28''', apelul subprogramului va furniza prin parametrul a valoarea '''23''', iar prin '''b''' valoarea '''19'''.

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
return 5 <= int(n) <= 1000000000

def sub(n, a, b):
def is_prime(x):
if x < 2:
return False
for i in range(2, int(x ** 0.5) + 1):
if x % i == 0:
return False
return True

found_primes = []
for i in range(n - 1, 1, -1):
if is_prime(i):
found_primes.append(i)
if len(found_primes) == 2:
break

a, b = found_primes[0], found_primes[1]
if a < b:
a, b = b, a

return a, b

if __name__ == '__main__':
a, b = 0, -1
# n = input("n=")
n = 28
if validare(n):
sub(n, a, b)
if a > b:
print("Datele de intrare sunt corecte.")
else:
print("Datele introduse nu sunt corecte.")
else:
print("Datele introduse nu sunt corecte.")
</syntaxhighlight>

==Explicatii==

În acest cod Python, se definește funcția validare(n) care primește un număr n și returnează True dacă n este între 5 și 1000000000, inclusiv, și False altfel. Aceasta este o verificare preliminară a valorii de intrare pentru a se asigura că se încadrează în intervalul de valori permis.

Funcția sub(n, a, b) primește un număr natural n și două variabile a și b prin referință, unde cele două variabile sunt inițializate cu valorile 0 și -1, respectiv. Funcția determină cele mai mari două numere prime mai mici decât n și le atribuie variabilelor a și b. Pentru a determina dacă un număr este prim, funcția utilizează o funcție internă is_prime(x) care primește un număr x și returnează True dacă este prim și False altfel.

În cadrul funcției principale __main__(), se citește valoarea n dintr-un input sau se atribuie o valoare presetată (în cazul de față, 28), iar apoi se verifică dacă valoarea introdusă este validă utilizând funcția validare(n). Dacă este validă, se apelează funcția sub(n, a, b) care determină cele două numere prime și le atribuie variabilelor a și b prin referință. Se verifică dacă a este mai mare decât b și se afișează un mesaj corespunzător. Dacă valoarea introdusă nu este validă, se afișează un mesaj corespunzător.

0020 - Suma divizorilor primi

2023-04-30T16:46:02Z

Cuceu Andrei:

==Cerință==

Să se scrie o funcție Python care să determine suma divizorilor primi ai unui număr natural transmis ca parametru. Funcția întoarce rezultatul prin intermediul unui parametru de ieşire.

==Restricții de precizări==

*numele funcției va fi '''sum_div_prim'''
*funcția va avea doi parametri, reprezentând numărul pentru care se calculează suma divizorilor, respectiv valoarea calculată
*numărul pentru care se calculează suma divizorilor primi va fi mai mare decât '''1''' și mai mic decât '''2.000.000.000'''

==Date de intrare==
Numărul '''n'''.

==Date de ieșire==
Dacă datele de intrare sunt corecte, apare mesajul '''Datele de intrare sunt corecte.''' și se returnează valoarea cerută, în caz contrar '''Datele de intrare sunt incorecte.'''.

==Exemplu==
===Exemplul 1===
====Date de intrare====
1234

====Date de ieșire====
'''Datele de intrare sunt corecte.''' și valoarea returnată va fi 619.

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validate_input(numar):
if numar.isdigit() and 1 <= int(numar) <= 2_000_000_000:
return True
return False

def sum_div_prim(numar, suma=0):
if validate_input(numar):
for i in range(2, numar + 1):
if numar % i == 0:
este_prim = True
for j in range(2, int(i ** 0.5) + 1):
if i % j == 0:
este_prim = False
break
if este_prim:
suma += i
return suma
else:
print("Datele de intrare sunt incorecte.")

if __name__ == '__main__':
numar = input()
if validate_input(numar):
print("Datele de intrare sunt corecte.")
numar = int(numar)
print(sum_div_prim(numar))
else:
print("Datele de intrare sunt incorecte.")

</syntaxhighlight>

==Explicatii==

În această soluție, am definit mai întâi funcția validate_input() care primește numărul de intrare și verifică dacă este un număr întreg și dacă este în intervalul specificat. Funcția returnează True dacă numărul este valid și False în caz contrar.

În funcția sum_div_prim(), apelăm mai întâi funcția validate_input() pentru a verifica dacă numărul este valid. Dacă nu este valid, afișăm un mesaj de eroare. Dacă este valid, efectuăm calculele pentru a găsi suma divizorilor primi.

În blocul if __name__ == '__main__':, am adăugat și o verificare suplimentară pentru a apela funcția validate_input() înainte de a afișa mesajul de intrare corectă și de a calcula suma divizorilor primi.

0909 - PermCircCif

2023-04-30T16:42:46Z

Cuceu Andrei:

==Cerință==
Să se scrie o funcție Python care să realizează permutarea circulară spre stânga a cifrelor unui număr natural. Numărul este transmis prin intermediul unui parametru care se întoarce din funcție modificat.

==Restricții de precizări==

*numele funcției va fi '''perm'''
*funcția va avea un singur parametru,''' n'''
*parametrul '''n''' va fi un număr natural nenul mai mic decât '''1.000.000.000'''

==Date de intrare==
Introduceți numărul '''n'''.

==Date de ieșire==
Dacă datele sunt corecte, apare textul '''"Datele sunt corecte."''' și se returnează valoarea corectă. Dacă datele sunt incorecte, apare mesajul '''"Datele nu corespund restricțiilor impuse."'''.

==Exemplu==
===Exemplul 1===

; Dacă '''n = 1372''', după apelul funcției '''perm''', valoarea lui n va fi '''3721'''.

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
if 1 <= n < 1000000000:
return True
else:
return False

def perm(n):
if n < 10:
return n

cifre = [int(digit) for digit in str(n)]
cifre.append(cifre.pop(0))

return int(''.join(map(str, cifre)))

if __name__ == '__main__':
n = int(input())
if validare(n):
print("Datele sunt corecte.")
print("Numarul initial: ", n)
n = perm(n)
print("Numarul rotit: ", n)
else:
print("Datele nu corespund restricțiilor impuse.")

</syntaxhighlight>
==Explicatie==

Funcția validare(n) verifică dacă numărul de intrare se află între 1 și 999.999.999. Funcția perm(n) rotește numărul cu o poziție și îl returnează. În blocul if/else din if __name__ == '__main__':, se verifică dacă numărul de intrare este valid și se execută funcția perm(n) dacă este valid.

0023 - Oglindit

2023-04-30T16:36:33Z

Cuceu Andrei:

==Cerinţa==
Să se scrie o funcție Python care să determine oglinditul unui număr natural transmis ca parametru. Funcția va întoarce rezultatul prin intermediul unui parametru de ieşire.

==Date de intrare==
*Un număr natural mai mic decât '''1.000.000.000'''

==Date de ieșire==
*Oglinditul numărului dat ca intrare.

==Restricţii şi precizări==

*Numele funcției va fi '''oglindit'''
*Funcția va avea doi parametri: primul parametru reprezintă numărul pentru care se calculează oglinditul, iar la doilea parametru reprezintă valoarea calculată
*Numărul pentru care se calculează oglinditul va fi mai mic decât '''1.000.000.000'''

==Exemplu==
===Exemplul 1===

;Intrare

:numar = 12345

;Ieșire
:Oglinditul lui 12345 este 54321

==Important==
Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
return n < 1_000_000_000

def oglindit(nr, oglindit_nr):
oglindit_nr = 0 # inițializăm oglinditul cu valoarea 0
while nr > 0:
oglindit_nr = oglindit_nr * 10 + nr % 10
nr = nr // 10
return oglindit_nr

if __name__ == '__main__':
nr = 12345
oglindit_nr = 0
if validare(nr):
n = int(nr)
print("Datele introduse corespund restricțiilor impuse")
print(f"Oglinditul lui {nr} este {oglindit(nr, oglindit_nr)}")
else:
print("Datele introduse nu corespund restricțiilor impuse")
</syntaxhighlight>

==Explicatii==
Această soluție constă în două funcții și o secțiune de cod care le utilizează:

Funcția validare(n) primește un număr întreg n și returnează True dacă n este mai mic decât 1 miliard, altfel returnează False. Această funcție verifică restricția impusă în enunțul problemei.

Funcția oglindit(nr, oglindit_nr) primește două parametri de tip întreg: nr - numărul pentru care se calculează oglinditul, și oglindit_nr - o variabilă care va conține oglinditul la final. Inițial, oglindit_nr este setat la 0. Apoi, funcția calculează oglinditul numărului nr prin preluarea ultimei cifre a acestuia (folosind operatorul modulo) și adăugarea acesteia la sfârșitul variabilei oglindit_nr (prin înmulțirea cu 10 și adunarea cu ultima cifră). Acest proces se repetă până când toate cifrele numărului nr au fost preluate și adăugate la oglindit_nr.

În secțiunea de cod if __name__ == '__main__': este introdusă o valoare de test pentru nr (în cazul de față, 12345). Se inițializează și variabila oglindit_nr la 0. În continuare, se verifică dacă nr îndeplinește restricțiile impuse prin apelul funcției validare(nr). Dacă acesta este adevărat, se afișează un mesaj corespunzător și se calculează oglinditul numărului nr prin apelul funcției oglindit(nr, oglindit_nr), care actualizează variabila oglindit_nr. În caz contrar, se afișează un alt mesaj care indică faptul că datele introduse nu corespund restricțiilor impuse.

0017 - Suma divizorilor 2

2023-04-30T16:23:03Z

Cuceu Andrei:

==Cerință==
Să se scrie o funcție Python care să determine suma divizorilor unui număr natural transmis ca parametru. Funcția întoarce rezultatul prin intermediul unui parametru de ieşire.

==Date de intrare==
*'''number''' - un număr natural nenul mai mic decât '''2000000000''' pentru care se calculează suma divizorilor
*'''div_sum''' - valoarea calculată a sumei divizorilor, inițial setată la '''0'''

==Date de ieșire==
*'''div_sum''' - suma divizorilor numărului dat ca intrare, calculată de funcția sum_div

==Restricții de precizări==
*Numele funcției va fi '''sum_div'''
*Funcția va avea doi parametri, reprezentând numărul pentru care se calculează suma
*divizorilor,respectiv valoarea calculată
*Valorile celor doi parametri vor fi numere naturale nenule mai mici decât '''2000000000'''

==Exemplu==

;Intrare

:12

;Ieșire
:28

==Important==
Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, result):
return 0 < int(n), int(result) < 2000000000

def sum_div(n, result):
result = 0
for i in range(1, n + 1):
if n % i == 0:
result += i
return result

if __name__ == "__main__":
n = input("Introduceți un număr: ")
result = 0
if validare(n, result):
n = int(n)
print("Datele introduse corespund restricțiilor impuse")
print(f"Suma divizorilor lui {n} este: {sum_div(n, result)}")
else:
print("Datele introduse nu corespund restricțiilor impuse")
</syntaxhighlight>

==Explicatii==

Acest cod reprezintă o implementare a funcției sum_div descrisă anterior și include și o funcție validare pentru a verifica dacă datele de intrare respectă restricțiile impuse în enunț.

Funcția sum_div primește două parametri: n reprezentând numărul pentru care trebuie să calculeze suma divizorilor și result reprezentând valoarea calculată a sumei divizorilor, inițial setată la 0. În interiorul acestei funcții, se calculează suma divizorilor lui n prin iterarea prin numerele de la 1 la n și adunarea tuturor divizorilor lui n.

Funcția validare primește doi parametri: n și result. În această funcție, se verifică dacă n este un număr natural nenul mai mic decât 2000000000 și dacă result este mai mic decât 2000000000.

În cadrul programului principal, utilizatorul este întâi întrebat să introducă un număr. Apoi, se verifică dacă datele de intrare sunt valide utilizând funcția validare. Dacă datele sunt valide, programul afișează suma divizorilor numărului introdus de utilizator, calculată utilizând funcția sum_div. În caz contrar, programul afișează un mesaj de eroare.

4182 - bac secventa

2023-04-30T16:10:41Z

Cuceu Andrei:

==Cerința==

Subprogramul '''secventa''' are un singur parametru, '''n''', prin care primește un număr natural, în care nu există secvențe de mai mult de două cifre identice aflate pe poziții consecutive. Subprogramul înlocuiește în '''n''' fiecare secvență '''22''' cu câte o secvență '''20''' și furnizează, prin același parametru, numărul obținut. Dacă nu se înlocuiește nicio secvență, subprogramul furnizează numărul nemodificat. Scrieți definiția completă a subprogramului.

==Date de intrare==
Un singur număr natural '''n (10 ≤ n < 1.000.000.000)'''.

==Date de ieșire==
Numărul obținut după înlocuirea fiecărei secvențe '''22 '''cu câte o secvență '''20'''. Dacă nu se face nicio înlocuire, funcția va returna numărul inițial '''n'''.

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

*'''10 ≤ n < 1.000.000.000'''
*Numele funcției va fi '''secventa'''
*Funcția va primi un singur parametru, numărul'''n''', iar la finalul funcției '''n'''va avea valoarea cerută.

==Exemplu==
Dacă '''n=202233228''', atunci, după apel, '''n=202033208'''.

==Important==

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

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validate_input(input_str):
try:
n = int(input_str)
if 10 <= n < 1_000_000_000:
return True, n
else:
return False, "Numărul trebuie să fie între 10 și 999.999.999."
except ValueError:
return False, "Introduceți un număr natural valid."

def secventa(n):
"""
Funcția înlocuiește în numărul natural dat fiecare secvență de două cifre
consecutive egale și diferite de zero cu o secvență de două cifre
formate din prima cifră a secvenței și zero. Returnează numărul modificat.
"""
# Convertim numărul în șir de caractere pentru a putea manipula cifrele individual
n_str = str(n)
i = 0
# Parcurgem șirul de la stânga la dreapta
while i < len(n_str) - 1:
# Dacă găsim o secvență de două cifre consecutive egale și diferite de zero
if n_str[i] == n_str[i + 1] != "0":
# Înlocuim secvența cu prima cifră a secvenței urmată de zero
n_str = n_str[:i] + n_str[i] + "0" + n_str[i + 2:]
i += 1 # Mutăm cursorul cu o poziție înainte pentru a evita procesarea secvenței din nou
i += 1 # Mutăm cursorul
def main():
# Citim input-ul de la utilizator și validăm intrarea
input_valid = False
while not input_valid:
input_str = input("Introduceți un număr natural între 10 și 999.999.999: ")
input_valid, n = validate_input(input_str)
if not input_valid:
print(n)

# Aplicăm funcția de înlocuire a secvențelor
n_modificat = secventa(n)
print(f"Numărul modificat este: {n_modificat}")

if __name__ == "__main__":
main()

</syntaxhighlight>
==Explicatii==
În prima funcție, validate_input(input_str), se încearcă conversia input-ului la un număr întreg folosind funcția int(). În cazul în care conversia este reușită, se verifică dacă numărul respectă restricțiile impuse, adică să fie între 10 și 999.999.999. În caz contrar, funcția returnează o valoare booleană False și un mesaj corespunzător pentru a indica utilizatorului că numărul introdus nu este valid. În cazul în care conversia nu este posibilă, funcția returnează tot False și un mesaj corespunzător.

A doua funcție, secventa(n), primește ca argument un număr natural, n, și începe prin a converti numărul într-un șir de caractere pentru a putea manipula cifrele individual. Aceasta parcurge șirul caracter cu caracter, de la stânga la dreapta, și verifică dacă există o secvență de două cifre consecutive egale și diferite de zero. Dacă găsește o astfel de secvență, înlocuiește acea secvență cu prima cifră a secvenței urmată de un zero. Astfel, se elimină secvențele de cifre egale și se adaugă un zero între cifrele diferite. În final, funcția returnează numărul modificat.

În blocul if __name__ == "__main__": se citește un număr natural de la utilizator folosind funcția input(), se verifică dacă numărul este valid folosind funcția validate_input(input_str), și în caz afirmativ, se aplică funcția secventa(n) asupra acestuia și se afișează rezultatul obținut. În caz contrar, se afișează mesajul de eroare corespunzător.

3119 - Impare Bac

2023-04-30T16:00:53Z

Cuceu Andrei:

==Cerință==

Subprogramul '''Impare''' are un singur parametru, '''n''', prin care primește un număr natural. Subprogramul înlocuiește fiecare cifră impară a lui '''n''' cu cea mai mare cifră pară strict mai mică decât ea (astfel cifra '''1''' se înlocuieşte cu cifra '''0''', cifra '''3''' cu cifra '''2''' etc.) și furnizează numărul obținut tot prin parametrul '''n'''.

Scrieți definiția completă a subprogramului.

==Date de intrare==
Un număr natural '''n, cu '''1 ≤ n ≤ 1.000.000.000'''.

==Date de ieșire==
Numărul obținut prin înlocuirea fiecărei cifre impare a lui n cu cea mai mare cifră pară strict mai mică decât ea. Rezultatul va fi returnat prin parametrul '''n'''.

==Restricții de precizări==

*'''≤ n ≤ 1.000.000.000'''
*Numele funcției va fi '''Impare'''
*Funcția va primi un singur parametru, numărul '''n''', iar la finalul funcției '''n''' va avea valoarea cerută.

==Exemplu==

Dacă '''n=235690''', atunci, după apel, '''n=224680''', iar dacă '''n=15690''', atunci, după apel, '''n=4680'''.

==Important==

Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">

def validare(n):
if n < 1 or n > 1000000000:
return False
return True

def impare(n):
cifre = list(str(n))
for i in range(len(cifre)):
if int(cifre[i]) % 2 != 0:
cifre[i] = str(int(cifre[i]) - 1)
j = i - 1
while j >= 0 and int(cifre[j]) == 8:
j -= 1
if j >= 0:
cifre[j] = str(int(cifre[j]) + 2)
n = int("".join(cifre))
return n

if __name__ == "__main__":
n = int(input("Introduceti numarul: "))
if validare(n):
n = Impare(n)
print("Numarul inlocuit: ", n)
else:
print("Numarul introdus nu respecta restrictiile.")

</syntaxhighlight>

==Explicatii==

Funcția Impare(n) primește un număr întreg n și returnează același număr, dar înlocuiește cifrele impare cu cea mai mare cifră pară, strict mai mică decât cifra impară înlocuită.

Pentru a face această înlocuire, funcția transformă numărul n într-o listă de cifre cu ajutorul funcției list(str(n)). Apoi, parcurge lista de cifre și verifică dacă fiecare cifră este impară.

Dacă cifra este impară, aceasta este înlocuită cu cea mai mare cifră pară, mai mică decât cifra impară înlocuită. Mai precis, se scade 1 din cifra impară și se caută cea mai mare cifră pară strict mai mică decât cifra impară înlocuită, parcurgând lista în sens invers.

La final, funcția reconstruiește numărul original din lista de cifre prin concatenarea acestora cu ajutorul funcției " ".join(cifre)) și transformă string-ul obținut înapoi într-un număr întreg prin intermediul funcției int().

Funcția validare(n) verifică dacă numărul n se încadrează în intervalul permis, și anume între 1 și 1000000000.

În cadrul blocului if __name__ == "__main__":, se citește un număr de la tastatură și se verifică dacă respectă restricțiile prin intermediul funcției validare(n). În caz afirmativ, se apelează funcția Impare(n) și se afișează rezultatul obținut, altfel se afișează un mesaj corespunzător.

2995 - Finserare

2023-04-30T15:48:01Z

Cuceu Andrei:

==Cerință==
Scrieți funcția inserare care primește ca parametru un număr natural n și furnizează prin intermediul aceluiași parametru numărul obținut din n prin inserarea, între oricare două cifre alăturate ale sale, a valorii absolute a diferenței acestora.

==Date de intrare==
Un număr natural '''n''' între '''10''' și '''99999'''.

==Date de ieșire==

Numărul obținut prin inserarea, între oricare două cifre alăturate ale lui n, a valorii absolute a diferenței acestora.

==Restricții de precizări==
*'''10 ≤ n ≤ 99999'''
*Puteți apela funcția matematică '''abs'''.

==Exemplul 1==
Dacă '''n = 7255''', atunci, după apelul '''inserare(n)''' valoarea lui n va fi '''7523505'''.

==Important==
Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
return 10 <= int(n) <= 99999

def inserare(n):
n_str = str(n)
result = n_str[0]
for i in range(1, len(n_str)):
diff = abs(int(n_str[i]) - int(n_str[i - 1]))
result += str(diff) + n_str[i]
return int(result)

if __name__ == '__main__':
n = input("Introduceți un număr natural: ")
if validare(n):
n = int(n)
print("Datele introduse corespund restricțiilor impuse")
n = inserare(n)
print(n)
else:
print("Datele introduse nu corespund restricțiilor impuse")
</syntaxhighlight>

0864 - CifMinMax

2023-04-30T15:46:29Z

Cuceu Andrei:

==Cerință==
Să se scrie o funcție Python care să determine cea mai mare și cea mai mică cifră a unui număr natural transmis ca parametru. Funcția va întoarce rezultatele prin intermediul unor parametri de ieşire.

==Date de intrare==

*'''numar''' - un număr natural pentru care se vor determina cea mai mare și cea mai mică cifră. Acesta trebuie să fie mai mic decât '''2.000.000.000'''.
*'''cif_max''' - o referință la o variabilă în care funcția va stoca cea mai mare cifră a numărului numar.
*'''cif_min''' - o referință la o variabilă în care funcția va stoca cea mai mică cifră a numărului numar.

==Date de ieșire==

*'''cif_max''' - cea mai mare cifră a numărului numar.
*'''cif_min''' - cea mai mică cifră a numărului numar.

==Restricții de precizări==
*Numele funcției va fi '''cifminmax'''
*Funcția va avea trei parametri: primul parametru reprezintă numărul pentru care se calculează valorile cerute; al doilea parametru va reprezenta cifra maximă, iar al treilea va reprezenta cifra minimă
*numărul pentru care se calculează cele doua valori va fi mai mic decât '''2.000.000.000'''

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

==Rezolvare==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
return 0 <= int(n) < 2_000_000_000

def cifminmax(numar, cifra_maxima, cifra_minima):
cifra_maxima = 0
cifra_minima = 9

while numar > 0:
cifra_curenta = numar % 10

if cifra_curenta > cifra_maxima:
cifra_maxima = cifra_curenta

if cifra_curenta < cifra_minima:
cifra_minima = cifra_curenta

numar //= 10

return cifra_maxima, cifra_minima

if __name__ == '__main__':
numar = input("Introduceti un numar pozitiv si mai mic decat 2.000.000.000: ")

if validare(numar):
numar = int(numar)
print("Datele introduse corespund restricțiilor impuse")
cifra_maxima, cifra_minima = cifminmax(numar, 0, 9)
print(f"Cea mai mare cifra a numarului {numar} este {cifra_maxima}.")
print(f"Cea mai mica cifra a numarului {numar} este {cifra_minima}.")
else:
print("Datele introduse nu corespund restricțiilor impuse")
</syntaxhighlight>

==Explicatii==

Acesta este un program Python care implementează funcția cifminmax descrisă anterior. Programul începe prin definirea unei funcții de validare care verifică dacă numărul introdus de utilizator se încadrează în restricțiile impuse (adica sa fie pozitiv și mai mic decât 2.000.000.000).

Funcția cifminmax primește ca parametri: numar, cifra_maxima și cifra_minima. cifra_maxima și cifra_minima sunt inițializate în interiorul funcției cu 0 și 9, deoarece sunt inițial cele mai mici și cele mai mari cifre posibile.

Apoi, programul folosește o buclă while pentru a itera prin fiecare cifră a numărului numar, începând cu ultima cifră (adica cifra unitatilor) și mergând către cifra cu cea mai mare putere (adică cifra cea mai semnificativă). În fiecare iterație, programul stochează cifra curentă într-o variabilă numită cifra_curenta.

Programul apoi verifică dacă cifra_curenta este mai mare decât cifra_maxima. Dacă da, atunci cifra_maxima este actualizată cu cifra_curenta. În mod similar, dacă cifra_curenta este mai mică decât cifra_minima, atunci cifra_minima este actualizată cu cifra_curenta.

După ce bucla while se încheie, programul returnează cele două valori cifra_maxima și cifra_minima.

În secțiunea if __name__ == '__main__':, programul primește inputul utilizatorului prin intermediul funcției input(), apoi verifică dacă numărul introdus este valid folosind funcția validare. Dacă numărul este valid, programul îl convertește într-un integer și calculează cifra maximă și cea minimă folosind funcția cifminmax. În cele din urmă, programul afișează cele două valori de ieșire pentru utilizator.

0911 - Cifre6

2023-04-30T15:40:03Z

Cuceu Andrei:

==Cerință==
Să se scrie o funcție Python care primește ca parametri două numere '''n''' și '''k''' și determină cel mai mare număr care poate fi scris cu '''k''' cifre ale lui '''n'''. Funcția va întoarce rezultatul prin intermediul unui parametru de ieşire.

==Date de intrare==

Datele de intrare trebuie să fie două numere întregi nenule, '''n''' și '''k''', cu restricția ca ambele să fie mai mici decât '''2.000.000.000''' și ca n să aibă cel puțin '''k''' cifre.

==Date de ieșire==

Datele de ieșire trebuie să fie cel mai mare număr care poate fi scris cu '''k''' cifre ale lui '''n''' și trebuie să fie întors prin intermediul unui parametru de ieșire al funcției.

==Restricții de precizări==
*Numele funcției va fi '''numar'''
*Funcția va avea trei parametri: primul parametru reprezintă numărul '''n'''; al doilea parametru reprezintă numărul '''k''', iar al treilea va reprezenta valoarea determinată de funcție toți parametrii vor fi numere naturale nenule mai mici decât '''2.000.000.000'''
*'''n''' va avea cel puțin '''k''' cifre

==Exemplu==
===Exemplul 1===
;Dupa apelul

:numar(27594 , 3 , x);

;Ieșire

:x va avea valoarea 975.

==Important==
Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, k):
return int(n) < 2_000_000_000 and len(n) >= int(k)

def numar(n, k, numar_maxim):
cifre = sorted(str(n), reverse=True) # Sortează cifrele lui n în ordine descrescătoare
numar_maxim = int(''.join(cifre[:k])) # Concatenează primele k cifre și le transformă în int
return numar_maxim # Returnează numărul maxim

if __name__ == '__main__':
n = 27594
k = 3
x = 0
if validare(str(n), k):
print("Datele de intrare corespund restricțiilor impuse.")
n, k = int(n), int(k)
numar_maxim = numar(n, k, x)
print("Cel mai mare numar ce poate fi scris cu", k, "cifre ale lui", n, "este", numar_maxim)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
</syntaxhighlight>

==Explicatii==
Acesta este un cod Python care implementează cerințele specificate în problema de programare.

Funcția "validare" verifică dacă valorile pentru n și k sunt conforme cu restricțiile impuse. Dacă n este mai mare sau egal cu 2 miliarde sau lungimea sa este mai mică decât k, funcția va returna "False", altfel va returna "True".

Funcția "numar" primește trei parametri: n, k și numar_maxim, unde numar_maxim este parametrul de ieșire care va fi folosit pentru a stoca numărul maxim. Funcția sortează cifrele lui n în ordine descrescătoare, concatenând apoi primele k cifre și transformându-le într-un intreg, pe care îl stochează în variabila numar_maxim. Funcția returnează apoi numar_maxim.

În "if name == 'main'" sunt datele de intrare și este testată validitatea lor prin apelul funcției "validare". Dacă datele sunt valide, se convertesc în int și se apelează funcția "numar". Rezultatul este stocat în variabila numar_maxim și apoi afișat. Dacă datele nu sunt valide, este afișat un mesaj corespunzător.

0910 - KPrefix

2023-04-30T15:35:53Z

Cuceu Andrei:

==Cerință==
Să se scrie o funcție Python care primește ca parametri două numere '''n''' și '''k''' și determină numărul format din primele '''k''' cifre ale lui '''n'''. Funcția va întoarce rezultatul prin intermediul unui parametru de ieşire.

==Date de intrare==

*'''n''', un număr natural mai mic decât '''2.000.000.000'''
*'''k''', un număr natural mai mic sau egal cu numărul de cifre al lui '''n'''

==Date de ieșire==

*'''numar_k''', un număr natural format din primele '''k''' cifre ale lui '''n'''

==Restricții de precizări==
*Numele funcției va fi '''prefix'''
*Funcția va avea trei parametri: primul parametru reprezintă numărul n;al doilea parametru reprezintă numărul '''k'''; iar al treilea va reprezenta valoarea determinată de funcție
*'''n''' va fi număr natural mai mic decât '''2.000.000.000'''
*'''n''' va avea cel puțin '''k''' cifre

==Exemplu==
===Exemplul 1===
;Dupa apelul

:prefix(27594 , 3 , x);

;Ieșire

:x va avea valoarea 275.

==Important==
Soluţia propusă va conţine doar 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==
===Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, k):
return len(str(n)) >= int(k) and int(n) < 2_000_000_000

def prefix(n, k, rezultat):
numar_prefix = int(str(n)[:k])
rezultat = numar_prefix
return rezultat

if __name__ == '__main__':
n = 27594
k = 3
x = 0
if validare(n, k):
print("Datele introduse corespund restricțiilor impuse.")
prefix(n, k, x)
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicatii==

Acesta este un exemplu de implementare în Python a funcției prefix descrisă în cerință.

Funcția validare este definită pentru a verifica dacă datele de intrare (n și k) corespund restricțiilor impuse în cerințe. Aceasta verifică dacă lungimea lui n este mai mare sau egală cu k și dacă n este mai mic decât 2.000.000.000.

Funcția prefix primește numerele n și k și un parametru rezultat prin referință, pentru a putea returna valoarea determinată de funcție prin intermediul acestuia.

În interiorul funcției, se extrage un număr format din primele k cifre ale lui n și se atribuie variabilei numar_prefix. Această valoare este apoi atribuită parametrului rezultat. În cele din urmă, valoarea parametrului rezultat este returnată de funcție.

În codul principal, sunt definite valorile de test pentru n și k, iar apoi se verifică dacă acestea corespund restricțiilor cu ajutorul funcției validare. Dacă datele de intrare sunt valide, se apelează funcția prefix cu valorile de intrare și cu o variabilă goală x ca parametru rezultat. Valoarea returnată de funcția prefix este apoi afișată. Dacă datele de intrare nu sunt valide, se afișează un mesaj corespunzător.