Bitnami MediaWiki - User contributions [en]

28450

2023-10-30T14:50:58Z

Adina Timiș:

'''28450 (Nicolae Mușuroia)'''

''Fie <math>n \in </math> ℕ, <math>n \geq 4</math> și <math>p \in \{1, 2,..., [n/2]\}.</math> Considerăm mulțimile disjuncte <math>A = \{ a_{1}, a_{2},..., a_{n} \}</math> și <math>B = \{ b_{1}, b_{2},..., b_{n} \}</math>, formate din primii <math>n</math> termeni a două progresii aritmetice <math>(a_{k})_{k\geq1}</math> și <math>(b_{k})_{k\geq1}</math> cu rații opuse, nenule. Arătați că printre orice <math>n + p + 1</math> elemente distincte ale mulțimii <math>A \cup B</math> există două a căror sumă este egală cu <math>a_{2p} + b_p.</math>''

'''Soluție:'''

Fie <math>r \in </math> <math>{\displaystyle \mathbb {R^*} }</math> rația primei progresii. Observăm că <math>a_{2p} + b_p = a_1 + b_1 + p \cdot r = a_{p+1} + b_1 = a_{p+2} + b_2 = ... = a_{n} + b_{n-p}. </math> (1) Presupunem că putem alege <math>n + p + 1 </math>, elemente distincte ale lui <math>A \cup B</math>, astfel încât suma a oricăror două dintre acestea să fie diferită de <math>a_{2p} + b_p.</math> Din (1) deducem că printre aceste <math>n + p + 1</math> elemente trebuie să se afle cel mult câte un element din fiecare dintre mulțimile <math> \{ a_{p+1}, b_{1} \}, \{ a_{p+2}, b_{2} \},..., \{ a_{n}, b_{n-p} \}</math>. Cum <math>2n - (n - p) = n + p < n + p + 1</math>, rezultă că printre cele <math>n + p + 1</math> numere alese se află cel puțin două care aparțin aceleiași dintre mulțimile precedente, contradicție.

E:16407

2023-10-30T14:48:26Z

Adina Timiș:

'''16407 (Cristina Vijdeluc, Salonic și Mihai Vijdeluc)'''

''Aflați cifrele nenule <math>a </math> și <math>b</math> pentru care <math>a + 10 \cdot (a + b)^{3} = \overline{baba}.</math>''

'''Soluție:'''

Egalitatea din enunț se scrie <math>a + 10 \cdot (a + b)^{3} = \overline{bab0} + a,</math> de unde <math>10 \cdot (a + b)^{3} = \overline{bab0} </math> și apoi <math>(a + b)^{3} = \overline{bab}.</math> Căutând prin încercări cuburi perfecte de 3 cifre, găsim <math>7^{3} = 343</math>. Astfel, <math>a = 4</math> și <math>b = 3</math>, de unde <math> \overline{ab} = 43.</math>

28450

2023-10-27T11:46:53Z

Adina Timiș:

'''28450 (Nicolae Mușuroia)'''

Fie <math>n \in </math> ℕ, <math>n \geq 4</math> și <math>p \in \{1, 2,..., [n/2]\}.</math> Considerăm mulțimile disjuncte <math>A = \{ a_{1}, a_{2},..., a_{n} \}</math> și <math>B = \{ b_{1}, b_{2},..., b_{n} \}</math>, formate din primii <math>n</math> termeni a două progresii aritmetice <math>(a_{k})_{k\geq1}</math> și <math>(b_{k})_{k\geq1}</math> cu rații opuse, nenule. Arătați că printre orice <math>n + p + 1</math> elemente distincte ale mulțimii <math>A \cup B</math> există două a căror sumă este egală cu <math>a_{2p} + b_p.</math>

'''Soluție:'''

Fie <math>r \in </math> <math>{\displaystyle \mathbb {R^*} }</math> rația primei progresii. Observăm că <math>a_{2p} + b_p = a_1 + b_1 + p \cdot r = a_{p+1} + b_1 = a_{p+2} + b_2 = ... = a_{n} + b_{n-p}. </math> (1) Presupunem că putem alege <math>n + p + 1 </math>, elemente distincte ale lui <math>A \cup B</math>, astfel încât suma a oricăror două dintre acestea să fie diferită de <math>a_{2p} + b_p.</math> Din (1) deducem că printre aceste <math>n + p + 1</math> elemente trebuie să se afle cel mult câte un element din fiecare dintre mulțimile <math> \{ a_{p+1}, b_{1} \}, \{ a_{p+2}, b_{2} \},..., \{ a_{n}, b_{n-p} \}</math>. Cum <math>2n - (n - p) = n + p < n + p + 1</math>, rezultă că printre cele <math>n + p + 1</math> numere alese se află cel puțin două care aparțin aceleiași dintre mulțimile precedente, contradicție.

28450

2023-10-27T11:46:01Z

Adina Timiș: Pagină nouă: '''28450 (Nicolae Mușuroia)''' Fie <math>n \in </math> ℕ, <math>n \geq 4</math> și <math>p \in \{1, 2,..., [n/2]\}.</math> Considerăm mulțimile disjuncte <math>A = \{ a_{1}, a_{2},..., a_{n} \}</math> și <math>B = \{ b_{1}, b_{2},..., b_{n} \}</math>, formate din primii <math>n</math> termeni a două progresii aritmetice <math>(a_{k})_{k\geq1}</math> și <math>(b_{k})_{k\geq1}</math> cu rații opuse, nenule. Arătați că printre orice <math>n + p + 1</math> elemente...

'''28450 (Nicolae Mușuroia)'''

Fie <math>n \in </math> ℕ, <math>n \geq 4</math> și <math>p \in \{1, 2,..., [n/2]\}.</math> Considerăm mulțimile disjuncte <math>A = \{ a_{1}, a_{2},..., a_{n} \}</math> și <math>B = \{ b_{1}, b_{2},..., b_{n} \}</math>, formate din primii <math>n</math> termeni a două progresii aritmetice <math>(a_{k})_{k\geq1}</math> și <math>(b_{k})_{k\geq1}</math> cu rații opuse, nenule. Arătați că printre orice <math>n + p + 1</math> elemente distincte ale mulțimii <math>A \cup B</math> există două a căror sumă este egală cu <math>a_{2p} + b_p.</math>

'''Soluție:'''

Fie <math>r \in </math> <math>{\displaystyle \mathbb {R^*} }</math> rația primei progresii. Observăm că <math>a_{2p} + b_p = a_1 + b_1 + p \cdot r = a_{p+1} + b_1 = a_{p+2} + b_2 = ... = a_{n} + b_{n-p}. </math> (1)

Presupunem că putem alege <math>n + p + 1 </math>, elemente distincte ale lui <math>A \cup B</math>, astfel încât suma a oricăror două dintre acestea să fie diferită de <math>a_{2p} + b_p.</math> Din (1) deducem că printre aceste <math>n + p + 1</math> elemente trebuie să se afle cel mult câte un element din fiecare dintre mulțimile <math> \{ a_{p+1}, b_{1} \}, \{ a_{p+2}, b_{2} \},..., \{ a_{n}, b_{n-p} \}</math>. Cum <math>2n - (n - p) = n + p < n + p + 1</math>, rezultă că printre cele <math>n + p + 1</math> numere alese se află cel puțin două care aparțin aceleiași dintre mulțimile precedente, contradicție.

E:16407

2023-10-27T10:00:42Z

Adina Timiș: Pagină nouă: '''16407 (Cristina Vijdeluc, Salonic și Mihai Vijdeluc)''' Aflați cifrele nenule <math>a </math> și <math>b</math> pentru care <math>a + 10 \cdot (a + b)^{3} = \overline{baba}.</math> '''Soluție:''' Egalitatea din enunț se scrie <math>a + 10 \cdot (a + b)^{3} = \overline{bab0} + a,</math> de unde <math>10 \cdot (a + b)^{3} = \overline{bab0} </math> și apoi <math>(a + b)^{3} = \overline{bab}.</math> Căutând prin încercări cuburi perfecte de 3 cifre, găsim <math>...

'''16407 (Cristina Vijdeluc, Salonic și Mihai Vijdeluc)'''

Aflați cifrele nenule <math>a </math> și <math>b</math> pentru care <math>a + 10 \cdot (a + b)^{3} = \overline{baba}.</math>

'''Soluție:'''

Egalitatea din enunț se scrie <math>a + 10 \cdot (a + b)^{3} = \overline{bab0} + a,</math> de unde <math>10 \cdot (a + b)^{3} = \overline{bab0} </math> și apoi <math>(a + b)^{3} = \overline{bab}.</math> Căutând prin încercări cuburi perfecte de 3 cifre, găsim <math>7^{3} = 343</math>. Astfel, <math>a = 4</math> și <math>b = 3</math>, de unde <math> \overline{ab} = 43.</math>

User:Adina Timiș

2023-10-27T09:58:45Z

Adina Timiș: Ștergerea conținutului paginii

User:Adina Timiș

2023-10-27T09:52:42Z

0886 - Secv Cons

2023-05-21T11:32:44Z

Adina Timiș:

==Cerința==
Se citește un șir format din cel mult 255 caractere, litere mici ale alfabetului englez. Să se determine cea mai lungă secvență din șir formată numai din consoane.
==Date de intrare==
Programul citește de la tastatură un șir de caractere S.
==Date de ieșire==
Programul va afișa pe ecran subșirul determinat.
==Restricții și precizări==
*dacă șirul dat conține mai multe subșiruri formate numai din consoane de lungime maximă se va afișa cea mai din dreapta;
*se garantează că în șirul dat există cel puțin o consoană;
==Exemplul 1==
;Intrare
:ukdiaehldjasmfx
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:smfx
==Exemplul 2==
;Intrare
:aeiou
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0886 - Secv Cons
def gaseste_sir(S):
cel_mai_mare_sir = "" # inițializăm cel mai mare subșir, format numai din consoane cu un șir gol
sirul_initial = "" # inițializăm șirul în care construim subșirul format numai din consoane
vocale = "aeiou" # definim lista de vocale
for c in S[::-1]: # iterăm prin caracterele șirului S, în ordine inversă
if c not in vocale: # dacă litera nu este o vocală
sirul_initial = c + sirul_initial # adăugăm caracterul la începutul șirului
else:
if len(sirul_initial) > len(cel_mai_mare_sir): # dacă lungimea șirului este mai mare decât lungimea, cel mai mare subșir găsit până acum
cel_mai_mare_sir = sirul_initial # actualizăm cel mai mare subșir
sirul_initial = "" # resetăm șirul curent
if len(sirul_initial) > len(cel_mai_mare_sir): # verificăm dacă șirul este cel mai mare subșir găsit
cel_mai_mare_sir = sirul_initial # actualizăm cel mai mare subșir
return cel_mai_mare_sir

if __name__ == "__main__":
S = input("Introduceți șirul de caractere: ")
if all(c.isalpha() and c.islower() for c in S) and len(S) <= 255 and any(c not in "aeiou" for c in S):
# verificarea restricțiilor
cel_mai_mare_sir = gaseste_sir(S) # găsim cel mai mare subșir format numai din consoane
print("Datele de intrare corespund restricțiilor impuse.")
print("Cel mai lung subșir format numai din consoane este:", cel_mai_mare_sir) # afișăm rezultatul
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

2692 - Lung Sort Desc

2023-05-21T11:21:21Z

Adina Timiș:

==Cerința==
Se dă un șir de caractere în care cuvintele sunt formate din litere mici și mari ale alfabetului englez și sunt separate prin spații. Să se afișeze cuvintele pe ecran, fiecare cuvânt pe câte o linie, în ordinea descrescătoare a numărului de litere. Dacă două cuvinte au același număr de litere atunci ele se vor afișa în ordine lexicografică.
==Date de intrare==
Programul citește de la tastatură șirul de caractere.
==Date de ieșire==
Programul va afișa cuvintele din șir pe ecran, conform cerinței.
==Restricții și precizări==
*șirul va conține maximum 255 de caractere;
==Exemplul 1==
;Intrare
:ana are mere
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:mere
:ana
:are
==Exemplul 2==
;Intrare
:1234
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2692- Lung Sort Desc
def sortare_cuvinte(s):
cuvinte = s.split() # separăm șirul în cuvinte
numar_litere = [len(cuvant) for cuvant in cuvinte] # listă cu numărul de litere al fiecărui cuvânt

