Bitnami MediaWiki - User contributions [en]

27036

2023-10-20T11:54:57Z

Carla Chereji: Pagină nouă: '''27036 (Radu Pop)''' ''Să se determine funcțiile derivabile <math>f </math> : ℝ -> ℝ cu proprietățile:'' ''a) <math>f' </math> este funcție strict crescătoare;'' ''b) <math>f'(0) = 0; </math>'' ''c) <math>f(yf'(x)) + f(x)f(y) = xy f'(x)f'(y) </math> , oricare ar fi x, y ∈ ℝ;'' '''Soluție:''' Cum <math>f' (x) > 0, x \in (0, \infty) </math>, rezultă că <math>f </math> este strict crescătoare, deci injectivă pe <math>[0, \infty) </math>. Deoarece e...

'''27036 (Radu Pop)'''

''Să se determine funcțiile derivabile <math>f
</math> : ℝ -> ℝ cu proprietățile:''

''a) <math>f'
</math> este funcție strict crescătoare;''

''b) <math>f'(0) = 0;
</math>''

''c) <math>f(yf'(x)) + f(x)f(y) = xy f'(x)f'(y)
</math> , oricare ar fi x, y ∈ ℝ;''

'''Soluție:'''

Cum <math>f' (x) > 0, x \in (0, \infty)
</math>, rezultă că <math>f
</math> este strict crescătoare, deci injectivă pe <math>[0, \infty)
</math>. Deoarece expresia <math>xyf'(x)f'(y)-f(x)f(y)
</math> simetrică in x și y, din c) rezultă că <math>f(yf'(x))=f(xf'(y))
</math>. Din injectivitatea lui <math>f
</math> obținem <math>yf'(x)=xf'(y)
</math>, pentru orice <math>x,y \in [0, \infty)
</math>. În particular, <math>f'(x) = f'(1)x
</math> , deci <math>f(x) = ax^2 +c
</math> , unde <math>a = \left ( \frac{f'(1)}{2} \right ) > 0
</math> și <math>c \in
</math> ℝ . Pentru <math>x, y \in [0, \infty)
</math> avem <math>f(2axy)+a^2 x^2 y^2 = 4a^2 x^2y^2
</math> , deci <math>4a^3x^2y^2+a^2x^2y^2=4a^2x^2y^2
</math>. Rezultă <math>a = \frac{3}{4}
</math> , deci <math>f(x) = \frac{3}{4}x^2, x \in [0, \infty)
</math>. Dacă <math>x, y \in (-\infty, 0]
</math>, atunci <math>yf'(x)\geq 0, xf'(y)\geq0
</math> și că mai sus avem <math>yf'(x)=xf'(y)
</math>. În particular <math>f'(x)=-f'(-1)x
</math>, deci <math>f(x)=bx^2 + d,
</math> cu <math>b>0
</math> și d <math>\in
</math> ℝ . Cum <math>0 = f(0) = d,
</math> rezultă că <math>f(x) = bx^2, x \in (-\infty, 0]
</math> Pentru <math>x = -1, y = 1
</math>, avem <math>f(-3b)+\frac{3}{4}b = 3b
</math>, deci <math>4b^3 = \frac{9}{4}b
</math>

și cum <math>b> 0
</math>, rezultă <math>b = \frac{3}{4}.
</math>

Obținem <math>f(x) = \frac{3}{4}x^2, x \in
</math>ℝ , funcție care verifică ipotezele din enunț.

0078 - F Citire Matrice

2023-04-26T15:16:08Z

Carla Chereji:

== Cerință ==
Scrieți definiția completă subprogramului citmat care citește de la tastatură dimensiunile și elementele unui tablou bidimensional. Subprogramul citmat va avea trei parametri: a, un tablou bidimensional cu elemente întregi, '''n, m''', reprezenând numărul de linii, respectiv de coloane ale tabloului '''a'''.

== Date de intrare ==
Programul citește de la tastatură numărul '''a, n și m'''.
== Date de ieșire ==
Programul va afișa pe ecran matricea citită.
== Restricții de precizări ==
*1 &les; '''n''' &les; 2^64
== Exemplul 1==
; Intrare
: 2 2
: 1 2, 3 4
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1 2
: 3 4
== Exemplul 2 ==
; Intrare
: 3 3
: 1 3 5, 7 8 9, 1 3 5
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1 3 5
: 7 8 9
: 1 3 5
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def citmat():
# Citirea numărului de rânduri și coloane ale matricei
n, m = map(int, input("Introduceți numărul de rânduri și coloane ale matricei, separate prin spațiu: ").split())
a = []
# Citirea elementelor matricei pentru fiecare rând în parte
for i in range(n):
row = list(map(int, input("Introduceți elementele rândului {} separate prin spațiu: ".format(i+1)).split()))
a.append(row)
# Afișarea matricei citite
print("Matricea citită:")
for row in a:
print(*row)
return a, n, m

def validare(a, n, m):
# Implementați aici logica de validare a matricei a
# În exemplul de mai jos se verifică doar dacă numărul de elemente din fiecare rând este egal cu m
for i in range(n):
if len(a[i]) != m:
return False
return True

def main():
a, n, m = citmat()
if validare(a, n, m):
print("Datele introduse corespund restricțiilor impuse.")
# Continuați cu logica dvs. de prelucrare a matricei
else:
print("Datele introduse nu corespund restricțiilor impuse.")
# Gestionarea cazului în care matricea nu este validă

if __name__ == "__main__":
main()

</syntaxhighlight>

0078 - F Citire Matrice

2023-04-26T15:14:36Z

Carla Chereji:

0078 - F Citire Matrice

2023-04-26T15:14:27Z

Carla Chereji: Pagină nouă: <nowiki>== Cerință ==</nowiki> Scrieți definiția completă subprogramului citmat care citește de la tastatură dimensiunile și elementele unui tablou bidimensional. Subprogramul citmat va avea trei parametri: a, un tablou bidimensional cu elemente întregi, n, m, reprezenând numărul de linii, respectiv de coloane ale tabloului a. <nowiki>== Date de intrare ==</nowiki> Programul citește de la tastatură numărul <code>a, n m</code>. <nowiki>== Date de ieșire ==...

<nowiki>== Cerință ==</nowiki>

Scrieți definiția completă subprogramului citmat care citește de la tastatură dimensiunile și elementele unui tablou bidimensional.

Subprogramul citmat va avea trei parametri: a, un tablou bidimensional cu elemente întregi, n, m, reprezenând numărul de linii, respectiv de coloane ale tabloului a.

<nowiki>== Date de intrare ==</nowiki>

Programul citește de la tastatură numărul <code>a, n m</code>.

<nowiki>== Date de ieșire ==</nowiki>

Programul va afișa pe ecran distanța dintre primul și ultimul bit setat al numărului citit.

<nowiki>== Restricții de precizări ==</nowiki>

<nowiki>*</nowiki>1 <nowiki>&</nowiki>les; n <nowiki>&</nowiki>les; 2^64

<nowiki>== Exemplul 1==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 2 2

<nowiki>:</nowiki> 1 2, 3 4

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 1 2

<nowiki>:</nowiki> 3 4

<nowiki> </nowiki>

<nowiki>== Exemplul 2 ==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 3 3

<nowiki>:</nowiki> 1 3 5, 7 8 9, 1 3 5

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 1 3 5

<nowiki>:</nowiki> 7 8 9

<nowiki>:</nowiki> 1 3 5

<nowiki> </nowiki>

<nowiki>== Rezolvare ver. 1 ==</nowiki>

3590 - Bit Distance

2023-04-26T14:41:18Z

Carla Chereji:

== Cerință ==
Se dă un număr natural '''n'''. Considerând reprezentarea in baza 2 a acestui număr, calculați distanța dintre primul bit setat și ultimul bit setat. Distanța dintre 2 biți este egală cu numărul de biți aflați intre biții respectivi.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Programul va afișa pe ecran distanța dintre primul și ultimul bit setat al numărului citit.
== Restricții de precizări ==
*1 &les; n &les; 2^64
== Exemplul 1==
; Intrare
: 82
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 6
== Exemplul 2 ==
; Intrare
: 4
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
return n.isdigit() and 1 <= int(n) <= pow(2, 64)

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

if validare(n):
n = int(n)

# Teoretic, primul bit este întotdeauna 1. Dacă mutăm toți biții la dreapta până când rămâne numărul 0b000001,
# vom afla distanța cerută.
distanta = 1

if n == 0:
distanta = 0
else:
# Întâi, mutăm biții la dreapta până când vom avea un 1 la final
while not (n & 0b001):
n >>= 1
# Acum, mutăm biții la dreapta până când rămâne numărul 1, adică până când ajungem la primul bit setat
while n != 1:
n >>= 1
distanta += 1

# Se afișează distanța calculată
print("Distanța cerută este:", distanta)
print("Datele introduse corespund restricțiilor impuse.")

else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

3590 - Bit Distance

2023-04-26T14:39:53Z

Carla Chereji:

== Cerință ==
Se dă un număr natural n. Considerând reprezentarea in baza 2 a acestui număr, calculați distanța dintre primul bit setat și ultimul bit setat. Distanța dintre 2 biți este egală cu numărul de biți aflați intre biții respectivi.
== Date de intrare ==
Programul citește de la tastatură numărul n.
== Date de ieșire ==
Programul va afișa pe ecran distanța dintre primul și ultimul bit setat al numărului citit.
== Restricții de precizări ==
*1 &les; n &les; 2^64
== Exemplul 1==
; Intrare
: 82
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 6
 
== Exemplul 2 ==
; Intrare
: 4
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1
 
== Rezolvare ver. 1 ==

3590 - Bit Distance

2023-04-26T14:39:45Z

Carla Chereji: Pagină nouă: <nowiki>== Cerință ==</nowiki> Se dă un număr natural <code>n</code>. Considerând reprezentarea in baza <code>2</code> a acestui număr, calculați distanța dintre primul bit setat și ultimul bit setat. Distanța dintre <code>2</code> biți este egală cu numărul de biți aflați intre biții respectivi. <nowiki>== Date de intrare ==</nowiki> Programul citește de la tastatură numărul <code>n</code>. <nowiki>== Date de ieșire ==</nowiki> Programul va afișa pe...

<nowiki>== Cerință ==</nowiki>

Se dă un număr natural <code>n</code>. Considerând reprezentarea in baza <code>2</code> a acestui număr, calculați distanța dintre primul bit setat și ultimul bit setat. Distanța dintre <code>2</code> biți este egală cu numărul de biți aflați intre biții respectivi.

<nowiki>== Date de intrare ==</nowiki>

Programul citește de la tastatură numărul <code>n</code>.

<nowiki>== Date de ieșire ==</nowiki>

Programul va afișa pe ecran distanța dintre primul și ultimul bit setat al numărului citit.

<nowiki>== Restricții de precizări ==</nowiki>

<nowiki>*</nowiki>1 <nowiki>&</nowiki>les; n <nowiki>&</nowiki>les; 2^64

<nowiki>== Exemplul 1==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 82

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 6

<nowiki> </nowiki>

<nowiki>== Exemplul 2 ==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 4

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 1

<nowiki> </nowiki>

<nowiki>== Rezolvare ver. 1 ==</nowiki>

2997 - Prescurtat

2023-04-26T14:11:31Z

Carla Chereji:

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

'''void Prescurtat(char s[])'''

Funcția primește ca parametru un text de cel mult 50 de caractere, alcătuit din cuvinte separate prin câte un spațiu și formate din litere mari ale alfabetului englez, urmate eventual de caracterul . (punct), dacă sunt scrise prescurtat. Textul reprezintă numele unei instituții de învățământ și doar cuvintele din mulțimea {COLEGIUL, LICEUL, NATIONAL, TEORETIC} pot fi prescurtate, eliminându-se ultimele lor litere. Funcția va returna tot prin intermediul parametrului s numele instituției scris fără prescurtări.
==Restricții de precizări==

* Lungimea inițială a șirului '''s''' va fi de cel mult 50, iar la final de cel mult 100.

* Puteți utiliza funcțiile pentru șirurile de caractere din biblioteca cstring

==Exemplul 1==
;Intrare

:COLEG. NAT. DE INFORMATICA

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:COLEGIUL NATIONAL DE INFORMATICA

== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(s):
return s.isalpha()

def Prescurtat(s):
con = "" # Variabila pentru stocarea sirului prescurtat
tokens = s.split(" ") # Impartirea sirului s in token-uri folosind spatiul ca delimitator
for token in tokens:
lp = len(token) # Lungimea token-ului curent
if token[lp-1] == '.': # Verificam daca token-ul se termina cu punct
if token[:2] == 'CO': # Verificam daca primele doua caractere ale token-ului sunt 'CO'
con += "COLEGIUL " # Adaugam la sirul prescurtat 'COLEGIUL '
elif token[:2] == 'LI': # Verificam daca primele doua caractere ale token-ului sunt 'LI'
con += "LICEUL " # Adaugam la sirul prescurtat 'LICEUL '
elif token[:2] == 'NA': # Verificam daca primele doua caractere ale token-ului sunt 'NA'
con += "NATIONAL " # Adaugam la sirul prescurtat 'NATIONAL '
elif token[:2] == 'TE': # Verificam daca primele doua caractere ale token-ului sunt 'TE'
con += "TEORETIC " # Adaugam la sirul prescurtat 'TEORETIC '
else:
con += token + " " # Daca token-ul nu se termina cu punct, il adaugam la sirul prescurtat cu un spatiu la final
con = con.rstrip() # Stergem spatiile de la sfarsitul sirului prescurtat
return con

if __name__ == "__main__":
s = input("Introduceti sirul de caractere: ") # Citim sirul de la tastatura
print("Inainte:", s) # Afisam sirul inainte de prescurtare
s = Prescurtat(s) # Apelam functia Prescurtat pentru a prescurta sirul
print("Dupa:", s) # Afisam sirul dupa prescurtare

if validare(s):
print("Datele introduse corespund restricțiilor impuse.")
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0914 - Half Sort 1

2023-04-26T13:32:32Z

Carla Chereji:

== Cerință ==
Se dă un vector cu '''n elemente numere întreg'''i, '''n fiind număr par'''. Să se ordoneze crescător elementele din prima jumătate a vectorului și descrescător elementele din a doua jumătate.

Se vor defini și apela următoarele subprograme:

'''citire''', care citește valoarea lui n și cele n elemente ale tabloului

'''afisare''', care afișează elementele tabloului, separate prin exact un spațiu

'''sortare''', care ordonează elementele vectorului cuprinse între doi indici transmiși ca parametru.
== Date de intrare ==
Fişierul de intrare halfsort1.in conţine pe prima linie numărul n si pe a doua linie n numere întregi separate prin spaţii.
== Date de ieșire ==
Fişierul de ieşire halfsort1.out va conţine pe prima linie cele n elemente ale vectorului, ordonate conform cerinței, separate printr-un spațiu.
== Restricții de precizări ==
*1 &les; '''n''' &les; 1000
*valoarea absolută a numerelor de pe a doua linie a fişierului de intrare va fi mai mică decât 1.000.000.00

== Exemplul 1==
; Intrare
: 6
: 8 2 9 4 5 7
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 2 8 9 7 5 4
== Exemplul 2==
; Intrare
: 6
: 2 4 3 9 5 8
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 2 3 4 9 8 5
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, a):
# Verifică dacă n este de tip int, este mai mare decât 1, mai mic sau egal cu 100 și toate elementele din a sunt de tip int
return isinstance(n, int) and n > 1 and n <= 100 and all(isinstance(x, int) for x in a)

def sortare(n, a, st, dr, ch):
if ch == 'c':
# Sortare crescătoare (crescent)
for i in range(st, dr):
for j in range(i + 1, dr):
if a[i] > a[j]:
a[i], a[j] = a[j], a[i]
else:
# Sortare descrescătoare (descendent)
for i in range(st, dr):
for j in range(i + 1, dr):
if a[i] < a[j]:
a[i], a[j] = a[j], a[i]

def afisare(n, a):
# Afișează elementele listei a
for i in range(n):
print(a[i], end=' ')
if __name__ == "__main__":
n = 0
a = []
# Citire date de intrare
n = int(input("Introduceți numărul de elemente: "))
for i in range(n):
a.append(int(input(f"Introduceți elementul {i + 1}: ")))
# Verificare validitate date de intrare
if validare(n, a):
print("Datele introduse corespund restricțiilor impuse.")
# Sortare
sortare(n, a, 0, n // 2 + n % 2, 'c')
sortare(n, a, n // 2 + n % 2, n, 'd')
# Afisare rezultat
print("Lista sortată:")
afisare(n, a)
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0914 - Half Sort 1

2023-04-26T13:29:11Z

Carla Chereji:

== Cerință ==
Se dă un vector cu n elemente numere întregi, n fiind număr par. Să se ordoneze crescător elementele din prima jumătate a vectorului și descrescător elementele din a doua jumătate.
Se vor defini și apela următoarele subprograme:
• citire, care citește valoarea lui n și cele n elemente ale tabloului
• afisare, care afișează elementele tabloului, separate prin exact un spațiu
• sortare, care ordonează elementele vectorului cuprinse între doi indici transmiși ca parametru. Criteriul de ordonare (crescător/descrescător) va fi transmis ca parametru.
== Date de intrare ==
Fişierul de intrare halfsort1.in conţine pe prima linie numărul n si pe a doua linie n numere întregi separate prin spaţii.
== Date de ieșire ==
Fişierul de ieşire halfsort1.out va conţine pe prima linie cele n elemente ale vectorului, ordonate conform cerinței, separate printr-un spațiu.
== Restricții de precizări ==
*1 &les; n &les; 1000
*valoarea absolută a numerelor de pe a doua linie a fişierului de intrare va fi mai mică decât 1.000.000.00

== Exemplul 1==
; Intrare
: 6
: 8 2 9 4 5 7
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 2 8 9 7 5 4
 
== Rezolvare ver. 1 ==

0914 - Half Sort 1

2023-04-26T13:28:55Z

Carla Chereji: Pagină nouă: <nowiki>== Cerință ==</nowiki> Se dă un vector cu n elemente numere întregi, n fiind număr par. Să se ordoneze crescător elementele din prima jumătate a vectorului și descrescător elementele din a doua jumătate. Se vor defini și apela următoarele subprograme: * citire, care citește valoarea lui n și cele n elemente ale tabloului * afisare, care afișează elementele tabloului, separate prin exact un spațiu * sortare, care ordonează elemente...

<nowiki>== Cerință ==</nowiki>

Se dă un vector cu n elemente numere întregi, n fiind număr par. Să se ordoneze crescător elementele din prima jumătate a vectorului și descrescător elementele din a doua jumătate.

Se vor defini și apela următoarele subprograme:

* citire, care citește valoarea lui n și cele n elemente ale tabloului
* afisare, care afișează elementele tabloului, separate prin exact un spațiu
* sortare, care ordonează elementele vectorului cuprinse între doi indici transmiși ca parametru. Criteriul de ordonare (crescător/descrescător) va fi transmis ca parametru.

<nowiki>== Date de intrare ==</nowiki>

Fişierul de intrare <code>halfsort1.in</code> conţine pe prima linie numărul <code>n</code> si pe a doua linie <code>n</code> numere întregi separate prin spaţii.

<nowiki>== Date de ieșire ==</nowiki>

Fişierul de ieşire <code>halfsort1.out</code> va conţine pe prima linie cele <code>n</code> elemente ale vectorului, ordonate conform cerinței, separate printr-un spațiu.

<nowiki>== Restricții de precizări ==</nowiki>

<nowiki>*</nowiki>1 <nowiki>&</nowiki>les; n <nowiki>&</nowiki>les; 1000

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

<nowiki>== Exemplul 1==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 6

<nowiki>:</nowiki> 8 2 9 4 5 7

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 2 8 9 7 5 4

<nowiki> </nowiki>

0996 - Div 3

2023-04-26T13:14:20Z

Carla Chereji:

== Cerință ==
Pe prima linie a fişierului div3.in se află numărul '''n''', iar pe a doua linie '''n numere naturale'''.
== Date de intrare ==
Pe prima linie a fişierului div3.in se află numărul '''n''', iar pe a doua linie '''n numere naturale'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." Pe prima linie a fişierului div3.out se vor afla elementele şirului dat pentru care suma cifrelor este divizibilă cu 3, separate printr-un spațiu. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==
*1 &les; '''n''' &les; 1000
*elementele şirului vor avea cel mult 9 cifre
== Exemplul 1==
; Intrare
: 7
: 124 51 231 7 24 31 5
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 51 231 24
== Exemplul 2 ==
; Intrare
: 5
: 124 51 abc 7 24
; Ieșire
: Datele introduse nu corespund restricțiilor impuse.
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, numere):
# Verifica daca datele de intrare sunt valide conform cerintei problemei.
# Verifica daca n este un numar intreg pozitiv
# si daca toate numerele din lista numere sunt numere intregi pozitive.
return n.isdigit() and all(x.isdigit() for x in numere) and 1 <= int(n) <= 1000

