Bitnami MediaWiki - User contributions [en]

Gazeta Matematică nr 4 2022

2023-10-20T11:18:18Z

Vardai Erwin:

'''28315 (Vasile Pop și Nicolae Mușuroia)'''

Fie <math>P_1P_2\ldots P_n</math> <math>(n \geq 3)</math> un poligon regulat și <math>M</math> un punct în interiorul poligonului. Notăm cu <math>M_1</math>, <math>M_2, \ldots, M_n</math> simetricele punctului <math>M</math> față de laturile poligonului. Arătați că, pentru orice alegere a punctului <math>M</math>, poligoanele <math>M_1</math><math>M_2 \ldots M_n</math> au același centru de greutate.

28315

2023-10-20T11:17:36Z

Vardai Erwin:

'''28315 (Vasile Pop și Nicolae Mușuroia)''' ‎
 
 
''Fie <math>P_1P_2\ldots P_n</math> <math>(n \geq 3)</math> un poligon regulat și <math>M</math> un punct în interiorul poligonului. Notăm cu <math>M_1</math>, <math>M_2, \ldots, M_n</math> simetricele punctului <math>M</math> față de laturile poligonului. Arătați că, pentru orice alegere a punctului <math>M</math>, poligoanele <math>M_1</math><math>M_2 \ldots M_n</math> au același centru de greutate.''
 
 
'''Soluție:'''
 
 
Vom demonstra următoarea lemă: În planul complex, simetricul punctului <math>M(m)</math> față de dreapta determinată de punctele <math>A(a)</math> și <math>B(b)</math>, unde <math>|a| = |b| = 1</math>, este punctul <math>M^{\prime}
</math> de afix <math>m^{\prime} = a + b - ab\overline{m}
.</math>
 
        Într-adevăr, din faptul că mijlocul <math>N(n)</math> al segmentului <math>[MM^{\prime}]</math> aparține dreptei <math>AB</math>, rezultă că <math>\frac{n-a}{b-a} \in \mathbb{R}</math>, adică <math>\frac{n-a}{b-a}</math> = <math>\frac{\overline{n}-\overline{a}}{\overline{b}-\overline{a}}, (1), </math> iar din <math>MM^{\prime} \perp AB</math>, deducem că <math>\frac{m^{\prime}-m}{b-a} \in i\mathbb{R^*}</math>, adică <math>\frac{m^{\prime}-m}{b-a} = - \frac{\overline{m^{\prime}}-\overline{m}}{\overline{b}-\overline{a}}, (2)</math>. Având în vedere că <math>\overline{a} = \frac{1}{a}, \overline{b} = \frac{1}{b}</math> și <math>n = \frac{m+m^{\prime}}{2}</math>, din relația <math>(1)</math> rezultă că <math>m^{\prime}+ m = 2(a + b) - ab(\overline{m^{\prime}}+\overline{m}), (3)</math>, iar din relația <math>(2)</math> că <math>m^{\prime}-m=ab(\overline{m^{\prime}}-\overline{m}), (4).</math> Adunând egalitățile <math>(3)</math> și <math>(4)</math> obținem <math>m^{\prime}=a+b-ab\overline{m}</math>.

        Revenind la problemă, considerăm un reper cartezian cu originea în centrul poligonului, astfel încât afixele punctelor <math>P_n</math> și <math>P_1</math> să fie <math>1</math>, respectiv <math>\epsilon = \cos\frac{2\pi}{n}+i\sin\frac{2\pi}{n}</math>. Ca urmare, afixul punctului <math>P_k</math> este <math>\epsilon^k</math>, pentru orice <math>k \in \{1, 2, \ldots, n\}
</math>.

        Fie <math>m</math> afixul punctului <math>M</math> și <math> m_k</math> afixul punctului <math>M_k, 1 \leq k \leq n.</math> Folosind lema, rezultă că <math> m_k=\epsilon^k+\epsilon^{k+1}-\epsilon^{2k+1} \overline{m}</math>, pentru orice <math>k</math>. În consecință, 
<math>
\sum_{k=1}^{n}m_k=(1+\epsilon) \sum_{k=1}^{n}\epsilon^k+\overline{m} \cdot \sum_{k=1}^{n}\epsilon^{2k+1}=(1+\epsilon)\cdot \epsilon \cdot \frac{\epsilon^n-1}{\epsilon-1}+\overline{m}\cdot\epsilon^3\cdot\frac{\epsilon^{2n}-1}{\epsilon^2-1}=0
</math>
, deci centrul de greutate al poligonului <math>M_1M_2 \ldots M_n</math> este originea, indiferent de alegerea punctului <math>M</math>.

Gazeta Matematică

2023-10-20T10:42:52Z

Vardai Erwin:

Această pagină conține o listă cu numerele revistei ''[https://gmb.ssmr.ro/ Gazeta Matematică]'' care conțin articole/probleme cu autori membri ai [https://ssmr.cunbm.utcluj.ro/ Filialei Maramureș] a [https://ssmr.ro/ Societății de Științe Matematice din România].
{| class="wikitable mw-collapsible"
|+
!Anul
!Numărul
!Numărul problemei
|-
|2022
|4 - [[Gazeta Matematică nr 4 2022|link]]
|-
|2018
|4 - [[Gazeta Matematică nr 4 2018|link]]
|
* [[S:E18.128]]
* [[S:E18.131]]
* [[S:E18.154]]
|-
|2015
|1 - [[Gazeta Matematică nr 27020 2015|link]]
|
* [[27020]]
|-
|2022
|4 - [[Gazeta Matematică nr 28315 2022|link]]
|
* [[28315]]
|}

28315

2023-10-20T10:37:11Z

Vardai Erwin: Pagină nouă:        '''28315.''' ‎''    Fie <math>P_1P_2\ldots P_n</math> <math>(n \geq 3)</math> un poligon regulat și <math>M</math> un punct în interiorul poligonului. Notăm cu <math>M_1</math>, <math>M_2, \ldots, M_n</math> simetricele punctului <math>M</math> față de laturile poligonului. Arătați că, pentru orice alegere a punctului <math>M</math>, poligoanele <math>M_1</math><math>M_2 \ldots M_n</math> au același centru de greutate.'' ::::::'...

'''28315.''' ‎''    Fie <math>P_1P_2\ldots P_n</math> <math>(n \geq 3)</math> un poligon regulat și <math>M</math> un punct în interiorul poligonului. Notăm cu <math>M_1</math>, <math>M_2, \ldots, M_n</math> simetricele punctului <math>M</math> față de laturile poligonului. Arătați că, pentru orice alegere a punctului <math>M</math>, poligoanele <math>M_1</math><math>M_2 \ldots M_n</math> au același centru de greutate.''
::::::'''''Vasile Pop'', Cluj-Napoca și ''Nicolae Mușuroia'', Baia Mare'''
‎ 
       '''''Soluție.''''' Vom demonstra următoarea lemă: În planul complex, simetricul punctului <math>M(m)</math> față de dreapta determinată de punctele <math>A(a)</math> și <math>B(b)</math>, unde <math>|a| = |b| = 1</math>, este punctul <math>M^{\prime}
</math> de afix <math>m^{\prime} = a + b - ab\overline{m}
.</math>
 
        Într-adevăr, din faptul că mijlocul <math>N(n)</math> al segmentului <math>[MM^{\prime}]</math> aparține dreptei <math>AB</math>, rezultă că <math>\frac{n-a}{b-a} \in \mathbb{R}</math>, adică <math>\frac{n-a}{b-a}</math> = <math>\frac{\overline{n}-\overline{a}}{\overline{b}-\overline{a}}, (1), </math> iar din <math>MM^{\prime} \perp AB</math>, deducem că <math>\frac{m^{\prime}-m}{b-a} \in i\mathbb{R^*}</math>, adică <math>\frac{m^{\prime}-m}{b-a} = - \frac{\overline{m^{\prime}}-\overline{m}}{\overline{b}-\overline{a}}, (2)</math>. Având în vedere că <math>\overline{a} = \frac{1}{a}, \overline{b} = \frac{1}{b}</math> și <math>n = \frac{m+m^{\prime}}{2}</math>, din relația <math>(1)</math> rezultă că <math>m^{\prime}+ m = 2(a + b) - ab(\overline{m^{\prime}}+\overline{m}), (3)</math>, iar din relația <math>(2)</math> că <math>m^{\prime}-m=ab(\overline{m^{\prime}}-\overline{m}), (4).</math> Adunând egalitățile <math>(3)</math> și <math>(4)</math> obținem <math>m^{\prime}=a+b-ab\overline{m}</math>.

        Revenind la problemă, considerăm un reper cartezian cu originea în centrul poligonului, astfel încât afixele punctelor <math>P_n</math> și <math>P_1</math> să fie <math>1</math>, respectiv <math>\epsilon = \cos\frac{2\pi}{n}+i\sin\frac{2\pi}{n}</math>. Ca urmare, afixul punctului <math>P_k</math> este <math>\epsilon^k</math>, pentru orice <math>k \in \{1, 2, \ldots, n\}
</math>.

        Fie <math>m</math> afixul punctului <math>M</math> și <math> m_k</math> afixul punctului <math>M_k, 1 \leq k \leq n.</math> Folosind lema, rezultă că <math> m_k=\epsilon^k+\epsilon^{k+1}-\epsilon^{2k+1} \overline{m}</math>, pentru orice <math>k</math>. În consecință, 
<math>
\sum_{k=1}^{n}m_k=(1+\epsilon) \sum_{k=1}^{n}\epsilon^k+\overline{m} \cdot \sum_{k=1}^{n}\epsilon^{2k+1}=(1+\epsilon)\cdot \epsilon \cdot \frac{\epsilon^n-1}{\epsilon-1}+\overline{m}\cdot\epsilon^3\cdot\frac{\epsilon^{2n}-1}{\epsilon^2-1}=0
</math>
, deci centrul de greutate al poligonului <math>M_1M_2 \ldots M_n</math> este originea, indiferent de alegerea punctului <math>M</math>.

Gazeta Matematică

2023-10-20T07:40:27Z

Vardai Erwin:

Această pagină conține o listă cu numerele revistei ''[https://gmb.ssmr.ro/ Gazeta Matematică]'' care conțin articole/probleme cu autori membri ai [https://ssmr.cunbm.utcluj.ro/ Filialei Maramureș] a [https://ssmr.ro/ Societății de Științe Matematice din România].
{| class="wikitable mw-collapsible"
|+
!Anul
!Numărul
!Numărul problemei
|-
|2018
|4 - [[Gazeta Matematică nr 4 2018|link]]
|
* [[S:E18.128]]
* [[S:E18.131]]
* [[S:E18.154]]
|-
|2015
|1 - [[Gazeta Matematică nr 27020 2015|link]]
|
* [[27020]]
|-
|
|
|
* [[28315]]
|}

3813 - Unghiuri

2023-05-07T20:30:00Z

Vardai Erwin: /* Explicație */

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

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

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

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

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

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

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

return (angle_a, angle_b, angle_c)

if __name__ == "__main__":
a, b, c = map(str, input().split())
if validare2(a, b, c):
a, b, c = float(a), float(b), float(c)
print("Datele de intrare corespund restrictiilor impuse.")
angles = calculate_angles(a, b, c)
if angles == "Imposibil":
print("Imposibil")
else:
print(*angles)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație==
Acest program calculează măsurile unghiurilor unui triunghi dat de lungimile laturilor sale.

Funcția validate_triangle(a, b, c) primește ca parametrii lungimile laturilor unui triunghi și verifică dacă triunghiul respectiv este valid, adică îndeplinește condițiile de existență ale unui triunghi: fiecare latură trebuie să fie mai mică decât suma celorlalte două laturi. Dacă triunghiul este valid, funcția returnează True, în caz contrar returnează False.

Funcția validare2(a, b, c) verifică dacă laturile triunghiului se încadrează în limitele impuse, în caz afirmativ returnează True, în caz contrar returnează False.

Funcția calculate_angles(a, b, c) primește ca parametrii lungimile laturilor triunghiului și calculează măsurile unghiurilor acestuia folosind formula lui Cosinus. Dacă triunghiul nu este valid, funcția returnează "Imposibil", altfel returnează un tuplu cu măsurile unghiurilor în ordinea A, B, C.

În funcția principală (if __name__ == "__main__":) se citesc lungimile laturilor triunghiului sub forma unor string-uri, se verifică dacă acestea respectă limitele impuse, apoi se convertesc în float-uri și se calculează măsurile unghiurilor triunghiului. Dacă triunghiul nu este valid, se afișează "Imposibil", altfel se afișează măsurile unghiurilor.

3813 - Unghiuri

2023-05-07T20:27:56Z

Vardai Erwin: /* Rezolvare ver. 1 */

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

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

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

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

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

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

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

return (angle_a, angle_b, angle_c)

if __name__ == "__main__":
a, b, c = map(str, input().split())
if validare2(a, b, c):
a, b, c = float(a), float(b), float(c)
print("Datele de intrare corespund restrictiilor impuse.")
angles = calculate_angles(a, b, c)
if angles == "Imposibil":
print("Imposibil")
else:
print(*angles)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

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

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

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

3813 - Unghiuri

2023-05-07T20:22:12Z

Vardai Erwin: /* Date de ieșire */

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

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

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

import math

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

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

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

return (angle_a, angle_b, angle_c)

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

if __name__ == "__main__":
main()

</syntaxhighlight>

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

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

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

3806 - Mediane

2023-05-07T20:03:23Z

Vardai Erwin: /* Rezolvare ver. 1 */

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran trei numere, reprezentând lungimile celor 3 mediane, fiecare cu 2 zecimale exacte, fără rotunjire, daca triunghiul este valid, altfel se afiseaza mesajul Imposibil. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:4.27 3.61 2.50

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

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

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

import math

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

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

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

if __name__ == "__main__":
a, b, c = map(str, input().split())
if validare2(a, b, c):
print("Datele de intrare corespund restrictiilor impuse.")
a, b, c = float(a), float(b), float(c)
medianele_triunghiului(a, b, c)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație==
Acest cod implementează un program care calculează medienele unui triunghi dat prin lungimile laturilor sale.

În funcția "validare", se verifică dacă laturile triunghiului îndeplinesc condiția de existență a triunghiului, adică suma oricăror două laturi trebuie să fie mai mare decât a treia latură.

În funcția "validare2", se verifică dacă laturile sunt în intervalul [1, 1000].

Funcția "medianele_triunghiului" calculează medienele triunghiului și le afișează în formatul "{:.2f} {:.2f} {:.2f}" (cu două zecimale).

În funcția principală, programul primește valorile laturilor triunghiului de la tastatură în formatul float, iar apoi verifică dacă acestea respectă intervalul [1, 1000] prin apelul funcției "validare2". Dacă valorile sunt în interval, se afișează un mesaj că datele corespund restricțiilor impuse, iar apoi laturile sunt transformate în int-uri și se apelează funcția "medianele_triunghiului". Dacă datele nu corespund restricțiilor impuse, se afișează un mesaj corespunzător.

3806 - Mediane

2023-05-07T20:02:26Z

Vardai Erwin: /* Rezolvare ver. 1 */

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran trei numere, reprezentând lungimile celor 3 mediane, fiecare cu 2 zecimale exacte, fără rotunjire, daca triunghiul este valid, altfel se afiseaza mesajul Imposibil. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:4.27 3.61 2.50

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

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

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

import math

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

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

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

if __name__ == "__main__":
a, b, c = map(str, input().split())
if validare2(a, b, c):
print("Datele de intrare corespund restrictiilor impuse.")
a, b, c = float(a), float(b), float(c)
medianele_triunghiului(a, b, c)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație==
Acest cod implementează un program care calculează medienele unui triunghi dat prin lungimile laturilor sale.

În funcția "validare", se verifică dacă laturile triunghiului îndeplinesc condiția de existență a triunghiului, adică suma oricăror două laturi trebuie să fie mai mare decât a treia latură.

În funcția "validare2", se verifică dacă laturile sunt în intervalul [1, 1000].

Funcția "medianele_triunghiului" calculează medienele triunghiului și le afișează în formatul "{:.2f} {:.2f} {:.2f}" (cu două zecimale).

În funcția principală, programul primește valorile laturilor triunghiului de la tastatură în formatul float, iar apoi verifică dacă acestea respectă intervalul [1, 1000] prin apelul funcției "validare2". Dacă valorile sunt în interval, se afișează un mesaj că datele corespund restricțiilor impuse, iar apoi laturile sunt transformate în int-uri și se apelează funcția "medianele_triunghiului". Dacă datele nu corespund restricțiilor impuse, se afișează un mesaj corespunzător.

3806 - Mediane

2023-05-07T20:01:36Z

Vardai Erwin: /* Explicatie */

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran trei numere, reprezentând lungimile celor 3 mediane, fiecare cu 2 zecimale exacte, fără rotunjire, daca triunghiul este valid, altfel se afiseaza mesajul Imposibil. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:4.27 3.61 2.50

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

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

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

import math

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

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

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

if __name__ == "__main__":
a, b, c = map(float, input().split())
if validare2(a, b, c):
print("Datele de intrare corespund restrictiilor impuse.")
a, b, c = int(a), int(b), int(c)
medianele_triunghiului(a, b, c)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație==
Acest cod implementează un program care calculează medienele unui triunghi dat prin lungimile laturilor sale.

În funcția "validare", se verifică dacă laturile triunghiului îndeplinesc condiția de existență a triunghiului, adică suma oricăror două laturi trebuie să fie mai mare decât a treia latură.

În funcția "validare2", se verifică dacă laturile sunt în intervalul [1, 1000].

Funcția "medianele_triunghiului" calculează medienele triunghiului și le afișează în formatul "{:.2f} {:.2f} {:.2f}" (cu două zecimale).

În funcția principală, programul primește valorile laturilor triunghiului de la tastatură în formatul float, iar apoi verifică dacă acestea respectă intervalul [1, 1000] prin apelul funcției "validare2". Dacă valorile sunt în interval, se afișează un mesaj că datele corespund restricțiilor impuse, iar apoi laturile sunt transformate în int-uri și se apelează funcția "medianele_triunghiului". Dacă datele nu corespund restricțiilor impuse, se afișează un mesaj corespunzător.

3806 - Mediane

2023-05-07T19:59:58Z

Vardai Erwin: /* Rezolvare ver. 1 */

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran trei numere, reprezentând lungimile celor 3 mediane, fiecare cu 2 zecimale exacte, fără rotunjire, daca triunghiul este valid, altfel se afiseaza mesajul Imposibil. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:4.27 3.61 2.50

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

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

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

import math

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

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

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

if __name__ == "__main__":
a, b, c = map(float, input().split())
if validare2(a, b, c):
print("Datele de intrare corespund restrictiilor impuse.")
a, b, c = int(a), int(b), int(c)
medianele_triunghiului(a, b, c)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicatie==

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

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

3806 - Mediane

2023-05-07T19:57:51Z

Vardai Erwin: /* Exemplul 2 */

3806 - Mediane

2023-05-07T19:57:34Z

Vardai Erwin: /* Exemplul 1 */

3806 - Mediane

2023-05-07T19:57:08Z

Vardai Erwin: /* Date de ieșire */

3812 - Înălțimi2

2023-05-07T19:52:17Z

Vardai Erwin: /* Explicatie */

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

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

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

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

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

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

</syntaxhighlight>

==Explicație==

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

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

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

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

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

3812 - Înălțimi2

2023-05-07T19:48:48Z

Vardai Erwin: /* Rezolvare ver. 1 */

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

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

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

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

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

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

</syntaxhighlight>

==Explicatie==

Funcția validate_triangle(a, b, c) verifică dacă triunghiul dat este valid folosind condiția de validitate menționată mai sus.
Funcția calculate_altitudes(a, b, c) calculează lungimile înălțimilor triunghiului dacă triunghiul dat este valid, altfel returnează un mesaj de eroare. Pentru calcularea lungimilor înălțimilor, am folosit formula dată mai sus și am rotunjit rezultatele la două zecimale folosind funcția round().
Funcția main() citește lungimile laturilor triunghiului de la tastatură folosind funcția input() și apoi apelează funcția calculate_altitudes(a, b, c) pentru a calcula lungimile înălțimilor triunghiului. Rezultatele sunt apoi afișate folosind funcția print().

3812 - Înălțimi2

2023-05-07T19:41:54Z

Vardai Erwin: /* Exemplul 2 */

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

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

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

def validate_triangle(a, b, c):
if a + b > c and a + c > b and b + c > a:
return True
return False

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

def main():
a, b, c = map(float, input().split())
ha, hb, hc = calculate_altitudes(a, b, c)
print(ha, hb, hc)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==

Funcția validate_triangle(a, b, c) verifică dacă triunghiul dat este valid folosind condiția de validitate menționată mai sus.
Funcția calculate_altitudes(a, b, c) calculează lungimile înălțimilor triunghiului dacă triunghiul dat este valid, altfel returnează un mesaj de eroare. Pentru calcularea lungimilor înălțimilor, am folosit formula dată mai sus și am rotunjit rezultatele la două zecimale folosind funcția round().
Funcția main() citește lungimile laturilor triunghiului de la tastatură folosind funcția input() și apoi apelează funcția calculate_altitudes(a, b, c) pentru a calcula lungimile înălțimilor triunghiului. Rezultatele sunt apoi afișate folosind funcția print().

3812 - Înălțimi2

2023-05-07T19:41:39Z

Vardai Erwin: /* Exemplul 1 */

3812 - Înălțimi2

2023-05-07T19:41:18Z

Vardai Erwin: /* Date de ieșire */

0970 - Gen

2023-05-07T19:35:21Z

Vardai Erwin: /* Rezolvare ver. 1 */

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

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

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

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

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

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

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

</syntaxhighlight>

==Explicatie==

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

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

0970 - Gen

2023-05-07T19:34:12Z

Vardai Erwin: /* Exemplul 1 */

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

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

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

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

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

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

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

</syntaxhighlight>

==Explicatie==

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

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

0970 - Gen

2023-05-07T19:33:47Z

Vardai Erwin: /* Date de ieșire */

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

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

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

==Cerință==

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

==Date de intrare==

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

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

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

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

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

;'''Iesire '''

1111101000010

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

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

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

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

</syntaxhighlight>

==Explicatie==

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

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

0970 - Gen

2023-05-07T19:32:58Z

Vardai Erwin: /* Enunt */

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

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

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==

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

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

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

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

;'''Iesire '''

1111101000010

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

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

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

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

</syntaxhighlight>

==Explicatie==

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

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

2579 - Putere 2 Interval

2023-05-07T19:22:36Z

Vardai Erwin:

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

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran puterile lui '''2''' din intervalul '''[a,b]'''.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

==Restricții și precizări==
*'''1 ≤ n ≤ 60'''
*'''1 ≤ a ≤ b < 2^64'''

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

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

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

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

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

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

if __name__ == '__main__':
n, a, b = map(int, input().split())
if not validate_input(n, a, b):
print("Datele de intrare nu corespund restrictiior impuse.")
else:
print("Datele de intrare corespund restrictiior impuse.")
putere_2_interval(n, a, b)
</syntaxhighlight>

==Explicație==
Acest cod este o implementare Python a unei funcții numită "putere_2_interval", care primește trei parametri de intrare: n, a și b. Scopul funcției este să afișeze primele n numere întregi care sunt puteri ale lui 2 și care se află în intervalul [a, b].

Înainte de a apela funcția "putere_2_interval", datele de intrare sunt verificate prin intermediul funcției "validate_input". Această funcție primește cele trei valori de intrare, verifică dacă acestea corespund condițiilor impuse, și returnează adevărat dacă datele de intrare sunt valide sau fals dacă nu sunt. În cazul în care datele de intrare nu sunt valide, se afișează un mesaj de eroare și programul se oprește.

Dacă datele de intrare sunt valide, se afișează un mesaj de confirmare și se apelează funcția "putere_2_interval". Această funcție parcurge toate puterile de 2 de la 1 la 2^63 și verifică dacă acestea se află în intervalul [a, b]. Toate puterile de 2 care se încadrează în acest interval sunt stocate într-o listă numită "powers_of_2". Această listă este sortată în ordine crescătoare și primele n elemente sunt afișate pe ecran.

În final, dacă datele de intrare sunt corecte, programul afișează primele n puteri ale lui 2 care se află în intervalul [a, b], sau un mesaj de eroare în caz contrar.

2579 - Putere 2 Interval

2023-05-07T19:16:42Z

Vardai Erwin: /* Exemplul 1 */

==Cerință==

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

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran puterile lui '''2''' din intervalul '''[a,b]'''.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

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

==Explicatie==

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

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

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

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

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

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

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==

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

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

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

2579 - Putere 2 Interval

2023-05-07T19:16:10Z

Vardai Erwin: /* Date de ieșire */

==Cerință==

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

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran puterile lui '''2''' din intervalul '''[a,b]'''.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Ieșire '''

8 16

==Explicatie==

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

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

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

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

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

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

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicatie==

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

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

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

0326 - Ultimul Par

2023-05-07T19:15:16Z

Vardai Erwin: /* Exemplul 1 */

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul afişează pe ecran ultimul număr par dintre cele date. Dacă nu au fost citite numere pare, se va afişa doar mesajul '''IMPOSIBIL'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Date de ieşire '''
:Datele de intrare corespund restricțiilor impuse.
:90

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

def validare2(numar):
return 0 < int(numar) <= 10 ** 9

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

if __name__ == '__main__':
n = input("Introduceti numarul de numere: ")
numere = []
if validare(n):
n = int(n)
for i in range(n):
numar = input()
if validare(numar):
numar = int(numar)
numere.append(numar)
print("Datele de intrare corespund restrictiilor impuse.")
ultimul_numar_par(n, numere)
else:
print("Datele de intrare corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație==

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

0326 - Ultimul Par

2023-05-07T19:14:44Z

Vardai Erwin: /* Rezolvare ver. 1 */

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul afişează pe ecran ultimul număr par dintre cele date. Dacă nu au fost citite numere pare, se va afişa doar mesajul '''IMPOSIBIL'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Date de ieşire '''
:Datele de intrare corespund restricțiilor impuse.
:90

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

def validare2(numar):
return 0 < int(numar) <= 10 ** 9

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

if __name__ == '__main__':
n = input("Introduceti numarul de numere: ")
numere = []
if validare(n):
n = int(n)
for i in range(n):
numar = input()
if validare(numar):
numar = int(numar)
numere.append(numar)
print("Datele de intrare corespund restrictiilor impuse.")
ultimul_numar_par(n, numere)
else:
print("Datele de intrare corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație==

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

0326 - Ultimul Par

2023-05-07T19:14:25Z

Vardai Erwin: /* Rezolvare ver. 1 */

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul afişează pe ecran ultimul număr par dintre cele date. Dacă nu au fost citite numere pare, se va afişa doar mesajul '''IMPOSIBIL'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Date de ieşire '''
:Datele de intrare corespund restricțiilor impuse.
:90

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

def validare2(numar):
return 0 <= 10 ** 9

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

if __name__ == '__main__':
n = input("Introduceti numarul de numere: ")
numere = []
if validare(n):
n = int(n)
for i in range(n):
numar = input()
if validare(numar):
numar = int(numar)
numere.append(numar)
print("Datele de intrare corespund restrictiilor impuse.")
ultimul_numar_par(n, numere)
else:
print("Datele de intrare corespund restrictiilor impuse.")

</syntaxhighlight>

==Explicație==

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

0326 - Ultimul Par

2023-05-07T19:02:32Z

Vardai Erwin:

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul afişează pe ecran ultimul număr par dintre cele date. Dacă nu au fost citite numere pare, se va afişa doar mesajul '''IMPOSIBIL'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Date de ieşire '''
:Datele de intrare corespund restricțiilor impuse.
:90

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

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

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

</syntaxhighlight>

==Explicație==

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

2276 - Cb

2023-05-07T18:45:28Z

Vardai Erwin: /* Explicatie */

==Enunț==

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran '''T''' linii. Pe fiecare linie '''i (i=1..T)''' se va afla un singur număr natural reprezentând răspunsul la a '''i'''-a întrebare. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:4
:9
:1
:0
:3
:0
:7

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

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

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

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

return counts

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

intervals = []
for i in range(T):
x, y = map(int, input().split())
intervals.append((x, y))
if validate_input(n, T, a, intervals):
print("Datele de intrare corespund restrictiilor impuse.")
counts = count_numbers_in_intervals(n, T, a, intervals)
for count in counts:
print(count)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

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

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

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

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

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

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

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

2276 - Cb

2023-05-07T18:45:14Z

Vardai Erwin: /* Rezolvare ver. 1 */

==Enunț==

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran '''T''' linii. Pe fiecare linie '''i (i=1..T)''' se va afla un singur număr natural reprezentând răspunsul la a '''i'''-a întrebare. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:4
:9
:1
:0
:3
:0
:7

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

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

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

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

return counts

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

intervals = []
for i in range(T):
x, y = map(int, input().split())
intervals.append((x, y))
if validate_input(n, T, a, intervals):
print("Datele de intrare corespund restrictiilor impuse.")
counts = count_numbers_in_intervals(n, T, a, intervals)
for count in counts:
print(count)
else:
print("Datele de intrare nu corespund restrictiilor impuse.")

</syntaxhighlight>

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

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

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

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

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

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

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

2276 - Cb

2023-05-07T18:43:02Z

Vardai Erwin: /* Exemplul 1 */

==Enunț==

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran '''T''' linii. Pe fiecare linie '''i (i=1..T)''' se va afla un singur număr natural reprezentând răspunsul la a '''i'''-a întrebare. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Ieșire '''
:Datele de intrare corespund restrictiilor impuse.
:4
:9
:1
:0
:3
:0
:7

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

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

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

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

return counts

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

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

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

for count in counts:
print(count)

</syntaxhighlight>

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

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

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

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

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

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

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

2276 - Cb

2023-05-07T18:42:19Z

Vardai Erwin: /* Date de ieșire */

==Enunț==

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Programul va afișa pe ecran '''T''' linii. Pe fiecare linie '''i (i=1..T)''' se va afla un singur număr natural reprezentând răspunsul la a '''i'''-a întrebare. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Ieșire '''

4
9
1
0
3
0
7

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

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

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

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

return counts

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

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

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

for count in counts:
print(count)

</syntaxhighlight>

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

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

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

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

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

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

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

2014 - Canguri

2023-05-07T18:41:58Z

Vardai Erwin: /* Explicatie */

==Enunț==

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

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

==Cerință==

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

==Date de intrare==

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

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
În fişierul canguri.out se va scrie:

*pe prima linie, numărul de concurs al cangurului care trece primul linia de sosire;
*pe cea de-a doua linie, un număr natural ce reprezintă numărul săriturilor efectuate de cangurul care a trecut primul linia de sosire.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''canguri.out '''
:354
:134

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

==Explicație==

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

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

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

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

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

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

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

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

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

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicație==

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

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

2276 - Cb

2023-05-07T18:41:43Z

Vardai Erwin: /* Enunt */

==Enunț==

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==

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

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

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

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

;'''Ieșire '''

4
9
1
0
3
0
7

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

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

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

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

return counts

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

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

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

for count in counts:
print(count)

</syntaxhighlight>

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

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

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

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

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

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

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

2014 - Canguri

2023-05-07T18:36:26Z

Vardai Erwin: /* Explicatie */

==Enunț==

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

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

==Cerință==

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

==Date de intrare==

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

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
În fişierul canguri.out se va scrie:

*pe prima linie, numărul de concurs al cangurului care trece primul linia de sosire;
*pe cea de-a doua linie, un număr natural ce reprezintă numărul săriturilor efectuate de cangurul care a trecut primul linia de sosire.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''canguri.out '''
:354
:134

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

==Explicație==

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

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

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

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

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

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

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

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

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

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatie==

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

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

2014 - Canguri

2023-05-07T18:35:44Z

Vardai Erwin: /* Exemplul 1 */

==Enunț==

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

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

==Cerință==

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

==Date de intrare==

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

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
În fişierul canguri.out se va scrie:

*pe prima linie, numărul de concurs al cangurului care trece primul linia de sosire;
*pe cea de-a doua linie, un număr natural ce reprezintă numărul săriturilor efectuate de cangurul care a trecut primul linia de sosire.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''canguri.out '''
:354
:134

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

==Explicatie==

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

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

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

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

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

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

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

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

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

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatie==

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

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

2014 - Canguri

2023-05-07T18:33:50Z

Vardai Erwin: /* Date de ieșire */

==Enunț==

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

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

==Cerință==

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

==Date de intrare==

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

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
În fişierul canguri.out se va scrie:

*pe prima linie, numărul de concurs al cangurului care trece primul linia de sosire;
*pe cea de-a doua linie, un număr natural ce reprezintă numărul săriturilor efectuate de cangurul care a trecut primul linia de sosire.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''canguri.out '''

354
134

==Explicatie==

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

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

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

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

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

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

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

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

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

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatie==

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

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

2014 - Canguri

2023-05-07T18:32:00Z

Vardai Erwin: /* Enunt */

==Enunț==

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

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

==Cerință==

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

==Date de intrare==

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

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

==Date de ieșire==

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

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

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

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

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

;'''canguri.out '''

354
134

==Explicatie==

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

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

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

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

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

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

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

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

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

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicatie==

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

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

1470 - Parcare

2023-05-07T18:23:19Z

Vardai Erwin: /* Explicatie */

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

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

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

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

==Cerință==

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

==Date de intrare==

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

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

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

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

==Date de ieșire==

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." Fişierul de ieşire '''parcare.out''' conţine pe prima linie o valoarea naturală reprezentând timpul cât mașina a stat în parcare, exprimat în minute, dacă cerinţa a fost''' 1''', respectiv suma de plată, dacă cerinţa a fost '''2'''. În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

30 01 17 33
30 01 21 01
3
1

;'''parcare.out'''
208

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

==Explicatie==

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

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

30 01 17 33
30 01 21 01
3
2

;'''parcare.out'''
12

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

==Explicație==

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

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

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

return True

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

return parking_time

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

return parking_fee

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

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

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

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

</syntaxhighlight>

3644 - Joc12

2023-05-07T18:16:58Z

Vardai Erwin: /* Rezolvare ver. 1 */

==Enunț==

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Pe ecran se va afișa numele fetei care câștigă și o valoare P ce reprezintă numărul care conduce la câștigarea jocului, separate printr-un spațiu. În caz de egalitate se va afișa '''Egalitate''' urmat de un spaţiu şi de numărul egal al multiplilor.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

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

==Explicație==

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

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

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

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

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

if __name__ == '__main__':
x = int(input())
a = int(input())
b = int(input())
y = int(input())
c = int(input())
d = int(input())
if validate_input(x, a, b, y, c, d):
print("Datele de intrare corespund restricțiilor impuse.")
winner, num = find_winner(x, a, b, y, c, d)
print(winner, num)
else:
print("Datele de intrare nu corespund restricțiilor impuse.")

</syntaxhighlight>

==Explicatie==

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

3644 - Joc12

2023-05-07T18:14:57Z

Vardai Erwin: /* Explicatie */

==Enunț==

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Pe ecran se va afișa numele fetei care câștigă și o valoare P ce reprezintă numărul care conduce la câștigarea jocului, separate printr-un spațiu. În caz de egalitate se va afișa '''Egalitate''' urmat de un spaţiu şi de numărul egal al multiplilor.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

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

==Explicație==

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

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

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

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

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

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

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

</syntaxhighlight>

==Explicatie==

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

3644 - Joc12

2023-05-07T18:14:49Z

Vardai Erwin: /* Exemplul 1 */

==Enunț==

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Pe ecran se va afișa numele fetei care câștigă și o valoare P ce reprezintă numărul care conduce la câștigarea jocului, separate printr-un spațiu. În caz de egalitate se va afișa '''Egalitate''' urmat de un spaţiu şi de numărul egal al multiplilor.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

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

==Explicatie==

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

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

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

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

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

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

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

</syntaxhighlight>

==Explicatie==

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

3644 - Joc12

2023-05-07T18:14:22Z

Vardai Erwin: /* Date de ieșire */

==Enunț==

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse."
Pe ecran se va afișa numele fetei care câștigă și o valoare P ce reprezintă numărul care conduce la câștigarea jocului, separate printr-un spațiu. În caz de egalitate se va afișa '''Egalitate''' urmat de un spaţiu şi de numărul egal al multiplilor.
În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

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

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

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

;'''Ieșire '''

Maria 4

==Explicatie==

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

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

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

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

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

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

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

</syntaxhighlight>

==Explicatie==

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

3644 - Joc12

2023-05-07T18:13:55Z

Vardai Erwin: /* Enunt */

==Enunț==

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

==Cerință==

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

==Date de intrare==

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

==Date de ieșire==

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

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

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

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

;'''Ieșire '''

Maria 4

==Explicatie==

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

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

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

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

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

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

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

</syntaxhighlight>

==Explicatie==

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

2644 - Clase

2023-05-07T17:58:17Z

Vardai Erwin: /* Exemplul 1 */

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

==Explicație==

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

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

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

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

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

return True

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

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

return classes_with_packages

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

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

# Validăm datele de intrare
if not validate_input(n, m, classes, packages):
print('Datele de intrare nu corespund restrictiilor impuse.')
else:
print('Datele de intrare corespund restrictiilor impuse.')
# Determinăm numărul de clase care primesc pachete cu cărți
classes_with_packages = count_classes_with_packages(n, classes, m, packages)
# Scriem rezultatul în fișierul de ieșire
with open('clase.out', 'w') as f:
f.write(str(classes_with_packages))

</syntaxhighlight>

==Explicație==

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

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

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

2644 - Clase

2023-05-07T17:57:58Z

Vardai Erwin: /* Explicatie */

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

==Explicație==

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

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

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

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

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

return True

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

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

return classes_with_packages

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

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

# Validăm datele de intrare
if not validate_input(n, m, classes, packages):
print('Datele de intrare nu corespund restrictiilor impuse.')
else:
print('Datele de intrare corespund restrictiilor impuse.')
# Determinăm numărul de clase care primesc pachete cu cărți
classes_with_packages = count_classes_with_packages(n, classes, m, packages)
# Scriem rezultatul în fișierul de ieșire
with open('clase.out', 'w') as f:
f.write(str(classes_with_packages))

</syntaxhighlight>

==Explicație==

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

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

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

2644 - Clase

2023-05-07T17:57:49Z

Vardai Erwin: /* Rezolvare ver. 1 */

==Cerință==

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

==Date de intrare==

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

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

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

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

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

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

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

==Explicație==

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

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

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

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

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

return True

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

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

return classes_with_packages

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

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

# Validăm datele de intrare
if not validate_input(n, m, classes, packages):
print('Datele de intrare nu corespund restrictiilor impuse.')
else:
print('Datele de intrare corespund restrictiilor impuse.')
# Determinăm numărul de clase care primesc pachete cu cărți
classes_with_packages = count_classes_with_packages(n, classes, m, packages)
# Scriem rezultatul în fișierul de ieșire
with open('clase.out', 'w') as f:
f.write(str(classes_with_packages))

</syntaxhighlight>

==Explicatie==

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

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

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