# sortăm cuvintele în funcție de lungimea acestora (descrescător) și în caz de egalitate, le sortăm în ordine alfabetică
cuvinte_sortate = sorted(cuvinte, key=lambda x: (-len(x), x))

# afișăm cuvintele sortate
for cuvant in cuvinte_sortate:
print(cuvant)

if __name__ == '__main__':
s = input('Introduceți șirul: ')
if len(s) <= 255 and not any(c.isdigit() for c in s): # verificarea restricțiilor
print("Datele de intrare corespund restricțiilor impuse.")
sortare_cuvinte(s) # sortăm și afișăm cuvintele
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3113 - Count Words

2023-05-21T11:17:18Z

Adina Timiș:

==Cerința==
Se dă un șir de caractere care conține litere mici și mari ale alfabetului englez, spații și semne de punctuație. Să se afișeze fiecare cuvânt și frecvența de apariție a lui în șirul de caractere pe câte o linie fiecare pereche cuvânt-frecvență ordonate lexicografic.
==Date de intrare==
Programul citește de la tastatură un șir de caractere.
==Date de ieșire==
Programul va afișa pe ecran pe câte o linie fiecare cuvânt și frecvența lui de apariție în șir.
==Restricții și precizări==
*1 ≤ strlen(sir) ≤ 10000;
==Exemplul 1==
;Intrare
:Ana are mere si prune si pere, insa Ana nu are masina si casa.
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:Ana 2
:are 2
:casa 1
:insa 1
:masina 1
:mere 1
:nu 1
:pere 1
:prune 1
:si 3
==Exemplul 2==
;Intrare
:1234
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#3113 - Count Words
import string

def calculeaza_frecventa_cuvinte(s):
s = s.translate(str.maketrans('', '', string.punctuation)) # eliminăm semnele de punctuație din șirul de caractere
cuvinte = s.split() # separăm șirul în cuvinte
frecventa_cuvinte = {} # dicționar pentru a stoca frecvența cuvintelor

# calculăm frecvența cuvintelor
for cuvant in cuvinte:
if cuvant in frecventa_cuvinte:
frecventa_cuvinte[cuvant] += 1
else:
frecventa_cuvinte[cuvant] = 1

cuvinte_sortate = sorted(frecventa_cuvinte.keys()) # sortăm cuvintele în ordine alfabetică

# afișăm cuvintele și frecvența lor
for cuvant in cuvinte_sortate:
print(cuvant, frecventa_cuvinte[cuvant])

if __name__ == '__main__':
s = input('Introduceți șirul: ')
if len(s) <= 10000 and not any(c.isdigit() for c in s): # verificarea restricțiilor
print("Datele de intrare corespund restricțiilor impuse.")
calculeaza_frecventa_cuvinte(s) # calculăm și afișăm frecvența cuvintelor
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
</syntaxhighlight>

0534 - Factorial 1

2023-05-21T11:13:02Z

Adina Timiș:

==Cerința==
Să se scrie un program care citește numărul natural n și determină valoarea lui n! = 1 * 2 * 3 * ... * n.
==Date de intrare==
Programul citește de la tastatură numărul n.
==Date de ieșire==
Programul afișează pe prima linie a ecranului valoarea lui n!.
==Restricții și precizări==
*0 ≤ n ≤ 1000;
*prin definiție, 0! = 1;
==Exemplul 1==
;Intrare
:4
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:24
==Exemplul 2==
;Intrare
:1001
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0534 - Factorial 1
def factorial(n):
if n == 0:
return 1 # factorialul lui 0 este 1
elif n < 0 or n > 1000 or not isinstance(n, int):
print("Datele de intrare nu corespund restricțiilor impuse.") # verificarea restricțiilor
return None
else:
result = 1 # inițializăm rezultatul cu 1
for i in range(1, n+1): # parcurgem valorile de la 1 la n
result *= i # calculăm produsul
return result

if __name__ == "__main__":
n = int(input("Introduceți n: "))
if factorial(n) is not None:
print("Datele de intrare corespund restricțiilor impuse.") # verificăm dacă rezultatul factorialului există
print(factorial(n)) # afișăm rezultatul

</syntaxhighlight>

0155 - Cif Max

2023-05-21T11:09:37Z

Adina Timiș:

==Cerința==
Scrieţi un program care citeşte de la tastatură un şir de cel mult 60 de caractere (litere mici şi mari ale alfabetului englez, cifre, puncte, virgule şi spaţii) şi afişează pe ecran cifra care apare de cele mai multe ori în şirul citit.
==Date de intrare==
Programul citeşte de la tastatură un şir de cel mult 60 de caractere.
==Date de ieșire==
Programul va afişa pe ecran cifra care apare de cele mai multe ori în şir.
==Restricții și precizări==
*dacă şirul conţine mai multe cifre cu număr maxim de apariţii si va afişa cea mai mică;
*dacă şirul nu conţine cifre se va afişa NU;
==Exemplul 1==
;Intrare
:Voi lua 9,5 la matematica 10 la informatica si 10 la romana
;Ieșire
:0
:Datele de intrare corespund restricțiilor impuse.
==Exemplul 2==
;Intrare
:aaaaaa
;Ieșire
:NU
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0155 - Cif Max
def numar_aparitii(sir):
sirul = [0] * 10 # inițializăm o listă de 10 elemente cu valoarea 0, pentru a număra aparițiile cifrelor
for char in sir:
if char.isdigit(): # verificăm dacă litera este o cifră
sirul[int(char)] += 1 # incrementăm numărul de apariții al cifrei
return sirul

def sir_maxim(sirul):
numar_maxim = max(sirul) # găsim valoarea maximă din lista de apariții
if numar_maxim == 0: # dacă nu există cifre în șir, returnăm "NU"
return "NU"
for numar in range(10): # parcurgem cifrele de la 0 la 9
if sirul[numar] == numar_maxim: # în cazul în care găsim o cifră cu numărul maxim de apariții
return numar # returnăm acea cifră

if __name__ == '__main__':
sir = input("Introduceți un șir de caractere: ")
if len(sir) > 60: # verificarea restricțiilor
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
sirul = numar_aparitii(sir) # calculăm lista de apariții a cifrelor în șir
cifra_maxima = sir_maxim(sirul) # găsim cifra cu numărul maxim de apariții
if cifra_maxima == "NU":
print("NU")
else:
print(cifra_maxima)
print("Datele de intrare corespund restricțiilor impuse.")

</syntaxhighlight>

1563 - Alfa Bet

2023-05-21T11:00:26Z

Adina Timiș:

==Cerința==
Se dă un cuvânt format din litere mici ale alfabetului englez. Să se afișeze literele sale în ordine alfabetică.
==Date de intrare==
Programul citește un cuvânt format doar din litere mici ale alfabetului englez.
==Date de ieșire==
Programul va afișa pe ecran literele cuvântului, citit în ordine alfabetică.
==Restricții și precizări==
*cuvântul va avea maximum 1000 de caractere;
==Exemplul 1==
;Intrare
:batman
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:aabmnt
==Exemplul 2==
;Intrare
:0123
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1563 - Alfa Bet
def alfabet():
cuvant = input("Introduceți cuvântul: ")

# verificarea restricțiilor
if len(cuvant) > 1000 or not cuvant.isalpha():
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
sorted_cuvant = sorted(cuvant)
print("Datele de intrare corespund restricțiilor impuse.")
print("".join(sorted_cuvant))

if __name__ == "__main__":
alfabet()

</syntaxhighlight>

0528 - Multimi

2023-05-21T10:55:24Z

Adina Timiș:

==Cerința==
Se dau două mulțimi de numere naturale. Să se afișeze reuniunea și intersecția lor.
==Date de intrare==
Programul citește de la tastatură, în ordine:
*numărul n de elemente ale primei mulțimi;
*n numere naturale diferite, ordonate crescător, reprezentând elementele primei mulțimi;
*numărul m de elemente ale celei de-a doua mulțimi;
*m numere naturale diferite, ordonate crescător, reprezentând elementele celei de-a doua mulțimi.
==Date de ieșire==
Programul va afișa pe ecran elementele reuniunii celor două mulțimi, în ordine crescătoare, separate prin exact un spațiu, iar pe rândul următor elementele intersecției celor două mulțimi, în ordine crescătoare, separate de asemenea prin exact un spațiu.
==Restricții și precizări==
*1 ≤ n , m ≤ 1000;
*elementele celor două mulțimi vor fi mai mici decât 1.000.000.000;
*cele două mulțimi date au cel puțin un element comun;
==Exemplul 1==
;Intrare
:5
:3 6 8 9 12
:7
:2 5 6 7 8 9 11
;Ieșire
:2 3 5 6 7 8 9 11 12
:6 8 9
:Datele de intrare corespund restricțiilor impuse.
==Exemplul 2==
;Intrare
:0
:9 22
:-1
:9 0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0528 - Multimi
def multimi():
n = int(input("Introduceți numărul de elemente ale primei mulțimi: "))
set1 = set(map(int, input("Introduceți elementele primei mulțimi: ").split()))

m = int(input("Introduceți numărul de elemente ale celei de-a doua mulțimi: "))
set2 = set(map(int, input("Introduceți elementele celei de-a doua mulțimi: ").split()))

# Verificarea restricțiilor
if n <= 0 or n > 1000 or m <= 0 or m > 1000 or max(set1.union(set2)) >= 1000000000:
print("\nDatele de intrare nu corespund restricțiilor impuse.")
else:
# Calcularea reuniunii și intersecției
union_set = sorted(list(set1.union(set2)))
intersection_set = sorted(list(set1.intersection(set2)))

# Afișarea rezultatelor
print("Reuniunea celor două mulțimi: ", end="")
for element in union_set:
print(element, end=" ")

print("\nIntersecția celor două mulțimi: ", end="")
for element in intersection_set:
print(element, end=" ")

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

if __name__ == "__main__":
multimi()

</syntaxhighlight>

0535 - Fabrica

2023-05-21T10:49:11Z

Adina Timiș:

==Cerința==
La secția de împachetare a produselor dintr-o fabrică lucrează n muncitori. Fiecare muncitor împachetează același tip de produs, iar pentru fiecare se cunoaște timpul necesar pentru împachetarea unui obiect. Să se determine câte obiecte vor fi împachetate de cei n muncitori într-un interval de timp dat, T.
==Date de intrare==
Programul citește de la tastatură numerele n și T, iar apoi n numere naturale nenule, reprezentând timpul necesar fiecărui muncitor pentru împachetarea unui obiect.
==Date de ieșire==
Programul va afișa pe ecran numărul C, reprezentând numărul de obiecte împachetate de cei n muncitori în intervalul dat.
==Restricții și precizări==
*1 ≤ n ≤ 1000;
*cele n numere citite vor fi mai mici decât 1.000;
*1 ≤ T ≤ 1.000.000;
*toate intervalele de timp sunt exprimate în aceeași unitate de măsură;
==Exemplul 1==
;Intrare
:6 30
:4 7 3 6 7 1
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:60
==Exemplul 2==
;Intrare
:0 10
:4 7 3 6 7 1
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0535 - Fabrica
def calculeaza_numarul_de_obiecte(n, T, timpi):
count = 0
for i in range(n):
obiecte = T // timpi[i]
count += obiecte
return count

if __name__ == "__main__":
# citim numărul de muncitori și intervalul de timp de la tastatură
n, T = map(int, input("Introduceți numărul de muncitori și intervalul de timp: ").split())

# citim timpii necesari pentru împachetarea unui obiect, pentru fiecare muncitor
timpi = list(map(int, input("Introduceți timpii necesari pentru împachetarea unui obiect: ").split()))