def suma_cifre(n, numere):
# Calculeaza suma cifrelor pentru fiecare numar din lista numere,
# si retine doar numerele pentru care suma cifrelor este divizibila cu 3.
suma_div3 = []
for x in numere:
if sum(int(d) for d in str(x)) % 3 == 0:
suma_div3.append(x)
return suma_div3

if __name__ == "__main__":
with open("div3.in", "r") as fin:
n = fin.readline().strip() # Citeste numarul de elemente din sir
numere = fin.readline().strip().split() # Citeste lista de numere

if validare(n, numere):
n = int(n) # Converteste n la integer
numere = list(map(int, numere)) # Converteste lista de numere la integers

print("Datele introduse corespund restricțiilor impuse.")
suma_div3 = suma_cifre(n, numere) # Calculeaza suma_div3
with open("div3.out", "w") as fout:
fout.write(" ".join(map(str, suma_div3))) # Scrie numerele in fisierul de iesire
fout.write("\n")
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0996 - Div 3

2023-04-26T13:12:25Z

Carla Chereji:

== Cerință ==
Pe prima linie a fişierului div3.in se află numărul '''n''', iar pe a doua linie '''n numere naturale'''.
== Date de intrare ==
Pe prima linie a fişierului div3.in se află numărul '''n''', iar pe a doua linie '''n numere naturale'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." Pe prima linie a fişierului div3.out se vor afla elementele şirului dat pentru care suma cifrelor este divizibilă cu 3, separate printr-un spațiu. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==
*1 &les; '''n''' &les; 1000
*elementele şirului vor avea cel mult 9 cifre
== Exemplul 1==
; Intrare
: 7
: 124 51 231 7 24 31 5
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 51 231 24
== Exemplul 2 ==
; Intrare
: 5
: 12 34 56 78 90
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 12 90
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, numere):
# Verifica daca datele de intrare sunt valide conform cerintei problemei.
# Verifica daca n este un numar intreg pozitiv
# si daca toate numerele din lista numere sunt numere intregi pozitive.
return n.isdigit() and all(x.isdigit() for x in numere) and 1 <= int(n) <= 1000

def suma_cifre(n, numere):
# Calculeaza suma cifrelor pentru fiecare numar din lista numere,
# si retine doar numerele pentru care suma cifrelor este divizibila cu 3.
suma_div3 = []
for x in numere:
if sum(int(d) for d in str(x)) % 3 == 0:
suma_div3.append(x)
return suma_div3

if __name__ == "__main__":
with open("div3.in", "r") as fin:
n = fin.readline().strip() # Citeste numarul de elemente din sir
numere = fin.readline().strip().split() # Citeste lista de numere

if validare(n, numere):
n = int(n) # Converteste n la integer
numere = list(map(int, numere)) # Converteste lista de numere la integers

print("Datele introduse corespund restricțiilor impuse.")
suma_div3 = suma_cifre(n, numere) # Calculeaza suma_div3
with open("div3.out", "w") as fout:
fout.write(" ".join(map(str, suma_div3))) # Scrie numerele in fisierul de iesire
fout.write("\n")
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0915 - Elim Palindrom

2023-04-26T12:53:40Z

Carla Chereji:

== Cerință ==
Se dă un tablou cu '''n''' elemente, numere naturale. Să se elimine din tablou toate elementele care sunt palindrom.

Se vor defini și apela următoarele subprograme:

'''citire''', care citește de la tastatură valoarea lui '''n''' și cele '''n elemente ale tabloului'''

'''afisare''', care afișează pe ecran elementele tabloului, separate prin exact un spațiu

'''palindrom''', care verifică dacă un număr dat ca parametru este palindrom

'''eliminare''', care elimină din tablou un element a cărui poziție este dată ca parametru.
== Date de intrare ==
Se citește de la tastatură numărul '''n''', iar apoi cele '''n''' elemente ale tabloului.
==Date de ieșire==
Se vor afișa pe ecran elementele tabloului, separate prin exact un spațiu
==Restricții de precizări ==
* 1 &les; '''n''' &les; 1000
*elementele tabloului vor fi mai mici decât 1.000.000.000

== Exemplul 1==
; Intrare
:7
:17 181 22 56 4 20 420
;Ieșire
:Datele introduse corespund restricțiilor impuse.
:17 56 20 420
==Exemplul 2==
;Intrare
: 4
:17 20 100 55
;Ieșire
:Datele introduse corespund restricțiilor impuse.
:17 20 100
==Rezolvare ver. 1==
<syntaxhighlight lang="python" line="1" start="1">
def citire():
while True:
try:
n = int(input("Introduceți numărul de elemente (n): ")) # Citim numărul de elemente n de la utilizator
if n > 0:
break
else:
print("Vă rugăm să introduceți un număr întreg pozitiv.")
except ValueError:
print("Vă rugăm să introduceți un număr întreg pozitiv.")

a = []
while True:
try:
a_str = input("Introduceți elementele listei separate prin spațiu: ") # Citim elementele listei separate prin spațiu
a = list(map(int, a_str.split())) # Convertim elementele la tipul int și le adăugăm într-o listă
if len(a) != n:
print("Numărul de elemente introduse nu corespunde valorii n.")
else:
break
except ValueError:
print("Vă rugăm să introduceți numere întregi separate prin spațiu.")

return n, a

def palindrom(n):
return str(n) == str(n)[::-1] # Verificăm dacă numărul n este palindrom, comparându-l cu el însuși scris invers

def eliminare(a, i):
return a[:i] + a[i+1:] # Eliminăm elementul de pe poziția i din lista a

def afisare(a):
print(*a, end=" ") # Afișăm elementele listei separate prin spațiu, fără linie nouă la sfârșit

def validare(n):
return n.isdigit() and 1 <= int(n) <= 1000 # Validăm dacă n este un număr întreg pozitiv între 1 și 1000

if __name__ == "__main__":
n = input("Introduceți numărul de elemente (n): ")
if validare(n): # Validăm dacă n-ul introdus corespunde restricțiilor
n = int(n)
a = []
a_str = input("Introduceți elementele listei separate prin spațiu: ")
a = list(map(int, a_str.split())) # Convertim elementele listei la tipul int și le adăugăm într-o listă
print("Datele introduse corespund restricțiilor impuse.")
if len(a) != n:
print("Numărul de elemente introduse nu corespunde valorii n.")
else:
i = 0
while i < n:
if palindrom(a[i]): # Verificăm dacă fiecare element din listă este palindrom
a = eliminare(a, i) # Eliminăm elementele palindrom din listă
n -= 1
else:
i += 1
afisare(a) # Afișăm lista de elemente rămase
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0915 - Elim Palindrom

2023-04-26T12:49:28Z

Carla Chereji:

== Cerință ==
Se dă un tablou cu n elemente, numere naturale. Să se elimine din tablou toate elementele care sunt palindrom.
Se vor defini și apela următoarele subprograme:
• citire, care citește de la tastatură valoarea lui n și cele n elemente ale tabloului
• afisare, care afișează pe ecran elementele tabloului, separate prin exact un spațiu
• palindrom, care verifică dacă un număr dat ca parametru este palindrom
• eliminare, care elimină din tablou un element a cărui poziție este dată ca parametru.
== Date de intrare ==
Se citește de la tastatură numărul n, iar apoi cele n elemente ale tabloului.
== Date de ieșire ==
Se vor afișa pe ecran elementele tabloului, separate prin exact un spațiu
== Restricții de precizări ==
*1 &les; n &les; 1000
*elementele tabloului vor fi mai mici decât 1.000.000.000

== Exemplul 1==
; Intrare
: 7
: 17 181 22 56 4 20 420
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 17 56 20 420
 
== Exemplul 2 ==
; Intrare
: 4
: 17 20 100 55
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 17 20 100
 
== Rezolvare ver. 1 ==

0915 - Elim Palindrom

2023-04-26T12:49:10Z

Carla Chereji: Pagină nouă: <nowiki>== Cerință ==</nowiki> Se dă un tablou cu n elemente, numere naturale. Să se elimine din tablou toate elementele care sunt palindrom. Se vor defini și apela următoarele subprograme: * citire, care citește de la tastatură valoarea lui n și cele n elemente ale tabloului * afisare, care afișează pe ecran elementele tabloului, separate prin exact un spațiu * palindrom, care verifică dacă un număr dat ca parametru este palindrom * eliminar...

<nowiki>== Cerință ==</nowiki>

Se dă un tablou cu n elemente, numere naturale. Să se elimine din tablou toate elementele care sunt palindrom.

Se vor defini și apela următoarele subprograme:

* citire, care citește de la tastatură valoarea lui n și cele n elemente ale tabloului
* afisare, care afișează pe ecran elementele tabloului, separate prin exact un spațiu
* palindrom, care verifică dacă un număr dat ca parametru este palindrom
* eliminare, care elimină din tablou un element a cărui poziție este dată ca parametru.

<nowiki>== Date de intrare ==</nowiki>

Se citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale tabloului.

<nowiki>== Date de ieșire ==</nowiki>

Se vor afișa pe ecran elementele tabloului, separate prin exact un spațiu

<nowiki>== Restricții de precizări ==</nowiki>

<nowiki>*</nowiki>1 <nowiki>&</nowiki>les; n <nowiki>&</nowiki>les; 1000

<nowiki>*</nowiki>elementele tabloului vor fi mai mici decât 1.000.000.000

<nowiki>== Exemplul 1==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 7

<nowiki>:</nowiki> 17 181 22 56 4 20 420

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 17 56 20 420

<nowiki> </nowiki>

<nowiki>== Exemplul 2 ==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 4

<nowiki>:</nowiki> 17 20 100 55

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 17 20 100

<nowiki> </nowiki>

<nowiki>== Rezolvare ver. 1 ==</nowiki>

2577 - Get Bit

2023-04-26T11:05:08Z

Carla Chereji:

== Cerință ==
Se dau mai multe perechi de forma număr, bit. Afișați pentru fiecare pereche valoarea bitului corespunzător din reprezentarea internă pe 64 de biți a numărului dat.
== Date de intrare ==
Programul citește de la tastatură numărul '''T''', iar apoi T linii care conțin, fiecare, câte două numere separate prin spațiu '''n''' și '''b''' cu semnificația că se cere valoarea bitului de pe poziția '''b''' din reprezentarea internă a numărului '''n.'''
== 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, neseparate prin spațiu, cele '''T''' valori, determinate, în ordinea dată. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==
*numerele n sunt memorate cu tipul de date pe 64 de biți, cu semn
*numărul b este natural, cuprins între 0 și 63, inclusiv
== Exemplul 1==
; Intrare
: 2
: 6 0
: 5 2
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 0 1
== Exemplul 2 ==
; Intrare
: 3
: 7 1
: 15 2
: 21 0
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1 1 1
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(T, n, b):
# Funcție de validare a datelor de intrare
# Verificăm dacă T este între 0 și 1000, iar n și b conțin numere între 0 și 2^63 - 1 și respectiv 0 și 63
return 0 <= int(T) <= 1000 and all(0 <= int(num) <= 2**63 - 1 for num in n) and all(0 <= int(bit) <= 63 for bit in b)

def getbit(T, n, b):
# Funcție pentru a obține valoarea bitului corespunzător din reprezentarea internă a numărului
for i in range(T):
bit_val = (n[i] & (1 << b[i])) >> b[i]
print(bit_val)

def main():
# Funcția principală a programului
T = input("Introduceți numărul de perechi de număr, bit: ")
n = []
b = []
for i in range(int(T)):
# Citirea datelor de intrare și adăugarea lor în liste separate pentru n și b
pair = input("Introduceți valorile n și b separate prin spațiu pentru perechea {}: ".format(i + 1)).split()
n.append(int(pair[0]))
b.append(int(pair[1]))

if validare(T, n, b):
# Verificăm dacă datele de intrare corespund restricțiilor impuse
print("Datele introduse corespund restricțiilor impuse.")
getbit(int(T), n, b)
else:
print("Datele introduse nu corespund restricțiilor impuse.")

if __name__ == "__main__":
# Apelează funcția main() doar atunci când scriptul este executat ca script principal
main()

</syntaxhighlight>

2999 - Trim

2023-04-26T09:50:56Z

Carla Chereji: /* Exemplul 2 */

==Cerință==
Scrieți un program care citește de la tastatură trei numere naturale '''n''', '''k''' și '''r''' și afișează:

* câte submulțimi sunt formate dintr-un număr de elemente pare (cardinalul submulțimilor este un număr par)

* media aritmetică a elementelor din submulțimile cu număr de ordine '''k''' și '''r''' (0 < k ≤ r ≤ 100)

* elementele submulțimii r sub forma: primul, al doilea, ultimul, al treilea, al patrulea, penultimul, etc.

==Date de intrare==
Programul va citi de la tastatură '''n''', '''k''' și '''r''' numere naturale.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Se afișează fiecare pe câte o linie:

* numărul de submulțimi cu număr de elemente pare

* media aritmetică a numerelor din submulțimile '''k și r'''

* elementele submulțimii r sub forma: primul, al doilea, ultimul, al treilea, al patrulea, penultimul, etc.

În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*1 &les; '''k''' &les; '''r''' &les; '''n''' 100
==Exemplul 1==
;Intrare

:10

:3

:7

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:1024

:5

:7 9

==Exemplul 2==
;Intrare

:12

:3

:4

;Ieșire
;
: Datele introduse corespund restricțiilor impuse.
: 4096
: 3
: 4 6 8 10 12

== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def numar_submultimi_pare(n):
# Calculează numărul de submulțimi cu cardinalitatea pară
return 2 ** n

def medie_submultimi(submultimi, k, r):
# Calculează media aritmetică a elementelor din submulțimile k și r
# Dacă k și r sunt în afara intervalului corect, returnează None
if k < 1 or r > len(submultimi) or k > r:
return None
else:
submultimi_k_r = submultimi[k-1:r:2] # obține submulțimile de la k la r, cu pași de 2
medie = sum(submultimi_k_r) / len(submultimi_k_r)
return medie

def submultime_specifica(submultimi, r):
# Obține elementele submulțimii r sub forma specificată
if r > len(submultimi):
return None
else:
submultime_r = submultimi[r-1::2] # obține elementele submulțimii r, cu pași de 2
return submultime_r

if __name__ == "__main__":
# Citirea datelor de intrare de la tastatură
n = int(input("Introduceți numărul total de elemente: "))
k = int(input("Introduceți numărul de ordine k: "))
r = int(input("Introduceți numărul de ordine r: "))

# Verificare restricții
if not (0 < k <= r <= 100):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
# Obținere număr de submulțimi cu cardinalitatea pară
numar_submultimi_pare = numar_submultimi_pare(n)
print("Numărul de submulțimi cu cardinalitatea pară:", numar_submultimi_pare)

# Generare submulțimi
submultimi = list(range(1, n+1))

# Obținere medie aritmetică
medie = medie_submultimi(submultimi, k, r)
if medie is not None:
print("Media aritmetică a numerelor din submulțimile k și r:", medie)
else:
print("Nu se poate calcula media aritmetică pentru valorile introduse.")

# Obținere submulțime specifică
submultime_specifica = submultime_specifica(submultimi, r)
if submultime_specifica is not None:
print("Elementele submulțimii r sub forma specificată:", submultime_specifica)
else:
print("Nu se poate obține submulțimea specificată pentru valorile introduse.")

</syntaxhighlight>

2999 - Trim

2023-04-26T09:50:02Z

Carla Chereji:

==Cerință==
Scrieți un program care citește de la tastatură trei numere naturale '''n''', '''k''' și '''r''' și afișează:

* câte submulțimi sunt formate dintr-un număr de elemente pare (cardinalul submulțimilor este un număr par)

* media aritmetică a elementelor din submulțimile cu număr de ordine '''k''' și '''r''' (0 < k ≤ r ≤ 100)

* elementele submulțimii r sub forma: primul, al doilea, ultimul, al treilea, al patrulea, penultimul, etc.

==Date de intrare==
Programul va citi de la tastatură '''n''', '''k''' și '''r''' numere naturale.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Se afișează fiecare pe câte o linie:

* numărul de submulțimi cu număr de elemente pare

* media aritmetică a numerelor din submulțimile '''k și r'''

* elementele submulțimii r sub forma: primul, al doilea, ultimul, al treilea, al patrulea, penultimul, etc.

În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*1 &les; '''k''' &les; '''r''' &les; '''n''' 100
==Exemplul 1==
;Intrare

:10

:3

:7

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:1024

:5

:7 9

==Exemplul 2==
;Intrare

:12

:3

:4

;Ieșire
: 4096
: 3
: 4 6 8 10 12

== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def numar_submultimi_pare(n):
# Calculează numărul de submulțimi cu cardinalitatea pară
return 2 ** n

def medie_submultimi(submultimi, k, r):
# Calculează media aritmetică a elementelor din submulțimile k și r
# Dacă k și r sunt în afara intervalului corect, returnează None
if k < 1 or r > len(submultimi) or k > r:
return None
else:
submultimi_k_r = submultimi[k-1:r:2] # obține submulțimile de la k la r, cu pași de 2
medie = sum(submultimi_k_r) / len(submultimi_k_r)
return medie

def submultime_specifica(submultimi, r):
# Obține elementele submulțimii r sub forma specificată
if r > len(submultimi):
return None
else:
submultime_r = submultimi[r-1::2] # obține elementele submulțimii r, cu pași de 2
return submultime_r

if __name__ == "__main__":
# Citirea datelor de intrare de la tastatură
n = int(input("Introduceți numărul total de elemente: "))
k = int(input("Introduceți numărul de ordine k: "))
r = int(input("Introduceți numărul de ordine r: "))

# Verificare restricții
if not (0 < k <= r <= 100):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
# Obținere număr de submulțimi cu cardinalitatea pară
numar_submultimi_pare = numar_submultimi_pare(n)
print("Numărul de submulțimi cu cardinalitatea pară:", numar_submultimi_pare)

# Generare submulțimi
submultimi = list(range(1, n+1))

# Obținere medie aritmetică
medie = medie_submultimi(submultimi, k, r)
if medie is not None:
print("Media aritmetică a numerelor din submulțimile k și r:", medie)
else:
print("Nu se poate calcula media aritmetică pentru valorile introduse.")

# Obținere submulțime specifică
submultime_specifica = submultime_specifica(submultimi, r)
if submultime_specifica is not None:
print("Elementele submulțimii r sub forma specificată:", submultime_specifica)
else:
print("Nu se poate obține submulțimea specificată pentru valorile introduse.")

</syntaxhighlight>

2587 - Swap Bytes

2023-04-25T17:06:08Z

Carla Chereji:

== Cerință ==
Se dă un număr '''n''', întreg și care va fi citit într-o variabilă pe 16 biți, cu semn. Calculați, într-o variabilă de același tip (și apoi afișați pe ecran valoarea acestei variabile) ceea ce se obține interschimbând cei doi octeți ai variabilei inițiale (secvența primilor 8 biți ajunge, în aceeași ordine pe ultimele 8 poziții, și invers).
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Programul va afișa pe ecran valoarea calculată.
== Restricții de precizări ==
*-32768 &les; '''n''' &les; 32767
== Exemplul 1==
; Intrare
: 1
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 256
== Exemplul 2 ==
; Intrare
: 5
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1280
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
return n.isdigit() and int(n) >= -2**15 and int(n) <= 2**15 - 1

def interschimbare_octeti(n):
# Verificăm dacă n este pe 16 biți folosind funcția de validare
if validare(n):
# Extragem primul octet și al doilea octet
primul_octet = int(n) & 0xFF
al_doilea_octet = (int(n) >> 8) & 0xFF

# Realizăm interschimbarea octeților prin combinarea lor într-un nou număr
n_interschimbat = (primul_octet << 8) | al_doilea_octet

return n_interschimbat
else:
print("Numărul introdus nu este pe 16 biți.")
return None

if __name__ == "__main__":
# Citirea valorii pentru n de la tastatură
n = input("Introduceți numărul n (pe 16 biți, cu semn): ")

# Validarea și apelarea funcției de interschimbare a octeților
if validare(n):
n_interschimbat = interschimbare_octeti(n)
if n_interschimbat is not None:
print(n_interschimbat)
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2587 - Swap Bytes

2023-04-25T17:03:22Z

Carla Chereji:

== Cerință ==
Se dă un număr n, întreg și care va fi citit într-o variabilă pe 16 biți, cu semn. Calculați, într-o variabilă de același tip (și apoi afișați pe ecran valoarea acestei variabile) ceea ce se obține interschimbând cei doi octeți ai variabilei inițiale (secvența primilor 8 biți ajunge, în aceeași ordine pe ultimele 8 poziții, și invers).
== Date de intrare ==
Programul citește de la tastatură numărul n.
== Date de ieșire ==
Programul va afișa pe ecran valoarea calculată.
== Restricții de precizări ==
*-32768 &les; n &les; 32767
== Exemplul 1==
; Intrare
: 1
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 256
 
== Exemplul 2 ==
; Intrare
: 5
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1280
 
== Rezolvare ver. 1 ==

2587 - Swap Bytes

2023-04-25T17:03:14Z

Carla Chereji: Pagină nouă: <nowiki>== Cerință ==</nowiki> Se dă un număr <code>n</code>, întreg și care va fi citit într-o variabilă pe <code>16</code> biți, cu semn. Calculați, într-o variabilă de același tip (și apoi afișați pe ecran valoarea acestei variabile) ceea ce se obține interschimbând cei doi octeți ai variabilei inițiale (secvența primilor <code>8</code> biți ajunge, în aceeași ordine pe ultimele <code>8</code> poziții, și invers). <nowiki>== Date de intrare ==</...

<nowiki>== Cerință ==</nowiki>

Se dă un număr <code>n</code>, întreg și care va fi citit într-o variabilă pe <code>16</code> biți, cu semn. Calculați, într-o variabilă de același tip (și apoi afișați pe ecran valoarea acestei variabile) ceea ce se obține interschimbând cei doi octeți ai variabilei inițiale (secvența primilor <code>8</code> biți ajunge, în aceeași ordine pe ultimele <code>8</code> poziții, și invers).

<nowiki>== Date de intrare ==</nowiki>

Programul citește de la tastatură numărul <code>n</code>.

<nowiki>== Date de ieșire ==</nowiki>

Programul va afișa pe ecran valoarea calculată.

<nowiki>== Restricții de precizări ==</nowiki>

<nowiki>*</nowiki>-32768 <nowiki>&</nowiki>les; n <nowiki>&</nowiki>les; 32767

<nowiki>== Exemplul 1==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 1

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 256

<nowiki> </nowiki>

<nowiki>== Exemplul 2 ==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 5

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 1280

<nowiki> </nowiki>

<nowiki>== Rezolvare ver. 1 ==</nowiki>

3956 - Erase Bits

2023-04-25T16:23:50Z

Carla Chereji:

== Cerință ==
Dându-se un număr natural '''n''', să se afle toate numerele obținute resetând succesiv cel mai nesemnificativ bit cu valoarea 1, fără a folosi variabile auxiliare.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Programul va afișa pe ecran numerele.
== Restricții de precizări ==
*1 &les; '''n''' &les; 10^18
== Exemplul 1==
; Intrare
: 123
; Ieșire
: Datele introduse corespund restricțiilor impuse.
122 121 119 111 95 63 0 
== Exemplul 2 ==
; Intrare
: 86
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 85 83 79 63 0

== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
return str(n).isdigit() and 1 <= int(n) <= 10**18

def resetare_bit(n):
while n > 0: # Cât timp n este mai mare ca și 0
print(n - 1, end=" ") # Afișăm numărul obținut prin scăderea cu 1
n &= n - 1 # Resetăm cel mai nesemnificativ bit cu valoarea 1
print(0) # Afișăm și 0 la final

if __name__ == "__main__":
# Citirea valorii pentru n de la tastatură
n = input("Introduceți numărul n: ")
if validare(n):
n = int(n)
print("Datele introduse corespund restricțiilor impuse.")
resetare_bit(n)
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

3956 - Erase Bits

2023-04-25T16:18:51Z

Carla Chereji:

== Cerință ==
Dându-se un număr natural n, să se afle toate numerele obținute resetând succesiv cel mai nesemnificativ bit cu valoarea 1, fără a folosi variabile auxiliare.
== Date de intrare ==
Programul citește de la tastatură numărul n.
== Date de ieșire ==
Programul va afișa pe ecran numerele.
== Restricții de precizări ==
*1 &les; n &les; 10^18
== Exemplul 1==
; Intrare
: 123
; Ieșire
: Datele introduse corespund restricțiilor impuse.
122 121 119 111 95 63 0
 
== Exemplul 2 ==
; Intrare
: 86
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 85 83 79 63 0
 
== Rezolvare ver. 1 ==

3956 - Erase Bits

2023-04-25T16:18:40Z

Carla Chereji: Pagină nouă: <nowiki>== Cerință ==</nowiki> Dându-se un număr natural <code>n</code>, să se afle toate numerele obținute resetând succesiv cel mai nesemnificativ bit cu valoarea <code>1</code>, fără a folosi variabile auxiliare. <nowiki>== Date de intrare ==</nowiki> Programul citește de la tastatură numărul <code>n</code>. <nowiki>== Date de ieșire ==</nowiki> Programul va afișa pe ecran numerele. <nowiki>== Restricții de precizări ==</nowiki> <nowiki>*</nowiki>1 <...

<nowiki>== Cerință ==</nowiki>

Dându-se un număr natural <code>n</code>, să se afle toate numerele obținute resetând succesiv cel mai nesemnificativ bit cu valoarea <code>1</code>, fără a folosi variabile auxiliare.

<nowiki>== Date de intrare ==</nowiki>

Programul citește de la tastatură numărul <code>n</code>.

<nowiki>== Date de ieșire ==</nowiki>

Programul va afișa pe ecran numerele.

<nowiki>== Restricții de precizări ==</nowiki>

<nowiki>*</nowiki>1 <nowiki>&</nowiki>les; n <nowiki>&</nowiki>les; 10^18

<nowiki>== Exemplul 1==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 123

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

122 121 119 111 95 63 0

<nowiki> </nowiki>

<nowiki>== Exemplul 2 ==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 86

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 85 83 79 63 0

<nowiki> </nowiki>

<nowiki>== Rezolvare ver. 1 ==</nowiki>

4237 - Araci

2023-04-25T11:50:26Z

Carla Chereji:

== Cerință ==
Să se determine lungimea maximă '''L''' pe care o poate obține pentru cel puțin '''A''' araci tăind bambușii.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' și '''A''', iar apoi '''n numere naturale''', separate prin spații, reprezentând dimensiunile tulpinilor de bambus.
== Date de ieșire ==
Programul va afișa pe ecran '''L''', reprezentând lungimea maximă posibilă a celor cel puțin A araci.
== Restricții de precizări ==
*3 &les; '''n''' &les; 100000
*1 &les; '''L''' &les; 30000
== Exemplul 1==
; Intrare
: 4 1
: 6 10 14 9
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 14
== Exemplul 2 ==
; Intrare
: 3
: 2
: 5 7 8
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 15 
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, A, bamboos):
n = str(n) # Convertim n la șir de caractere
return n.isdigit() and 3 <= int(n) <= 100000

def calculate_max_length(n, A, bamboos):
bamboos.sort() # Se sortează lista de dimensiuni de bambus în ordine crescătoare
max_length = 0 # Variabila pentru lungimea maximă
count = 0 # Variabila pentru numărul de araci
i = n - 1 # Indexul pentru parcurgerea listei de la sfârșit
while i >= 0 and count < A: # Se parcurge lista în ordine descrescătoare până când se obține numărul minim de araci
max_length += bamboos[i] # Se adaugă dimensiunea curentă de bambus la lungimea maximă
count += 1 # Se incrementează numărul de araci
i -= 1 # Se trece la următorul bambus
return max_length # Se returnează lungimea maximă

def main():
n = int(input("Introduceti numarul de dimensiuni de bambus: "))
A = int(input("Introduceti numarul minim de araci: "))
bamboos = list(map(int, input("Introduceti dimensiunile separate prin spatii: ").split()))
max_length = calculate_max_length(n, A, bamboos)
print("Lungimea maxima posibila:", max_length)

if validare(n, A, bamboos):
print("Datele introduse corespund restricțiilor impuse.")
else:
print("Datele introduse nu corespund restricțiilor impuse.")

if __name__ == "__main__":
main()

</syntaxhighlight>

4237 - Araci

2023-04-25T11:48:39Z

Carla Chereji:

== Cerință ==
Să se determine lungimea maximă L pe care o poate obține pentru cel puțin A araci tăind bambușii.
== Date de intrare ==
Programul citește de la tastatură numerele n și A, iar apoi n numere naturale, separate prin spații, reprezentând dimensiunile tulpinilor de bambus.
== Date de ieșire ==
Programul va afișa pe ecran L, reprezentând lungimea maximă posibilă a celor cel puțin A araci.
== Restricții de precizări ==
*3 &les; n &les; 100000
*1 &les; d &les; 30000
== Exemplul 1==
; Intrare
: 4 1
: 6 10 14 9
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 14
 
== Exemplul 2 ==
; Intrare
: 3
: 2
: 5 7 8
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 15
 
== Rezolvare ver. 1 ==

4237 - Araci

2023-04-25T11:48:28Z

Carla Chereji: Pagină nouă: <nowiki>== Cerință ==</nowiki> Să se determine lungimea maximă <code>L</code> pe care o poate obține pentru cel puțin <code>A</code> araci tăind bambușii. <nowiki>== Date de intrare ==</nowiki> Programul citește de la tastatură numerele <code>n</code> și <code>A</code>, iar apoi <code>n</code> numere naturale, separate prin spații, reprezentând dimensiunile tulpinilor de bambus. <nowiki>== Date de ieșire ==</nowiki> Programul va afișa pe ecran <code>L</cod...

<nowiki>== Cerință ==</nowiki>

Să se determine lungimea maximă <code>L</code> pe care o poate obține pentru cel puțin <code>A</code> araci tăind bambușii.

<nowiki>== Date de intrare ==</nowiki>

Programul citește de la tastatură numerele <code>n</code> și <code>A</code>, iar apoi <code>n</code> numere naturale, separate prin spații, reprezentând dimensiunile tulpinilor de bambus.

<nowiki>== Date de ieșire ==</nowiki>

Programul va afișa pe ecran <code>L</code>, reprezentând lungimea maximă posibilă a celor cel puțin <code>A</code> araci.

<nowiki>== Restricții de precizări ==</nowiki>

<nowiki>*</nowiki>3 <nowiki>&</nowiki>les; n <nowiki>&</nowiki>les; 100000

<nowiki>*</nowiki>1 <nowiki>&</nowiki>les; d <nowiki>&</nowiki>les; 30000

<nowiki>== Exemplul 1==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 4 1

<nowiki>:</nowiki> 6 10 14 9

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 14

<nowiki> </nowiki>

<nowiki>== Exemplul 2 ==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 3

<nowiki>:</nowiki> 2

<nowiki>:</nowiki> 5 7 8

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 15

<nowiki> </nowiki>

<nowiki>== Rezolvare ver. 1 ==</nowiki>

0508 - Cautare Binara

2023-04-25T11:13:08Z

Carla Chereji:

== Cerință ==

Se dă un vector '''x''' cu n elemente numere naturale, ordonate crescător, și un vector '''y''' cu '''m''' elemente, de asemenea numere naturale. Verificați pentru fiecare element al vectorului '''y''' dacă apare în '''x'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi cele '''n''' elemente ale vectorului '''x'''. Apoi și citește '''m''' și celem '''m''' elemente ale lui '''y'''.
== Date de ieșire ==
Programul va afișa pe ecran '''m''' valori 0 sau 1, separate prin exact un spațiu. A j-a valoare afișată este 1, dacă al j-lea element al șirului '''y''' apare în '''x,''' respectiv 0 în caz contrar.

== Restricții de precizări ==
*1 &les; '''n''' &les; 25000
*1 &les; '''m''' &les; 25000
*elementele celor 2 vectori vor fi mai mici decât 10000

== Exemplul 1==
; Intrare
: 5
: 2 4 6 8 10
: 3
: 4 7 9
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 1 0 0
== Exemplul 2 ==
; Intrare
: 3

: 1 5 7

: 4
: 3 8 1 0
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 0 0 0 0
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, x, m, y):
return str(n).isdigit() and 1 <= int(n) <= 25000 and str(m).isdigit() and 1 <= int(m) <= 2000000
# Verifică dacă n și m sunt cifre și se află în intervalul specificat

def element_in_vector(x, y):
result = [] # Lista în care se vor stoca rezultatele verificării
j = 0 # Variabilă utilizată pentru a parcurge vectorul x
for i in range(len(y)): # Se parcurge vectorul y
while j < len(x) and x[j] < y[i]: # Se parcurge vectorul x până la valoarea din y[i]
j += 1
if j < len(x) and x[j] == y[i]: # Dacă s-a găsit o valoare din y în x, se adaugă 1 în result
result.append(1)
else: # Altfel, se adaugă 0 în result
result.append(0)
return result # Se returnează lista cu rezultatele verificării

def main():
# Citirea vectorului x
n = int(input("Introduceți numărul de elemente în vectorul x: "))
x = []
for i in range(n):
x.append(int(input(f"Introduceți elementul {i + 1} din x: ")))

# Citirea vectorului y
m = int(input("Introduceți numărul de elemente în vectorul y: "))
y = []
for i in range(m):
y.append(int(input(f"Introduceți elementul {i + 1} din y: ")))

# Verificarea elementelor din y în x
result = element_in_vector(x, y)

# Afișarea rezultatului
print("Rezultatul verificării:")
print(*result, sep=" ")

if validare(n, x, m, y):
print("Datele introduse corespund restricțiilor impuse.")
else:
print("Datele introduse nu corespund restricțiilor impuse.")

if __name__ == "__main__":
main()

</syntaxhighlight>

0508 - Cautare Binara

2023-04-25T10:55:22Z

Carla Chereji:

== Cerință ==

Se dă un vector x cu n elemente numere naturale, ordonate crescător, și un vector y cu m elemente, de asemenea numere naturale. Verificați pentru fiecare element al vectorului y dacă apare în x.
== Date de intrare ==
Programul citește de la tastatură numărul n, iar apoi cele n elemente ale vectorului x. Apoi și citește m și cele m elemente ale lui y.
== Date de ieșire ==
Programul va afișa pe ecran m valori 0 sau 1, separate prin exact un spațiu. A j-a valoare afișată este 1, dacă al j-lea element al șirului y apare în x, respectiv 0 în caz contrar.

== Restricții de precizări ==
*1 &les; n &les; 25000
*1 &les; m &les; 25000
*elementele celor 2 vectori vor fi mai mici decât 10000

== Exemplul 1==
; Intrare
: 7
: 1
: 2
: 5
: 6
: 9
: 10
: 14
: 8
: 8
: 14
: 9
:14
: 16
: 15
: 4
: 2
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 0
: 1
: 1
: 1
: 0
: 0
: 0
: 1
 
== Exemplul 2 ==
; Intrare
: 3
 
: 1
: 5
: 7
 
: 4
 
: 3
: 8
: 1
: 0
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 0
: 0
: 1
: 0
 
== Rezolvare ver. 1 ==

0508 - Cautare Binara

2023-04-25T10:55:11Z

Carla Chereji: Pagină nouă: <nowiki>== Cerință ==</nowiki> Se dă un vector '''x''' cu n elemente numere naturale, ordonate crescător, și un vector '''y''' cu '''m''' elemente, de asemenea numere naturale. Verificați pentru fiecare element al vectorului '''y''' dacă apare în '''x'''. <nowiki>== Date de intrare ==</nowiki> Programul citește de la tastatură numărul '''n''', iar apoi cele '''n''' elemente ale vectorului '''x'''. Apoi și citește '''m''' și cele '''m''' elemente ale lui '''y...

