https://wiki.universitas.ro/api.php?action=feedcontributions&feedformat=atom&user=Tuca+Liviu+RazvanBitnami MediaWiki - User contributions [en]2026-05-01T03:38:18ZUser contributionsMediaWiki 1.42.1https://wiki.universitas.ro/index.php?title=E:14742&diff=9530E:147422024-01-16T18:25:25Z<p>Tuca Liviu Razvan: Pagină nouă: '''E:14742 (Liliana Puț, Sighetul Marmației)''' ''a) Arătati că oricare ar fi numerele reale a, b, c avem |a + b| + |a + c| ≥ |b - c|.'' ''b) Demonstrați că pentru orice număr real X avem |x + 1| + |x + 2| + |x + 3| + ... + |x + 2014| ≥ <math>1007^2</math>.'' '''Soluție''' a) Arătăm că |x| + |y| ≥ |x - y|, (1). Cum |x - y| = |y - x|, relația (1) este simetrică în x și y și este suficient să analizăm cazul x ≥ y. Mai mult, deoar...</p>
<hr />
<div>'''E:14742 (Liliana Puț, Sighetul Marmației)'''<br />
<br />
''a) Arătati că oricare ar fi numerele reale a, b, c avem<br />
|a + b| + |a + c| ≥ |b - c|.''<br />
''b) Demonstrați că pentru orice număr real X avem<br />
|x + 1| + |x + 2| + |x + 3| + ... + |x + 2014| ≥ <math>1007^2</math>.''<br />
<br />
'''Soluție'''<br />
<br />
a) Arătăm că |x| + |y| ≥ |x - y|, (1). Cum |x - y| = |y - x|, relația (1) este simetrică în x și y și este suficient să analizăm cazul x ≥ y. Mai mult, deoarece |x| = | - x|, vom analiza numai cazul x ≥ 0 și y ≥ 0, iar în acest caz x + y ≥ x - y conduce la y ≥ 0, care este adevărată. Luând x = a + b și y = a + c, obținem inegalitatea din enunț.<br />
<br />
b) Membrul stâng al inegalității are 2014 termeni. Grupăm câte doi termeni egal depărtați de capete și conform punctului a) avem |x + 2015 - k| + |x + k| ≥ |x + 2015 - k - x - k| = 2015 - 2k, pentru orice k ∈ {1, 3, 5, ... , 1007}. Astfel, suma este mai mare sau egală cu 2013 + 2011 + ... + 1 = (2013 + 1) + (2011 + 3) + ... + (1009 + 1005) + 1007 = 2014 • 503 + 1007 = <math>1007^2</math>.</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0453_-_Distincte1&diff=55720453 - Distincte12023-04-29T19:22:05Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se citesc de la tastatură '''trei numere naturale'''. Să se determine numărul de valori '''distincte'''. ==Date de intrare== Programul va citi de la tastatură '''trei numere naturale'''. ==Date de ieșire== Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran numărul de valori '''distincte''' care apar.În caz contrar, se va afișa pe ecran: "Datele de intrare nu...</p>
<hr />
<div>==Cerință==<br />
Se citesc de la tastatură '''trei numere naturale'''. Să se determine numărul de valori '''distincte'''.<br />
<br />
==Date de intrare==<br />
Programul va citi de la tastatură '''trei numere naturale'''.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran numărul de valori '''distincte''' care apar.În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Numerele citite sunt cuprinse între '''0 și 1.000.000.000''', inclusiv.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:100 41 100<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:2<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(numar1, numar2, numar3):<br />
if 0 <= numar1 <= 1000000000 and 0 <= numar2 <= 1000000000 and 0 <= numar3 <= 1000000000:<br />
return True<br />
return False<br />
<br />
<br />
def distincte(numar1, numar2, numar3):<br />
if numar1 == numar2 == numar3:<br />
return 1<br />
elif numar1 == numar2 or numar1 == numar3 or numar2 == numar3:<br />
return 2<br />
else:<br />
return 3<br />
<br />
<br />
if __name__ == "__main__":<br />
numar1, numar2, numar3 = map(int, input().split())<br />
if validare(numar1, numar2, numar3):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(distincte(numar1, numar2, numar3))<br />
else:<br />
print(<br />
"Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight><br />
<br />
==Explicatie==<br />
Acest cod Python definește două funcții, validare și distincte, și le utilizează pentru a verifica dacă trei numere introduse la intrare sunt valide și distincte.<br />
<br />
Funcția validare primește trei argumente, numar1, numar2, numar3, și verifică dacă fiecare dintre ele se încadrează în intervalul [0, 1000000000]. Dacă toate cele trei numere sunt valide, atunci funcția returnează True. În caz contrar, funcția returnează False.<br />
<br />
Funcția distincte primește trei argumente, numar1, numar2, numar3, și verifică dacă cele trei numere sunt distincte. Dacă toate cele trei numere sunt egale, funcția returnează 1. Dacă două dintre cele trei numere sunt egale, funcția returnează 2. În caz contrar, funcția returnează 3.<br />
<br />
În funcția principală (if __name__ == "__main__":), se citește input-ul de la utilizator și se verifică dacă acestea sunt valide, folosind funcția validare. Dacă acestea sunt valide, se afișează un mesaj de confirmare, "Datele de intrare corespund restricțiilor impuse.", și se afișează numărul de numere distincte folosind funcția distincte. În caz contrar, se afișează mesajul "Datele de intrare nu corespund restricțiilor impuse." pentru a indica faptul că datele introduse nu sunt valide.</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0448_-_Cif_Ord&diff=55690448 - Cif Ord2023-04-29T19:18:12Z<p>Tuca Liviu Razvan: /* Rezolvare ver. 1 */</p>
<hr />
<div>==Cerință==<br />
Se citește de la tastatură un '''număr natural''' de 3 cifre. Să se afișeze '''cifrele''' sale în ordine '''crescătoare'''.<br />
<br />
==Date de intrare==<br />
Programul va citi de la tastatură un '''număr natural''', de 3 cifre.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran cifrele numărului citit, în ordine '''crescătoare''', separate prin exact un spațiu.În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Numărul citit de la tastatură este '''natural''', de '''3 cifre'''<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:101<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:0 1 1<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(numar): # Cream o functie de validare ca sa ne asiguram ca numarul introdus se afla in restrictiile impuse<br />
if 100 <= numar <= 999:<br />
return True<br />
return False<br />
<br />
<br />
def cifre_ordonate(numar):<br />
cifre = [int(d) for d in str(numar)] # transforma numarul intr-o lista de cifre<br />
cifre.sort() # sorteaza cifrele in ordine crescatoare<br />
rezultat = ' '.join(map(str, cifre)) # transforma cifrele in string-uri si le concateneaza cu un spatiu intre ele<br />
print(rezultat)<br />
<br />
<br />
if __name__ == "__main__":<br />
numar = int(input('Introduceti un numar de 3 cifre: ')) # Citim un numar de la tastatura<br />
if validare(numar): # Aplicam functia de validare pentru numarul introdus<br />
print("Datele de intrare corespund restricțiilor impuse.") # Afisam un mesaj de confirmare a validarii numarului<br />
cifre_ordonate(numar) # Aplicam functia de ordonare a cifrelor numarului<br />
else:<br />
print(<br />
"Datele de intrare nu corespund restricțiilor impuse.") # Afisam un mesaj de eroare pentru numarul invalid.<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0448_-_Cif_Ord&diff=55660448 - Cif Ord2023-04-29T19:11:54Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se citește de la tastatură un '''număr natural''' de 3 cifre. Să se afișeze '''cifrele''' sale în ordine '''crescătoare'''. ==Date de intrare== Programul va citi de la tastatură un '''număr natural''', de 3 cifre. ==Date de ieșire== Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran cifrele numărului citit, în ordine '''crescătoare''', separate prin exac...</p>
<hr />
<div>==Cerință==<br />
Se citește de la tastatură un '''număr natural''' de 3 cifre. Să se afișeze '''cifrele''' sale în ordine '''crescătoare'''.<br />
<br />
==Date de intrare==<br />
Programul va citi de la tastatură un '''număr natural''', de 3 cifre.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran cifrele numărului citit, în ordine '''crescătoare''', separate prin exact un spațiu.În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Numărul citit de la tastatură este '''natural''', de '''3 cifre'''<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:101<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:0 1 1<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(numar): # Cream o functie de validare ca sa ne asiguram ca numarul introdus se afla in restrictiile impuse<br />
if 100 <= numar <= 999:<br />
return True<br />
return False<br />
<br />
<br />
def cifre_ordonate(numar):<br />
cifre = [int(d) for d in str(numar)] # transforma numarul intr-o lista de cifre<br />
cifre.sort() # sorteaza cifrele in ordine crescatoare<br />
rezultat = ' '.join(map(str, cifre)) # transforma cifrele in string-uri si le concateneaza cu un spatiu intre ele<br />
print(rezultat)<br />
<br />
<br />
if __name__ == "__main__":<br />
numar = int(input('Introduceti un numar de 3 cifre: ')) # Citim un numar de la tastatura<br />
if validare(numar): # Aplicam functia de validare pentru numarul introdus<br />
print(<br />
"Datele de intrare corespund restricțiilor impuse.") # Afisam un mesaj de confirmare a validarii numarului<br />
cifre_ordonate(numar) # Aplicam functia de ordonare a cifrelor numarului<br />
else:<br />
print(<br />
"Datele de intrare nu corespund restricțiilor impuse.") # Afisam un mesaj de eroare pentru numarul invalid.<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0793_-_Sum_Prod&diff=55650793 - Sum Prod2023-04-29T19:02:02Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dau trei numere naturale '''a b c'''. Să se determine cea mai mare valoare care se poate obține prin '''înmulțirea''' a două dintre numere și '''adunarea''' rezultatului cu al treilea. ==Date de intrare== Programul citește de la tastatură numerele '''a b c'''. ==Date de ieșire== Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran numărul '''R''', reprezen...</p>
<hr />
<div>==Cerință==<br />
Se dau trei numere naturale '''a b c'''. Să se determine cea mai mare valoare care se poate obține prin '''înmulțirea''' a două dintre numere și '''adunarea''' rezultatului cu al treilea.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele '''a b c'''.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran numărul '''R''', reprezentând '''maximul''' determinat.În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Numerele '''a, b, c''' sunt incluse intre 0 si 1000, inclusiv.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:3 2 4<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:14<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(a, b, c): # Punem conditia ca numerele sa fie incluse intre 0 si 1000, inclusiv<br />
if 0 <= a <= 1000 and 0 <= b <= 1000 and 0 <= c <= 1000:<br />
return True<br />
return False<br />
<br />
<br />
def sum_prod(a, b, c):<br />
# Determinăm produsul maxim dintre două dintre cele trei numere date<br />
max_prod = max(a * b, b * c, c * a)<br />
# Adunăm produsul maxim la cel de-al treilea număr<br />
R = max_prod + min(a, b, c)<br />
return R<br />
<br />
<br />
if __name__ == "__main__":<br />
a, b, c = map(int, input().split()) # Citim numerele de la tastatura<br />
if validare(a, b, c): # Aplicam functia de validare pe numerele introduse<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(sum_prod(a, b, c)) # Apelam functia sum_prod ca sa aflam rezultatul<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=2606_-_Luni_R%C4%83mase&diff=55202606 - Luni Rămase2023-04-29T16:47:33Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se citește de la tastatură un '''număr natural''' ce reprezintă o lună a anului (dacă citim 3 ne referim la a treia lună, deci Martie). Programul va afișa (câte unul pe rând) numele '''lunilor rămase''' în acel an după cea citită. Se garantează că se introduce de la intrare o valoare cuprinsă între '''1 și 11'''. ==Date de intrare== Programul citește de la tastatură un număr '''l'''. ==Date de ieșire== Dacă datele sunt introduse corect,...</p>
<hr />
<div>==Cerință==<br />
Se citește de la tastatură un '''număr natural''' ce reprezintă o lună a anului (dacă citim 3 ne referim la a treia lună, deci Martie). Programul va afișa (câte unul pe rând) numele '''lunilor rămase''' în acel an după cea citită. Se garantează că se introduce de la intrare o valoare cuprinsă între '''1 și 11'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură un număr '''l'''.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran câte una pe rând, cu inițială mare, lunile rămase după cea cu numărul citit.În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''l''' ≤ 11<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:9<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:Octombrie<br />
:Noiembrie<br />
:Decembrie<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(l):<br />
if 1 <= l <= 11:<br />
return True<br />
return False<br />
<br />
<br />
def luni_ramase(l):<br />
if l == 1:<br />
print("Februarie\nMartie\nAprilie\nMai\nIunie\nIulie\nAugust\nSeptembrie\nOctombrie\nNoiembrie\nDecembrie")<br />
elif l == 2:<br />
print("Martie\nAprilie\nMai\nIunie\nIulie\nAugust\nSeptembrie\nOctombrie\nNoiembrie\nDecembrie")<br />
elif l == 3:<br />
print("Aprilie\nMai\nIunie\nIulie\nAugust\nSeptembrie\nOctombrie\nNoiembrie\nDecembrie")<br />
elif l == 4:<br />
print("Mai\nIunie\nIulie\nAugust\nSeptembrie\nOctombrie\nNoiembrie\nDecembrie")<br />
elif l == 5:<br />
print("Iunie\nIulie\nAugust\nSeptembrie\nOctombrie\nNoiembrie\nDecembrie")<br />
elif l == 6:<br />
print("Iulie\nAugust\nSeptembrie\nOctombrie\nNoiembrie\nDecembrie")<br />
elif l == 7:<br />
print("August\nSeptembrie\nOctombrie\nNoiembrie\nDecembrie")<br />
elif l == 8:<br />
print("Septembrie\nOctombrie\nNoiembrie\nDecembrie")<br />
elif l == 9:<br />
print("Octombrie\nNoiembrie\nDecembrie")<br />
elif l == 10:<br />
print("Noiembrie\nDecembrie")<br />
elif l == 11:<br />
print("Decembrie")<br />
<br />
<br />
if __name__ == "__main__":<br />
l = int(input())<br />
if validare(l):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
luni_ramase(l)<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight><br />
<br />
==Explicatie==<br />
Acest cod este o implementare a unei funcții care primește o valoare întreagă l și determină luna sau lunile rămase într-un an, începând cu luna dată de l.<br />
<br />
Funcția validare(l) verifică dacă l se află în intervalul [1, 11] și returnează True dacă da și False în caz contrar.<br />
<br />
Funcția luni_ramase(l) afișează luna sau lunile rămase în anul curent, începând cu luna dată de l. Fiecare condiție elif verifică luna curentă și afișează luna sau lunile rămase. De exemplu, dacă l este 5, atunci afișează lunile de la iunie până în decembrie.<br />
<br />
În if __name__ == "__main__":, utilizatorul introduce valoarea întreagă l prin intermediul funcției input(). Dacă valoarea introdusă este validă, se afișează "Datele de intrare corespund restricțiilor impuse." și apoi funcția luni_ramase(l) este apelată pentru a afișa luna sau lunile rămase. În caz contrar, se afișează "Datele de intrare nu corespund restricțiilor impuse."</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=2694_-_Min_Max2&diff=55142694 - Min Max22023-04-29T16:39:08Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dau '''2 numere naturale''' cu exact '''3 cifre''' fiecare, să se afișeze '''cel mai mare și cel mai mic''' număr de două cifre scris cu o cifră din '''primul''' număr și cu o cifră din '''al doilea'''. ==Date de intrare== Programul citește de la tastatură 2 numere separate prin spații. ==Date de ieșire== Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe e...</p>
<hr />
<div>==Cerință==<br />
Se dau '''2 numere naturale''' cu exact '''3 cifre''' fiecare, să se afișeze '''cel mai mare și cel mai mic''' număr de două cifre scris cu o cifră din '''primul''' număr și cu o cifră din '''al doilea'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură 2 numere separate prin spații.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran '''cel mai mare și cel mai mic''' număr de două cifre scris cu o cifră din '''primul''' număr și cu o cifră din '''al doilea''' în această ordine, separate prin spații.În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*100 ≤ '''a''' ≤ '''b''' ≤ 999<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:123 912<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:93 11<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(a, b):<br />
if 100 <= a <= b <= 999:<br />
return True<br />
return False<br />
<br />
<br />
def maxi(n):<br />
ma = 0<br />
while n:<br />
if n % 10 > ma:<br />
ma = n % 10<br />
n //= 10<br />
return ma<br />
<br />
<br />
def minim_maxim2(a, b):<br />
max1 = maxi(a)<br />
max2 = maxi(b)<br />
if max1 > max2:<br />
ma = max1 * 10 + max2<br />
else:<br />
ma = max2 * 10 + max1<br />
<br />
v = [0] * 4<br />
v1 = [0] * 4<br />
p = p1 = 0<br />
print(ma, end=' ')<br />
while a:<br />
v[p] = a % 10<br />
p += 1<br />
a //= 10<br />
while b:<br />
v1[p1] = b % 10<br />
p1 += 1<br />
b //= 10<br />
v = sorted(v[:p])<br />
v1 = sorted(v1[:p1])<br />
min1, min2 = v[0], v1[0]<br />
if v1[0] == 0 and v[0] == 0:<br />
mi = 10<br />
for i in range(p):<br />
if v[i] < mi and v[i] != 0:<br />
mi = v[i]<br />
if v1[i] < mi and v1[i] != 0:<br />
mi = v1[i]<br />
m = mi * 10<br />
print(m)<br />
else:<br />
if min1 == 0 or min2 == 0:<br />
if min1 > min2:<br />
print(min1 * 10)<br />
else:<br />
print(min2 * 10)<br />
else:<br />
if min1 < min2:<br />
print(min1 * 10 + min2)<br />
else:<br />
print(min2 * 10 + min1)<br />
<br />
<br />
if __name__ == "__main__":<br />
a, b = map(int, input().split())<br />
<br />
if validare(a, b):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(minim_maxim2(a, b))<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight><br />
<br />
==Explicatie==<br />
Acest cod este o implementare a unei funcții care primește două numere întregi a și b și determină o valoare maximă și o valoare minimă într-un anumit mod.<br />
<br />
Funcția validare(a, b) verifică dacă valorile introduse pentru a și b sunt între 100 și 999, inclusiv, și returnează True dacă da, altfel returnează False.<br />
<br />
Funcția maxi(n) primește un număr întreg n și determină cifra maximă din numărul respectiv. Se face acest lucru prin iterarea prin cifrele numărului (obținute prin împărțirea repetată la 10) și compararea fiecărei cifre cu valoarea maximă curentă.<br />
<br />
Funcția minim_maxim2(a, b) calculează valoarea maximă și valoarea minimă într-un anumit mod. Mai întâi se calculează valoarea maximă (denumită ma) prin combinarea cifrei maxime din fiecare dintre cele două numere într-un singur număr. Apoi, se descompun numerele a și b în cifre și se ordonează cifrele crescător. Cifrele sunt stocate în listele v și v1. Valoarea minimă este apoi determinată ca fiind prima cifră din aceste liste. Dacă una dintre aceste cifre este 0, se caută cea mai mică cifră nenulă în cele două liste și se combină pentru a forma valoarea minimă. În cele din urmă, valoarea minimă și valoarea maximă sunt combinate pentru a forma valoarea finală.<br />
<br />
În secțiunea if __name__ == "__main__": se primește intrarea de la utilizator pentru valorile a și b. Dacă valorile introduse sunt valide, se afișează un mesaj corespunzător și se apelează funcția minim_maxim2(a, b) pentru a determina valorile minime și maxime. Altfel, se afișează un mesaj de eroare.</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=2696_-_CifP_cifl&diff=54932696 - CifP cifl2023-04-29T16:18:23Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dau '''2 numere de exact 2 cifre''', dacă numerele au '''aceeași''' paritate se va afișa numărul total de cifre '''pare''' din cele două numere altfel dacă au parităti '''diferite''' atunci se afisează numărul total de cifre '''impare''' din cele două numere. ==Date de intrare== Programul citește de la tastatură 2 numere, separate prin spații. ==Date de ieșire== Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare cor...</p>
<hr />
<div><br />
==Cerință==<br />
Se dau '''2 numere de exact 2 cifre''', dacă numerele au '''aceeași''' paritate se va afișa numărul total de cifre '''pare''' din cele două numere altfel dacă au parităti '''diferite''' atunci se afisează numărul total de cifre '''impare''' din cele două numere.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură 2 numere, separate prin spații.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran numărul de cifre '''pare/impare''' conform cerinței.În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Numerele '''a''' si '''b''' au exact 2 cifre<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:78 18<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:2<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(a, b):<br />
if 10 <= a < 100 and 10 <= b < 100:<br />
return True<br />
return False<br />
<br />
<br />
def paritate(a, b):<br />
if a % 2 == b % 2:<br />
rezultat = (a // 10 % 2 == 0) + (a % 2 == 0) + (b // 10 % 2 == 0) + (b % 2 == 0)<br />
else:<br />
rezultat = a // 10 % 2 + a % 2 + b // 10 % 2 + b % 2<br />
return rezultat<br />
<br />
<br />
if __name__ == "__main__":<br />
a, b = map(int, input().split())<br />
<br />
if validare(a, b):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(paritate(a, b))<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight><br />
<br />
==Explicatie==<br />
Codul definește două funcții: validare(a, b) și paritate(a, b), care iau ca parametri două numere întregi, a și b.<br />
<br />
Funcția validare(a, b) verifică dacă ambele numere sunt între 10 și 99, adică au două cifre. Dacă da, funcția returnează True, altfel returnează False.<br />
<br />
Funcția paritate(a, b) verifică dacă cele două numere au aceeași paritate. Dacă da, se calculează și se returnează numărul total de cifre pare în cele două numere. În caz contrar, se calculează și se returnează numărul total de cifre impare.<br />
<br />
În blocul if __name__ == "__main__":, se citește de la tastatură două numere separate prin spațiu și se verifică dacă acestea sunt valide folosind funcția validare(a, b). Dacă sunt valide, se calculează și se afișează numărul total de cifre pare/impare conform cerinței folosind funcția paritate(a, b). Dacă nu sunt valide, se afișează un mesaj corespunzător.</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0446_-_Cif_Max_3&diff=54880446 - Cif Max 32023-04-29T15:59:52Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se citește de la tastatură un '''număr natural''' de 3 cifre. Să se afișeze pe ecran cea mai mare cifră a sa. ==Date de intrare== Programul va citi de la tastatură un '''număr natural''', de 3 cifre. ==Date de ieșire== Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran cea mai '''mare''' cifră a numărului citit.În caz contrar, se va afișa pe ecran: "Date...</p>
<hr />
<div>==Cerință==<br />
Se citește de la tastatură un '''număr natural''' de 3 cifre. Să se afișeze pe ecran cea mai mare cifră a sa.<br />
<br />
==Date de intrare==<br />
Programul va citi de la tastatură un '''număr natural''', de 3 cifre.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran cea mai '''mare''' cifră a numărului citit.În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Numărul citit de la tastatură este natural, de 3 cifre<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:187<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:8<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(numar):<br />
"""<br />
Verifică dacă numărul dat respectă restricțiile impuse.<br />
<br />
Args:<br />
numar (int): Numărul de verificat.<br />
<br />
Returns:<br />
bool: True dacă numărul respectă restricțiile, False în caz contrar.<br />
"""<br />
if 99 < numar < 1000: # verificăm dacă numărul este între 99 și 1000 (dar nu inclusiv)<br />
return True<br />
return False<br />
<br />
<br />
def cifra_maxima(numar):<br />
"""<br />
Afișează cifra maxima a unui număr natural de trei cifre.<br />
<br />
Args:<br />
numar (int): Numărul de trei cifre de verificat.<br />
<br />
Returns:<br />
int: Cifra maxima a numărului.<br />
"""<br />
# Extragem cifrele numărului<br />
sute = numar // 100<br />
zeci = numar % 100 // 10<br />
unitati = numar % 10<br />
<br />
# Găsim cifra cea mai mare<br />
if sute > zeci:<br />
if sute > unitati:<br />
return sute<br />
elif zeci > unitati:<br />
return zeci<br />
else:<br />
return unitati<br />
<br />
<br />
if __name__ == "__main__":<br />
numar = int(input("Introduceti un numar natural: ")) # citim numărul de la tastatură<br />
if validare(numar): # dacă numărul respectă restricțiile impuse<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(cifra_maxima(numar)) # afișăm cifra maxima<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.") # afișăm un mesaj de eroare<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0447_-_Cif_Mid&diff=54860447 - Cif Mid2023-04-29T15:52:38Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se citește de la tastatură un '''număr natural''' de 3 cifre, distincte. Să se afișeze pe ecran cifra din mijloc, ca valoare. ==Date de intrare== Programul va citi de la tastatură un '''număr natural''' de 3 cifre. ==Date de ieșire== Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran cifra care nu este nici minimă și nici maximă.În caz contrar, se va afi...</p>
<hr />
<div>==Cerință==<br />
Se citește de la tastatură un '''număr natural''' de 3 cifre, distincte. Să se afișeze pe ecran cifra din mijloc, ca valoare.<br />
<br />
==Date de intrare==<br />
Programul va citi de la tastatură un '''număr natural''' de 3 cifre.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran cifra care nu este nici minimă și nici maximă.În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Numărul citit de la tastatură este '''natural, de 3 cifre'''<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:397<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:7<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(numar):<br />
"""<br />
Verifică dacă numărul dat respectă restricțiile impuse.<br />
<br />
Args:<br />
numar (int): Numărul de verificat.<br />
<br />
Returns:<br />
bool: True dacă numărul respectă restricțiile, False în caz contrar.<br />
"""<br />
if 99 < numar < 1000: # verificăm dacă numărul este între 99 și 1000 (dar nu inclusiv)<br />
return True<br />
return False<br />
<br />
<br />
def cifra_din_mijloc(numar):<br />
"""<br />
Afișează cifra din mijloc a unui număr natural de trei cifre, distincte.<br />
<br />
Args:<br />
numar (int): Numărul de trei cifre de verificat.<br />
<br />
Returns:<br />
int: Cifra din mijloc a numărului.<br />
"""<br />
# Extragem cifrele numărului<br />
sute = numar // 100<br />
zeci = numar % 100 // 10<br />
unitati = numar % 10<br />
<br />
# Găsim cifra din mijloc<br />
if sute > zeci:<br />
if zeci > unitati:<br />
return zeci<br />
elif sute > unitati:<br />
return unitati<br />
elif sute > unitati:<br />
return sute<br />
elif zeci > unitati:<br />
return unitati<br />
<br />
<br />
if __name__ == "__main__":<br />
numar = int(input("Introduceti un numar natural: ")) # citim numărul de la tastatură<br />
if validare(numar): # dacă numărul respectă restricțiile impuse<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(cifra_din_mijloc(numar)) # afișăm cifra din mijloc<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.") # afișăm un mesaj de eroare<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0449_-_Nr_Cif&diff=54790449 - Nr Cif2023-04-29T15:46:30Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se citește de la tastatură un '''număr natural''' de maxim 3 cifre. Să se determine câte cifre are. ==Date de intrare== Programul va citi de la tastatură un '''număr natural''' de 3 cifre ==Date de ieșire== Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran numărul de cifre ale valorii citite.În caz contrar, se va afișa pe ecran: "Datele de intrare nu core...</p>
<hr />
<div>==Cerință==<br />
Se citește de la tastatură un '''număr natural''' de maxim 3 cifre. Să se determine câte cifre are.<br />
<br />
==Date de intrare==<br />
Programul va citi de la tastatură un '''număr natural''' de 3 cifre<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran numărul de cifre ale valorii citite.În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Numărul citit de la tastatură este natural, cu cel mult 3 cifre<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:397<br />
<br />
;Ieșire<br />
<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:3<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(numar):<br />
"""<br />
Verifică dacă numărul dat respectă restricțiile impuse.<br />
<br />
Args:<br />
numar (int): Numărul de verificat.<br />
<br />
Returns:<br />
bool: True dacă numărul respectă restricțiile, False în caz contrar.<br />
"""<br />
if 0 < numar < 1000: # verificăm dacă numărul este între 0 și 1000 (dar nu inclusiv)<br />
return True<br />
return False<br />
<br />
<br />
def numar_cifre(numar):<br />
"""<br />
Afișează numărul de cifre ale numărului dat.<br />
<br />
Args:<br />
numar (int): Numărul de verificat.<br />
"""<br />
if numar // 100 != 0: # verificăm dacă numărul are trei cifre<br />
print(3)<br />
elif numar // 100 == 0 and numar // 10 != 0: # verificăm dacă numărul are două cifre<br />
print(2)<br />
else:<br />
print(1) # afișăm 1 pentru numerele cu o singură cifră<br />
<br />
<br />
if __name__ == "__main__":<br />
numar = int(input("Introduceti un numar natural: ")) # citim numărul de la tastatură<br />
if validare(numar): # dacă numărul respectă restricțiile impuse<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
numar_cifre(numar) # afișăm numărul de cifre<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.") # afișăm un mesaj de eroare<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0450_-_Mini_Calc&diff=54760450 - Mini Calc2023-04-29T15:43:07Z<p>Tuca Liviu Razvan: /* Rezolvare ver. 1 */</p>
<hr />
<div>==Cerință==<br />
Se citesc de la tastatură 3 numere naturale, '''a, b, c'''. Să se realizeze cu '''a''' și '''b''' operația codificată prin numărul '''c'''.<br />
<br />
==Date de intrare==<br />
Programul va citi de la tastatură 3 numere naturale.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran mesajul :<br />
<br />
Dacă al treilea număr este '''1''' programul va afișa pe ecran '''suma''' primelor două numere.<br />
<br />
Dacă al treilea număr este '''2''' programul va afișa pe ecran '''diferența''' dintre primul număr și al doilea.<br />
<br />
Dacă al treilea număr este '''3''' programul va afișa pe ecran '''produsul''' primelor două numere.<br />
<br />
Dacă al treilea număr este '''4''' programul va afișa pe ecran '''câtul''' împărțirii dintre primul număr și al doilea.<br />
<br />
Dacă al treilea număr este '''5''' programul va afișa pe ecran '''restul''' împărțirii dintre primul număr și al doilea.<br />
<br />
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Primele două numere sunt naturale, mai mici decât 32676.<br />
*Primul număr este mai mare sau egal cu al doilea.<br />
*Al doilea număr este nenul.<br />
*Al treilea număr este din mulțimea {1,2,3,4,5}.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:4 2 3<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:8<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(a, b, c):<br />
if 0 <= a < 32676 and 0 < b < 32676 and a >= b and c in [1, 2, 3, 4, 5]:<br />
return True<br />
return False<br />
<br />
<br />
def operatie(a, b, c):<br />
if c == 1:<br />
# Suma primelor doua numere<br />
rezultat = a + b<br />
elif c == 2:<br />
# Diferenta dintre primul si al doilea numar<br />
rezultat = a - b<br />
elif c == 3:<br />
# Produsul primelor doua numere<br />
rezultat = a * b<br />
elif c == 4:<br />
# Catul impartirii dintre primul si al doilea numar<br />
rezultat = a // b<br />
elif c == 5:<br />
# Restul impartirii dintre primul si al doilea numar<br />
rezultat = a % b<br />
return rezultat<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citim cele trei numere de la tastatura<br />
a = int(input("Introdu primul numar: "))<br />
b = int(input("Introdu al doilea numar: "))<br />
c = int(input("Introdu cifra operatiei dorite (1 pentru suma, 2 pentru diferenta, 3 pentru produs, 4 pentru catul impartirii, 5 pentru restul impartirii): "))<br />
<br />
if validare(a, b, c): # Apelam functia de validare<br />
print("Datele de intrare corespund restricțiilor impuse.") # In caz afirmativ afisam mesajul pozitiv si apelam functia operatie<br />
print(operatie(a, b, c))<br />
else: # In caz contrar afisam mesajul corespunzator<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0450_-_Mini_Calc&diff=54720450 - Mini Calc2023-04-29T15:35:34Z<p>Tuca Liviu Razvan: /* Rezolvare ver. 1 */</p>
<hr />
<div>==Cerință==<br />
Se citesc de la tastatură 3 numere naturale, '''a, b, c'''. Să se realizeze cu '''a''' și '''b''' operația codificată prin numărul '''c'''.<br />
<br />
==Date de intrare==<br />
Programul va citi de la tastatură 3 numere naturale.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran mesajul :<br />
<br />
Dacă al treilea număr este '''1''' programul va afișa pe ecran '''suma''' primelor două numere.<br />
<br />
Dacă al treilea număr este '''2''' programul va afișa pe ecran '''diferența''' dintre primul număr și al doilea.<br />
<br />
Dacă al treilea număr este '''3''' programul va afișa pe ecran '''produsul''' primelor două numere.<br />
<br />
Dacă al treilea număr este '''4''' programul va afișa pe ecran '''câtul''' împărțirii dintre primul număr și al doilea.<br />
<br />
Dacă al treilea număr este '''5''' programul va afișa pe ecran '''restul''' împărțirii dintre primul număr și al doilea.<br />
<br />
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Primele două numere sunt naturale, mai mici decât 32676.<br />
*Primul număr este mai mare sau egal cu al doilea.<br />
*Al doilea număr este nenul.<br />
*Al treilea număr este din mulțimea {1,2,3,4,5}.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:4 2 3<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:8<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(a, b, c):<br />
if 0 <= a < 32676 and 0 < b < 32676 and a >= b and c in [1, 2, 3, 4, 5]:<br />
return True<br />
return False<br />
<br />
<br />
def operatie(a, b, c):<br />
if c == 1:<br />
# Suma primelor doua numere<br />
rezultat = a + b<br />
elif c == 2:<br />
# Diferenta dintre primul si al doilea numar<br />
rezultat = a - b<br />
elif c == 3:<br />
# Produsul primelor doua numere<br />
rezultat = a * b<br />
elif c == 4:<br />
# Catul impartirii dintre primul si al doilea numar<br />
rezultat = a // b<br />
elif c == 5:<br />
# Restul impartirii dintre primul si al doilea numar<br />
rezultat = a % b<br />
return rezultat<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citim cele trei numere de la tastatura<br />
a = int(input("Introdu primul numar: "))<br />
b = int(input("Introdu al doilea numar: "))<br />
c = int(input("Introdu cifra operatiei dorite (1 pentru suma, 2 pentru diferenta, 3 pentru produs, 4 pentru catul impartirii, 5 pentru restul impartirii): "))<br />
<br />
if validare(a, b, c): # Apelam functia de validare<br />
print(<br />
"Datele de intrare corespund restricțiilor impuse.") # In caz afirmativ afisam mesajul pozitiv si apelam functia operatie<br />
print(operatie(a, b, c))<br />
else: # In caz contrar afisam mesajul corespunzator<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0450_-_Mini_Calc&diff=54710450 - Mini Calc2023-04-29T15:33:17Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se citesc de la tastatură 3 numere naturale, '''a, b, c'''. Să se realizeze cu '''a''' și '''b''' operația codificată prin numărul '''c'''. ==Date de intrare== Programul va citi de la tastatură 3 numere naturale. ==Date de ieșire== Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran mesajul : Dacă al treilea număr este '''1''' programul va afișa pe ecran '...</p>
<hr />
<div>==Cerință==<br />
Se citesc de la tastatură 3 numere naturale, '''a, b, c'''. Să se realizeze cu '''a''' și '''b''' operația codificată prin numărul '''c'''.<br />
<br />
==Date de intrare==<br />
Programul va citi de la tastatură 3 numere naturale.<br />
<br />
==Date de ieșire==<br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran mesajul :<br />
<br />
Dacă al treilea număr este '''1''' programul va afișa pe ecran '''suma''' primelor două numere.<br />
<br />
Dacă al treilea număr este '''2''' programul va afișa pe ecran '''diferența''' dintre primul număr și al doilea.<br />
<br />
Dacă al treilea număr este '''3''' programul va afișa pe ecran '''produsul''' primelor două numere.<br />
<br />
Dacă al treilea număr este '''4''' programul va afișa pe ecran '''câtul''' împărțirii dintre primul număr și al doilea.<br />
<br />
Dacă al treilea număr este '''5''' programul va afișa pe ecran '''restul''' împărțirii dintre primul număr și al doilea.<br />
<br />
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
==Restricții și precizări==<br />
*Primele două numere sunt naturale, mai mici decât 32676.<br />
*Primul număr este mai mare sau egal cu al doilea.<br />
*Al doilea număr este nenul.<br />
*Al treilea număr este din mulțimea {1,2,3,4,5}.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:4 2 3<br />
<br />
;Ieșire<br />
:Datele de intrare corespund restricțiilor impuse.<br />
:8<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(a, b, c):<br />
if 0 <= a < 32676 and 0 < b < 32676 and a >= b and c in [1, 2, 3, 4, 5]:<br />
return True<br />
return False<br />
<br />
<br />
def operatie(a, b, c):<br />
if c == 1:<br />
# Suma primelor doua numere<br />
rezultat = a + b<br />
elif c == 2:<br />
# Diferenta dintre primul si al doilea numar<br />
rezultat = a - b<br />
elif c == 3:<br />
# Produsul primelor doua numere<br />
rezultat = a * b<br />
elif c == 4:<br />
# Catul impartirii dintre primul si al doilea numar<br />
rezultat = a // b<br />
elif c == 5:<br />
# Restul impartirii dintre primul si al doilea numar<br />
rezultat = a % b<br />
return rezultat<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citim cele trei numere de la tastatura<br />
a = int(input("Introdu primul numar: "))<br />
b = int(input("Introdu al doilea numar: "))<br />
c = int(input(<br />
"Introdu cifra operatiei dorite (1 pentru suma, 2 pentru diferenta, 3 pentru produs, 4 pentru catul impartirii, 5 pentru restul impartirii): "))<br />
<br />
if validare(a, b, c):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(operatie(a, b, c))<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0106_-_Minim3&diff=54700106 - Minim32023-04-29T15:12:35Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursa: [https://www.pbinfo.ro/probleme/106/minim3 0106 - Minim3]<br />
----<br />
== Cerinţa ==<br />
Se dau 3 numere întregi '''numar1''', '''numar2''' și '''numar3'''. Calculaţi minimul celor 3 numere date.<br />
== Date de intrare ==<br />
Programul citește de la tastatură numerele '''numar1''', '''numar2''' și '''numar3''', separate prin câte un spațiu.<br />
== Date de ieșire == <br />
Programul va afişa pe ecran cel mai mic dintre numerele citite.<br />
<br />
== Restricţii şi precizări ==<br />
* '''numar1''', '''numar2''', '''numar3''' &isin; &#8484;<br />
* abs('''numar1'''), abs('''numar2'''), abs('''numar3''') < 1.000.000.000<br />
* abs - valoarea absolută<br />
== Exemplu ==<br />
; Intrare<br />
: 125 68 200<br />
; Ieșire<br />
: Datele introduse corespund restricțiilor impuse.<br />
: 68<br />
<br><br />
; Intrare<br />
: abc 63.5 20<br />
; Ieșire<br />
: Datele introduse nu corespund restricțiilor impuse.<br />
<br><br />
; Intrare<br />
: -25 20 1000000001<br />
; Ieșire<br />
: Datele introduse nu corespund restricțiilor impuse.<br />
<br><br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
# 0106 - Minim 3<br />
<br />
def validare_date_numere(numar1: str, numar2: str, numar3: str) -> bool:<br />
try:<br />
int(numar1)<br />
int(numar2)<br />
int(numar3)<br />
<br />
return True<br />
except ValueError:<br />
return False<br />
<br />
<br />
def validare_valori(numar1: int, numar2: int, numar3: int) -> bool:<br />
if len(str(abs(numar1))) < 10 and len(str(abs(numar2))) < 10 and len(str(abs(numar3))) < 10:<br />
return True<br />
else:<br />
return False<br />
<br />
<br />
def minim3(*args) -> int:<br />
return min(args)<br />
<br />
<br />
if __name__ == "__main__":<br />
linie1 = input()<br />
linie1 = linie1.split(" ")<br />
<br />
numar1, numar2, numar3 = linie1[0], linie1[1], linie1[2]<br />
<br />
if validare_date_numere(numar1, numar2, numar3):<br />
numar1, numar2, numar3 = int(numar1), int(numar2), int(numar3)<br />
<br />
if validare_valori(numar1, numar2, numar3):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(minim3(numar1, numar2, numar3))<br />
<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
<br />
</syntaxhighlight><br />
=== Rezolvare ver. 2 ===<br />
<syntaxhighlight lang="python" line><br />
# 0106 - Minim 3<br />
<br />
def validare_date_numere(numar1: str, numar2: str, numar3: str) -> bool:<br />
try:<br />
int(numar1)<br />
int(numar2)<br />
int(numar3)<br />
<br />
return True<br />
except ValueError:<br />
return False<br />
<br />
<br />
def validare_valori(numar1: int, numar2: int, numar3: int) -> bool:<br />
if len(str(abs(numar1))) < 10 and len(str(abs(numar2))) < 10 and len(str(abs(numar3))) < 10:<br />
return True<br />
else:<br />
return False<br />
<br />
<br />
def minim3(numar1: int, numar2: int, numar3: int) -> int:<br />
minim: int = numar1<br />
<br />
if numar2 < minim:<br />
minim = numar2<br />
if numar3 < minim:<br />
minim = numar3<br />
<br />
return minim<br />
<br />
<br />
if __name__ == "__main__":<br />
linie1 = input()<br />
linie1 = linie1.split(" ")<br />
<br />
numar1, numar2, numar3 = linie1[0], linie1[1], linie1[2]<br />
<br />
if validare_date_numere(numar1, numar2, numar3):<br />
numar1, numar2, numar3 = int(numar1), int(numar2), int(numar3)<br />
<br />
if validare_valori(numar1, numar2, numar3):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(minim3(numar1, numar2, numar3))<br />
<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=3185_-_Concurs1&diff=54693185 - Concurs12023-04-29T15:11:47Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/3185/concurs1 3185 - Concurs1]<br />
== Cerință ==<br />
La un concurs pot participa copii cu vârste între a și b ani, inclusiv. Gigel are n ani. Stabiliți dacă poate participa la concurs.<br />
== Date de intrare ==<br />
Programul citește de la tastatură numerele naturale a b n.<br />
== Date de ieșire == <br />
Programul afișează pe ecran mesajul DA, dacă numărul Gigel poate participa la concurs, respectiv NU în caz contrar.<br />
<br />
== Restricții și precizări ==<br />
1 ≤ a,b,n ≤ 1000,<br />
<br />
a ≤ b<br />
== Exemplu ==<br />
; Intrare<br />
: 4 9 8<br />
; Ieșire<br />
: DA<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0469_-_Interval2&diff=54680469 - Interval22023-04-29T15:11:33Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/469/interval2 0469 - Interval2]<br />
== Cerință ==<br />
Se dau trei numere naturale a b x. Să se verifice dacă numărul x aparține intervalului [a,b].<br />
== Date de intrare ==<br />
Programul citește de la tastatură numerele a b x.<br />
== Date de ieșire == <br />
Programul afișează pe ecran mesajul DA, dacă numărul x aparține intervalului [a,b], respectiv NU în caz contrar.<br />
<br />
== Restricții și precizări ==<br />
0 ≤ a,b,x ≤ 1000,<br />
<br />
a ≤ b<br />
== Exemplu ==<br />
; Intrare<br />
: 4 9 8<br />
; Ieșire<br />
: DA<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0469_-_Interval2&diff=54670469 - Interval22023-04-29T15:11:23Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/469/interval2 0469 - Interval2]<br />
== Cerință ==<br />
Se dau trei numere naturale a b x. Să se verifice dacă numărul x aparține intervalului [a,b].<br />
== Date de intrare ==<br />
Programul citește de la tastatură numerele a b x.<br />
== Date de ieșire == <br />
programul afișează pe ecran mesajul DA, dacă numărul x aparține intervalului [a,b], respectiv NU în caz contrar.<br />
<br />
== Restricții și precizări ==<br />
0 ≤ a,b,x ≤ 1000,<br />
<br />
a ≤ b<br />
== Exemplu ==<br />
; Intrare<br />
: 4 9 8<br />
; Ieșire<br />
: DA<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0832_-_Problema_Nota&diff=54660832 - Problema Nota2023-04-29T15:11:02Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/832/nota 0832 - Problema Nota]<br />
== Cerință ==<br />
Fiind dată nota unui elev să se afișeze dacă acesta este corigent sau promovat.<br />
== Date de intrare ==<br />
Programul citește de la tastatură numărul natural '''nota'''.<br />
== Date de ieșire == <br />
Programul afișează pe ecran mesajul '''corigent''' dacă '''nota''' este mai mic ca 5, altfel va afișa '''promovat'''.<br />
<br />
== Restricții și precizări ==<br />
1 ≤ nota ≤ 10<br />
== Exemplu ==<br />
; Intrare<br />
: 5<br />
; Ieșire<br />
: promovat<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0816_-_Problema_Sticle&diff=54650816 - Problema Sticle2023-04-29T15:10:39Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/816/sticle 0816 - Problema Sticle]<br />
== Cerință ==<br />
Scrieți un program care determină câte sticle de x litri cu apă trebuie deschise pentru a umple un vas de y litri.<br />
== Date de intrare ==<br />
Programul citește de la tastatură numerele naturale x și y.<br />
== Date de ieșire == <br />
Programul afișează pe ecran mesajul numărul '''n''', reprezentând numărul de sticle ce trebuie deschise.<br />
<br />
== Restricții și precizări ==<br />
1 ≤ x,y ≤ 1.000.000 și sunt numere naturale<br />
== Exemplu ==<br />
; Intrare<br />
: 5 8<br />
; Ieșire<br />
: 2<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0105_-_max2&diff=54640105 - max22023-04-29T15:10:13Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/105/max2 0105 - max2]<br />
== Cerință ==<br />
Să se scrie un program care determină maximul a două numere întregi citite de la tastatură.<br />
== Date de intrare ==<br />
Programul va citi de la tastatură două numere întregi.<br />
== Date de ieșire == <br />
Programul afișează pe ecran mesajul numărul cel mai mare dintre cele două numere citite.<br />
<br />
== Restricții și precizări ==<br />
valorile absolute ale numerelor citite vor fi mai mici decât 2.000.000.000<br />
== Exemplu ==<br />
; Intrare<br />
: 125 68<br />
; Ieșire<br />
: 125<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0105_-_max2&diff=54630105 - max22023-04-29T15:09:24Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/105/max2 0105 - max2]<br />
== Cerință ==<br />
Să se scrie un program care determină maximul a două numere întregi citite de la tastatură.<br />
== Date de intrare ==<br />
Programul va citi de la tastatură două numere întregi.<br />
== Date de ieșire == <br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran mesajul numărul cel mai mare dintre cele două numere citite. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
== Restricții și precizări ==<br />
valorile absolute ale numerelor citite vor fi mai mici decât 2.000.000.000<br />
== Exemplu ==<br />
; Intrare<br />
: 125 68<br />
; Ieșire<br />
: 125<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0816_-_Problema_Sticle&diff=54620816 - Problema Sticle2023-04-29T15:08:38Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/816/sticle 0816 - Problema Sticle]<br />
== Cerință ==<br />
Scrieți un program care determină câte sticle de x litri cu apă trebuie deschise pentru a umple un vas de y litri.<br />
== Date de intrare ==<br />
Programul citește de la tastatură numerele naturale x și y.<br />
== Date de ieșire == <br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran mesajul numărul '''n''', reprezentând numărul de sticle ce trebuie deschise. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
== Restricții și precizări ==<br />
1 ≤ x,y ≤ 1.000.000 și sunt numere naturale<br />
== Exemplu ==<br />
; Intrare<br />
: 5 8<br />
; Ieșire<br />
: 2<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0832_-_Problema_Nota&diff=54610832 - Problema Nota2023-04-29T15:07:34Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/832/nota 0832 - Problema Nota]<br />
== Cerință ==<br />
Fiind dată nota unui elev să se afișeze dacă acesta este corigent sau promovat.<br />
== Date de intrare ==<br />
Programul citește de la tastatură numărul natural '''nota'''.<br />
== Date de ieșire == <br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran mesajul '''corigent''' dacă '''nota''' este mai mic ca 5, altfel va afișa '''promovat'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
== Restricții și precizări ==<br />
1 ≤ nota ≤ 10<br />
== Exemplu ==<br />
; Intrare<br />
: 5<br />
; Ieșire<br />
: promovat<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0469_-_Interval2&diff=54600469 - Interval22023-04-29T15:06:49Z<p>Tuca Liviu Razvan: /* Date de ieșire */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/469/interval2 0469 - Interval2]<br />
== Cerință ==<br />
Se dau trei numere naturale a b x. Să se verifice dacă numărul x aparține intervalului [a,b].<br />
== Date de intrare ==<br />
Programul citește de la tastatură numerele a b x.<br />
== Date de ieșire == <br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran mesajul DA, dacă numărul x aparține intervalului [a,b], respectiv NU în caz contrar. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
<br />
== Restricții și precizări ==<br />
0 ≤ a,b,x ≤ 1000,<br />
<br />
a ≤ b<br />
== Exemplu ==<br />
; Intrare<br />
: 4 9 8<br />
; Ieșire<br />
: DA<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=3185_-_Concurs1&diff=54593185 - Concurs12023-04-29T15:05:11Z<p>Tuca Liviu Razvan: /* Date de intrare */</p>
<hr />
<div>Sursă: [https://www.pbinfo.ro/probleme/3185/concurs1 3185 - Concurs1]<br />
== Cerință ==<br />
La un concurs pot participa copii cu vârste între a și b ani, inclusiv. Gigel are n ani. Stabiliți dacă poate participa la concurs.<br />
== Date de intrare ==<br />
Programul citește de la tastatură numerele naturale a b n.<br />
== Date de ieșire == <br />
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." și programul afișează pe ecran mesajul DA, dacă numărul Gigel poate participa la concurs, respectiv NU în caz contrar. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."<br />
== Restricții și precizări ==<br />
1 ≤ a,b,n ≤ 1000,<br />
<br />
a ≤ b<br />
== Exemplu ==<br />
; Intrare<br />
: 4 9 8<br />
; Ieșire<br />
: DA<br />
== Rezolvare == <br />
=== Rezolvare ver. 1 ===<br />
<syntaxhighlight lang="python" line><br />
<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0382_-_Aproape_K&diff=37430382 - Aproape K2023-04-16T12:39:59Z<p>Tuca Liviu Razvan: /* Rezolvare ver. 1 */</p>
<hr />
<div>==Cerință==<br />
Se dau două numere naturale nenule '''n''' și '''k'''. Să se determine multiplul lui '''k''' cel mai apropiat de '''n'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele '''n''' și '''k''', în această ordine.<br />
<br />
==Date de ieșire==<br />
Programul afișează pe ecran numărul '''p''', reprezentând multiplul lui '''k''' cel mai apropiat de '''n'''.<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''k''' ≤ '''n''' ≤ 1.000.000<br />
*dacă există mai mulți multipli ai lui '''k''' la fel de apropiați de '''n''', se va afișa cel mai mic.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:18 5<br />
<br />
;Ieșire<br />
<br />
:20<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
# Definirea funcției de validare a datelor de intrare<br />
def validare(n, k):<br />
if 1 <= k <= 1000000 and 1 <= n <= 1000000 and k <= n:<br />
return True<br />
return False<br />
<br />
<br />
# Definirea funcției pentru calculul valorii apropiate de k<br />
def aproape_k(k, n):<br />
p = k // n<br />
if k - p * n > n * (p + 1) - k: # Cautam multiplul cel mai apropiat de n<br />
return n * (p + 1)<br />
else:<br />
return p * n<br />
<br />
<br />
# Citirea datelor de intrare și apelarea funcțiilor de validare și de calcul<br />
if __name__ == "__main__":<br />
n, k = map(int, input().split()) # Introducem datele de la tastatura<br />
if validare(n, k): # Apelam functia de validare<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(aproape_k(n, k)) # Apelam functia care cauta multiplul lui k cel mai apropiat de n<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0382_-_Aproape_K&diff=37420382 - Aproape K2023-04-16T12:37:40Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dau două numere naturale nenule '''n''' și '''k'''. Să se determine multiplul lui '''k''' cel mai apropiat de '''n'''. ==Date de intrare== Programul citește de la tastatură numerele '''n''' și '''k''', în această ordine. ==Date de ieșire== Programul afișează pe ecran numărul '''p''', reprezentând multiplul lui '''k''' cel mai apropiat de '''n'''. ==Restricții și precizări== *1 ≤ '''k''' ≤ '''n''' ≤ 1.000.000 *dacă există mai mulți...</p>
<hr />
<div>==Cerință==<br />
Se dau două numere naturale nenule '''n''' și '''k'''. Să se determine multiplul lui '''k''' cel mai apropiat de '''n'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele '''n''' și '''k''', în această ordine.<br />
<br />
==Date de ieșire==<br />
Programul afișează pe ecran numărul '''p''', reprezentând multiplul lui '''k''' cel mai apropiat de '''n'''.<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''k''' ≤ '''n''' ≤ 1.000.000<br />
*dacă există mai mulți multipli ai lui '''k''' la fel de apropiați de '''n''', se va afișa cel mai mic.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:18 5<br />
<br />
;Ieșire<br />
<br />
:20<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
# Definirea funcției de validare a datelor de intrare<br />
def validare(n, k):<br />
if 1 <= k <= 1000000 and 1 <= n <= 1000000 and k <= n:<br />
return True<br />
return False<br />
<br />
<br />
# Definirea funcției pentru calculul valorii apropiate de k<br />
def aproape_k(k, n):<br />
p = k // n<br />
if k - p * n > n * (p + 1) - k:<br />
return n * (p + 1)<br />
else:<br />
return p * n<br />
<br />
<br />
# Citirea datelor de intrare și apelarea funcțiilor de validare și de calcul<br />
if __name__ == "__main__":<br />
n, k = map(int, input().split())<br />
if validare(n, k):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(aproape_k(n, k))<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=3207_-_Cercuri&diff=37413207 - Cercuri2023-04-16T12:30:02Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dau coordonatele şi razele a două cercuri. Să se determine în câte puncte se '''intersectează''' cele două cercuri. ==Date de intrare== Programul citește de la tastatură numerele reale '''r1, x1, y1''', raza şi coordonatele primului cerc, şi numerele reale '''r2, x2, y2''', raza şi coordonatele ale celui de-al doilea cerc. ==Date de ieșire== Programul va afişa pe ecran '''numărul de puncte''' în care se intersectează cele două cercuri, sau...</p>
<hr />
<div>==Cerință==<br />
Se dau coordonatele şi razele a două cercuri. Să se determine în câte puncte se '''intersectează''' cele două cercuri.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele reale '''r1, x1, y1''', raza şi coordonatele primului cerc, şi numerele reale '''r2, x2, y2''', raza şi coordonatele ale celui de-al doilea cerc.<br />
<br />
==Date de ieșire==<br />
Programul va afişa pe ecran '''numărul de puncte''' în care se intersectează cele două cercuri, sau '''infinit''' dacă cercurile sunt identice.<br />
<br />
==Restricții și precizări==<br />
*Numerele '''r1''' şi '''r2''' sunt numere reale, pozitive şi mai mici decât 100000.<br />
*Numerele '''x1, x2, y1, y2''' sunt numere reale cu valoarea absolută mai mică decât 10000.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:4 2 -2<br />
:2 -3 1<br />
<br />
;Ieșire<br />
<br />
:2<br />
<br />
==Exemplul 2==<br />
;Intrare<br />
<br />
:8 0 5<br />
:2 0 -5<br />
<br />
;Ieșire<br />
<br />
:1<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(r1, x1, y1, r2, x2, y2):<br />
if 0 < r1 < 100000 and 0 < r2 < 100000 and -10000 < x1 < 10000 and -10000 < y1 < 10000 and -10000 < x2 < 10000 and -10000 < y2 < 10000:<br />
return True<br />
return False<br />
<br />
<br />
def puncte_cercuri(r1, x1, y1, r2, x2, y2):<br />
if r1 == r2 and x1 == x2 and y1 == y2:<br />
print("infinit")<br />
elif (x1 - x2) ** 2 + (y1 - y2) ** 2 == (r1 + r2) ** 2 or (x1 - x2) ** 2 + (y1 - y2) ** 2 == (r1 - r2) ** 2:<br />
print(1)<br />
elif (x1 - x2) ** 2 + (y1 - y2) ** 2 > (r1 + r2) ** 2 or (r1 - r2) ** 2 > (x1 - x2) ** 2 + (y1 - y2) ** 2 or (<br />
x1 - x2) ** 2 + (y1 - y2) ** 2 == 0:<br />
print(0)<br />
else:<br />
print(2)<br />
<br />
<br />
if __name__ == "__main__":<br />
r1, x1, y1 = map(int, input('Cercul 1 = ').split())<br />
r2, x2, y2 = map(int, input('Cercul 2 = ').split())<br />
if validare(r1, x1, y1, r2, x2, y2):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
puncte_cercuri(r1, x1, y1, r2, x2, y2)<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight><br />
<br />
==Explicatie==<br />
Acest cod contine doua functii, 'validare' si 'puncte_cercuri', si un bloc 'if' care citeste datele de intrare si apeleaza cele doua functii.<br />
<br />
Functia 'validare' verifica daca datele de intrare corespund anumitor restrictii. Aceasta accepta 6 argumente, care sunt razele si coordonatele a doua cercuri si returneaza True daca acestea se afla in intervalul permis (r1, r2 intre 0 si 100000, x1, y1, x2, y2 intre -10000 si 10000), altfel returneaza False.<br />
<br />
Functia 'puncte_cercuri' calculeaza numarul de puncte de intersectie dintre cele doua cercuri, sau mesajul "infinit" daca cele doua cercuri sunt identice si se suprapun. Aceasta accepta aceleasi 6 argumente ca si functia 'validare'. Calculeaza distanta dintre centrul cercurilor si verifica daca sunt doua, una sau zero puncte de intersectie. Rezultatul este afisat prin intermediul instructiunii 'print'.<br />
<br />
Blocul 'if' citeste datele de intrare de la utilizator pentru cele doua cercuri si verifica daca acestea sunt valide apeland functia 'validare'. Daca datele de intrare sunt valide, afiseaza un mesaj corespunzator si calculeaza numarul de puncte de intersectie apeland functia 'puncte_cercuri'. Daca datele de intrare nu sunt valide, afiseaza un alt mesaj corespunzator.</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0334_-_Dreapta&diff=37400334 - Dreapta2023-04-16T12:10:59Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dau coordonatele a două puncte diferite din plan. Să se stabilească dacă dreapta determinată de cele două puncte este '''orizontală''', '''verticală''' sau '''oblică'''. ==Date de intrare== Programul citește de la tastatură numerele întregi '''x1, y1, x2, y2''', reprezentând coordonatele celor două puncte. ==Date de ieșire== Programul afișează pe ecran unul dintre mesajele '''orizontala''', '''verticala''' sau '''oblica''', în funcție de...</p>
<hr />
<div>==Cerință==<br />
Se dau coordonatele a două puncte diferite din plan. Să se stabilească dacă dreapta determinată de cele două puncte este '''orizontală''', '''verticală''' sau '''oblică'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele întregi '''x1, y1, x2, y2''', reprezentând coordonatele celor două puncte.<br />
<br />
==Date de ieșire==<br />
Programul afișează pe ecran unul dintre mesajele '''orizontala''', '''verticala''' sau '''oblica''', în funcție de natura dreptei determinate de cele două puncte.<br />
<br />
==Restricții și precizări==<br />
*coordonatele celor două puncte sunt '''numere întregi''' din intervalul [-1000 , 1000]<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:-1 2 4 -3<br />
<br />
;Ieșire<br />
<br />
:oblica<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
# Definirea functiei de validare care verifica daca coordonatele sunt in intervalul [-1000, 1000]<br />
def validare(x1, y1, x2, y2):<br />
if -1000 <= x1 <= 1000 and -1000 <= y1 <= 1000 and -1000 <= x2 <= 1000 and -1000 <= y2 <= 1000:<br />
return True<br />
return False<br />
<br />
<br />
# Definirea functiei dreapta care determina natura celor doua puncte<br />
def dreapta(x1, y1, x2, y2):<br />
if x1 == x2:<br />
print('verticala') # daca coordonata x a celor doua puncte este aceeasi, dreapta este verticala<br />
elif y1 == y2:<br />
print('orizontala') # daca coordonata y a celor doua puncte este aceeasi, dreapta este orizontala<br />
else:<br />
print('oblica') # daca niciuna dintre coordonate nu este aceeasi, dreapta este oblica<br />
<br />
<br />
if __name__ == "__main__":<br />
x1, y1, x2, y2 = map(int, input().split()) # citirea coordonatelor de la tastatura si maparea lor la tipul int<br />
if validare(x1, y1, x2, y2): # verificarea daca coordonatele sunt valide<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
dreapta(x1, y1, x2, y2) # apelarea functiei care determina natura dreptei<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0333_-_Triunghi1&diff=37390333 - Triunghi12023-04-16T11:56:00Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Să se scrie un program care citeşte trei numere reale şi verifică dacă aceste numere pot fi lungimile laturilor unui triunghi și în caz afirmativ determină daca triunghiul este '''ascuțitunghic''', '''dreptunghic''' sau '''obtuzunghic'''. ==Date de intrare== Programul citește de la tastatură trei numere reale '''a, b, c'''. ==Date de ieșire== Programul afișează pe ecran mesajul '''nu este triunghi''', dacă cele trei numere nu pot fi lungimile la...</p>
<hr />
<div>==Cerință==<br />
Să se scrie un program care citeşte trei numere reale şi verifică dacă aceste numere pot fi lungimile laturilor unui triunghi și în caz afirmativ determină daca triunghiul este '''ascuțitunghic''', '''dreptunghic''' sau '''obtuzunghic'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură trei numere reale '''a, b, c'''.<br />
<br />
==Date de ieșire==<br />
Programul afișează pe ecran mesajul '''nu este triunghi''', dacă cele trei numere nu pot fi lungimile laturilor unui triunghi, respectiv unul dintre mesajele '''triunghi ascutitunghic''', '''triunghi dreptunghic''' sau '''triunghi obtuzunghic''', în funcție de natura triunghiului.<br />
<br />
==Restricții și precizări==<br />
*0 ≤ '''a,b,c''' ≤ 100<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:3 5 4<br />
<br />
;Ieșire<br />
<br />
:triunghi dreptunghic<br />
<br />
==Exemplul 2==<br />
;Intrare<br />
<br />
:5 1 4<br />
<br />
;Ieșire<br />
<br />
:nu este triunghi<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(a, b, c):<br />
# Verifică dacă lungimile laturilor sunt cuprinse între 0 și 100<br />
if 0 <= a <= 100 and 0 <= b <= 100 and 0 <= c <= 100:<br />
return True<br />
return False<br />
<br />
<br />
def triunghi(a, b, c):<br />
if a <= 0 or b <= 0 or c <= 0 or a >= b + c or b >= a + c or c >= a + b:<br />
# Dacă laturile nu pot forma un triunghi, afișează un mesaj corespunzător<br />
print("nu este triunghi")<br />
elif a * a + b * b == c * c or b * b + c * c == a * a or c * c + a * a == b * b:<br />
# Dacă triunghiul este dreptunghic, afișează un mesaj corespunzător<br />
print("triunghi dreptunghic")<br />
elif a * a + b * b > c * c and b * b + c * c > a * a and c * c + a * a > b * b:<br />
# Dacă triunghiul este ascutitunghic, afișează un mesaj corespunzător<br />
print("triunghi ascutitunghic")<br />
else:<br />
# Dacă triunghiul este obtuzunghic, afișează un mesaj corespunzător<br />
print("triunghi obtuzunghic")<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citeste lungimile laturilor triunghiului de la tastatură<br />
a, b, c = map(float, input().split())<br />
if validare(a, b, c):<br />
# Dacă laturile sunt valide, afișează un mesaj corespunzător și calculează tipul triunghiului<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
triunghi(a, b, c)<br />
else:<br />
# Dacă laturile nu sunt valide, afișează un mesaj corespunzător<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=1301_-_Isoscel&diff=37381301 - Isoscel2023-04-16T11:45:50Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se citesc trei numere reale de la tastatură. Să se verifice dacă formează laturile unui triunghi '''isoscel'''. ==Date de intrare== Programul citește de la tastatură trei numere '''a b c'''. ==Date de ieșire== Programul va afișa pe ecran unul din următoarele mesaje: '''Formeaza triunghi isoscel''' – în cazul în care triunghiul este isoscel; '''Nu formeaza triunghi isoscel''' – în cazul în care triunghiul este echilateral sau oarecare; '''Nu fo...</p>
<hr />
<div>==Cerință==<br />
Se citesc trei numere reale de la tastatură. Să se verifice dacă formează laturile unui triunghi '''isoscel'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură trei numere '''a b c'''.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran unul din următoarele mesaje:<br />
'''Formeaza triunghi isoscel''' – în cazul în care triunghiul este isoscel;<br />
'''Nu formeaza triunghi isoscel''' – în cazul în care triunghiul este echilateral sau oarecare;<br />
'''Nu formeaza triunghi''' – în cazul în care numerele nu pot fi laturile unui triunghi.<br />
<br />
==Restricții și precizări==<br />
*triunghiul echilateral '''nu''' este considerat isoscel<br />
*laturile triunghiului oarecare sunt distincte două câte două<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:5 7.5 5<br />
<br />
;Ieșire<br />
<br />
:Formeaza triunghi isoscel<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(a, b, c):<br />
# Verifică dacă laturile triunghiului sunt pozitive și nenule<br />
if a <= 0 or b <= 0 or c <= 0:<br />
return False<br />
return True<br />
<br />
<br />
def isoscel(a, b, c):<br />
# Verifică dacă laturile formează un triunghi<br />
if a + b <= c or a + c <= b or b + c <= a:<br />
print("Nu formeaza triunghi")<br />
# Verifică dacă triunghiul este isoscel<br />
elif a == b and b != c or a == c and c != b or b == c and b != a:<br />
print("Formeaza triunghi isoscel")<br />
else:<br />
print("Nu formeaza triunghi isoscel")<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citeste valorile de la tastatură și verifică dacă sunt valide<br />
a, b, c = map(float, input().split())<br />
if validare(a, b, c):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
# Verifică dacă laturile formează un triunghi isoscel<br />
isoscel(a, b, c)<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=1358_-_Minciuna&diff=37371358 - Minciuna2023-04-16T11:29:14Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Andrei este foarte dezorganizat şi uneori mai strecoară câte o minciună. Pentru a-l responsabiliza, mama i-a dat în grijă biletele la teatru. Când aceasta îl întreabă unde a pus biletele, Andrei spune că între paginile numerotate cu '''x''' şi '''y''' ale manualului de informatică. Să se verifice dacă răspunsul lui Andrei poate fi corect – dacă poate plasa biletele între paginile numerotate cu '''x''' și '''y''' ale manualului de informati...</p>
<hr />
<div>==Cerință==<br />
Andrei este foarte dezorganizat şi uneori mai strecoară câte o minciună. Pentru a-l responsabiliza, mama i-a dat în grijă biletele la teatru. Când aceasta îl întreabă unde a pus biletele, Andrei spune că între paginile numerotate cu '''x''' şi '''y''' ale manualului de informatică.<br />
<br />
Să se verifice dacă răspunsul lui Andrei poate fi corect – dacă poate plasa biletele între paginile numerotate cu '''x''' și '''y''' ale manualului de informatică.<br />
<br />
==Date de intrare==<br />
Programul citeşte de la tastatură numerele naturale '''x''' şi '''y''' (reprezentând numărul paginilor).<br />
<br />
==Date de ieșire==<br />
Programul va afişa pe ecran mesajul '''Andrei e mai responsabil''', dacă Andrei poate plasa biletele între paginile numerotate cu '''x''' și '''y'''; în caz contrar programul va afişa '''minciuna'''.<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''x, y''' ≤ 1000<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:49 50<br />
<br />
;Ieșire<br />
<br />
:minciuna<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(x, y):<br />
if 1 <= x <= 1000 and 1 <= y <= 1000:<br />
return True<br />
return False<br />
<br />
<br />
def minciuna(x, y):<br />
if x + 1 == y and x % 2 == 0 or y + 1 == x and y % 2 == 0:<br />
print('Andrei e mai responsabil')<br />
else:<br />
print('minciuna')<br />
<br />
<br />
if __name__ == "__main__":<br />
x, y = map(int, input().split())<br />
if validare(x, y):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
minciuna(x, y)<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight><br />
<br />
==Explicatie==<br />
Acest program are două funcții definite, validare și minciuna, și un bloc if-else care încearcă să valideze datele de intrare, apoi să apeleze funcția minciuna dacă datele sunt valide, altfel să afișeze un mesaj de eroare.<br />
<br />
Funcția validare primește două parametri, x și y, și verifică dacă ambele valori se încadrează în intervalul 1-1000 inclusiv. Dacă această condiție este îndeplinită, funcția returnează True, altfel returnează False.<br />
<br />
Funcția minciuna primește, de asemenea, doi parametri, x și y, și verifică dacă una dintre condițiile de minciună este adevărată sau nu. Dacă x este cu 1 mai mare decât y și x este un număr par, sau dacă y este cu 1 mai mare decât x și y este un număr par, atunci se afișează mesajul "Andrei e mai responsabil". În caz contrar, se afișează mesajul "minciuna".<br />
<br />
În blocul if-else din programul principal, utilizatorul este întâi întrebat să introducă două valori întregi prin intermediul funcției input. Aceste valori sunt apoi convertite în numere întregi utilizând funcția map și funcția int. Dacă aceste valori sunt validate utilizând funcția validare, un mesaj de confirmare este afișat, iar funcția minciuna este apelată cu valorile x și y ca parametri. În caz contrar, un mesaj de eroare este afișat.</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=2765_-_Check_Color&diff=37362765 - Check Color2023-04-16T11:19:51Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Orice culoare poate fi reprezentată drept o combinație de intensități de roșu (RED), verde (GREEN) și albastru (BLUE). Calculatorul tău folosește, cel mai probabil, culori reprezentate pe 24 de biți, câte 8 rezervați fiecărei dintre cele trei culori anterior menționate. Dându-se trei numere, '''R''', '''G''' și '''B''', verificați dacă acestea pot reprezenta o culoare sau o nuanță de gri. O culoare se consideră nuanță de gri dacă și numai...</p>
<hr />
<div>==Cerință==<br />
Orice culoare poate fi reprezentată drept o combinație de intensități de roșu (RED), verde (GREEN) și albastru (BLUE). Calculatorul tău folosește, cel mai probabil, culori reprezentate pe 24 de biți, câte 8 rezervați fiecărei dintre cele trei culori anterior menționate.<br />
Dându-se trei numere, '''R''', '''G''' și '''B''', verificați dacă acestea pot reprezenta o culoare sau o nuanță de gri. O culoare se consideră nuanță de gri dacă și numai dacă diferența dintre oricare două coduri ce reprezintă culorile primare nu depășește 10.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură trei numere întregi, '''R''', '''G''' și '''B'''.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran:<br />
<br />
*'''NU E CULOARE''' dacă '''R''', '''G''' și '''B''' nu pot reprezenta o culoare;<br />
*'''CULOARE''' dacă '''R''', '''G''' și '''B''' pot reprezenta o culoare, dar nu o nuanță de gri;<br />
*'''GRI''' dacă '''R''', '''G''' și '''B''' pot reprezenta o nuanță de gri;<br />
<br />
==Restricții și precizări==<br />
*-1000 ≤ '''R, G, B''' ≤ 1000;<br />
*0 ≤ '''Rv, Gv, Bv''' ≤ 255 – unde v înseamnă valid.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:0 128 256<br />
<br />
;Ieșire<br />
<br />
:NU E CULOARE<br />
<br />
==Exemplul 2==<br />
;Intrare<br />
<br />
:118 128 255<br />
<br />
;Ieșire<br />
<br />
:CULOARE<br />
<br />
==Exemplul 3==<br />
;Intrare<br />
<br />
:118 119 120<br />
<br />
;Ieșire<br />
<br />
:GRI<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(R, G, B):<br />
# Verifică dacă R, G și B se află în intervalul [-1000, 1000]<br />
if -1000 <= R <= 1000 and -1000 <= G <= 1000 and -1000 <= B <= 1000:<br />
return True<br />
return False<br />
<br />
<br />
def verifica_culoare(R, G, B):<br />
a = [R, G, B]<br />
# Sortează vectorul a pentru a putea calcula diferența dintre cel mai mare și cel mai mic element<br />
a.sort()<br />
dif = a[2] - a[0]<br />
if 0 <= a[0] <= 255 and 0 <= a[2] <= 255:<br />
# Verifică dacă diferența dintre cel mai mare și cel mai mic element este mai mică sau egală cu 10<br />
if dif <= 10:<br />
return 'GRI'<br />
else:<br />
return 'CULOARE'<br />
else:<br />
return 'NU E CULOARE'<br />
<br />
<br />
# Verificarea daca codul este executat direct sau este importat ca un modul<br />
if __name__ == "__main__":<br />
R = int(input("Introduceti R: "))<br />
G = int(input("Introduceti G: "))<br />
B = int(input("Introduceti B: "))<br />
if validare(R, G, B):<br />
# Daca datele de intrare sunt valide, afiseaza un mesaj de confirmare si apeleaza functia verifica_culoare cu parametrii specificati<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(verifica_culoare(R, G, B))<br />
else:<br />
# Daca datele de intrare nu sunt valide, afiseaza un mesaj de eroare<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0179_-_Triunghi&diff=37350179 - Triunghi2023-04-16T10:53:09Z<p>Tuca Liviu Razvan: /* Cerință */</p>
<hr />
<div>==Cerință==<br />
Să se scrie un program care citeşte '''trei numere reale''' şi verifică dacă aceste numere pot fi lungimile laturilor unui triunghi.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură trei numere reale '''a, b, c'''.<br />
<br />
==Date de ieșire==<br />
Programul afișează pe ecran mesajul '''da''', dacă cele trei numere pot fi lungimile laturilor unui triunghi, respectiv '''nu''', în caz contrar.<br />
<br />
==Restricții și precizări==<br />
*0 ≤ '''a,b,c''' ≤ 1000<br />
*trei numere reale pot fi lungimile laturilor unui triunghi dacă sunt strict pozitive şi suma oricăror două este mai mare decât al treilea.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:3 4 5<br />
<br />
;Ieșire<br />
<br />
:da<br />
<br />
==Exemplul 2==<br />
;Intrare<br />
<br />
:1 4 5<br />
<br />
;Ieșire<br />
<br />
:nu<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
# Definirea functiei "validare" pentru a verifica daca a, b si c se incadreaza in limitele acceptate<br />
def validare(a, b, c):<br />
if 0 <= a <= 1000 and 0 <= b <= 1000 and 0 <= c <= 1000:<br />
return True<br />
return False<br />
<br />
<br />
# Definirea functiei "triunghi" pentru a verifica daca a, b si c formeaza un triunghi valid<br />
def triunghi(a, b, c):<br />
if a < b + c and b < a + c and c < a + b:<br />
print('da') # Daca triunghiul este valid, afiseaza "da"<br />
else:<br />
print('nu') # Daca triunghiul nu este valid, afiseaza "nu"<br />
<br />
<br />
# Verificarea daca codul este executat direct sau este importat ca un modul<br />
if __name__ == "__main__":<br />
a, b, c = map(int, input().split()) # Citeste 3 numere de la tastatura si le atribuie variabilelor a, b si c<br />
if validare(a, b, c):<br />
# Daca datele de intrare sunt valide, afiseaza un mesaj de confirmare si apeleaza functia triunghi cu parametrii specificati<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
triunghi(a, b, c)<br />
else:<br />
# Daca datele de intrare nu sunt valide, afiseaza un mesaj de eroare<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0179_-_Triunghi&diff=37340179 - Triunghi2023-04-16T10:52:34Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Să se scrie un program care citeşte '''trei''' numere reale şi verifică dacă aceste numere pot fi lungimile laturilor unui triunghi. ==Date de intrare== Programul citește de la tastatură trei numere reale '''a, b, c'''. ==Date de ieșire== Programul afișează pe ecran mesajul '''da''', dacă cele trei numere pot fi lungimile laturilor unui triunghi, respectiv '''nu''', în caz contrar. ==Restricții și precizări== *0 ≤ '''a,b,c''' ≤ 1000 *trei n...</p>
<hr />
<div>==Cerință==<br />
Să se scrie un program care citeşte '''trei''' numere reale şi verifică dacă aceste numere pot fi lungimile laturilor unui triunghi.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură trei numere reale '''a, b, c'''.<br />
<br />
==Date de ieșire==<br />
Programul afișează pe ecran mesajul '''da''', dacă cele trei numere pot fi lungimile laturilor unui triunghi, respectiv '''nu''', în caz contrar.<br />
<br />
==Restricții și precizări==<br />
*0 ≤ '''a,b,c''' ≤ 1000<br />
*trei numere reale pot fi lungimile laturilor unui triunghi dacă sunt strict pozitive şi suma oricăror două este mai mare decât al treilea.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:3 4 5<br />
<br />
;Ieșire<br />
<br />
:da<br />
<br />
==Exemplul 2==<br />
;Intrare<br />
<br />
:1 4 5<br />
<br />
;Ieșire<br />
<br />
:nu<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
# Definirea functiei "validare" pentru a verifica daca a, b si c se incadreaza in limitele acceptate<br />
def validare(a, b, c):<br />
if 0 <= a <= 1000 and 0 <= b <= 1000 and 0 <= c <= 1000:<br />
return True<br />
return False<br />
<br />
<br />
# Definirea functiei "triunghi" pentru a verifica daca a, b si c formeaza un triunghi valid<br />
def triunghi(a, b, c):<br />
if a < b + c and b < a + c and c < a + b:<br />
print('da') # Daca triunghiul este valid, afiseaza "da"<br />
else:<br />
print('nu') # Daca triunghiul nu este valid, afiseaza "nu"<br />
<br />
<br />
# Verificarea daca codul este executat direct sau este importat ca un modul<br />
if __name__ == "__main__":<br />
a, b, c = map(int, input().split()) # Citeste 3 numere de la tastatura si le atribuie variabilelor a, b si c<br />
if validare(a, b, c):<br />
# Daca datele de intrare sunt valide, afiseaza un mesaj de confirmare si apeleaza functia triunghi cu parametrii specificati<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
triunghi(a, b, c)<br />
else:<br />
# Daca datele de intrare nu sunt valide, afiseaza un mesaj de eroare<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0252_-_U2_Impare&diff=37330252 - U2 Impare2023-04-16T10:41:08Z<p>Tuca Liviu Razvan: /* Rezolvare ver. 1 */</p>
<hr />
<div>==Cerință==<br />
Se dă un număr natural '''n'''. Să se determine cele mai mari două numere impare, mai mici decât '''n'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numărul '''n'''.<br />
<br />
==Date de ieșire==<br />
Programul afișează pe prima linie a ecranului cele două numere '''impare''' determinate, în ordine '''crescătoare''', separate printr-un spaţiu.<br />
<br />
==Restricții și precizări==<br />
*4 ≤ '''n''' ≤ 1.000.000.000<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:8<br />
<br />
;Ieșire<br />
<br />
:5 7<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
# Definim functia pentru a verifica integritatea datelor<br />
def validare(n):<br />
if 4 <= n <= 1000000000:<br />
return True<br />
return False<br />
<br />
<br />
# Definim o functie care afiseaza ultimele 2 numere impare precedente numarului introdus<br />
def u2_impare(n):<br />
if n % 2 == 1: # Verificam paritatea numarului<br />
print(n - 4, ' ', n - 2)<br />
else:<br />
print(n - 3, ' ', n - 1)<br />
<br />
<br />
if __name__ == "__main__":<br />
n = int(input()) # Introducem un numar de la tastatura<br />
# Apelam functia de validare<br />
if validare(n):<br />
# Afiseaza un mesaj de confirmare a datelor de intrare valide<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
# Afiseaza rezultatul apelarii functiei u2_impare cu parametrii specificati<br />
u2_impare(n)<br />
else:<br />
# Afiseaza un mesaj de eroare daca datele de intrare nu sunt valide<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0253_-_U2_Pare&diff=37320253 - U2 Pare2023-04-16T10:40:25Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dă un număr natural '''n'''. Să se determine cele mai mici două numere pare, mai mari decât '''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 cele două numere '''pare''' determinate, în ordine '''crescătoare''', separate printr-un spaţiu. ==Restricții și precizări== *1 ≤ '''n''' ≤ 1.000.000.000 ==Exemplul 1== ;Intrare :8 ;Ieșire :10 12...</p>
<hr />
<div>==Cerință==<br />
Se dă un număr natural '''n'''. Să se determine cele mai mici două numere pare, mai mari decât '''n'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numărul '''n'''.<br />
<br />
==Date de ieșire==<br />
Programul afișează pe prima linie a ecranului cele două numere '''pare''' determinate, în ordine '''crescătoare''', separate printr-un spaţiu.<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''n''' ≤ 1.000.000.000<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:8<br />
<br />
;Ieșire<br />
<br />
:10 12<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
# Definim functia pentru a verifica integritatea datelor<br />
def validare(n):<br />
if 1 <= n <= 1000000000:<br />
return True<br />
return False<br />
<br />
<br />
# Definim o functie care afiseaza primele 2 numere pare mai mari decat numarul introdus<br />
def u2_pare(n):<br />
if n % 2 == 1: # Verificam paritatea numarului<br />
print(n + 1, ' ', n + 3)<br />
else:<br />
print(n + 2, ' ', n + 4)<br />
<br />
<br />
if __name__ == "__main__":<br />
n = int(input()) # Introducem un numar de la tastatura<br />
# Apelam functia de validare<br />
if validare(n):<br />
# Afiseaza un mesaj de confirmare a datelor de intrare valide<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
# Afiseaza rezultatul apelarii functiei u2_pare cu parametrii specificati<br />
u2_pare(n)<br />
else:<br />
# Afiseaza un mesaj de eroare daca datele de intrare nu sunt valide<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=0252_-_U2_Impare&diff=37310252 - U2 Impare2023-04-16T10:33:57Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dă un număr natural '''n'''. Să se determine cele mai mari două numere impare, mai mici decât '''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 cele două numere '''impare''' determinate, în ordine '''crescătoare''', separate printr-un spaţiu. ==Restricții și precizări== *4 ≤ '''n''' ≤ 1.000.000.000 ==Exemplul 1== ;Intrare :8 ;Ieșire :5...</p>
<hr />
<div>==Cerință==<br />
Se dă un număr natural '''n'''. Să se determine cele mai mari două numere impare, mai mici decât '''n'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numărul '''n'''.<br />
<br />
==Date de ieșire==<br />
Programul afișează pe prima linie a ecranului cele două numere '''impare''' determinate, în ordine '''crescătoare''', separate printr-un spaţiu.<br />
<br />
==Restricții și precizări==<br />
*4 ≤ '''n''' ≤ 1.000.000.000<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:8<br />
<br />
;Ieșire<br />
<br />
:5 7<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
# Definim functia pentru a verifica integritatea datelor<br />
def validare(n):<br />
if 4 <= n <= 1000000000:<br />
return True<br />
return False<br />
<br />
<br />
# Definim o functie care afiseaza ultimele 2 numere impare precedente numarului introdus<br />
def impare(n):<br />
if n % 2 == 1: # Verificam paritatea numarului<br />
print(n - 4, ' ', n - 2)<br />
else:<br />
print(n - 3, ' ', n - 1)<br />
<br />
<br />
if __name__ == "__main__":<br />
n = int(input()) # Introducem un numar de la tastatura<br />
# Apelam functia de validare<br />
if validare(n):<br />
# Afiseaza un mesaj de confirmare a datelor de intrare valide<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
# Afiseaza rezultatul apelarii functiei impare cu parametrii specificati<br />
impare(n)<br />
else:<br />
# Afiseaza un mesaj de eroare daca datele de intrare nu sunt valide<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=3925_-_Rest1&diff=37133925 - Rest12023-04-15T18:11:13Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dau numerele naturale '''n''', '''c''' și '''r'''. Să se determine numărul minim '''m''', strict mai mare decât '''n''', care dă restul '''r''' prin împărțire la '''c'''. ==Date de intrare== Programul citește de la tastatură numerele '''n''', '''c''' și '''r'''. ==Date de ieșire== Programul va afișa pe ecran numărul '''m'''. ==Restricții și precizări== *1 ≤ '''n''' ≤ 1.000.000.000.000 *0 ≤ '''r''' < '''c''' ≤ 1.000.000.000.000 ==E...</p>
<hr />
<div>==Cerință==<br />
Se dau numerele naturale '''n''', '''c''' și '''r'''. Să se determine numărul minim '''m''', strict mai mare decât '''n''', care dă restul '''r''' prin împărțire la '''c'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele '''n''', '''c''' și '''r'''.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran numărul '''m'''.<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''n''' ≤ 1.000.000.000.000<br />
*0 ≤ '''r''' < '''c''' ≤ 1.000.000.000.000<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:30 7 1<br />
<br />
;Ieșire<br />
<br />
:36<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(n, c, r):<br />
# Verifica daca n este intre 1 si 1000000000000<br />
if n < 1 or n > 1000000000000:<br />
return False<br />
# Verifica daca c este intre 0 si 1000000000000<br />
if c < 0 or c > 1000000000000:<br />
return False<br />
# Verifica daca r este intre 0 si c-1<br />
if r < 0 or r >= c:<br />
return False<br />
# Daca toate conditiile sunt indeplinite, returneaza True<br />
return True<br />
<br />
<br />
def numar_minim(n, c, r):<br />
m = n + 1<br />
# Cat timp restul impartirii lui m la c nu este egal cu r, adauga 1 la m<br />
while m % c != r:<br />
m += 1<br />
return m<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citirea datelor de intrare<br />
n, c, r = map(int, input().split())<br />
<br />
# Verificarea datelor de intrare și calculul valorilor cerute<br />
if validare(n, c, r):<br />
# Afiseaza un mesaj de confirmare a datelor de intrare valide<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
# Afiseaza rezultatul apelarii functiei numar_minim cu parametrii specificati<br />
print(numar_minim(n, c, r))<br />
else:<br />
# Afiseaza un mesaj de eroare daca datele de intrare nu sunt valide<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=2248_-_Coordonate&diff=37072248 - Coordonate2023-04-15T17:42:05Z<p>Tuca Liviu Razvan: </p>
<hr />
<div>==Cerință==<br />
Se consideră un pătrat mare împărțită în '''n''' x '''n''' pătrățele identice. Pătratul are deci '''n''' linii și '''n''' coloane (numerotate de la 1 la '''n'''), iar în fiecare pătrățel este trecut câte un număr natural cuprins între 1 și '''<math>n^2</math>''', ca în exemplul de mai jos în care '''n''' = 4:<br />
<br />
Pentru valorile '''n, x, y, val''' date, trebuie să determinați:<br />
<br />
*ce valoare V se află în pătratul n x n la poziția (x, y).<br />
*la ce poziție (i, j) se află valoarea val în pătratul n x n.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele '''n, x, y, val''', separate prin spații.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran numerele '''V, i, j''', separate prin câte un spațiu, unde '''V''' reprezintă valoarea de la poziția ('''x''', '''y'''), iar ('''i''', '''j''') reprezintă poziția unde se află valoarea val.<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''n''' ≤ 20000<br />
*1 ≤ '''x''', '''y''' ≤ '''n'''<br />
*1 ≤ '''val''' ≤ '''<math>n^2</math>'''<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:4 2 3 12<br />
<br />
;Ieșire<br />
<br />
:7 3 4<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(n, x, y, val):<br />
# Verifică dacă datele de intrare îndeplinesc condițiile impuse de enunț<br />
if not (1 <= n <= 20000):<br />
return False<br />
if not (1 <= x <= n):<br />
return False<br />
if not (1 <= y <= n):<br />
return False<br />
if not (1 <= val <= n ** 2):<br />
return False<br />
return True<br />
<br />
<br />
def calculeaza_val(n, x, y, val):<br />
# Calculează valoarea Val care se află în pătratul n x n la poziția (x, y)<br />
result_str = str((x - 1) * n + y) + ' '<br />
<br />
# Calculează poziția (i, j) a valorii val în pătratul n x n<br />
if val % n == 0:<br />
result_str += str(val // n) + ' ' + str(n)<br />
else:<br />
result_str += str(val // n + 1) + ' ' + str(val % n)<br />
return result_str<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citirea datelor de intrare<br />
n = int(input("n= "))<br />
x = int(input("x= "))<br />
y = int(input("y= "))<br />
val = int(input("val= "))<br />
<br />
# Verificarea datelor de intrare și calculul valorilor cerute<br />
if validare(n, x, y, val):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(calculeaza_val(n, x, y, val))<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight><br />
<br />
==Explicatie==<br />
Programul de mai jos determină valoarea V care se află în pătratul n x n la poziția (x, y) și poziția (i, j) a valorii val în pătratul n x n. Funcția '''validare''' verifică dacă datele de intrare îndeplinesc condițiile impuse de enunț, iar funcția '''calculeaza_val''' calculează valorile cerute în enunț.<br />
Programul citește datele de intrare de la tastatură și le trimite apoi la funcția '''validare''' pentru a verifica dacă valorile îndeplinesc restricțiile impuse de enunț. Dacă valorile sunt valide, programul calculează valorile cerute prin apelarea funcției '''calculeaza_val''' și le afișează pe ecran. Dacă valorile nu sunt valide, programul afișează un mesaj corespunzător pe ecran.</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=2248_-_Coordonate&diff=37062248 - Coordonate2023-04-15T17:41:46Z<p>Tuca Liviu Razvan: /* Cerință */</p>
<hr />
<div>==Cerință==<br />
Se consideră un pătrat mare împărțită în '''n''' x '''n''' pătrățele identice. Pătratul are deci '''n''' linii și '''n''' coloane (numerotate de la 1 la '''n'''), iar în fiecare pătrățel este trecut câte un număr natural cuprins între 1 și <math>n^2</math>, ca în exemplul de mai jos în care '''n''' = 4:<br />
<br />
Pentru valorile '''n, x, y, val''' date, trebuie să determinați:<br />
<br />
*ce valoare V se află în pătratul n x n la poziția (x, y).<br />
*la ce poziție (i, j) se află valoarea val în pătratul n x n.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele '''n, x, y, val''', separate prin spații.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran numerele '''V, i, j''', separate prin câte un spațiu, unde '''V''' reprezintă valoarea de la poziția ('''x''', '''y'''), iar ('''i''', '''j''') reprezintă poziția unde se află valoarea val.<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''n''' ≤ 20000<br />
*1 ≤ '''x''', '''y''' ≤ '''n'''<br />
*1 ≤ '''val''' ≤ '''<math>n^2</math>'''<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:4 2 3 12<br />
<br />
;Ieșire<br />
<br />
:7 3 4<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(n, x, y, val):<br />
# Verifică dacă datele de intrare îndeplinesc condițiile impuse de enunț<br />
if not (1 <= n <= 20000):<br />
return False<br />
if not (1 <= x <= n):<br />
return False<br />
if not (1 <= y <= n):<br />
return False<br />
if not (1 <= val <= n ** 2):<br />
return False<br />
return True<br />
<br />
<br />
def calculeaza_val(n, x, y, val):<br />
# Calculează valoarea Val care se află în pătratul n x n la poziția (x, y)<br />
result_str = str((x - 1) * n + y) + ' '<br />
<br />
# Calculează poziția (i, j) a valorii val în pătratul n x n<br />
if val % n == 0:<br />
result_str += str(val // n) + ' ' + str(n)<br />
else:<br />
result_str += str(val // n + 1) + ' ' + str(val % n)<br />
return result_str<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citirea datelor de intrare<br />
n = int(input("n= "))<br />
x = int(input("x= "))<br />
y = int(input("y= "))<br />
val = int(input("val= "))<br />
<br />
# Verificarea datelor de intrare și calculul valorilor cerute<br />
if validare(n, x, y, val):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(calculeaza_val(n, x, y, val))<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight><br />
<br />
==Explicatie==<br />
Programul de mai jos determină valoarea V care se află în pătratul n x n la poziția (x, y) și poziția (i, j) a valorii val în pătratul n x n. Funcția '''validare''' verifică dacă datele de intrare îndeplinesc condițiile impuse de enunț, iar funcția '''calculeaza_val''' calculează valorile cerute în enunț.<br />
Programul citește datele de intrare de la tastatură și le trimite apoi la funcția '''validare''' pentru a verifica dacă valorile îndeplinesc restricțiile impuse de enunț. Dacă valorile sunt valide, programul calculează valorile cerute prin apelarea funcției '''calculeaza_val''' și le afișează pe ecran. Dacă valorile nu sunt valide, programul afișează un mesaj corespunzător pe ecran.</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=2248_-_Coordonate&diff=37052248 - Coordonate2023-04-15T17:40:51Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se consideră un pătrat mare împărțită în '''n''' x '''n''' pătrățele identice. Pătratul are deci '''n''' linii și '''n''' coloane (numerotate de la 1 la '''n'''), iar în fiecare pătrățel este trecut câte un număr natural cuprins între 1 și '''n^2''', ca în exemplul de mai jos în care '''n''' = 4: Pentru valorile '''n, x, y, val''' date, trebuie să determinați: *ce valoare V se află în pătratul n x n la poziția (x, y). *la ce poziți...</p>
<hr />
<div>==Cerință==<br />
Se consideră un pătrat mare împărțită în '''n''' x '''n''' pătrățele identice. Pătratul are deci '''n''' linii și '''n''' coloane (numerotate de la 1 la '''n'''), iar în fiecare pătrățel este trecut câte un număr natural cuprins între 1 și '''n^2''', ca în exemplul de mai jos în care '''n''' = 4:<br />
<br />
Pentru valorile '''n, x, y, val''' date, trebuie să determinați:<br />
<br />
*ce valoare V se află în pătratul n x n la poziția (x, y).<br />
*la ce poziție (i, j) se află valoarea val în pătratul n x n.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele '''n, x, y, val''', separate prin spații.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran numerele '''V, i, j''', separate prin câte un spațiu, unde '''V''' reprezintă valoarea de la poziția ('''x''', '''y'''), iar ('''i''', '''j''') reprezintă poziția unde se află valoarea val.<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''n''' ≤ 20000<br />
*1 ≤ '''x''', '''y''' ≤ '''n'''<br />
*1 ≤ '''val''' ≤ '''n^2'''<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:4 2 3 12<br />
<br />
;Ieșire<br />
<br />
:7 3 4<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(n, x, y, val):<br />
# Verifică dacă datele de intrare îndeplinesc condițiile impuse de enunț<br />
if not (1 <= n <= 20000):<br />
return False<br />
if not (1 <= x <= n):<br />
return False<br />
if not (1 <= y <= n):<br />
return False<br />
if not (1 <= val <= n ** 2):<br />
return False<br />
return True<br />
<br />
<br />
def calculeaza_val(n, x, y, val):<br />
# Calculează valoarea Val care se află în pătratul n x n la poziția (x, y)<br />
result_str = str((x - 1) * n + y) + ' '<br />
<br />
# Calculează poziția (i, j) a valorii val în pătratul n x n<br />
if val % n == 0:<br />
result_str += str(val // n) + ' ' + str(n)<br />
else:<br />
result_str += str(val // n + 1) + ' ' + str(val % n)<br />
return result_str<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citirea datelor de intrare<br />
n = int(input("n= "))<br />
x = int(input("x= "))<br />
y = int(input("y= "))<br />
val = int(input("val= "))<br />
<br />
# Verificarea datelor de intrare și calculul valorilor cerute<br />
if validare(n, x, y, val):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(calculeaza_val(n, x, y, val))<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight><br />
<br />
==Explicatie==<br />
Programul de mai jos determină valoarea V care se află în pătratul n x n la poziția (x, y) și poziția (i, j) a valorii val în pătratul n x n. Funcția '''validare''' verifică dacă datele de intrare îndeplinesc condițiile impuse de enunț, iar funcția '''calculeaza_val''' calculează valorile cerute în enunț.<br />
Programul citește datele de intrare de la tastatură și le trimite apoi la funcția '''validare''' pentru a verifica dacă valorile îndeplinesc restricțiile impuse de enunț. Dacă valorile sunt valide, programul calculează valorile cerute prin apelarea funcției '''calculeaza_val''' și le afișează pe ecran. Dacă valorile nu sunt valide, programul afișează un mesaj corespunzător pe ecran.</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=3805_-_Raz%C4%83_Cerc_Circumscris&diff=37033805 - Rază Cerc Circumscris2023-04-15T17:17:35Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dau lungimile laturilor unui triunghi. Aflați '''raza''' cercului circumscris triunghiului. ==Date de intrare== Programul citește de la tastatură numerele '''a''', '''b''', '''c''', reprezentand lungimile laturilor triunghiului. ==Date de ieșire== Programul va afișa pe ecran numărul '''R''', reprezentând lungimea razei cercului circumscris cu '''2 zecimale exacte''', daca triunghiul este valid, altfel se va afisa mesajul '''Imposibil''' ==Restricți...</p>
<hr />
<div>==Cerință==<br />
Se dau lungimile laturilor unui triunghi. Aflați '''raza''' cercului circumscris triunghiului.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele '''a''', '''b''', '''c''', reprezentand lungimile laturilor triunghiului.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran numărul '''R''', reprezentând lungimea razei cercului circumscris cu '''2 zecimale exacte''', daca triunghiul este valid, altfel se va afisa mesajul '''Imposibil'''<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''a''', '''b''', '''c''' ≤ 1000<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:3 4 5<br />
<br />
;Ieșire<br />
<br />
:2.50<br />
<br />
==Exemplul 2==<br />
;Intrare<br />
<br />
:4 5 10<br />
<br />
;Ieșire<br />
<br />
:Imposibil<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
import math<br />
<br />
<br />
# Functia pentru validarea lungimilor laturilor triunghiului<br />
def validare(a, b, c):<br />
# Verifica daca fiecare lungime de latura este intre 1 si 1000<br />
if 1 <= a <= 1000 and 1 <= b <= 1000 and 1 <= c <= 1000:<br />
return True<br />
return False<br />
<br />
<br />
# Functia pentru calcularea razei cercului circumscris triunghiului<br />
def raza_cercului(a, b, c):<br />
# Verifica daca lungimile sunt pozitive si conform conditiei triunghiului<br />
if a <= 0 or b <= 0 or c <= 0:<br />
print("Imposibil")<br />
elif a + b <= c or b + c <= a or c + a <= b:<br />
print("Imposibil")<br />
else:<br />
# Calculeaza semiperimetrul triunghiului<br />
s = (a + b + c) / 2<br />
# Calculeaza aria triunghiului folosind formula lui Heron<br />
area = math.sqrt(s * (s - a) * (s - b) * (s - c))<br />
# Calculeaza raza cercului circumscris folosind formula ariei si lungimile laturilor<br />
radius = (a * b * c) / (4 * area)<br />
# Afiseaza rezultatul cu doua zecimale exacte<br />
print("{:.2f}".format(radius))<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citeste lungimile laturilor triunghiului de la tastatura<br />
a = int(input("Introduceti lungimea primei laturi: "))<br />
b = int(input("Introduceti lungimea celei de-a doua laturi: "))<br />
c = int(input("Introduceti lungimea celei de-a treia laturi: "))<br />
<br />
# Verifica daca lungimile laturilor sunt valide<br />
if validare(a, b, c):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
# Calculeaza raza cercului circumscris si o afiseaza<br />
raza_cercului(a, b, c)<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=1303_-_Calculator&diff=37011303 - Calculator2023-04-15T17:01:31Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dau '''două numere naturale''' și un simbol pentru una dintre operațiile '''+, -, *, /''' (adunare, scădere, înmulțire, impărțire). Să se determine rezultatul operației aplicate pentru cele două numere. ==Date de intrare== Programul citește de la tastatură numerele '''A B''', iar apoi '''simbolul operației'''. ==Date de ieșire== Programul va afișa pe ecran numărul '''R''', reprezentând rezultatul operației. ==Restricții și precizări==...</p>
<hr />
<div>==Cerință==<br />
Se dau '''două numere naturale''' și un simbol pentru una dintre operațiile '''+, -, *, /''' (adunare, scădere, înmulțire, impărțire). Să se determine rezultatul operației aplicate pentru cele două numere.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele '''A B''', iar apoi '''simbolul operației'''.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran numărul '''R''', reprezentând rezultatul operației.<br />
<br />
==Restricții și precizări==<br />
*atât numerele date cât și rezultatul operației au '''cel mult 9 cifre''';<br />
*numerele '''A''' și '''B''' nu sunt neapărat în ordine crescătoare sau descrescătoare; pentru operațiile de scădere și împărțire primul operand va fi numărul mai mare;<br />
*'''/''' reprezintă determinarea câtului împărțirii întregi.<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:10 20<br />
:+<br />
<br />
;Ieșire<br />
<br />
:30<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(a, b):<br />
if len(str(a)) > 9 or len(str(b)) > 9:<br />
print("Numerele trebuie să aibă cel mult 9 cifre!")<br />
return False<br />
return True<br />
<br />
<br />
def calculeaza(a, b, operatie):<br />
if operatie == '+':<br />
r = a + b<br />
elif operatie == '-':<br />
if b > a:<br />
r = b - a<br />
else:<br />
r = a - b<br />
elif operatie == '*':<br />
r = a * b<br />
elif operatie == '/':<br />
if a > b:<br />
if b != 0:<br />
r = a / b<br />
else:<br />
print("Impartirea la zero nu este permisa!")<br />
else:<br />
if a != 0:<br />
r = b / a<br />
else:<br />
print("Impartirea la zero nu este permisa!")<br />
return None<br />
else:<br />
print("Operatie invalida!")<br />
return None<br />
return r<br />
<br />
<br />
if __name__ == "__main__":<br />
a = int(input("Introdu primul numar: "))<br />
b = int(input("Introdu al doilea numar: "))<br />
operatie = input("Introdu operatia (+, -, *, /): ")<br />
if validare(a, b):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(calculeaza(a, b, operatie))<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight><br />
<br />
==Explicatie==<br />
<br />
Programul este scris în Python și conține două funcții, '''validare(a, b)''' și '''calculeaza(a, b, operatie)''', care verifică dacă numerele introduse și simbolul de operație sunt valide și calculează rezultatul operației respective. Funcția '''validare(a, b)''' verifică dacă ambele numere au cel mult 9 cifre, iar funcția '''calculeaza(a, b, operatie)''' efectuează operația specificată și returnează rezultatul.<br />
<br />
În funcția '''calculeaza(a, b, operatie)''', mai întâi se verifică simbolul de operație pentru a determina operația specificată. Apoi, se efectuează operația specificată pe numerele a și b și se stochează rezultatul în variabila '''r'''. În cazul în care simbolul de operație este '''/''', se verifică mai întâi dacă primul operand este mai mare decât al doilea, în caz contrar se inversează numerele. De asemenea, se verifică și dacă divisorul este zero, caz în care se afișează o eroare.<br />
<br />
În funcția '''main''', utilizatorul este întâi solicitat să introducă cele două numere și simbolul de operație. Apoi, se verifică dacă datele de intrare sunt valide utilizând funcția '''validare(a, b)'''. În caz afirmativ, se afișează un mesaj de confirmare și se calculează rezultatul utilizând funcția '''calculeaza(a, b, operatie)'''. În caz contrar, se afișează un mesaj de eroare.<br />
<br />
În plus, sunt incluse și câteva instrucțiuni de control a fluxului (if/else) și utilizarea parametrului special '''__name__''' pentru a verifica dacă programul este rulat direct sau importat ca modul.<br />
<br />
Pentru a face codul mai ușor de citit și de înțeles, sunt incluse și câteva comentarii. Acestea încep cu semnul '''#''' și sunt ignorate de către interpretorul Python la rulare. Comentariile explică modul în care funcțiile sunt utilizate și detalii despre ceea ce face fiecare funcție.</div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=2311_-_Rapunzel&diff=36972311 - Rapunzel2023-04-15T16:40:33Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Rapunzel s-a născut într-un ţinut îndepărtat într-un regat necunoscut. Mama vitregă a închis-o pe Rapunzel într-un turn foarte înalt ce avea '''N''' metri. Aici Rapunzel urma să-şi petreacă toată copilăria. Pentru a-i trece timpul mai uşor, Rapunzel cânta din zori şi până în seară, cântecul ei auzindu-se în tot ţinutul. Atras de vocea de privighetoare a fetei, Flynn Rider şi-a propus să se caţere pe pereţii exterior ai turnului şi...</p>
<hr />
<div>==Cerință==<br />
Rapunzel s-a născut într-un ţinut îndepărtat într-un regat necunoscut. Mama vitregă a închis-o pe Rapunzel într-un turn foarte înalt ce avea '''N''' metri. Aici Rapunzel urma să-şi petreacă toată copilăria.<br />
<br />
Pentru a-i trece timpul mai uşor, Rapunzel cânta din zori şi până în seară, cântecul ei auzindu-se în tot ţinutul. Atras de vocea de privighetoare a fetei, Flynn Rider şi-a propus să se caţere pe pereţii exterior ai turnului şi în fiecare zi să procedeze astfel: de la răsăritul până la asfinţitul soarelui să parcurgă '''M1''' metri iar apoi, de la asfinţit până la miezul nopţii încă '''M2''' metri.<br />
<br />
Scrieţi un program care determină după câte zile ajunge Flynn Rider la Rapunzel.<br />
<br />
==Date de intrare==<br />
De pe prima linie a fişierului '''rapunzel.in''' se citesc trei numere naturale '''N''', '''M1''' şi '''M2''', în această ordine, despărţite prin câte un spaţiu, având semnificaţia din enunţ.<br />
<br />
==Date de ieșire==<br />
În fişierul '''rapunzel.out''' se va afişa, pe prima linie, un număr natural ce reprezintă numărul de zile necesar lui Flynn Rider pentru a ajunge la Rapunzel.<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''n''' ≤ 5 000 000 000<br />
*1 ≤ '''M1''', '''M2''' ≤ 2 500<br />
<br />
==Exemplul 1==<br />
;rapunzel.in<br />
<br />
:7 3 4<br />
<br />
;rapunzel.out<br />
<br />
:1<br />
<br />
==Explicatie==<br />
Turnul are înălţimea de 7 metri. Flynn urcă până la asfinţit 3 metri iar apoi încă 4 metri. După o zi el va ajunge la Rapunzel.<br />
<br />
==Exemplul 2==<br />
;rapunzel.in<br />
<br />
:10 1 3<br />
<br />
;rapunzel.out<br />
<br />
:3<br />
<br />
==Explicatie==<br />
Turnul are înălţimea de 10 metri. Flynn urcă până la asfinţit 1 metru iar până la miezul nopţii încă 4 metri. După 3 zile el va ajunge la Rapunzel.<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
# Definim o funcție pentru validarea datelor de intrare<br />
def validare(n, m1, m2):<br />
if not (1 <= n <= 5000000000 and 1 <= m1 <= 2500 and 1 <= m2 <= 2500):<br />
return False<br />
else:<br />
return True<br />
<br />
<br />
# Definim o funcție pentru calcularea numărului de zile necesare lui Flynn<br />
def calculare_zile(n, m1, m2):<br />
z = m1 + m2<br />
d = n // z<br />
if d * z == n:<br />
return d<br />
else:<br />
return d + 1<br />
<br />
<br />
# Verificăm dacă acesta este fișierul principal și apelăm cele două funcții definite mai sus<br />
if __name__ == "__main__":<br />
# Deschidem fișierul de intrare pentru citire și fișierul de ieșire pentru scriere<br />
with open("rapunzel.in", "r") as fin, open("rapunzel.out", "w") as fout:<br />
# Citim n, m1 și m2 de la intrare și calculăm numărul de zile necesare<br />
n, m1, m2 = map(int, fin.readline().split())<br />
days = calculare_zile(n, m1, m2)<br />
# Verificăm dacă datele de intrare sunt valide și scriem numărul de zile necesare în fișierul de ieșire<br />
if validare(n, m1, m2):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
fout.write(str(days))<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=2419_-_%C3%8Ent%C3%A2lnire&diff=36952419 - Întâlnire2023-04-15T16:27:43Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Doi prieteni se afla pe axa '''Ox''', in puncte cu coordonate întregi. Primul se află în punctul '''x1 = a''', iar al doilea se află în punctul '''x2 = b'''. Fiecare se poate mișca cu o poziție, la stânga sau la dreapta, de un număr nelimitat de ori. Când se mișcă, oboseala se modifică după următoarea regulă: la '''prima''' mișcare oboseala crește cu '''1''', la '''a doua''' mișcare oboseala crește cu '''2''', la '''a treia''' cu '''3''' și...</p>
<hr />
<div>==Cerință==<br />
Doi prieteni se afla pe axa '''Ox''', in puncte cu coordonate întregi. Primul se află în punctul '''x1 = a''', iar al doilea se află în punctul '''x2 = b'''. Fiecare se poate mișca cu o poziție, la stânga sau la dreapta, de un număr nelimitat de ori. Când se mișcă, oboseala se modifică după următoarea regulă: la '''prima''' mișcare oboseala crește cu '''1''', la '''a doua''' mișcare oboseala crește cu '''2''', la '''a treia''' cu '''3''' și asa mai departe. De exemplu, dacă un prieten se mișcă mai întâi la stânga, apoi la dreapta, și apoi iar la stânga, oboseala lui devine 1 + 2 + 3 = 6.<br />
<br />
Prietenii vor să se întâlnească într-un punct cu coordonata număr întreg. Aflați oboseala totală '''minimă''' pe care cei doi cei doi o vor acumula.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele '''a''' si '''b'''.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran numărul '''S''', reprezentând oboseala minimă posibilă acumulată de cei doi prieteni.<br />
<br />
==Restricții și precizări==<br />
*1 ≤ '''a''' ≤ 1000<br />
*1 ≤ '''b''' ≤ 1000<br />
*'''a≠b'''<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:3 4<br />
<br />
;Ieșire<br />
<br />
:1<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(a, b):<br />
# Verifică dacă a și b sunt în intervalul [0,1000] și diferite între ele.<br />
if 0 <= a <= 1000 and 0 <= b <= 1000 and a != b:<br />
return True<br />
return False<br />
<br />
<br />
def oboseala_minima(a, b):<br />
if a > b:<br />
a, b = b, a<br />
<br />
ok = True # Inițializăm ok cu True, pentru a intra în bucla while.<br />
s = 0 # Inițializăm variabila s cu 0.<br />
i = 1 # Inițializăm i cu 1.<br />
<br />
while ok:<br />
if a != b:<br />
a += 1 # Incrementăm a.<br />
s += i # Adăugăm la s valoarea lui i.<br />
if a == b:<br />
ok = False # În cazul în care a ajunge egal cu b, ieșim din bucla while.<br />
else:<br />
b -= 1 # Decrementăm b.<br />
s += i # Adăugăm la s valoarea lui i.<br />
else:<br />
ok = False # În cazul în care a ajunge egal cu b, ieșim din bucla while.<br />
i += 1 # Incrementăm i.<br />
<br />
print(s) # Afișăm valoarea finală a variabilei s.<br />
<br />
<br />
if __name__ == "__main__":<br />
a = int(input()) # Citim prima valoare.<br />
b = int(input()) # Citim a doua valoare.<br />
if validare(a, b): # Verificăm dacă valorile citite sunt valide, folosind funcția validare.<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
oboseala_minima(a, b) # Dacă valorile sunt valide, apelăm funcția oboseala_minima.<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=3275_-_Nr_Sum_Cif_Max&diff=36923275 - Nr Sum Cif Max2023-04-15T16:11:41Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Se dau '''3''' numere naturale, fiecare având câte '''două cifre'''. Afișați-le pe acelea care au suma cifrelor '''maximă'''. ==Date de intrare== Programul citește de la tastatură cele trei numere, separate prin spații. ==Date de ieșire== Programul va afișa pe ecran, separate prin câte un spațiu, numerele care au '''suma cifrelor maximă'''. Dacă sunt mai multe, acestea se vor afișa în ordinea în care au fost introduse. ==Restricții și prec...</p>
<hr />
<div>==Cerință==<br />
Se dau '''3''' numere naturale, fiecare având câte '''două cifre'''. Afișați-le pe acelea care au suma cifrelor '''maximă'''.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură cele trei numere, separate prin spații.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran, separate prin câte un spațiu, numerele care au '''suma cifrelor maximă'''. Dacă sunt mai multe, acestea se vor afișa în ordinea în care au fost introduse.<br />
<br />
==Restricții și precizări==<br />
*se garantează că numerele introduse sunt de '''două''' cifre;<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:17 22 26<br />
<br />
;Ieșire<br />
<br />
:17 26<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(numar1, numar2, numar3):<br />
# Convertim argumentele in numere intregi.<br />
numar1 = int(numar1)<br />
numar2 = int(numar2)<br />
numar3 = int(numar3)<br />
# Verificam daca fiecare numar se afla intre 10 si 99.<br />
if 9 < numar1 < 100 and 9 < numar2 < 100 and 9 < numar3 < 100:<br />
return True<br />
return False<br />
<br />
<br />
def numere_cu_suma_maxima(numar1, numar2, numar3):<br />
# Calculam suma cifrelor fiecarui numar.<br />
suma1 = sum(int(c) for c in str(numar1))<br />
suma2 = sum(int(c) for c in str(numar2))<br />
suma3 = sum(int(c) for c in str(numar3))<br />
<br />
# Determinam suma maxima dintre cele trei numere.<br />
suma_maxima = max(suma1, suma2, suma3)<br />
<br />
# Initializam o lista goala pentru a adauga numerele cu suma maxima.<br />
numere = []<br />
if suma1 == suma_maxima:<br />
numere.append(numar1)<br />
if suma2 == suma_maxima:<br />
numere.append(numar2)<br />
if suma3 == suma_maxima:<br />
numere.append(numar3)<br />
<br />
return numere<br />
<br />
<br />
if __name__ == "__main__":<br />
# Citim cele trei numere de la tastatura.<br />
numar1, numar2, numar3 = input("Introduceti cele 3 numere separate prin spatiu: ").split()<br />
# Calculam numerele cu suma maxima.<br />
numere = numere_cu_suma_maxima(numar1, numar2, numar3)<br />
# Verificam daca cele trei numere respecta conditiile impuse.<br />
if validare(numar1, numar2, numar3):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
# Afisam numerele cu suma maxima, separate prin spatiu.<br />
print(*numere)<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=2782_-_Parada&diff=36822782 - Parada2023-04-15T14:43:55Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Pe un câmp orizontal se află doi stâlpi perpendiculari pe sol în punctele '''A''' și '''B'''. În vârful fiecărui stâlp se află o pasăre de pradă. Pe dreapta '''d''' determinată de punctele '''A''' si '''B''' apare un șoarece în punctul '''C'''. Cele două păsări zboară spre șoarece în linie dreaptă cu aceeași viteză. Cunoscând '''HA''' = înălțimea primului stâlp, '''HB''' = înălțimea celui de-al doilea stâlp, '''D''' = distanța...</p>
<hr />
<div>==Cerință==<br />
Pe un câmp orizontal se află doi stâlpi perpendiculari pe sol în punctele '''A''' și '''B'''. În vârful fiecărui stâlp se află o pasăre de pradă. Pe dreapta '''d''' determinată de punctele '''A''' si '''B''' apare un șoarece în punctul '''C'''. Cele două păsări zboară spre șoarece în linie dreaptă cu aceeași viteză.<br />
<br />
Cunoscând '''HA''' = înălțimea primului stâlp, '''HB''' = înălțimea celui de-al doilea stâlp, '''D''' = distanța dintre cei doi stâlpi, să se afle distanța '''X''' dintre șoarece și baza stâlpului mai înalt astfel încât păsările să ajungă la șoarece în același timp și să-l împartă frățește.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numerele naturale '''HA''', '''HB''' și '''D'''.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran numărul '''X''', reprezentând distanța dintre șoarece și baza stâlpului mai înalt astfel încât păsările să ajungă la șoarece în același timp și să-l împartă frățește.<br />
<br />
==Restricții și precizări==<br />
*Se garantează că '''HA''', '''HB''', '''D''', '''X''' sunt naturale si '''mai mici sau egale''' cu 1000<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:30 20 50<br />
<br />
;Ieșire<br />
<br />
:20<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
# Definim functia de validare pentru input<br />
def validare(ha, hb, d, x):<br />
if 0 < ha <= 1000 and 0 < hb <= 1000 and 0 < d <= 1000 and 0 < x <= 1000:<br />
return True<br />
return False<br />
<br />
<br />
# Definim functia de calcul a distantei dintre soarece si baza<br />
def distanta_soarece_baza(ha, hb, d):<br />
# Rearanjam valorile lui ha si hb, astfel incat ha sa fie mai mare sau egal cu hb<br />
if ha < hb:<br />
ha, hb = hb, ha<br />
# Calculam distanta dintre soarece si baza, folosind teorema lui Pitagora si aplicand formula generala<br />
c = ((hb ** 2 + d ** 2 - ha ** 2) / (2 * d))<br />
# Returnam valoarea absoluta a distantei<br />
return abs(c)<br />
<br />
<br />
if __name__ == "__main__":<br />
# Primește input-ul de la utilizator<br />
ha = int(input("Introduceti inaltimea primului stalp: "))<br />
hb = int(input("Introduceti celui de-al doilea stalp: "))<br />
d = int(input("Introduceti distanta dintre cei doi stalpi: "))<br />
# Calculam distanta dintre soarece si baza si o salvam in variabila x<br />
x = distanta_soarece_baza(ha, hb, d)<br />
<br />
# Verifică dacă input-ul este valid și afișează rezultatul<br />
if validare(ha, hb, d, x):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
print(int(x))<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvanhttps://wiki.universitas.ro/index.php?title=3060_-_Melc&diff=36813060 - Melc2023-04-15T14:21:34Z<p>Tuca Liviu Razvan: Pagină nouă: ==Cerință== Un melc se deplasează cu viteza de''' v km/h'''. El trebuie să parcurgă distanța de '''d''' metri. Să se determine în câte minute va parcurge melcul această distanță. ==Date de intrare== Programul citește de la tastatură numărul real '''v''' și numarul natural '''d''', separate prin spații. ==Date de ieșire== Programul va afișa pe ecran numărul întreg '''t''', reprezentând timpul exprimat în minute în care melcul va parcurge distanța '''...</p>
<hr />
<div>==Cerință==<br />
Un melc se deplasează cu viteza de''' v km/h'''. El trebuie să parcurgă distanța de '''d''' metri. Să se determine în câte minute va parcurge melcul această distanță.<br />
<br />
==Date de intrare==<br />
Programul citește de la tastatură numărul real '''v''' și numarul natural '''d''', separate prin spații.<br />
<br />
==Date de ieșire==<br />
Programul va afișa pe ecran numărul întreg '''t''', reprezentând timpul exprimat în minute în care melcul va parcurge distanța '''d'''.<br />
<br />
==Restricții și precizări==<br />
*numărul '''v''' este de tip double<br />
*0 < '''d''' < 1.000.000.000<br />
<br />
==Exemplul 1==<br />
;Intrare<br />
<br />
:0.3 20<br />
<br />
;Ieșire<br />
<br />
:4<br />
<br />
==Rezolvare==<br />
===Rezolvare ver. 1===<br />
<syntaxhighlight lang="python" line="1" start="1"><br />
def validare(v, d):<br />
"""<br />
Verifică dacă numărul v este de tip float și dacă numărul d este între 0 și 1.000.000.000.<br />
Args:<br />
v (float): numărul v de verificat<br />
d (int): numărul d de verificat<br />
Returns:<br />
bool: True dacă ambele condiții sunt îndeplinite, False în caz contrar<br />
"""<br />
if not isinstance(v, float): # dacă v nu este de tip float, returnează False<br />
return False<br />
if not (0 < d < 1000000000): # dacă d nu este între 0 și 1.000.000.000, returnează False<br />
return False<br />
return True<br />
<br />
<br />
def timp_parcurgere_distanta(v, d):<br />
"""<br />
Calculează timpul necesar pentru a parcurge o distanță dată la o anumită viteză.<br />
Args:<br />
v (float): viteza melcului (exprimată în km/h)<br />
d (int): distanța pe care trebuie să o parcurgă melcul (exprimată în metri)<br />
Returns:<br />
None: afișează timpul necesar pentru a parcurge distanța, exprimat în minute<br />
"""<br />
v = v * 1000 / 60 # convertește km/h în m/s<br />
T = 1.0 * d / v # calculează timpul necesar pentru a parcurge distanța<br />
t = int(T) # transformă timpul în minute întregi<br />
if T > t: # dacă există fracții de minut, adaugă 1 minut la timp<br />
t += 1<br />
print(t) # afișează timpul necesar pentru a parcurge distanța, exprimat în minute<br />
<br />
<br />
if __name__ == "__main__":<br />
# Primește input-ul de la utilizator<br />
v = float(input("Introduceti viteza (km/h): "))<br />
d = int(input("Introduceti distanta (m): "))<br />
<br />
# Verifică dacă input-ul este valid și afișează rezultatul<br />
if validare(v, d):<br />
print("Datele de intrare corespund restricțiilor impuse.")<br />
timp_parcurgere_distanta(v, d)<br />
else:<br />
print("Datele de intrare nu corespund restricțiilor impuse.")<br />
</syntaxhighlight></div>Tuca Liviu Razvan