# verificarea restricțiilor
if n < 1 or n > 1000 or (max(timpi) > 1000 and (T < 1 or T > 1000000)):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")

# calculăm numărul total de obiecte împachetate
C = calculeaza_numarul_de_obiecte(n, T, timpi)

# afișăm rezultatul
print(f"{C} obiecte au fost împachetate, de către cei {n} muncitori, în intervalul de timp dat.")
</syntaxhighlight>

0567 - Pereche

2023-05-21T10:44:01Z

Adina Timiș:

==Cerința==
n elevi numerotați de la 1 la n stau în cerc, astfel încât elevul 1 și elevul n sunt vecini. Pentru fiecare elev se cunoaște înălțimea. O pereche de elevi învecinați este pereche potrivită dacă diferența dintre înălțimile elevilor este minimă. Determinați o pereche potrivită.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n înălțimi ale elevilor, în ordine.
==Date de ieșire==
Programul va afișa pe ecran numerele de ordine i j, separate prin exact un spatiu, a elevilor care formează o pereche potrivită.
==Restricții și precizări==
*2 ≤ n ≤ 1000;
*cele n numere citite vor fi mai mici decât 1.000;
*dacă există mai multe perechi potrivite, se poate afișa oricare;
==Exemplul 1==
;Intrare
:5
:4 6 3 5 3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1 5
==Exemplul 2==
;Intrare
:1
:4 6 3 5 3
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0567 - Pereche
def gaseste_pereche_potrivita(n, inaltimi):
# calculăm diferența absolută între prima și ultima înălțime
diferenta_primul_ultimul = abs(inaltimi[0] - inaltimi[-1])
indice_elev1, indice_elev2 = 0, n - 1

# parcurgem lista de înălțimi pentru a găsi perechea cu cea mai mică diferență
for i in range(n - 1):
diferenta = abs(inaltimi[i] - inaltimi[i+1])
if diferenta < diferenta_primul_ultimul:
diferenta_primul_ultimul = diferenta
indice_elev1, indice_elev2 = i, i+1

return indice_elev1 + 1, indice_elev2 + 1

if __name__ == "__main__":
n = int(input("Introduceți numărul de elevi: "))
inaltimi = list(map(int, input("Introduceți înălțimile: ").split()))

# verificarea restricțiilor
if n < 2 or n > 1000 or max(inaltimi) > 1000:
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
indice_elev1, indice_elev2 = gaseste_pereche_potrivita(n, inaltimi)
print(f"Perechea potrivită este: {indice_elev1} {indice_elev2}")

</syntaxhighlight>

0133 - Nume Prenume

2023-05-21T10:40:08Z

Adina Timiș:

==Cerința==
Scrieți un program care citește de la tastatură două șiruri formate fiecare din cel mult 20 de caractere. Primul șir reprezintă numele unei persoane, iar al doilea șir reprezintă prenumele aceleiași persoane. Atât numele, cât și prenumele sunt formate doar din litere ale alfabetului englez și fiecare conține cel puțin o consoană. Programul construiește în memorie și afișează pe ecran un al treilea șir de caractere, care va conține consoanele din prenumele citit dispuse în ordinea în care apar în prenume, urmate de exact un spațiu și de numele citit.
==Date de intrare==
Programul citeşte de la tastatură cele două șiruri.
==Date de ieșire==
Programul afişează pe ecran șirul construit după regula precizată.
==Exemplul 1==
;Intrare
:Popescu Vasile
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:Vsl Popescu
==Exemplul 2==
;Intrare
:aaaaaa Vasile
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0133 - Nume Prenume
def verifica_sir(sir):
# verificăm dacă șirul conține doar litere
if not sir.isalpha():
return False

consoane = "bcdfghjklmnpqrstvwxyz"
# verificăm dacă șirul conține cel puțin o consoană
for litera in sir.lower():
if litera in consoane:
return True

return False

def construieste_sir(nume, prenume):
sir_final = ""

# verificăm fiecare literă din prenume și adăugăm doar consoanele în șirul final
for litera in prenume:
if litera.lower() in "bcdfghjklmnpqrstvwxyz":
sir_final += litera

# adăugăm numele la finalul șirului
sir_final += " " + nume

return sir_final

if __name__ == '__main__':
# citim numele și prenumele de la tastatură
nume = input("Introduceți numele: ")
prenume = input("Introduceți prenumele: ")

# verificarea restricțiilor
if verifica_sir(nume) and verifica_sir(prenume):
# construim și afișăm șirul final
sir_final = construieste_sir(nume, prenume)
print(sir_final)
print("Datele de intrare corespund restricțiilor impuse.")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

0514 - Sort PIE

2023-05-21T10:28:25Z

Adina Timiș:

==Cerința==
Se dă un vector cu n elemente, numere naturale. Afișați în ordine descrescătoare valorile din vector care sunt prime cu ultimul element al vectorului.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului.
==Date de ieșire==
Programul va afișa pe ecran valorile cerute, în ordine descrescătoare, separate prin exact un spațiu.
==Restricții și precizări==
*1 ≤ n ≤ 1000;
*cele n numere citite vor fi mai mici decât 1.000.000.000;
==Exemplul 1==
;Intrare
:8
:16 7 6 3 1 5 9 14
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:9 5 3 1
==Exemplul 2==
;Intrare
:0
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0514 - Sort PIE
def sort():
# citim numarul de elemente din sir, dar si vectorul de la tastatura
n = int(input())
a = list(map(int, input().split()))

# sortam sirul in ordine descrescatoare
for i in range(n - 2):
for j in range(i + 1, n - 1):
if a[i] < a[j]:
a[i], a[j] = a[j], a[i]

# verificam restrictiile
if 1 <= n <= 1000 and max(a) < 1000000000:
print("Datele de intrare corespund restricțiilor impuse.")
# parcurgem fiecare element din sir si verificam daca este prim
for i in range(n - 1):
x = a[i]
y = a[-1]
while y:
r = x % y
x = y
y = r
if x == 1:
print(a[i], end=' ')
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

if __name__ == '__main__':
# apelam functia
sort()

</syntaxhighlight>

2804 - Strncat

2023-05-21T10:23:17Z

Adina Timiș:

==Cerința==
Pentru un cuvânt format din litere mici ale alfabetului englez s și un număr natural x mai mic sau egal cu lungimea cuvântului, definim următoarea operație:
*dacă x este par, la s se vor adăuga primele sale x litere, în ordinea din șir;
*dacă x este impar, la s se vor adăuga primele sale x litere, în ordinea inversă din șir.
Se dă un cuvânt s și un șir de n numere naturale x[1], x[2], …, x[n]. Se aplică succesiv operația definită mai sus între șirul s și numerele din șir, în ordinea acestora. Afișați șirul s după aplicarea acestor operații.
==Date de intrare==
Programul citește de la tastatură cuvântul s, numărul n și cele n elemente ale șirului.
==Date de ieșire==
Programul va afișa pe ecran cuvântul rezultat.
==Restricții și precizări==
*lungimea inițială a cuvântului este de cel mult 1000 de caractere;
*1 ≤ n ≤ 1000;
*fiecare element al șirului dat va fi mai mic sau egal cu minimul dintre 1000 și lungimea curentă a șirului s;
==Exemplul 1==
;Intrare
:alina
:3
:4 3 2
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:alinaalinilaal
==Exemplul 2==
;Intrare
:alina
:0
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2804 - Strncat
def strncat(s, x):
# verifica daca x este par
if x % 2 == 0:
# adauga primele x caractere din s la sfarsitul lui s
s += s[:x]
else:
# adauga primele x caractere din s, dar inversate, la sfarsitul lui s
s += s[:x][::-1]
return s

if __name__ == "__main__":
# citeste cuvantul
s = input("Introduceți cuvântul: ")
# citeste numarul de operatii
n = int(input("Introduceți numărul de operații: "))
# citeste lista de numere
x = list(map(int, input("Introduceți numerele: ").split()))

# verificarea restricțiilor
if n >= 1 and n <= 1000 and len(s) <= 1000 and all(i <= 1000 for i in x):
# parcurge lista de numere si aplica fiecare operatie pe rand
for i in x:
s = strncat(s, i)
print(s)
print("Datele de intrare corespund restricțiilor impuse.")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")
</syntaxhighlight>

1191 - Arhitectura

2023-05-21T10:19:24Z

Adina Timiș:

==Cerința==
Primăria dorește să realizeze un proiect de sistematizare a orașului și pentru aceasta îl angajează pe arhitectul Gigel. Orașul constă în n clădiri; pentru fiecare se cunoaște înălțimea, iar Gigel trebuie să ordoneze descrescător aceste înălțimi.
==Date de intrare==
Programul citește de la tastatură prima linie numărul n, apoi n numere naturale separate prin spații, reprezentând înălțimile celor n clădiri.
==Date de ieșire==
Programul va afișa pe ecran n numere naturale, separate prin câte un spațiu, reprezentând înălțimile clădirilor, după ordonare.
==Restricții și precizări==
*1 ≤ n ≤ 1000
*înălțimile clădirilor vor fi mai mici decât 1.000.000.000
==Exemplul 1==
;Intrare
:5
:1 2 7 3 6
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:7 6 3 2 1
==Exemplul 2==
;Intrare
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1191 - Arhitectura
def arhitectura():
# citim numărul de înălțimi
n = int(input())
# citim lista de înălțimi
inaltimi = list(map(int, input().split()))

# verificăm restricțiile
if n < 1 or n > 1000 or any(h < 1 or h >= 1000000000 for h in inaltimi):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
# sortăm lista de înălțimi, în ordine descrescătoare
inaltimi_ord = ordonare_descrescatoare(inaltimi)
# afișăm lista sortată de înălțimi
print(*inaltimi_ord)

def ordonare_descrescatoare(lista):
# sortează lista în ordine descrescătoare
return sorted(lista, reverse=True)

if __name__ == '__main__':
# apelăm funcția arhitectura()
arhitectura()

</syntaxhighlight>

0084 - Interschimbare Litere

2023-05-21T10:13:20Z

Adina Timiș:

==Cerința==
Să se scrie un program care citește un cuvânt și îl afișează după interschimbarea primei vocale cu ultima consoană.
==Date de intrare==
Programul citeşte de la tastatură un şir de caractere, reprezentând un cuvânt.
==Date de ieșire==
Programul afişează pe ecran cuvântul obținut prin interschimbarea primei vocale cu ultima consoană.
==Restricții și precizări==
*şirul de caractere citit va conţine cel mult 10 caractere, litere mari și mici ale alfabetului englez;
*se consideră vocale următoarele caractere: a e i o u A E I O U;
*dacă cuvântul conține doar vocale sau doar consoane se va afișa IMPOSIBIL;
==Exemplul 1==
;Intrare
:PrograM
;Ieșire
:PrMgrao
:Datele de intrare corespund restricțiilor impuse.
==Exemplul 2==
;Intrare
:aeiou
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
:IMPOSIBIL
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0084 - Interschimbare Litere
def interschimbare_vocale_si_consoane(cuvant):
# definim lista de vocale și de consoane
vocale = "aeiouAEIOU"
consoane = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"

# inițializăm pozițiile vocalei și consoanei cu -1
pozitie_vocala = -1
pozitie_consoana = -1

# parcurgem cuântul și găsim prima apariție a vocalei și consoanei
for i, litera in enumerate(cuvant):
if litera in vocale and pozitie_vocala == -1:
pozitie_vocala = i
if litera in consoane:
pozitie_consoana = i

# verificăm dacă am găsit atât o vocală cât și o consoană
if pozitie_vocala == -1 or pozitie_consoana == -1:
return "IMPOSIBIL"

# realizăm interschimbarea
cuvant_nou = cuvant[:pozitie_vocala] + cuvant[pozitie_consoana] + cuvant[pozitie_vocala + 1:pozitie_consoana] + cuvant[pozitie_vocala] + cuvant[pozitie_consoana + 1:]
return cuvant_nou

if __name__ == '__main__':
# citim cuvântul de la tastatură
cuvant = input("Introduceți cuvântul: ")