<nowiki>== Cerință ==</nowiki>

Se dă un vector '''x''' cu n elemente numere naturale, ordonate crescător, și un vector '''y''' cu '''m''' elemente, de asemenea numere naturale. Verificați pentru fiecare element al vectorului '''y''' dacă apare în '''x'''.

<nowiki>== Date de intrare ==</nowiki>

Programul citește de la tastatură numărul '''n''', iar apoi cele '''n''' elemente ale vectorului '''x'''. Apoi și citește '''m''' și cele '''m''' elemente ale lui '''y'''.

<nowiki>== Date de ieșire ==</nowiki>

Programul va afișa pe ecran m valori '''0 sau 1''', separate prin exact un spațiu. A j-a valoare afișată este '''1''', dacă al j-lea element al șirului '''y''' apare în '''x''', respectiv '''0''' în caz contrar.

<nowiki>== Restricții de precizări ==</nowiki>

<nowiki>*</nowiki>1 <nowiki>&</nowiki>les; n <nowiki>&</nowiki>les; 25000

<nowiki>*</nowiki>1 <nowiki>&</nowiki>les; m <nowiki>&</nowiki>les; 25000

<nowiki>*</nowiki>elementele celor 2 vectori vor fi mai mici decât 10000

<nowiki>== Exemplul 1==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 7

<nowiki>:</nowiki> 1

<nowiki>:</nowiki> 2

<nowiki>:</nowiki> 5

<nowiki>:</nowiki> 6

<nowiki>:</nowiki> 9

<nowiki>:</nowiki> 10

<nowiki>:</nowiki> 14

<nowiki>:</nowiki> 8

<nowiki>:</nowiki> 8

<nowiki>:</nowiki> 14

<nowiki>:</nowiki> 9

<nowiki>:</nowiki>14

<nowiki>:</nowiki> 16

<nowiki>:</nowiki> 15

<nowiki>:</nowiki> 4

<nowiki>:</nowiki> 2

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 0

<nowiki>:</nowiki> 1

<nowiki>:</nowiki> 1

<nowiki>:</nowiki> 1

<nowiki>:</nowiki> 0

<nowiki>:</nowiki> 0

<nowiki>:</nowiki> 0

<nowiki>:</nowiki> 1

<nowiki> </nowiki>

<nowiki>== Exemplul 2 ==</nowiki>

<nowiki>;</nowiki> Intrare

<nowiki>:</nowiki> 3

<nowiki> </nowiki>

<nowiki>:</nowiki> 1

<nowiki>:</nowiki> 5

<nowiki>:</nowiki> 7

<nowiki> </nowiki>