# apelăm funcția interschimbare_vocale_si_consoane
cuvant_nou = interschimbare_vocale_si_consoane(cuvant)

# verificăm rezultatul și afișăm mesajele corespunzătoare
if cuvant_nou == "IMPOSIBIL":
print("Datele de intrare nu corespund restricțiilor impuse.")
print(cuvant_nou)
else:
print("Datele de intrare corespund restricțiilor impuse.")
print(cuvant_nou)

</syntaxhighlight>

0312 - Putere N

2023-05-21T10:06:10Z

Adina Timiș: /* Rezolvare */

==Cerința==
Se dau două numere naturale <math>x</math> şi n. Calculaţi <math> {x}^n</math>.
==Date de intrare==
Programul citește de la tastatură numerele <math>x</math> şi n.
==Date de ieșire==
Programul afișează pe ecran numărul P, valoarea calculată.
==Restricții și precizări==
*1 ≤ x ≤ 1000;
*1 ≤ n ≤ 1000;
==Exemplul 1==
;Intrare
:2 40
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1099511627776
==Exemplul 2==
;Intrare
:0 0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0312 - Putere N
def putere():
# variabilele sunt inițializate și convertite în integer
x = int(input("Introduceti x: "))
n = int(input("Introduceti n: "))
return x, n

if __name__ == "__main__":
# apelăm funcția și atribuim valorile returnate în x și n
x, n = putere()

# verificarea restricțiilor
if n >= 1 and x >= 1 and n <= 1000 and x <= 1000:
# calcularea lui x ridicat la puterea n
p = x ** n
print("Datele de intrare corespund restricțiilor impuse.")
print("x la puterea n este:", p)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

0514 - Sort PIE

2023-05-05T20:28:15Z

Adina Timiș: Pagină nouă: ==Cerința== Se dă un vector cu n elemente, numere naturale. Afișați în ordine descrescătoare valorile din vector care sunt prime cu ultimul element al vectorului. ==Date de intrare== Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului. ==Date de ieșire== Programul va afișa pe ecran valorile cerute, în ordine descrescătoare, separate prin exact un spațiu. ==Restricții și precizări== *1 ≤ n ≤ 1000...

0135 - Sablon

2023-05-05T20:00:09Z