<nowiki>:</nowiki> 4

<nowiki> </nowiki>

<nowiki>:</nowiki> 3

<nowiki>:</nowiki> 8

<nowiki>:</nowiki> 1

<nowiki>:</nowiki> 0

<nowiki>;</nowiki> Ieșire

<nowiki>:</nowiki> Datele introduse corespund restricțiilor impuse.

<nowiki>:</nowiki> 0

<nowiki>:</nowiki> 0

<nowiki>:</nowiki> 1

<nowiki>:</nowiki> 0

<nowiki> </nowiki>

<nowiki>== Rezolvare ver. 1 ==</nowiki>

4277 - Upper Lower

2023-04-25T10:46:01Z

Carla Chereji:

== Cerință ==
Scrieți funcția cu următorul antet: UpperLower(a, U, L)

Funcția primește ca parametri trei șiruri de caractere '''a, U și L'''. Șirul '''U''' trebuie să memoreze caracterele din '''a''', dar în care literele mici au fost convertite la majuscule, iar șirul '''L''' trebuie să memoreze caracterele din '''a''', dar în care literele mari au fost convertite la litere mici.

==Date de intrare==
Se citește de la tastatură un șir de caractere.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Șirul '''U''' memorează caracterele din '''a''', dar în care literele mici au fost convertite la majuscule, iar șirul '''L''' memorează caracterele din '''a''', dar în care literele mari au fost convertite la litere mici.
Va fi afișat '''U''' și '''L'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==

*Șirul a poate conține și alte caractere în afară de litere, dar acestea rămân nemodificate.
*Indexarea șirurilor începe de la 0

==Exemplu==
=== Exemplul 1===
; Intrare
: I Am a Sith Lord
; Ieșire
: I AM A SITH LORD
: i am a sith lord

==Rezolvare==
=== Rezolvare var. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
def validare(a, U, L):
return all.isdigit()

def UpperLower(a, U, L):
# Această funcție primește un string 'a' ca intrare și două stringuri goale 'U' și 'L' pentru a stoca caracterele majuscule și minuscule
for c in a:
if c.islower():
# Dacă caracterul este literă mică, adaugă varianta sa majusculă în 'U' și caracterul original în 'L'
U += c.upper()
L += c
elif c.isupper():
# Dacă caracterul este literă mare, adaugă caracterul în 'U' și varianta sa minuscule în 'L'
U += c
L += c.lower()
else:
# Dacă caracterul nu este nici literă mare, nici literă mică (de exemplu, cifre, semne de punctuație etc.), adaugă-l atât în 'U', cât și în 'L'
U += c
L += c
# Returnează stringurile rezultate pentru literele majuscule și minuscule
return U, L

if __name__ == "__main__":
# Obține input de la utilizator și elimină spațiile albe de la început și sfârșit
a = input().strip()
U = ""
L = ""
# Apelează funcția UpperLower cu stringul de intrare 'a' și cu stringurile goale 'U' și 'L'
U, L = UpperLower(a, U, L)
# Afișează stringurile rezultate pentru literele majuscule și minuscule
print("U:", U)
print("L:", L)
if validare(a, L ,U):
print("Datele introduse corespund restricțiilor impuse.")
UpperLower(a, U, L)

else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

1479 - Pretios

2023-04-25T08:55:24Z

Carla Chereji:

== Cerință ==
Un număr natural în baza 10 se numește prețios dacă numărul de cifre ale sale din baza 2 este număr prim. Se dă un interval '''[a,b]'''. Determinați câte numere prețioase se află în acest interval.
== Date de intrare ==
Programul citește de la tastatură numerele '''a''' și '''b'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul va afișa pe ecran numărul '''x''', reprezentând numărul de numere prețioase din intervalul dat. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==
*1 &les; '''a, b''' &les; 10.000.000.000.000.000.000
==Exemplu==
=== Exemplul 1===
; Intrare
: 1
: 4
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 3
==Explicație==
Cele '''3''' numere prețioase sunt '''2 3 4'''.
==Rezolvare==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
import math

def is_prime(n):
# Funcție pentru verificarea primarității unui număr
# Returnează True dacă numărul este prim, False în caz contrar
if n < 2:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True

def count_precious_numbers(a, b):
# Funcție pentru numărarea numerele prețioase într-un interval dat [a, b]
count = 0
for num in range(a, b + 1):
binary_digits = bin(num)[2:] # Conversia numărului la reprezentare binară și eliminarea prefixului '0b'
if is_prime(len(binary_digits)): # Verificare dacă lungimea reprezentării binare a numărului este primă
count += 1
return count

if __name__ == '__main__':
a = int(input("Introduceți numărul a: ")) # Citirea valorii numărului a de la tastatură și convertirea la tipul int
b = int(input("Introduceți numărul b: ")) # Citirea valorii numărului b de la tastatură și convertirea la tipul int

if 1 <= a <= b <= 10 ** 18: # Verificare validitate interval [a, b]
print("Datele de intrare corespund restricțiilor impuse.")
result = count_precious_numbers(a, b) # Apelarea funcției count_precious_numbers() pentru calcularea numărului de numere prețioase
print("Numărul de numere prețioase din intervalul dat este:", result)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3957 - Countercase

2023-04-25T08:54:01Z

Carla Chereji:

== Cerință ==
Dându-se un număr natural '''n''' să se afle câte numere se pot obține folosind biții acestuia.Un număr natural x se obține folosind biții lui '''n''' dacă mulțimea biților setați ai lui x este inclusă în mulțimea biților setați ai lui '''n'''. De exemplu, pentru n = 5 reprezentarea binară este 101; x poate lua valorile 101, 100, 001, 000, adică 5, 4, 1, 0.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul va afișa pe ecran valoarea cerută. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==
*'''n''' are cel mult 500 de cifre
==Exemplu==
=== Exemplul 1===
; Intrare
: 5
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 4

==Rezolvare==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
# Funcție pentru validarea numărului de intrare
# Returnează True dacă numărul este valid, False în caz contrar
return n.isdigit() and int(n) <= 500

def counterase(n):
# Funcție pentru calcularea numărului de numere posibile
numar_posibil = 0

for x in range(n + 1):
if x & n == x:
# Verificare dacă x & n == x, adică x reprezintă un submulțime a lui n în reprezentarea binară
numar_posibil += 1

print("Numarul de numere posibile este:", numar_posibil)

if __name__ == '__main__':
n = input("Introduceti numarul n: ") # Citirea numărului de la tastatură
if validare(n): # Verificare validitate numărului utilizând funcția validare()
n = int(n) # Convertirea valorii numărului la tipul int
print("Datele introduse corespund restricțiilor impuse.")
counterase(n) # Apelarea funcției counterase() pentru calcularea numărului de numere posibile
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2335 - Bi Binar

2023-04-25T08:51:43Z

Carla Chereji:

==Cerință==
Se dau '''n''' numere naturale. Fiecare număr dat se transformă în baza 2 şi se formează toate numerele de două cifre din scrierea acestuia binară, scriind cele două cifre în ordinea în care apar în scrierea binară. Toate aceste numere de două cifre binare se trec în baza 10 şi se face suma numerelor obţinute. Să se afle, pentru fiecare dintre cele '''n''' numere naturale date, această sumă.
==Date de intrare==
Fișierul de intrare bibinar.in conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse.".
Fișierul de ieșire bibinar.out va conține pe prima linie cele '''n''' sume obţinute, separate prin spaţiu. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*1 &les; '''n''' &les; 10000

*numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât 1.000.000.000 şi mai mari decât 1
==Exemplu==
===Exemplul 1===
;bibinar.in

:2

:5 85

;bibinar.out
:3 9

;Ieșire

:Datele introduse corespund restricțiilor impuse.

==Rezolvare==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
# Funcție pentru validarea numerelor de intrare
# Returnează True dacă numărul este valid, False în caz contrar
return n.isdigit() and 1 <= int(n) <= 10000

def bibinar():
# Funcție pentru procesarea fișierului "bibinar.in" și generarea rezultatului în fișierul "bibinar.out"
with open("bibinar.in") as f:
n = f.readline().strip() # Citirea primului rând din fișier, reprezentând numărul de numere care urmează să fie procesate
numbers = list(map(int, f.readline().split())) # Citirea al doilea rând din fișier, reprezentând lista de numere

if validare(n): # Verificare validitate numărului de numere de procesat utilizând funcția validare()
n = int(n) # Convertirea valorii numărului la tipul int
x = True
for i in numbers:
if str(i).isdigit():
x = True
else:
x = False # Verificare dacă toate numerele din lista de numere sunt valide (reprezentate doar de cifre)
results = []
for num in numbers:
binary = bin(num)[2:] # Convertirea fiecărui număr la reprezentarea binară și eliminarea prefixului '0b'
pairs = [binary[i:i + 2] for i in range(len(binary) - 1)] # Impărțirea reprezentării binare în perechi de câte 2 cifre
decimal = sum([int(pair, 2) for pair in pairs]) # Convertirea perechilor de cifre din baza 2 la baza 10 și calculul sumei lor
results.append(decimal) # Adăugarea rezultatului la lista de rezultate

with open("bibinar.out", "w") as f:
f.write(" ".join(map(str, results))) # Scrierea rezultatelor în fișierul "bibinar.out", separate prin spațiu

if __name__ == '__main__':
x = None # Inițializarea variabilei x cu None
bibinar() # Apelarea funcției bibinar() pentru procesarea fișierului și generarea rezultatului
if x: # Verificare valoare x (care nu este modificată în cod)
print("Datele introduse corespund restricțiilor impuse.")
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2872 - Easy Pow

2023-04-25T08:51:03Z

Carla Chereji:

== Cerință ==
Se dă numărul natural n. Calculați <math>2^n</math> , apoi afișați rezultatul în baza 2.
== Date de intrare ==
Programul citește de la tastatură numărul '''n'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul va afișa pe ecran numărul <math>2^n</math>, conform cerinței. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizăr ==
*0 &les; n &les; 10000
== Exemplul 1==
; Intrare
: 1
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 10

==Rezolvare==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
def validare_date(n):
# Funcție pentru validarea numerelor de intrare
# Returnează True dacă numărul este valid, False în caz contrar
return n.isdigit() and 0 <= int(n) <= 10000

def calcul(n):
# Funcție pentru calcularea valorii 2 la puterea n în baza 2 și afișarea rezultatului
rezultat = bin(2 ** n)[2:] # Convertirea rezultatului 2 la puterea n în baza 2 și eliminarea prefixului '0b'
print("2 la puterea", n, "este", rezultat, "în baza 2.")

if __name__ == '__main__':
n = input("Introduceți numărul: ") # Solicitare număr de la utilizator

if validare_date(n): # Verificare validitate număr utilizând funcția validare_date()
n = int(n) # Convertirea valorii numărului la tipul int
print("Datele de intrare corespund restricțiilor impuse.")
calcul(n) # Apelarea funcției calcul() pentru a calcula și afișa rezultatul
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

0426 - Baza B

2023-04-25T08:50:08Z

Carla Chereji:

==Cerință==
Se dă un număr natural '''numar''' și o bază de numerație '''baza'''. Să se determine cea mai mare cifră a reprezentării lui '''numar''' în baza '''baza'''.
==Date de intrare==
Programul citește de la tastatură două numere naturale '''numar, baza''' .
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran valoarea cerută. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*1 &les; '''numar''' &les; 1.000.000.000

*2 &les; '''baza''' &les; 10

==Exemplu==
;Intrare

:878

:6

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:4

==Rezolvare==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
def validare_date(numar, baza):
# Funcție pentru validarea numerelor de intrare
# Returnează True dacă numerele sunt valide, False în caz contrar
return numar.isdigit() and 1 <= int(numar) <= 10000 and baza.isdigit() and 1 <= int(baza) <= 10

def max_cifra(numar, baza):
# Funcție pentru calcularea și afișarea celei mai mari cifre într-un număr într-o anumită bază
max_cifra = 0 # Variabila pentru stocarea celei mai mari cifre, inițializată cu 0

while numar > 0: # Parcurgerea cifrelor numărului până când acesta devine 0
cifra = numar % baza # Obținerea ultimei cifre a numărului în baza specificată
if cifra > max_cifra: # Compararea cifrei curente cu cea mai mare cifră găsită până acum
max_cifra = cifra # Dacă cifra curentă este mai mare, o înlocuim pe cea mai mare cifră
numar //= baza # Eliminarea ultimei cifre din număr, trecând la următoarea cifră în bază

print(max_cifra) # Afișarea celei mai mari cifre găsite

if __name__ == '__main__':
numar = input("Introduceți numărul n: ") # Solicitare număr de la utilizator
baza = input("Introduceți baza de numerație b: ") # Solicitare bază de numerație de la utilizator

if validare_date(numar, baza): # Verificare validitate număr și bază utilizând funcția validare_date()
numar, baza = int(numar), int(baza) # Convertirea valorilor număr și bază la tipul int
print("Datele de intrare corespund restricțiilor impuse.")
max_cifra(numar, baza) # Apelarea funcției max_cifra() pentru a calcula și afișa cea mai mare cifră
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

0982 - Puteri1

2023-04-25T08:49:11Z

Carla Chereji:

==Cerință==
Se dau '''n''' numere naturale. Aflați câte dintre acestea se pot scrie ca sumă de puteri distincte ale unui număr natural '''k'''.
==Date de intrare==
Programul citește de la tastatură numerele '''k și n''', iar apoi '''n''' numere naturale, separate prin spații.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul va afișa pe ecran numărul de numere din șirul dat care se pot scrie ca sumă de puteri distincte ale lui '''k'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*1 &les; '''n''' &les; 10000

*2 &les; '''k''' &les; 10

*cele n numere citite vor fi mai mici decât 1.000.000
==Exemplu==
===Exemplul 1===
;Intrare

:5

:3

:6
:37
:12
:9
:5

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:3

==Rezolvare==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, k):
# Funcție pentru validarea valorilor n și k
# Returnează True dacă valorile sunt valide, False în caz contrar
return 1 <= int(n) <= 100_000 and 2 <= int(k) <= 10

def numar_puteri_distincte(n, k):
# Funcție pentru calcularea numărului de puteri distincte
nr = 0
for i in range(1, n + 1):
x = int(input("numbers:")) # Solicitare valoare de la utilizator pentru fiecare iterație
c = 1
while x != 0:
if x % k > 1: # Verificare dacă restul împărțirii lui x la k este mai mare decât 1
c = 0 # Dacă da, setează c la 0 și iesi din while
break
x //= k # Împărțirea lui x la k și reținerea partea întreagă
if c:
nr += 1 # Dacă c este nenul, incrementarea numărului de puteri distincte
return nr

if __name__ == "__main__":
n = input("n: ") # Solicitare valoare pentru n
k = input("k: ") # Solicitare valoare pentru k
if validare(n, k): # Verificare validitate valori n și k utilizând funcția validare()
n, k = int(n), int(k) # Convertirea valorilor n și k la tipul int
x = numar_puteri_distincte(n, k) # Apelarea funcției numar_puteri_distincte() pentru a calcula numărul de puteri distincte
print("Datele introduse corespund restricțiilor impuse.")
print(x) # Afișare rezultat
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0946 - Doua Baze

2023-04-25T08:47:43Z

Carla Chereji:

== Cerință ==
Se dă un număr '''n''' scris în baza 2. Să se afișeze valoarea acestuia în baza 4.
== Date de intrare ==
Programul citește de la tastatură scrierea în baza 2 a numărului '''n'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul va afișa pe ecran scrierea în baza 4 a numărului '''n'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==
*'''n''' are cel mult 100 de cifre în baza 2;
==Exemplu==
=== Exemplul 1===
; Intrare
: 100011
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 203
=== Exemplul 2 ===
; Intrare
: 11010110
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 3112
==Rezolvare==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
# Funcție care validează dacă numărul introdus este un număr binar valid
return n.isdigit() and 0 <= len(n) <= 100