Adina Timiș: Pagină nouă: ==Cerința== Un șir de caractere s este șablon pentru un șir de caractere x dacă are aceeași lungime cu x și este alcătuit numai din caractere ale mulțimii {*, #, ?}, iar pe fiecare poziție din s în care apare * în x apare vocală, pe fiecare poziție din s în care apare # în x apare consoană, iar pe fiecare poziție din s în care apare ? în x putem avea orice caracter. Scrieți un program care citește de tastatură două șiruri de cel mult 30 caractere de...

==Cerința==
Un șir de caractere s este șablon pentru un șir de caractere x dacă are aceeași lungime cu x și este alcătuit numai din caractere ale mulțimii {*, #, ?}, iar pe fiecare poziție din s în care apare * în x apare vocală, pe fiecare poziție din s în care apare # în x apare consoană, iar pe fiecare poziție din s în care apare ? în x putem avea orice caracter. Scrieți un program care citește de tastatură două șiruri de cel mult 30 caractere de aceeași lungime care conțin doar litere mici ale alfabetului englez și construiește în memorie și apoi afișează pe ecran un cel mai bun șablon comun al lor, adică șablonul comun cu număr minim de caractere ?.
==Date de intrare==
Programul citeşte de la tastatură cele două șiruri, pe acelaşi rând, separate printr-un spaţiu.
==Date de ieșire==
Programul afişează pe ecran cel mai bun șablon comun.
==Restricții și precizări==
*se consideră vocale caracterele din mulțimea {a, e, i, o, u};
==Exemplul 1==
;Intrare
:diamant pierdut
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:<nowiki>#**#??#</nowiki>
==Exemplul 2==
;Intrare
:tttttt mmmmm
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0135 - Sablon
def compare_strings(a, b):
result = ''
for i in range(len(a)):
if (a[i] in ['a', 'e', 'i', 'o', 'u']) and (b[i] in ['a', 'e', 'i', 'o', 'u']):
result += '*' # daca ambele caractere sunt vocale, adaugam un asterisc
elif (a[i] in ['a', 'e', 'i', 'o', 'u']) and (b[i] not in ['a', 'e', 'i', 'o', 'u']):
result += '?' #daca primul caracter este vocala, iar al doilea nu este, adaugam un semn de intrebare
elif (a[i] not in ['a', 'e', 'i', 'o', 'u']) and (b[i] in ['a', 'e', 'i', 'o', 'u']):
result += '?' #daca primul caracter nu este vocala, iar al doilea este vocala, adaugam un semn de intrebare
else:
result += '#' #daca ambele caractere nu sunt vocale, adaugam un diez
return result

if __name__ == '__main__':
a, b = input().split()
#verificarea restrictiilor
if len(a) <= 30 and len(b) <= 30 and any(char in ['a', 'e', 'i', 'o', 'u'] for char in a + b):
print("Datele de intrare corespund restricțiilor impuse.")
result = compare_strings(a, b)
print(result)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

3406 - As Easy As ABC

2023-05-05T19:02:46Z

Adina Timiș: Pagină nouă: ==Cerința== Fie N un număr întreg impar și un vector A cu N elemente. Pentru fiecare element <math>A_{i}</math>, acesta se poate incrementa cu 1. Fiecare element sepoate incrementa cel mult odată. Mai mult, se pot realiza cel mult K incrementări. Scopul este de a maximiza medianul lui A. Medianul unui vector este definit ca fiind elementul din mijlocul vectorului după sortarea acestuia. De exemplu, medianul vectorului [5, 8, 2, 9, 1] este 5. ==Date de intrare== Pr...

==Cerința==
Fie N un număr întreg impar și un vector A cu N elemente. Pentru fiecare element <math>A_{i}</math>, acesta se poate incrementa cu 1. Fiecare element sepoate incrementa cel mult odată. Mai mult, se pot realiza cel mult K incrementări. Scopul este de a maximiza medianul lui A. Medianul unui vector este definit ca fiind elementul din mijlocul vectorului după sortarea acestuia. De exemplu, medianul vectorului [5, 8, 2, 9, 1] este 5.
==Date de intrare==
Prima linie conține un număr impar N și un întreg K. Pe a doua linie se află N numere separate prin spații naturale, reprezentând elementele vectorului.
==Date de ieșire==
Programul va afișa pe ecran numărul ce reprezintă maximul posibil al medianului după aplicarea operațiilor de incrementare.
==Restricții și precizări==
*1 ≤ k ≤ n ≤ 1000, N e impar;
*1 ≤ <math>A_{i}</math> ≤ 1000;
==Exemplul 1==
;Intrare
:9 3
:4 4 4 8 2 2 9 9 1
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:5
==Explicație==
:Se pot incrementa elementele de pe pozițiile 1, 2 și 3. Valoarea comună reprezintă medianul maxim care se poate obține.
==Exemplul 2==
;Intrare
:0 0
:0 0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#3406 - As Easy As ABC
def maximize_median(vector, k):
n = len(vector)
mid = n // 2
median = vector[mid]

# pentru a crește valoarea medianei, vom parcurge elementele din stânga acesteia
for i in range(mid - 1, -1, -1):
if k <= 0:
break
# calculăm diferența dintre valoarea medianei și elementul curent i, din stânga ei
# această diferență trebuie să fie mai mică sau egală cu numărul de operații disponibile k
diff = min(vector[mid] - vector[i], k // (mid - i))
# creștem valoarea medianei cu diferența calculată
median += diff
# scădem din numărul total de operații k, numărul de operații realizate, pentru a crește valoarea medianei
k -= diff * (mid - i)

# pentru a crește valoarea medianei, vom parcurge elementele din dreapta medianei
for i in range(mid + 1, n):
if k <= 0:
break
# calculăm diferența dintre elementul curent i din dreapta medianei și valoarea acesteia
# diferența trebuie să fie mai mică sau egală cu numărul de operații disponibile k
diff = min(vector[i] - vector[mid], k // (i - mid))
# creștem valoarea medianei cu diferența calculată
median += diff
# scădem din numărul total de operații k, numărul de operații realizate pentru a crește valoarea medianei
k -= diff * (i - mid)

# returnăm valoarea maximă a medianei
return median

if __name__ == "__main__":
# citim numărul n de elemente din vector și numărul k de operații care pot fi realizate
# elementele vectorului sunt sub forma de listă de numere
n, k = map(int, input().split())
vector = list(map(int, input().split()))

# verificăm restricțiile
if n % 2 == 0 or n < 1 or n > 1000 or k < 1 or k > n or any(a < 1 or a > 1000 for a in vector):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
vector.sort()
max_median = maximize_median(vector, k)
# în caz contrar, apelăm funcția și afișăm valoarea maximă a medianei
print(max_median)

</syntaxhighlight>

1960 - Perfecte

2023-05-05T18:19:16Z

Adina Timiș: Pagină nouă: ==Cerința== Un număr natural nenul se numește perfect dacă este egal cu suma divizorilor săi naturali strict mai mici decât el. Exemplu: 28 este număr perfect pentru că 28 = 1 + 2 + 4 + 7 + 14. Se dă un șir de n numere naturale. Pentru fiecare element din șir se va afișa valoarea 1 dacă acesta este perfect sau 0 în caz contrar. ==Date de intrare== Programul citește de la tastatură numărul n și apoi n numere naturale. ==Date de ieșire== Programul va afi...

==Cerința==
Un număr natural nenul se numește perfect dacă este egal cu suma divizorilor săi naturali strict mai mici decât el.

Exemplu: 28 este număr perfect pentru că 28 = 1 + 2 + 4 + 7 + 14. Se dă un șir de n numere naturale. Pentru fiecare element din șir se va afișa valoarea 1 dacă acesta este perfect sau 0 în caz contrar.
==Date de intrare==
Programul citește de la tastatură numărul n și apoi n numere naturale.
==Date de ieșire==
Programul va afișa pe ecran șirul de valori 1 și 0 separate prin câte un spațiu, conform cerinței.
==Restricții și precizări==
*0 < n < 1000;
*numerele citite vor fi mai mici decât <math>10^{19}</math>;
==Exemplul 1==
;Intrare
:5
:28 7 8 9 6
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1 0 0 0 1
==Explicație==
:28 și 6 sunt numere perfecte.
==Exemplul 2==
;Intrare
:0
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="">
#1960 - Perfecte
# definim funcția care primește ca argument un număr natural și verifică dacă acesta este perfect
def is_perfect(num):
divisors_sum = 0
for i in range(1, num):
if num % i == 0:
divisors_sum += i
return divisors_sum == num

if __name__ == "__main__":
# citim de la tastatură numărul de elemente și vectorul de numere
n = int(input("Introduceți numărul de elemente: "))
vector = list(map(int, input("Introduceți elementele vectorului: ").split()))
# verificarea restricțiilor
if 0 < n < 1000 and all(0 <= i < 10**19 for i in vector):
print("Datele de intrare corespund restricțiilor impuse.")
# pentru fiecare număr din vector, verificăm dacă este perfect și afișăm rezultatul
for num in vector:
if is_perfect(num):
print("1", end=" ")
else:
print("0", end=" ")
print()
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

2923 - Min Pal

2023-05-05T17:03:09Z

Adina Timiș: /* Rezolvare */

==Cerința==
Se dă numărul natural n și un șir de n numere naturale. Determinați numărul minim de operații necesare pentru a face șirul palindromic. Singura operație admisă este înlocuirea a două elemente adiacente cu un element care conține suma lor.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi cele n elemente ale șirului, separate prin spații.
==Date de ieșire==
Programul va afișa pe ecran numărul minim de operații pentru a transforma șirul dat într-un șir palindromic.
==Restricții și precizări==
*1 ≤ n ≤ 1000.000;

*elementele șirului dat vor fi mai mici decât 10.000;

*un șir este palindromic dacă se citește la fel în ambele sensuri;
==Exemplul 1==
;Intrare

:4

:1 4 5 1

;Ieșire

:Datele de intrare corespund restricțiilor impuse.

:1
==Exemplul 2==
;Intrare

:0

:0

;Ieșire

:Datele de intrare nu corespund restricțiilor impuse.
==Explicație==
Se adună 4 cu 5, iar șirul devine 1 9 1
==Rezolvare==
<syntaxhighlight lang="python" line="1">

#2923 - Min Pal

# definim funcția care primește un șir și returnează numărul minim de operații
# pentru a forma șirul palindromic

def min_op_palindrome(arr):

n = len(arr) # lungimea șirului

operations = 0 # inițializăm numărul de operații cu zero

# iterăm prima jumătate a șirului

for i in range(n//2):

left = arr[i] # primul element, din perechea curentă

right = arr[n-i-1] # al doilea element din perechea curentă

# verificăm dacă unul dintre elemente este 0 și trecem la perechea următoare

if left == 0 or right == 0:

continue

# verificăm dacă cele două elemente sunt egale și trecem la perechea următoare

if left == right:

continue

# dacă primul element este mai mare decât al doilea, le interschimbăm

if left > right:

left, right = right, left

# în timp ce primul element este mai mic decât al doilea, îl dublăm și creștem numărul de operații

while left < right:

left *= 2

operations += 1

return operations # returnăm numărul total de operații

# programul principal

if __name__ == '__main__':

n = int(input("Introduceti numărul de elemente: ")) # citim lungimea șirului de la tastatură

arr = list(map(int, input("Introduceti elementele sirului: ").split())) # citim elementele șirului de la

# tastatură și le convertim într-o listă de numere întregi

# verificarea restricțiilor

if 1 <= n <= 1000000 and all(0 <= arr[i] < 10000 for i in range(n)):

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

print(min_op_palindrome(arr)) # afișăm numărul minim de operații necesare pentru a transforma șirul

else:

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

</syntaxhighlight>

2923 - Min Pal

2023-05-05T17:02:13Z

Adina Timiș: /* Rezolvare */

==Cerința==
Se dă numărul natural n și un șir de n numere naturale. Determinați numărul minim de operații necesare pentru a face șirul palindromic. Singura operație admisă este înlocuirea a două elemente adiacente cu un element care conține suma lor.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi cele n elemente ale șirului, separate prin spații.
==Date de ieșire==
Programul va afișa pe ecran numărul minim de operații pentru a transforma șirul dat într-un șir palindromic.
==Restricții și precizări==
*1 ≤ n ≤ 1000.000;

*elementele șirului dat vor fi mai mici decât 10.000;

*un șir este palindromic dacă se citește la fel în ambele sensuri;
==Exemplul 1==
;Intrare

:4

:1 4 5 1

;Ieșire

:Datele de intrare corespund restricțiilor impuse.

:1
==Exemplul 2==
;Intrare

:0

:0

;Ieșire

:Datele de intrare nu corespund restricțiilor impuse.
==Explicație==
Se adună 4 cu 5, iar șirul devine 1 9 1
==Rezolvare==
<syntaxhighlight lang="python" line="1">

#2923 - Min Pal

# definim funcția care primește un șir și returnează numărul minim de operații
# pentru a forma șirul palindromic

def min_op_palindrome(arr):

n = len(arr) # lungimea șirului

operations = 0 # inițializăm numărul de operații cu zero

# iterăm prima jumătate a șirului

for i in range(n//2):

left = arr[i] # primul element, din perechea curentă

right = arr[n-i-1] # al doilea element din perechea curentă

# verificăm dacă unul dintre elemente este 0 și trecem la perechea următoare

if left == 0 or right == 0:

continue

# verificăm dacă cele două elemente sunt egale și trecem la perechea următoare

if left == right:

continue

# dacă primul element este mai mare decât al doilea, le interschimbăm

if left > right:

left, right = right, left

# în timp ce primul element este mai mic decât al doilea, îl dublăm și creștem numărul de operații

while left < right:

left *= 2

operations += 1

return operations # returnăm numărul total de operații

# programul principal

if __name__ == '__main__':

n = int(input("Introduceti numărul de elemente: ")) # citim lungimea șirului de la tastatură

arr = list(map(int, input("Introduceti elementele sirului: ").split())) # citim elementele șirului de la

# tastatură și le convertim într-o listă de numere întregi

# verificarea restricțiilor

if 1 <= n <= 1000000 and all(0 <= arr[i] < 10000 for i in range(n)):

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

print(min_op_palindrome(arr)) # afișăm numărul minim de operații necesare pentru a # transforma șirul într-un palindrom

else:

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

</syntaxhighlight>

2923 - Min Pal

2023-05-05T17:01:10Z

Adina Timiș:

==Cerința==
Se dă numărul natural n și un șir de n numere naturale. Determinați numărul minim de operații necesare pentru a face șirul palindromic. Singura operație admisă este înlocuirea a două elemente adiacente cu un element care conține suma lor.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi cele n elemente ale șirului, separate prin spații.
==Date de ieșire==
Programul va afișa pe ecran numărul minim de operații pentru a transforma șirul dat într-un șir palindromic.
==Restricții și precizări==
*1 ≤ n ≤ 1000.000;

*elementele șirului dat vor fi mai mici decât 10.000;

*un șir este palindromic dacă se citește la fel în ambele sensuri;
==Exemplul 1==
;Intrare

:4

:1 4 5 1

;Ieșire

:Datele de intrare corespund restricțiilor impuse.

:1
==Exemplul 2==
;Intrare

:0

:0

;Ieșire

:Datele de intrare nu corespund restricțiilor impuse.
==Explicație==
Se adună 4 cu 5, iar șirul devine 1 9 1
==Rezolvare==
<syntaxhighlight lang="python" line="1">

#2923 - Min Pal

# definim funcția care primește un șir și returnează numărul minim de operații
# pentru a forma șirul palindromic

def min_op_palindrome(arr):

n = len(arr) # lungimea șirului

operations = 0 # inițializăm numărul de operații cu zero

# iterăm prima jumătate a șirului

for i in range(n//2):

left = arr[i] # primul element, din perechea curentă

right = arr[n-i-1] # al doilea element din perechea curentă

# verificăm dacă unul dintre elemente este 0 și trecem la perechea următoare

if left == 0 or right == 0:

continue

# verificăm dacă cele două elemente sunt egale și trecem la perechea următoare

if left == right:

continue

# dacă primul element este mai mare decât al doilea, le interschimbăm

if left > right:

left, right = right, left

# în timp ce primul element este mai mic decât al doilea, îl dublăm și creștem numărul de operații

while left < right:

left *= 2

operations += 1

return operations # returnăm numărul total de operații

# programul principal

if __name__ == '__main__':

n = int(input("Introduceti numărul de elemente: ")) # citim lungimea șirului de la tastatură

arr = list(map(int, input("Introduceti elementele sirului: ").split())) # citim elementele șirului de la

# tastatură și le convertim într-o listă de numere întregi

# verificarea restricțiilor

if 1 <= n <= 1000000 and all(0 <= arr[i] < 10000 for i in range(n)):

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

print(min_op_palindrome(arr)) # afișăm numărul minim de operații necesare pentru a transforma # șirul într-un palindrom

else:

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

</syntaxhighlight>

2923 - Min Pal

2023-05-05T16:55:39Z

Adina Timiș: Pagină nouă: ==Cerința== Se dă numărul natural n și un șir de n numere naturale. Determinați numărul minim de operații necesare pentru a face șirul palindromic. Singura operație admisă este înlocuirea a două elemente adiacente cu un element care conține suma lor. ==Date de intrare== Programul citește de la tastatură numărul n, iar apoi cele n elemente ale șirului, separate prin spații. ==Date de ieșire== Programul va afișa pe ecran numărul minim de operații pentru...

==Cerința==
Se dă numărul natural n și un șir de n numere naturale. Determinați numărul minim de operații necesare pentru a face șirul palindromic. Singura operație admisă este înlocuirea a două elemente adiacente cu un element care conține suma lor.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi cele n elemente ale șirului, separate prin spații.
==Date de ieșire==
Programul va afișa pe ecran numărul minim de operații pentru a transforma șirul dat într-un șir palindromic.
==Restricții și precizări==
*1 ≤ n ≤ 1000.000;

*elementele șirului dat vor fi mai mici decât 10.000;

*un șir este palindromic dacă se citește la fel în ambele sensuri;
==Exemplul 1==
;Intrare

:4

:1 4 5 1

;Ieșire

:Datele de intrare corespund restricțiilor impuse.

:1
==Exemplul 2==
;Intrare

:0

:0

;Ieșire

:Datele de intrare nu corespund restricțiilor impuse.
==Explicație==
Se adună 4 cu 5, iar șirul devine 1 9 1
==Rezolvare==
<syntaxhighlight lang="python" line="1">

#2923 - Min Pal

# definim funcția care primește un șir și returnează numărul minim de operații
# pentru a forma șirul palindromic

def min_op_palindrome(arr):

n = len(arr) # lungimea șirului

operations = 0 # inițializăm numărul de operații cu zero

# iterăm prima jumătate a șirului

for i in range(n//2):

left = arr[i] # primul element, din perechea curentă

right = arr[n-i-1] # al doilea element din perechea curentă

# verificăm dacă unul dintre elemente este 0 și trecem la perechea următoare

if left == 0 or right == 0:

continue

# verificăm dacă cele două elemente sunt egale și trecem la perechea următoare

if left == right:

continue

# dacă primul element este mai mare decât al doilea, le interschimbăm

if left > right:

left, right = right, left

# în timp ce primul element este mai mic decât al doilea, îl dublăm și creștem numărul de operații

while left < right:

left *= 2

operations += 1

return operations # returnăm numărul total de operații

# programul principal

if __name__ == '__main__':

n = int(input("Introduceti numărul de elemente: ")) # citim lungimea șirului de la tastatură

arr = list(map(int, input("Introduceti elementele sirului: ").split())) # citim elementele șirului de la

# tastatură și le convertim într-o listă de numere întregi

# verificarea restricțiilor

if 1 <= n <= 1000000 and all(0 <= arr[i] < 10000 for i in range(n)):

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

print(min_op_palindrome(arr)) # afișăm numărul minim de operații necesare pentru a transforma # șirul într-un palindrom

else:

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

</syntaxhighlight>

0180 - Sort Min Max

2023-04-29T14:30:54Z

Adina Timiș: Pagină nouă: ==Cerința== Să se ordoneze crescător elementele dintr-un şir dat cuprinse între elementul de valoare maximă şi cel de valoare minimă. ==Date de intrare== Programul citește de la tastatură numărul n, iar apoi n numere naturale distincte, separate prin spaţii. ==Date de ieșire== Programul afișează pe ecran elementele şirului după ordonare. ==Restricții și precizări== *0 < n ≤ 1000; *elementele şirului sunt numere naturale mai mici decât 1.000.000; ==Exe...

==Cerința==
Să se ordoneze crescător elementele dintr-un şir dat cuprinse între elementul de valoare maximă şi cel de valoare minimă.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale distincte, separate prin spaţii.
==Date de ieșire==
Programul afișează pe ecran elementele şirului după ordonare.
==Restricții și precizări==
*0 < n ≤ 1000;
*elementele şirului sunt numere naturale mai mici decât 1.000.000;
==Exemplul 1==
;Intrare
:5
:10 20 15 7 12
;Ieșire
:10 7 15 20 12
:Datele de intrare corespund restricțiilor impuse.
==Exemplul 2==
;Intrare
:0
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0180 - Sort Min Max
def min_max_pos(n, a):
min_val = float('inf') # initializam minimul cu o valoare mare
max_val = float('-inf') # initializam maximul cu o valoare mica
min_pos = 0
max_pos = 0
for i in range(n):
if a[i] < min_val:
min_val = a[i]
min_pos = i
if a[i] > max_val:
max_val = a[i]
max_pos = i
if min_pos > max_pos: # verificam daca pozitia minima e mai mare decat pozitia maxima
min_pos, max_pos = max_pos, min_pos # interschimbam pozitiile
return min_pos, max_pos

def sort_min_max(n, a):
min_pos, max_pos = min_max_pos(n, a) # gasim pozitia minima si pozitia maxima
for i in range(min_pos, max_pos): # parcurgem elementele din vector intre pozitia minima si
# pozitia maxima
for j in range(i+1, max_pos+1): # parcurgem elementele din vector intre pozitia i si
# pozitia maxima
if a[i] > a[j]: # daca elementul de pe pozitia i e mai mare decat cel de pe j
a[i], a[j] = a[j], a[i] # interschimbam elementele

if __name__ == '__main__':
n = int(input("Introduceti numarul de elemente din vector: "))
a = list(map(int, input("Introduceti elementele vectorului: ").split()))
# verificarea restrictiilor
if 0 < n <= 1000 and all(1 <= x <= 10**6 for x in a):
sort_min_max(n, a) # sortam elementele din vector intre pozitia minima si
# pozitia maxima
print("Vectorul sortat:")
print(*a) # afisam vectorul sortat folosind * pentru a separa elementele cu spatiu
print("Datele de intrare corespund restricțiilor impuse.")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

0513 - K Sort 1

2023-04-29T11:39:42Z

Adina Timiș: Pagină nouă: ==Cerința== Se dă un șir cu n elemente, numere naturale, numerotate începând cu 1 și un număr k. Considerăm k subșiruri ale șirului, astfel: *primul subșir este format din elementele din șir numerotate cu 1, k+1, 2*k+1, … *al doilea subșir este format din elementele din șir numerotate cu 2, k+2, 2*k+2, … *… *al k-lea subșir este format din elementele din șir numerotate cu k, 2*k, 3*k, … Ordonați crescător fiecare dintre aceste subșiruri și afișa...

==Cerința==
Se dă un șir cu n elemente, numere naturale, numerotate începând cu 1 și un număr k. Considerăm k subșiruri ale șirului, astfel:
*primul subșir este format din elementele din șir numerotate cu 1, k+1, 2*k+1, …
*al doilea subșir este format din elementele din șir numerotate cu 2, k+2, 2*k+2, …
*…
*al k-lea subșir este format din elementele din șir numerotate cu k, 2*k, 3*k, …
Ordonați crescător fiecare dintre aceste subșiruri și afișați șirul obținut.
==Date de intrare==
Programul citește de la tastatură numerele n și k, iar apoi n numere naturale, reprezentând elementele șirului.
==Date de ieșire==
Programul va afișa pe ecran elementele șirului, separate prin exact un spațiu, după efectuarea operațiilor cerute.
==Restricții și precizări==
*1 ≤ k < n ≤ 1000;
*cele n numere citite vor fi mai mici decât 1.000.000.000;
==Exemplul 1==
;Intrare
:11 3
:7 5 4 3 1 6 8 9 11 10 2
;Ieșire
:3 1 4 7 2 6 8 5 11 10 9
:Datele de intrare corespund restricțiilor impuse.
==Exemplul 2==
;Intrare
:0
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0513 - K Sort 1
def sortare_intercalata(n, k, a):
# sortare intercalata
for i in range(k):
v = []
p = 0
for j in range(i, n, k):
v.append(a[j])
p += 1
v.sort()
p = 0
for j in range(i, n, k):
a[j] = v[p]
p += 1
return a

if __name__ == '__main__':
# citirea numarului de elemente din vector si a vectorului
n, k = map(int, input("Introduceti numarul de elemente si valoarea k: ").split())
a = list(map(int, input("Introduceti elementele vectorului (separate prin spatiu): ").split()))

# verificarea restrictiilor
if 1 <= n <= 1000 and all(1 <= x <= 10**9 for x in a):
a_sorted = sortare_intercalata(n, k, a)
# afisarea vectorului sortat
print("Datele de intrare corespund restricțiilor impuse.")
for i in range(n):
print(a_sorted[i], end=" ")
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

4146 - Sort 10

2023-04-29T11:03:05Z

Adina Timiș: Pagină nouă: ==Cerința== Se dă un vector cu n elemente, numere naturale. Afișați în ordine descrescătoare valorile divizibile cu 10 din acest vector. ==Date de intrare== Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului. ==Date de ieșire== Programul va afișa pe ecran valorile divizibile cu 10 din vector, în ordine descrescătoare, separate prin exact un spațiu. Dacă în vector nu există numere divizibile cu 10, atu...

==Cerința==
Se dă un vector cu n elemente, numere naturale. Afișați în ordine descrescătoare valorile divizibile cu 10 din acest vector.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului.
==Date de ieșire==
Programul va afișa pe ecran valorile divizibile cu 10 din vector, în ordine descrescătoare, separate prin exact un spațiu. Dacă în vector nu există numere divizibile cu 10, atunci se va afișa "NU EXISTA".
==Restricții și precizări==
*1 ≤ n ≤ 1000;
*cele n numere citite vor fi mai mici decât 1.000.000.000;
==Exemplul 1==
;Intrare
:7
:13 1 10 15 3 700 110
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
==Exemplul 2==
;Intrare
:0
:0
;Ieșire
:NU EXISTA
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="">
#4146 - Sort 10
def vector_desc():
# citirea numarului de elemente din vector
n = int(input("Introduceti numarul de elemente: "))
# initializarea vectorului si citirea elementelor
a = []
arr = input(f"Introduceti elementele vectorului: ").split()
for i in range(n):
x = int(arr[i])
# verificarea daca elementul este multiplu de 5 si numar par
if x % 5 == 0 and x % 2 == 0:
a.append(x)
return n, a

if __name__ == "__main__":
n, a = vector_desc()
# verificarea restrictiilor
if 1 <= n <= 1000 and all(1 <= x <= 10**9 for x in a):
# sortarea si afisarea vectorului
a.sort(reverse=True)
print("Datele de intrare corespund restricțiilor impuse.")
print(" ".join(str(x) for x in a))
else:
print("NU EXISTA")
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

0512 - Sort Max

2023-04-29T08:39:19Z

Adina Timiș:

==Cerința==
Se dă un vector cu n elemente, numere naturale distincte. Ordonați crescător elementele situate înaintea valorii maxime din vector și descrescător elementele situate după această valoare.
==Date de intrare==
Programul citește de la tastatură numerele n, iar apoi n numere naturale, reprezentând elementele vectorului.
==Date de ieșire==
Programul va afișa pe ecran elementele vectorului, separate prin exact un spațiu, după efectuarea operațiilor cerute.
==Restricții și precizări==
*1 ≤ n ≤ 1000;
*cele n numere citite vor fi mai mici decât 1.000.000.000;
==Exemplul 1==
;Intrare
:7
:13 1 10 15 3 7 11
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1 10 13 15 11 7 3
==Exemplul 2==
;Intrare
:0
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0512 - Sort Max
# definim o funcție pentru sortare
def sort_vector(n, a):
# găsim valoarea maximă și indexul acesteia în vector
max_val = max(a)
max_index = a.index(max_val)
# sortăm valorile de dinainte și de după valoarea maximă
a[:max_index] = sorted(a[:max_index])
a[max_index:] = sorted(a[max_index:], reverse=True)
# returnăm elementele vectorului, sortate
return a

if __name__ == "__main__":
# citim valorile de intrare
n = int(input())
a = list(map(int, input().split()))

# verificăm restricțiile
if n >= 2 and n <= 1000 and max(a) < 1000000000:
# dacă valorile de intrare respectă restricțiile impuse, sortăm vectorul și îl afișăm
print("Datele de intrare corespund restricțiilor impuse.")
a = sort_vector(n, a)
print(*a)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

0512 - Sort Max

2023-04-29T07:44:49Z

Adina Timiș: Pagină nouă: ==Cerința== Se dă un vector cu n elemente, numere naturale distincte. Ordonați crescător elementele situate înaintea valorii maxime din vector și descrescător elementele situate după această valoare. ==Date de intrare== Programul citește de la tastatură numerele n, iar apoi n numere naturale, reprezentând elementele vectorului. ==Date de ieșire== Programul va afișa pe ecran elementele vectorului, separate prin exact un spațiu, după efectuarea operațiilor cer...

==Cerința==
Se dă un vector cu n elemente, numere naturale distincte. Ordonați crescător elementele situate înaintea valorii maxime din vector și descrescător elementele situate după această valoare.
==Date de intrare==
Programul citește de la tastatură numerele n, iar apoi n numere naturale, reprezentând elementele vectorului.
==Date de ieșire==
Programul va afișa pe ecran elementele vectorului, separate prin exact un spațiu, după efectuarea operațiilor cerute.
==Restricții și precizări==
*1 ≤ n ≤ 1000;
*cele n numere citite vor fi mai mici decât 1.000.000.000;
==Exemplul 1==
;Intrare
:7
:13 1 10 15 3 7 11
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1 10 13 15 11 7 3
==Exemplul 2==
;Intrare
:0
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="">
#0512 - Sort Max
# definim o funcție pentru sortare
def sort_vector(n, a):
# găsim valoarea maximă și indexul acesteia în vector
max_val = max(a)
max_index = a.index(max_val)
# sortăm valorile de dinainte și de după valoarea maximă
a[:max_index] = sorted(a[:max_index])
a[max_index:] = sorted(a[max_index:], reverse=True)
# returnăm elementele vectorului, sortate
return a

# citim valorile de intrare
n = int(input())
a = list(map(int, input().split()))

# verificăm restricțiile
if n >= 2 and n <= 1000 and max(a) < 1000000000:
# dacă valorile de intrare respectă restricțiile impuse, sortăm vectorul și îl afișăm
print("Datele de intrare corespund restricțiilor impuse.")
a = sort_vector(n, a)
print(*a)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

0511 - K Sort

2023-04-28T22:42:35Z

Adina Timiș:

==Cerința==
Se dă un vector cu n elemente, numere naturale și un număr k. Ordonați crescător primele k elemente ale vectorului și descrescător ultimele n-k elemente.
==Date de intrare==
Programul citește de la tastatură numerele n și k, iar apoi n numere naturale, reprezentând elementele vectorului.
==Date de ieșire==
Programul va afișa pe ecran elementele vectorului, separate prin exact un spațiu, după efectuarea operațiilor cerute.
==Restricții și precizări==
*1 ≤ k < n ≤ 1000
*cele n numere citite vor fi mai mici decât 1.000.000.000
==Exemplul 1==
;Intrare
:7 3
:13 1 10 15 3 7 11
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1 10 13 15 11 7 3
==Exemplul 2==
;Intrare
:0 7
:1 10 13 15 11 7 3
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0511 - K Sort
# definim functia care va citi si va returna un vector de n elemente, dat de la tastatura
def citeste_vector(n):
return list(map(int, input().split()))
# definim functia care va returna primele k elemente in ordine crescatoare dintr-un vector dat
def ordonare_primele_k_elemente(k, vector):
return sorted(vector[:k])
# definim functia care va returna ultimele n-k elemente in ordine descrescatoare
# dintr-un vector dat
def ordonare_ultimele_n_minus_k_elemente(n, k, vector):
return sorted(vector[k:], reverse=True)

if __name__ == '__main__':
n, k = map(int, input().split())
vector = citeste_vector(n)
# verificarea restrictiilor
if n < 2 or n > 1000 or k < 1 or k >= n or any(x >= 1000000000 for x in vector):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
primele_k_elemente = ordonare_primele_k_elemente(k, vector)
ultimele_n_minus_k_elemente = ordonare_ultimele_n_minus_k_elemente(n, k, vector)
print(*(primele_k_elemente + ultimele_n_minus_k_elemente)) # afisam rezultatul

</syntaxhighlight>

0618 - Inaltimi

2023-04-28T22:34:54Z

Adina Timiș:

==Cerința==
Se dau înălțimile a n copii, numerotați de la 1 la n, exprimate prin numere naturale. Afișați numerele de ordine ale copiilor în ordinea crescătoare a înălțimii lor.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații, reprezentând, în ordine, înălțimile copiilor.
==Date de ieșire==
Programul va afișa pe ecran n numere naturale distincte cuprinse între 1 și n, separate prin exact un spațiu, reprezentând numerele de ordine ale copiilor în ordinea crescătoare a înălțimii.
==Restricții și precizări==
*1 ≤ n ≤ 1000
*înălțimile copiilor vor fi numere naturale distincte din intervalul [1, 10.000]
==Exemplul 1==
;Intrare
:7
:8 20 16 14 10 4 12
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:6 1 5 7 4 3 2
==Exemplul 2==
;Intrare
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0618 - Inaltimi
# definim o functie pentru citirea inaltimilor, aceasta va returna o lista de numere intregi
def citeste_inaltimi(n):
inaltimi = list(map(int, input().split()))
return inaltimi
# definim o functie pentru ordonarea crescatoare a inaltimilor si afisarea numerelor corespunzatoare
def ordonare_crescatoare_si_afisare(n, inaltimi):
numere_ordine = list(range(1, n+1)) # definim o lista de numere de la 1 la n
for i in range(n):
for j in range(i+1, n):
if inaltimi[j] < inaltimi[i]: # comparam inaltimile iar daca sunt in ordine gresita, le
# interschimbam
inaltimi[i], inaltimi[j] = inaltimi[j], inaltimi[i]
numere_ordine[i], numere_ordine[j] = numere_ordine[j], numere_ordine[i]
print(*numere_ordine) # afisam numerele, ordonate crescator

if __name__ == '__main__':
n = int(input()) # citim numarul de inaltimi
inaltimi = citeste_inaltimi(n) # apelam functia de citire a inaltimilor
if n < 1 or n > 1000 or (min(inaltimi) < 1 or max(inaltimi) > 10000): # verificarea
# restrictiilor
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
ordonare_crescatoare_si_afisare(n, inaltimi) # apelam functia de ordonare si afisare a
# numerelor

</syntaxhighlight>

0621 - Numar Lipsa

2023-04-28T22:20:59Z

Adina Timiș:

==Cerința==
Se dă un șir cu n numere naturale. Determinați cel mai mic număr natural nenul care nu apare printre numerele date.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale.
==Date de ieșire==
Programul va afișa pe ecran numărul determinat X.
==Restricții și precizări==
*1 ≤ n ≤ 100;
*cele n numere citite vor fi mai mici decât 1.000.000.000;
==Exemplul 1==
;Intrare
:5
:4 2 7 6 1
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:Cel mai mic număr natural nenul care nu apare în șirul dat este: 3
==Exemplul 2==
;Intrare
:0
:1 2 4
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0621 - Numar Lipsa
def gaseste_numar(n, numere): # definim o functie care cauta cel mai mic numar natural nenul care
# nu apare in lista data
numere_date = set(numere) # convertim lista de numere intr-un set pentru a elimina dublurile
for i in range(1, max(numere_date) + 2): # iteram prin numerele de la 1 pana la maximul din set
# plus 2, trebuie sa cautam pana la urmatorul numar
# natural nenul
if i not in numere_date: # daca numarul nu se gaseste in set, atunci il returnam
return i

if __name__ == "__main__":
n = int(input("Introduceți numărul de cifre din șir: ")) # citim numarul de cifre din sir si
# lista de numere de la tastatura
numere = list(map(int, input("Introduceți cifrele separate prin spațiu: ").split()))
if n < 1 or n > 100 or max(numere) > 1000000000: # verificarea restrictiilor
print("Datele de intrare nu corespund restricțiilor impuse.")

else:
print("Datele de intrare corespund restricțiilor impuse.")
X = gaseste_numar(n, numere) # apelam functia si afisam rezultatul
print(f"Cel mai mic număr natural nenul care nu apare în șirul dat este: {X}")

</syntaxhighlight>

1573 - Verif Progresie

2023-04-28T22:13:24Z

Adina Timiș: /* Rezolvare */

==Cerința==
Se dau n valori naturale. Stabiliți dacă există o progresie aritmetică cu rația număr natural mai mare decât 1 din care să facă parte toate aceste valori.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații.
==Date de ieșire==
Programul va afișa pe ecran mesajul DA , dacă există progresia aritmetică cerută, respectiv NU în caz contrar.
==Restricții și precizări==
*1 ≤ n ≤ 2500;
*cele n numere citite vor fi mai mici decât 2.000.000.000;
==Exemplul 1==
;Intrare
:6
:2 10 12 16 20 18
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:DA
==Exemplul 2==
;Intrare
:0
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1573 - Verif Progresie
def progresie_aritmetica(numere): # definim o functie ce cauta o progresie progresie_aritmetica
# formata din trei elemente intr-o lista de numere
n = len(numere)
if n < 3:
return None
for i in range(n):
for j in range(i+1, n):
for k in range(j+1, n):
if numere[i] + numere[k] == 2 * numere[j]:
return [numere[i], numere[j], numere[k]]
return None

if __name__ == "__main__":
n = int(input("Introduceți numărul de valori: ")) # citim numărul de valori și lista de numere
# de la tastatură
numere = list(map(int, input("Introduceți valorile, separate prin spațiu: ").split()))
if n < 1 or n > 2500 or max(numere) > 2000000000: # verificarea restrictiilor
print("Datele de intrare nu corespund restricțiilor impuse.")
if progresie_aritmetica(numere): # apelam functia progresie_aritmetica si afisam DA daca
# exista o progresie aritmetica si NU in caz contrar
print("NU")
else:
print("Datele de intrare corespund restricțiilor impuse.")
print("DA")

</syntaxhighlight>

1573 - Verif Progresie

2023-04-28T22:11:43Z

Adina Timiș:

==Cerința==
Se dau n valori naturale. Stabiliți dacă există o progresie aritmetică cu rația număr natural mai mare decât 1 din care să facă parte toate aceste valori.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații.
==Date de ieșire==
Programul va afișa pe ecran mesajul DA , dacă există progresia aritmetică cerută, respectiv NU în caz contrar.
==Restricții și precizări==
*1 ≤ n ≤ 2500;
*cele n numere citite vor fi mai mici decât 2.000.000.000;
==Exemplul 1==
;Intrare
:6
:2 10 12 16 20 18
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:DA
==Exemplul 2==
;Intrare
:0
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
:
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#1573 - Verif Progresie
def progresie_aritmetica(numere): # definim o functie ce cauta o progresie progresie_aritmetica
# formata din trei elemente intr-o lista de numere
n = len(numere)
if n < 3:
return None
for i in range(n):
for j in range(i+1, n):
for k in range(j+1, n):
if numere[i] + numere[k] == 2 * numere[j]:
return [numere[i], numere[j], numere[k]]
return None

if __name__ == "__main__":
n = int(input("Introduceți numărul de valori: ")) # citim numărul de valori și lista de numere de la tastatură
numere = list(map(int, input("Introduceți valorile, separate prin spațiu: ").split()))
if n < 1 or n > 2500 or max(numere) > 2000000000: # verificarea restrictiilor
print("Datele de intrare nu corespund restricțiilor impuse.")
if progresie_aritmetica(numere): # apelam functia progresie_aritmetica si afisam DA daca exista o progresie aritmetica si NU in caz contrar
print("NU")
else:
print("Datele de intrare corespund restricțiilor impuse.")
print("DA")

</syntaxhighlight>

0812 - Gen Mat 19

2023-04-28T21:53:01Z

Adina Timiș:

==Cerința==
Scrieţi un program care citeşte de la tastatură un număr natural n şi construieşte în memorie o matrice cu n linii şi n coloane în care:
*toate elementele de pe prima coloană au valoarea 1;
*ultima linie conţine, în ordine strict crescătoare, numerele naturale din intervalul [1, n];
*oricare alt element este obţinut prin însumarea celor două elemente vecine cu el, aflate pe linia imediat următoare şi pe aceeaşi coloană cu el, respectiv pe aceeaşi linie cu el şi pe coloana anterioară.
==Date de intrare==
Programul citește de la tastatură numărul n.
==Date de ieșire==
Programul afișează pe ecran matricea construită, câte o linie a matricei pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spaţiu.
==Restricții și precizări==
*3 ≤ n ≤ 15
==Exemplul 1==
;Intrare
:4
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1 5 15 35
:1 4 10 20
:1 3 6 10
:1 2 3 4
==Exemplul 2==
;Intrare
:2 20
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0812 - Gen Mat 19
def construieste_matrice(n): # definim functia care construieste matricea
A = [[0 for i in range(n)] for j in range(n)] # initializam matricea cu valori de 0

for i in range(n): # adaugam 1 pe prima coloana
A[i][0] = 1
# adaugam numerele de la 1 la n pe ultima linie
for i in range(n):
A[n-1][i] = i+1

for i in range(n-2, -1, -1): # parcurgem matricea de jos in sus si de la dreapta la stanga si
# adaugam elementele
for j in range(1, n):
A[i][j] = A[i+1][j] + A[i][j-1]

return A

if __name__ == "__main__":
n = int(input("Introduceti n: "))
if n < 3 or n > 15: #verificarea restrictiilor
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
A = construieste_matrice(n)
for rand in A:
print(" ".join(str(x) for x in rand)) # afisam matricea sub forma de tabela

</syntaxhighlight>

3304 - Doua zeci Doua zeci

2023-04-28T21:43:44Z

Adina Timiș:

==Cerința==
Vasilica şi Viorica au primit cadou de la moşul un joc cu n jetoane pe care sunt scrise nişte numere. Cerinţa jocului este să afle dacă se pot alege câteva jetoane astfel încât produsul numerelor să fie 2020.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații.
==Date de ieșire==
Programul va afișa pe ecran DA dacă pot fi alese câteva jetoane cu produsul numerelor 2020, sau NU în caz contrar.
==Restricții și precizări==
*1 ≤ n ≤ 100;
*cele n numere citite vor fi numere naturale mai mici decât 2021;
==Exemplul 1==
;Intrare
:5
:1 2 2020 3 7
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:DA
==Exemplul 2==
;Intrare
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
:NU
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#3304 - Doua zeci Doua zeci
def cauta_produs(numere):
for i in range(len(numere)): # parcurgem lista numere
for j in range(i+1, len(numere)): # cautam in continuare numere distincte
if numere[i] * numere[j] == 2020: # daca gasim o pereche a carei produs este 2020
return True
return False

if __name__ == "__main__": # se verifica daca input-ul este valid, atunci se citeste o lista de
# numere de lungime n si se verifica daca exista o pereche de numere a
# caror produs este 2020, atunci se afiseaza "DA", altfel, "NU"
n = int(input("Introduceti numarul de jetoane: "))
if n < 1 or n > 100:
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
numere = list(map(int, input("Introduceti numerele de pe jeton, separate prin spatiu: ").split()))
if cauta_produs(numere):
print("DA")
else:
print("NU")

</syntaxhighlight>

0993 - Gen Mat 20

2023-04-28T21:37:28Z

Adina Timiș:

==Cerința==
Scrieţi un program care citeşte de la tastatură un număr natural n şi construieşte în memorie o matrice cu n linii şi n coloane în care fiecare linie a matricei să conţină o permutare a mulţimii {1,2,...,n}, astfel încât pe linii diferite ale matricei să se afle permutări diferite.
==Date de intrare==
Programul citește de la tastatură numărul n.
==Date de ieșire==
Programul afișează pe ecran matricea construită, câte o linie a matricei pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spaţiu.
==Restricții și precizări==
*3 ≤ n ≤ 15
*orice matrice afișată care respectă condițiile problemei este corectă
==Exemplul 1==
;Intrare
:4
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:1 4 2 3
:3 1 2 4
:3 4 1 2
:2 4 1 3
==Exemplul 2==
;Intrare
:2
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0993 - Gen Mat 20
import random

def construieste_matrice(n):
A = [] # initializam matricea goala
for i in range(n): # parcurgem liniile matricei
permutare = list(range(1, n+1)) # initializam o lista cu numerele de la 1 la n
random.shuffle(permutare) # amestecam aleator elementele listei permutare
A.append(permutare) # adaugam permutarea in matricea A
return A

if __name__ == "__main__":
n = int(input("Introduceti n: "))
if n < 3 or n > 15: # verificam daca n respecta restrictiile impuse
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
A = construieste_matrice(n) # generam matricea conform dimensiunii n
for rand in A: # afisam matricea linie cu linie
print(" ".join(str(x) for x in rand)) # convertim fiecare element la sir il afisam

</syntaxhighlight>

2841 - Gen Mat 27

2023-04-28T21:28:29Z

Adina Timiș:

==Cerința==
Scrieţi un program care citește de la tastatură două numere naturale, m și n (2 ≤ m ≤ 20, 2 ≤ n ≤ 20), și construiește în memorie un tablou bidimensional A, cu m linii și n coloane, astfel încât parcurgându-l, linie cu linie, de sus în jos și fiecare linie de la stânga la dreapta, să se obțină șirul primelor n·m numere naturale, pare, care nu sunt divizibile cu 5, ordonat strict crescător. Programul afişează pe ecran tabloul obținut, fiecare linie a tabloului pe câte o linie a ecranului, elementele de pe aceeași linie fiind separate prin câte un spațiu.
==Date de intrare==
Programul citește de la tastatură numerele m și n.
==Date de ieșire==
Programul afișează pe ecran tabloul construit, câte o linie a matricei pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spaţiu.
==Restricții și precizări==

* 2 ≤ m, n ≤ 20

==Exemplul 1==
;Intrare
:4 3
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:2 4 6
:8 12 14
:16 18 22
:24 26 28
==Exemplul 2==
;Intrare
:0 21
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#2841 - Gen Mat 27
# definim functia care returneaza daca un numar este par si nu este multiplu de 5
def numar_valid(num):
return num % 2 == 0 and num % 5 != 0

# definim functia matrice care construieste o matrice de m linii si n coloane
def matrice(m, n):
A = [] # initializam lista goala A care va contine randurile matricei
numar_curent = 2 # incepem de la 2, primul numar valid
for i in range(m): # parcurgem liniile matricei
rand = [] # initializam lista goala
for j in range(n): # parcurgem coloanele matricei
while not numar_valid(numar_curent): # cautam primul numar valid, daca nu gasim, il cautam pe urmatorul
numar_curent += 1
rand.append(numar_curent) # adaugam numarul valid gasit in randul curent
numar_curent += 1 # trecem la urmatorul numar pentru a-l valida si a adauga in randul curent
A.append(rand) # adaugam randul curent in matricea finala A
return A

if __name__ == "__main__":
m = int(input("Introduceți numărul de linii: "))
n = int(input("Introduceți numărul de coloane: "))
if m < 2 or m > 20 or n < 2 or n > 20: # verificam restrictiile
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
A = matrice(m, n) # generam matricea conform dimensiunilor introduse
for rand in A: # afisam matricea linie cu linie
print(" ".join(str(x) for x in rand))
</syntaxhighlight>

0226 - Gen Mat 13

2023-04-25T19:46:09Z

Adina Timiș:

Programul afișează pe ecran matricea construită, câte o linie a matricei pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spaţiu.
==Restricții și precizări==
*2≤n≤24
*1<a<n
*1<b<n
*liniile şi coloanele sunt numerotate de la 1
==Exemplul 1==
;Intrare
:5 4 3
;Iesire
:1 1 0 2 2
:1 1 0 2 2
:1 1 0 2 2
:0 0 0 0 0
:3 3 0 4 4
==Exemplul 2==
;Intrare
:0 0 0

;Iesire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0226 - Gen Mat 13
def construieste_matrice(n, a, b):
# inițializăm matricea cu zero
matrice = [[0 for _ in range(n)] for _ in range(n)]
# parcurgem fiecare element din matrice
for i in range(n):
for j in range(n):
# dacă elementul este pe poziția a sau b, setăm valoarea sa la zero
if i == a-1 or j == b-1:
matrice[i][j] = 0
# dacă elementul se află deasupra și la stânga (a,b), setăm valoarea la 1
elif i < a-1 and j < b-1:
matrice[i][j] = 1
# dacă elementul se află deasupra și la dreapta elementului (a,b), setăm valoarea la 2
elif i < a-1 and j > b-1:
matrice[i][j] = 2
# dacă elementul se află sub (a,b) și la stânga, setăm valoarea sa la 3
elif i > a-1 and j < b-1:
matrice[i][j] = 3
# dacă elementul se află sub (a,b) și la dreapta, setăm valoarea la 4
else:
matrice[i][j] = 4

return matrice

if __name__ == '__main__':
# citim de la tastatură dimensiunea matricei și pozițiile a și b
n = int(input("Introduceți dimensiunea n a matricei: "))
a = int(input("Introduceți poziția liniei a: "))
b = int(input("Introduceți poziția coloanei b: "))

# verificăm restricțiile
if a < 1 or a > n or b < 1 or b > n:
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
# construim matricea și o afișăm
matrice = construieste_matrice(n, a, b)
print()
for linie in matrice:
print(*linie)
</syntaxhighlight>

3458 - Sin Cos

2023-04-25T19:22:11Z

Adina Timiș: /* Rezolvare */

==Cerința==
Se dă un număr natural x, reprezentând mărimea în grade sexagesimale a unui unghi. Să se afișeze sin(x) și cos(x).
==Date de intrare==
Programul citește de la tastatură numărul x.
==Date de ieșire==
Programul va afișa pe ecran două numere separate printr-un spațiu, reprezentând sin(x) și cos(x).
==Restricții și precizări==
*1 ≤ x ≤ 180;
*se recomandă afișarea rezultatelor cu cel puțin trei zecimale;
==Exemplul 1==
;Intrare
:30
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:0.5 0.866
==Exemplul 2==
;Intrare
:181
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#3458 - Sin Cos
import math

def calculeaza_valori(x):
sin_x = round(math.sin(math.radians(x)), 3) # calculăm valoarea sin și o rotunjim la 3 zecimale
cos_x = round(math.cos(math.radians(x)), 3) # calculăm cos și rotunjim la 3 zecimale
return sin_x, cos_x # returnăm cele două valori

if __name__ == "__main__":
x = int(input("Introduceți unghiul x în grade: ")) # citim unghiul x, de la tastatură
if x < 0 or x > 180: # verificăm restricțiile
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
sin_x, cos_x = calculeaza_valori(x) # apelăm funcția pentru a calcula valorile sin si cos
print(sin_x, cos_x) # afișăm valorile obținute
</syntaxhighlight>

3458 - Sin Cos

2023-04-25T19:20:54Z

Adina Timiș:

==Cerința==
Se dă un număr natural x, reprezentând mărimea în grade sexagesimale a unui unghi. Să se afișeze sin(x) și cos(x).
==Date de intrare==
Programul citește de la tastatură numărul x.
==Date de ieșire==
Programul va afișa pe ecran două numere separate printr-un spațiu, reprezentând sin(x) și cos(x).
==Restricții și precizări==
*1 ≤ x ≤ 180;
*se recomandă afișarea rezultatelor cu cel puțin trei zecimale;
==Exemplul 1==
;Intrare
:30
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:0.5 0.866
==Exemplul 2==
;Intrare
:181
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#3458 - Sin Cos
import math

def calculeaza_valori(x):
sin_x = round(math.sin(math.radians(x)), 3) # calculam valoarea sin si o rotunjim la 3 zecimale
cos_x = round(math.cos(math.radians(x)), 3) # calculam valoarea cos si o rotunjim la 3 zecimale
return sin_x, cos_x # returnam cele doua valori

if __name__ == "__main__":
x = int(input("Introduceți unghiul x în grade: ")) # citim unghiul x de la tastatură
if x < 0 or x > 180: # verificăm restricțiile
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
sin_x, cos_x = calculeaza_valori(x) # apelăm funcția pentru a calcula valorile sin si cos
print(sin_x, cos_x) # afișăm valorile obținute
</syntaxhighlight>

0085 - Interclasare Asterisc

2023-04-25T19:12:17Z

Adina Timiș: /* Rezolvare */

==Cerința==
Să se scrie un program care citește un text și inserează după fiecare vocală caracterul "*".
==Date de intrare==
Programul citeşte de la tastatură un şir de caractere, reprezentând textul dat.
==Date de ieșire==
Programul afişează pe ecran textul obținut.
==Restricții și precizări==
*şirul de caractere citit va conţine cel mult 100 de caractere, litere mici ale alfabetului englez și spații;
*se consideră vocale următoarele caractere: a, e, i, o, u;
*dacă cuvântul nu conține vocale se va afișa doar mesajul "FARA VOCALE";
==Exemplul 1==
;Intrare
:ana are mere
;Ieșire
:a*na* a*re* me*re*
:Datele de intrare corespund restricțiilor impuse.
==Exemplul 2==
;Intrare
:QWRTSFG
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
:FARA VOCALE
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#0085 - Interclasare Asterisc
# definim funcția care primește un text și inserează un asterisc după fiecare vocală
# cu excepția literelor majuscule
def inserare_vocale(text):
vocale = "aeiou" # definim o variabilă care conține toate vocalele
text_nou = "" # definim un șir vid pentru a stoca textul modificat
for litera in text:
text_nou += litera # adăugăm litera la textul modificat
if litera.lower() in vocale: # dacă litera este vocală, adăugăm un asterisc după ea
text_nou += "*"
return text_nou # returnăm textul modificat

if __name__ == '__main__':
text = input("Introduceți textul: ")
text_fara_spatii = text.replace(" ", "") # eliminăm spațiile din text
if not any(litera.lower() in "aeiou" for litera in text_fara_spatii): # verificăm dacă textul
# conține cel puțin o vocală
print("Datele de intrare nu corespund restricțiilor impuse.")
print("FARA VOCALE")
else:
# apelăm funcția 'inserare_vocale' pentru a modifica textul
text_inserat = inserare_vocale(text)
print(text_inserat) # afișăm textul modificat
print("Datele de intrare corespund restricțiilor impuse.")
</syntaxhighlight>

0085 - Interclasare Asterisc

2023-04-25T19:09:07Z

Adina Timiș:

4149 - Inlocuire Max

2023-04-25T18:56:35Z

Adina Timiș:

==Cerința==
Se dă un vector cu n numere naturale. Să se înlocuiască fiecare element cu cel mai mare număr care se poate obține din cifrele lui și să se afișeze elementele astfel obținute în ordine inversă.
==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spaţii, reprezentând elementele vectorului.
==Date de ieșire==
Programul afișează pe ecran elementele vectorului, după înlocuire, în ordine inversă, separate prin exact un spațiu.
==Restricții și precizări==
*1 ≤ n ≤ 200;
*elementele vectorului vor fi cuprinse între 1 și 1.000.000
==Exemplul 1==
;Intrare
:4
:170 104 24 2500
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:5200 42 410 710
==Exemplul 2==
;Intrare
:0
:0
;Ieșire
:Datele de intrare nu corespund restricțiilor impuse.
==Rezolvare==
<syntaxhighlight lang="python" line="1">
#4149 - Inlocuire Max
# funcția sortează cifrele numărului primit, în ordine descrescătoare, iar mai apoi returnează
# numărul astfel obținut
def transform(numar):
cifre = [int(x) for x in str(numar)]
cifre.sort(reverse=True)
return int(''.join(map(str, cifre)))

if __name__ == '__main__':
# citirea numărului de elemente
n = int(input())

# citirea listei de elemente
v = [int(x) for x in input().split()]

# verificarea restricțiilor de intrare
if n >= 1 and n <= 200 and all(x > 0 and x <= 1000000 for x in v):
print("Datele de intrare corespund restricțiilor impuse.")

# aplicarea functiei de transformare, la fiecare element din listă
v_transform = [transform(x) for x in v]

# afișarea valorilor transformate, în ordine inversă
for i in range(n - 1, -1, -1):
print(v_transform[i], end=' ')
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>