def douabaze(n):
# Funcție care convertește un număr din baza 2 în baza 4
# Verificăm dacă lungimea numărului n este impară și, dacă da, adăugăm un 0 la început pentru a obține o lungime pară
while len(n) % 2 != 0:
n = '0' + n
# Tabela de conversie din baza 2 în baza 4
conversion_table = {'00': '0', '01': '1', '10': '2', '11': '3'}
# Rezultatul final în baza 4
result = ''
# Parcurgem numărul n în grupuri de câte 2 caractere și le convertim folosind tabela de conversie
for i in range(0, len(n), 2):
result += conversion_table[n[i:i + 2]]
return result

if __name__ == '__main__':
n = input("Introduceți un număr în baza 2: ")
if validare(n):
print("Datele introduse corespund restricțiilor impuse.")
# Apelăm funcția douabaze pentru a realiza conversia
print("Numărul în baza 4 este:", douabaze(n))
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0945 - Baze

2023-04-25T08:44:26Z

Carla Chereji:

==Cerință==
Se dă un număr '''n''' scris în baza '''b'''. Să se afișeze scrierea acestuia în baza '''c.'''
==Date de intrare==
Programul citește de la tastatură numerele '''n, b și c''' 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." și programul va afișa pe ecran scrierea numărului '''n''' în baza '''c'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*2 &les; '''b, c''' &les; 10

*numărul n este natural si are cel mult nouă cifre

*rezolvarea acestei probleme necesită utilizarea tablourilor sau a altor forme de memorare a unui număr variabil de valori.
==Exemplul 1==
;Intrare

:2013

:4

:7

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:252

== Rezolvare ==
=== Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, b, c):
# Verifică dacă n conține doar cifre valide pentru baza b și dacă n este între 0 și 999999999 în baza 10
# Verifică de asemenea dacă b și c sunt între 2 și 10
return all(digit.isdigit() and int(digit) < int(b) for digit in n) and 0 <= int(n, int(b)) <= 999999999 and 2 <= int(b) <= 10 and 2 <= int(c) <= 10

def baze(n, b, c):
n_baza_10 = int(n, b) # Converteste numarul n din baza b in baza 10
n_baza_c = format(n_baza_10, '0' + str(len(n)) + 'd') # Converteste numarul din baza 10 in baza c si completeaza cu zerouri la stanga daca este necesar
base_c_digits = "0123456789abcdefghijklmnopqrstuvwxyz"[:c] # Defineste caracterele valide pentru baza c
base_c_num = ""
remainder = n_baza_10
while remainder > 0:
digit = base_c_digits[remainder % c] # Obtine ultima cifra in baza c
base_c_num = digit + base_c_num # Adauga cifra la stanga numarului in baza c
remainder //= c # Actualizeaza catul pentru urmatoarea iteratie
print("Numărul {} în baza {} este {}".format(n, c, int(base_c_num))) # Afiseaza rezultatul final

if __name__ == '__main__':
n = input("Introdu numărul n: ")
b = input("Introdu baza b: ")
c = input("Introdu baza c: ")

if validare(n, b, c):
b, c = int(b), int(c)
print("Datele introduse corespund restricțiilor impuse.")
baze(n, b, c) # Apeleaza functia pentru a afisa rezultatul final
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

3349 - Putere1

2023-04-25T08:41:38Z

Carla Chereji:

== Cerință ==
Se dau numerele naturale '''b n p'''. Determinați numărul format din ultimele '''p''' cifre ale lui <math>b^n</math>.
== Date de intrare ==
Programul citește de la tastatură numerele '''b n p'''.
== Date de ieșire ==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul va afișa pe ecran numărul format din ultimele p cifre ale lui <math>b^n</math>. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==
*1 &les; '''b''' &les; 1000000000
*1 &les; '''n''' &les; 2^31
*1 &les; '''p''' &les; 9
==Exemplu==
=== Exemplul 1===
; Intrare
: 2
: 10
: 2
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 24
=== Exemplul 2 ===
; Intrare
: 123456789
: 5
: 3
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 949
==Rezolvare==
=== Rezolvare vers. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
def validare(b, n, p):
# Verifică dacă b, n și p sunt formate doar din cifre și dacă respectă restricțiile impuse
return b.isdigit() and 1 <= int(b) <= 1000000000 and n.isdigit() and 1 <= int(n) <= 2 ** 31 and p.isdigit() and 1 <= int(p) <= 9

def putere(b, n, p):
result = str(b ** n)[-p:] # Calculează rezultatul final ca ultimele p cifre din rezultatul b la puterea n
print(int(result))

if __name__ == '__main__':
b = input("Introduceti numarul b: ")
n = input("Introduceti puterea n: ")
p = input("Introduceti numarul de cifre dorit: ")
if validare(b, n, p):
b, n, p = int(b), int(n), int(p)
print("Datele introduse corespund restricțiilor impuse.")
putere(b, n, p) # Afișează rezultatul final
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

3348 - Suma Puteri 2

2023-04-25T08:40:43Z

Carla Chereji:

==Cerință==
Se dă un număr natural '''n'''. Descompuneți numărul '''n''' ca sumă de puteri ale lui 2.
==Date de intrare==
Programul citește de la tastatură numărul '''n'''.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul va afișa pe ecran, în ordine crescătoare, separate prin câte un spațiu, puterile lui 2 care au suma '''n'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*1 &les; '''n''' &les; 2^31
==Exemplul 1==
;Intrare

:43

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:1

:2

:8

:32

==Rezolvare==
=== Rezolvare ver. 1===
<syntaxhighlight lang="python" line="1">
def validare(n):
# Verifică dacă n este format doar din cifre și dacă este între 1 și 2^31 - 1
return n.isdigit() and 1 <= int(n) < pow(2, 31)

def descompunere_in_puteri_de_2(n):
puteri_de_2 = [] # Lista pentru a stoca puterile de 2
k = 0 # Contorul puterilor de 2
while 2 ** k <= n: # Găsește cel mai mare exponent k pentru care 2^k este mai mic sau egal cu n
k += 1
k -= 1 # Scade 1 din k pentru a obține cel mai mare exponent valid
while k >= 0: # Descompune n în sumă de puteri de 2
if 2 ** k <= n:
puteri_de_2.append(2 ** k) # Adaugă puterea de 2 la lista puteri_de_2
n -= 2 ** k # Scade puterea de 2 din n pentru a obține restul
k -= 1 # Scade 1 din k pentru a trece la următorul exponent mai mic
return puteri_de_2[::-1] # Returnează lista puterilor de 2 în ordine descrescătoare

if __name__ == '__main__':
n = input("Introduceți numărul n: ")
if validare(n):
n = int(n)
print("Datele introduse corespund restricțiilor impuse.")
puteri_de_2 = descompunere_in_puteri_de_2(n)
print("{}".format("\n".join(
str(p) for p in puteri_de_2))) # Afișează puterile de 2 separate pe linii
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

0661 - Triunghiuri1

2023-04-25T08:39:20Z

Carla Chereji:

==Cerință==
Se dau '''n''' numere naturale distincte. Determinaţi câte triunghiuri distincte pot avea lungimile laturilor printre aceste numere.
==Date de intrare==
Programul citește de la tastatură numărul '''n''', iar apoi cele '''n''' numere naturale.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul va afișa pe ecran numărul C, reprezentând numărul de triunghiuri determinate. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*1 &les; '''n''' &les; 1000

*cele '''n''' numere citite vor fi mai mici decât 1.000.000
==Exemplu==
===Exemplul 1===
;Intrare

:5

:3 5 10 7 6

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:7

==Rezolvare==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
return n.isdigit() and 1 <= int(n) <= 1000 # Verificăm dacă input-ul este un număr valid între 1 și 1000.

def triunghiuri1(n, lat):
lat.sort() # Sortăm lista de lungimi de laturi în ordine crescătoare.
cnt = 0 # Inițializăm contorul la 0.
for i in range(n - 2): # Parcurgem lista până la penultimul element.
for j in range(i + 1, n - 1): # Parcurgem sublista începând de la al doilea element până la penultimul.
a = lat[i] # Alegem prima latură a triunghiului ca fiind elementul de pe poziția i în lista sortată.
b = lat[j] # Alegem a doua latură a triunghiului ca fiind elementul de pe poziția j în lista sortată.
dr = n - 1 # Setăm indicele dreptului pe ultimul element din listă.
st = j + 1 # Setăm indicele stângului pe poziția imediat următoare după j.
while dr >= st: # Cat timp dreapta nu a depășit stânga în parcurgerea listei.
mij = (dr + st) // 2 # Calculăm mijlocul listei.
if lat[mij] < a + b: # Dacă suma celor trei laturi formează un triunghi valid.
st = mij + 1 # Avansăm în dreapta pentru a căuta valori mai mari care să formeze triunghiuri.
else:
dr = mij - 1 # Altfel, avansăm în stânga pentru a căuta valori mai mici care să formeze triunghiuri.
cnt += dr - j # Adăugăm la contor diferența între dreapta și j, care reprezintă numărul de triunghiuri posibile.

print(cnt) # Afișăm rezultatul.

if __name__ == '__main__':
x = None # Inițializăm x la None.
n = input() # Citim valoarea lui n de la tastatură.
lat = list(map(int, input().split())) # Citim lista de lungimi de laturi de triunghi și o convertim la tipul int.
if validare(n): # Verificăm dacă valoarea introdusă corespunde restricțiilor impuse.
for i in range(int(n)): # Parcurgem valorile de la 0 la n-1.
if str(i).isdigit() and i < 1_000_000: # Verificăm dacă i este un număr valid și nu depășește 1_000_000.
x = True # Dacă da, x devine True.
else:
x = False # Altfel, x devine False.
if x is True
print("Datele introduse corespund restricțiilor impuse.")
n = int(n) # Convertim n la tipul int pentru a-l folosi în funcția triunghiuri1.
triunghiuri1(n, lat) # Apelăm funcția triunghiuri1 pentru a calcula numărul de triunghiuri posibile.
else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2589 - Set Last 2

2023-04-25T08:35:59Z

Carla Chereji:

== Cerință ==
Se citește un număr n într-o variabilă de tip întreg pe 16 biți cu semn. Setați la valoarea 1 cei mai puțin semnificativi doi biți ai săi apoi afișați valoarea variabilei.
== Date de intrare ==
Programul citește de la tastatură numărul n.
== 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 valoarea cerută. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==
*-32768 &les; n &les; 32768
== Exemplul 1==
; Intrare
: 5
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 7
== Exemplul 2 ==
; Intrare
: 100
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 103
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
return n.isdigit() and 1 <= int(n) <= 32767 # Verificăm dacă input-ul este un număr valid între 1 și 32767.

def setlast(n):
# Setăm cei mai puțin semnificativi 2 biți la 1 folosind operatorul de bit OR.
n = n | 3
print("Valoarea după setarea celor mai puțin semnificativi 2 biți la 1: ", n) # Afișăm rezultatul.

if __name__ == "__main__":
n = input("Introduceți un număr pe 16 biți cu semn: ") # Citim valoarea numărului de la tastatură.
if validare(n): # Verificăm dacă valoarea introdusă corespunde restricțiilor impuse.
n = int(n) # Convertim valoarea într-un număr întreg.

print("Datele introduse corespund restricțiilor impuse.")
setlast(n) # Apelăm funcția setlast cu valoarea numărului.

else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2799 - Add One

2023-04-25T08:32:02Z

Carla Chereji:

==Cerință==
Se citește un număr '''n'''. Să se calculeze '''n+1''', folosind doar operatori pe biți.
==Date de intrare==
Programul citește de la tastatură numărul '''n'''.
==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 '''p''', reprezentând valoarea lui '''n+1'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*1 &les; '''n''' &les; 10000
==Exemplul 1==
;Intrare

:5

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:6
==Exemplul 2==
;Intrare

:2

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:3

== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
return n.isdigit() and 1 <= int(n) <= 10000 # Verificăm dacă input-ul este un număr valid între 1 și 10000.

def add(n):
p = (n ^ 1) | 1 # Calculăm valoarea lui n+1 folosind doar operatori pe biți.
print("Valoarea lui n+1 =", p) # Afișăm rezultatul.

if __name__ == "__main__":
n = input("Introduceți valoarea lui n: ") # Citim valoarea lui n de la tastatură.
if validare(n): # Verificăm dacă valoarea introdusă corespunde restricțiilor impuse.
n = int(n) # Convertim valoarea lui n într-un număr întreg.

print("Datele introduse corespund restricțiilor impuse.")
add(n) # Apelăm funcția add cu valoarea lui n.

else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2735 - Insert Biti

2023-04-25T08:17:08Z

Carla Chereji:

== Cerință ==
Se citesc trei numere naturale '''n m i'''. Să se schimbe valorile biților lui '''n''' de la poziția '''i''' spre stânga, cu valorile biților lui '''m''' de la 0 până la cel mai semnificativ bit de 1 din '''m''' și apoi să se afișeze '''n'''.Numerotare biților se face de la dreapta spre stânga începând de la 0.
== Date de intrare ==
Programul citește de la tastatură numerele '''n, m și i''', 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." Programul citește de la tastatură numerele '''n, m și i''', separate prin spații. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==

* numerele '''n, m''' sunt se reprezintă pe 64 de biți, fără semn.

* pozițiile biților sunt indexate de la 0.

== Exemplul 1==
; Intrare
: 5
: 6
: 2
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 13

== Exemplul 2 ==
; Intrare
: 10101
: 111
: 3
; Ieșire
: Datele introduse corespund restricțiilor impuse.
: 53

== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, m, i):
return n.isdigit() and m.isdigit() and i.isdigit() and 1 <= int(n), int(m), int(i) <= pow(2, 63)

def lg_bit(n):
return n.bit_length()

def insertbiti(n, m, i):
# Gasim poziția celui mai semnificativ bit de 1 din m
poziția = lg_bit(m) - 1

# Creăm o mască pentru a șterge biții lui n
mask = (1 << i) - 1

# Ștergem biții lui n de la poziția i în stânga
n &= mask

# Copiem biții lui m în n
n |= (m >> (poziția + 1 - i)) << i

# Returnăm n-ul rezultat
return n

if __name__ == "__main__":
n = input("Introduceti n: ")
m = input("Introduceti m: ")
i = input("Introduceti i: ")

if validare(n, m, i):
n = int(n)
m = int(m)
i = int(i)

print("Datele introduse corespund restricțiilor impuse.")
rezultat = insertbiti(n, m, i)
print("Rezultatul este:", rezultat)

else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2624 - Inv Bits

2023-04-25T08:15:43Z

Carla Chereji:

==Cerință==
Dat fiind un număr natural '''n''', să se determine numărul natural '''m''' care are are proprietatea că are în reprezentarea în baza 2 biți de 1 pe pozițiile unde n are biți de 0 și are biți de 0 pe pozițiile unde n are biți de 1. De exemplu, dacă n = 346, atunci m = 165, deoarece n se reprezintă în baza 2 prin 101011010, iar m prin 010100101.
==Date de intrare==
Programul citește de la tastatură numărul '''n'''.
==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 '''m'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*0 &les; '''n''' &les; 10000
==Exemplul 1==
;Intrare

:346

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:165
==Exemplul 2==
;Intrare

:255

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:0

== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def validare(n):
"""Funcție pentru validarea unui număr n."""
return n.isdigit() and 0 <= int(n) <= 10000

def transform(n):
"""Funcție pentru transformarea unui număr n în forma sa complementară în baza 2."""
binary_n = bin(n)[2:] # convertim numarul n in reprezentarea sa in baza 2 (binara)
binary_list = list(binary_n) # transformam sirul binar intr-o lista de caractere

inverted_list = ["1" if x == "0" else "0" for x in binary_list] # initializam un nou sir de caractere cu caracterele opuse
inverted_binary_n = "".join(inverted_list) # convertim noul sir de caractere intr-un numar intreg
m = int(inverted_binary_n, 2)

print("Numarul m este:", m) # afisam numarul calculat

if __name__ == "__main__":
n = input("Introduceți numărul n: ") # citim n de la tastatură

if validare(n):
n = int(n)

print("Datele introduse corespund restricțiilor impuse.")
transform(n)

else:
print("Datele introduse nu corespund restricțiilor impuse.")
</syntaxhighlight>

2708 - Verif Paritate

2023-04-25T08:13:23Z

Carla Chereji:

==Cerință==
Se citesc '''n''' numere naturale. Determinați pentru fiecare dintre ele dacă este par sau impar.
==Date de intrare==
Programul citește de la tastatură numărul '''n''', iar apoi '''n numere naturale'''.
==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 '''n''' valori '''0''' sau '''1''', separate prin spații. Dacă numărul corespunzător este par se va afișa '''0''', iar dacă este impar se va afișa '''1'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*1 &les; '''n''' &les; 1000

*se recomandă utilizarea operațiilor pe biți

*cele n numere citite se pot reprezenta pe 64 de biți, fără semn;
==Exemplul 1==
;Intrare

:3

:1 2 3

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:1 0 1
==Exemplul 2==
;Intrare

:4

:4 10 7 0

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:0 0 1 0

== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def este_par_sau_impar(numar):
#funcție care determină dacă un număr este par sau impar
if numar % 2 == 0:
return 0 # Returnează 0 pentru numere pare
else:
return 1 # Returnează 1 pentru numere impare

def main():
try:
n = int(input("Introduceți numărul de numere naturale: ")) # Citirea numărului de numere de la tastatură
if n <= 0:
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
numere = []
for i in range(n):
numar = int(input(f"Introduceți numărul {i+1}: ")) # Citirea fiecărui număr din lista de numere
numere.append(numar) # Adăugarea numărului citit în lista de numere

# Verificăm dacă fiecare număr din listă este par sau impar și afișăm rezultatul corespunzător
for numar in numere:
print(este_par_sau_impar(numar), end=" ") # Afișarea rezultatului returnat de funcția este_par_sau_impar
except ValueError:
print("Datele de intrare nu corespund restricțiilor impuse.") # Gestionarea excepției în cazul în care datele introduse nu sunt numere

if __name__ == '__main__':
main()

else:
print("Datele introduse nu corespund restricțiilor impuse.")

</syntaxhighlight>

2999 - Trim

2023-04-25T07:17:44Z

Carla Chereji: Am modificat codul.

==Cerință==
Scrieți un program care citește de la tastatură trei numere naturale '''n''', '''k''' și '''r''' și afișează:

* câte submulțimi sunt formate dintr-un număr de elemente pare (cardinalul submulțimilor este un număr par)

* media aritmetică a elementelor din submulțimile cu număr de ordine '''k''' și '''r''' (0 < k ≤ r ≤ 100)

* elementele submulțimii r sub forma: primul, al doilea, ultimul, al treilea, al patrulea, penultimul, etc.

==Date de intrare==
Programul va citi de la tastatură '''n''', '''k''' și '''r''' numere naturale.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Se afișează fiecare pe câte o linie:

* numărul de submulțimi cu număr de elemente pare

* media aritmetică a numerelor din submulțimile '''k și r'''

* elementele submulțimii r sub forma: primul, al doilea, ultimul, al treilea, al patrulea, penultimul, etc.

În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții de precizări==
*1 &les; '''k''' &les; '''r''' &les; '''n''' 100
==Exemplul 1==
;Intrare

:10

:3

:7

;Ieșire

:Datele introduse corespund restricțiilor impuse.

:1024

:5

:3 5 7 9

== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
def numar_submultimi_pare(n):
# Calculează numărul de submulțimi cu cardinalitatea pară
return 2 ** n

def medie_submultimi(submultimi, k, r):
# Calculează media aritmetică a elementelor din submulțimile k și r
# Dacă k și r sunt în afara intervalului corect, returnează None
if k < 1 or r > len(submultimi) or k > r:
return None
else:
submultimi_k_r = submultimi[k-1:r:2] # obține submulțimile de la k la r, cu pași de 2
medie = sum(submultimi_k_r) / len(submultimi_k_r)
return medie

def submultime_specifica(submultimi, r):
# Obține elementele submulțimii r sub forma specificată
if r > len(submultimi):
return None
else:
submultime_r = submultimi[r-1::2] # obține elementele submulțimii r, cu pași de 2
return submultime_r

if __name__ == "__main__":
# Citirea datelor de intrare de la tastatură
n = int(input("Introduceți numărul total de elemente: "))
k = int(input("Introduceți numărul de ordine k: "))
r = int(input("Introduceți numărul de ordine r: "))

# Verificare restricții
if not (0 < k <= r <= 100):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
# Obținere număr de submulțimi cu cardinalitatea pară
numar_submultimi_pare = numar_submultimi_pare(n)
print("Numărul de submulțimi cu cardinalitatea pară:", numar_submultimi_pare)

# Generare submulțimi
submultimi = list(range(1, n+1))

# Obținere medie aritmetică
medie = medie_submultimi(submultimi, k, r)
if medie is not None:
print("Media aritmetică a numerelor din submulțimile k și r:", medie)
else:
print("Nu se poate calcula media aritmetică pentru valorile introduse.")

# Obținere submulțime specifică
submultime_specifica = submultime_specifica(submultimi, r)
if submultime_specifica is not None:
print("Elementele submulțimii r sub forma specificată:", submultime_specifica)
else:
print("Nu se poate obține submulțimea specificată pentru valorile introduse.")

</syntaxhighlight>

4277 - Upper Lower

2023-04-25T06:49:07Z

Carla Chereji: Am pus comentarii.

== Cerință ==
Scrieți funcția cu următorul antet: UpperLower(a, U, L)

Funcția primește ca parametri trei șiruri de caractere '''a, U și L'''. Șirul '''U''' trebuie să memoreze caracterele din '''a''', dar în care literele mici au fost convertite la majuscule, iar șirul '''L''' trebuie să memoreze caracterele din '''a''', dar în care literele mari au fost convertite la litere mici.

==Date de intrare==
Se citește de la tastatură un șir de caractere.

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Șirul '''U''' memorează caracterele din '''a''', dar în care literele mici au fost convertite la majuscule, iar șirul '''L''' memorează caracterele din '''a''', dar în care literele mari au fost convertite la litere mici.
Va fi afișat '''U''' și '''L'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

== Restricții de precizări ==

*Șirul a poate conține și alte caractere în afară de litere, dar acestea rămân nemodificate.
*Indexarea șirurilor începe de la 0

==Exemplu==
=== Exemplul 1===
; Intrare
: I Am a Sith Lord
; Ieșire
: I AM A SITH LORD
: i am a sith lord

==Rezolvare==
=== Rezolvare var. 1 ===
<syntaxhighlight lang="python" line="1" start="1">
def UpperLower(a, U, L):
# Această funcție primește un string 'a' ca intrare și două stringuri goale 'U' și 'L' pentru a stoca caracterele majuscule și minuscule
for c in a:
if c.islower():
# Dacă caracterul este literă mică, adaugă varianta sa majusculă în 'U' și caracterul original în 'L'
U += c.upper()
L += c
elif c.isupper():
# Dacă caracterul este literă mare, adaugă caracterul în 'U' și varianta sa minuscule în 'L'
U += c
L += c.lower()
else:
# Dacă caracterul nu este nici literă mare, nici literă mică (de exemplu, cifre, semne de punctuație etc.), adaugă-l atât în 'U', cât și în 'L'
U += c
L += c
# Returnează stringurile rezultate pentru literele majuscule și minuscule
return U, L

if __name__ == "__main__":
# Obține input de la utilizator și elimină spațiile albe de la început și sfârșit
a = input().strip()
U = ""
L = ""
# Apelează funcția UpperLower cu stringul de intrare 'a' și cu stringurile goale 'U' și 'L'
U, L = UpperLower(a, U, L)
# Afișează stringurile rezultate pentru literele majuscule și minuscule
print("U:", U)
print("L:", L)

</syntaxhighlight>