Bitnami MediaWiki - User contributions [en]

1149 - Exista Prime Div Imp

2023-12-03T16:49:14Z

Gabi: Pagină nouă: = Cerinţa = Se dă un şir cu <code>n</code> elemente, numere naturale. Folosind metoda Divide et Impera să se verifice dacă în şir există elemente prime. = Date de intrare = Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale şirului. = Date de ieşire = Programul afișează pe ecran mesajul <code>DA</code>, dacă şirul conţine elemente prime, respectiv <code>NU</code> în caz contrar. = Restricţii şi precizăr...

= Cerinţa =
Se dă un şir cu <code>n</code> elemente, numere naturale. Folosind metoda Divide et Impera să se verifice dacă în şir există elemente prime.

= Date de intrare =
Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale şirului.

= Date de ieşire =
Programul afișează pe ecran mesajul <code>DA</code>, dacă şirul conţine elemente prime, respectiv <code>NU</code> în caz contrar.

= Restricţii şi precizări =

* <code>1 ≤ n ≤ 200</code>
* elementele şirului vor fi mai mici decât <code>1.000.000.000</code>

= Exemplul 1 =
Date de intrare
5
21 8 6 10 8
Date de ieșire
NU

= Exemplul 2 =
Date de intrare
2000
Date de ieșire
Eroare: Numărul de elemente trebuie să fie între 1 și 200.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def is_prime(num):
if num < 2:
return False
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True

def has_prime_elements(arr, start, end):
if start == end:
return is_prime(arr[start])

mid = (start + end) // 2

left_has_prime = has_prime_elements(arr, start, mid)
right_has_prime = has_prime_elements(arr, mid + 1, end)

return left_has_prime or right_has_prime

def validate_input(n):
if not (1 <= n <= 200):
print("Eroare: Numărul de elemente trebuie să fie între 1 și 200.")
exit()

def main():
n = int(input("Introduceți numărul de elemente: "))

validate_input(n)

arr = []

for i in range(n):
element = int(input(f"Introduceți elementul {i + 1}: "))
arr.append(element)

if has_prime_elements(arr, 0, n - 1):
print("DA")
else:
print("NU")

if __name__ == "__main__":
main()
</syntaxhighlight>

1018 - Cnt Impare

2023-12-03T16:45:34Z

Gabi: Pagină nouă: = Cerința = Se consideră un șir cu <code>n</code> elemente, numere naturale. Folosind metoda Divide et Impera, determinați câte elemente impare sunt în acest șir. = Date de intrare = Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale șirului. = Date de ieșire = Programul va afișa pe ecran numărul <code>C</code>, reprezentând valoarea cerută. = Restricții și precizări = * <code>1 ≤ n ≤ 1000</code> * el...

= Cerința =
Se consideră un șir cu <code>n</code> elemente, numere naturale. Folosind metoda Divide et Impera, determinați câte elemente impare sunt în acest șir.

= Date de intrare =
Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale șirului.

= Date de ieșire =
Programul va afișa pe ecran numărul <code>C</code>, reprezentând valoarea cerută.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* elementele șirului vor fi mai mici decât <code>1.000.000</code>
* se recomandă folosirea metodei Divide et Impera

= Exemplul 1 =
Intrare
6
4 1 8 4 3 5
Ieșire
3

== Exemplul 2 ==
Intrare
1001
Ieșire
Eroare: Numărul de elemente trebuie să fie între 1 și 1000.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare_restrictii(n, arr):
# Verifică restricția 1: 1 ≤ n ≤ 1000
if not (1 <= n <= 1000):
print("Eroare: Numărul de elemente trebuie să fie între 1 și 1000.")
return False

# Verifică restricția 2: Elementele șirului vor fi mai mici decât 1.000.000
if any(x >= 1000000 for x in arr):
print("Eroare: Elementele șirului trebuie să fie mai mici decât 1.000.000.")
return False

return True

def numar_elemente_impare(arr, stanga, dreapta):
if stanga == dreapta:
return arr[stanga] % 2

mijloc = (stanga + dreapta) // 2

# Numără elementele impare în stânga și dreapta
impare_stanga = numar_elemente_impare(arr, stanga, mijloc)
impare_dreapta = numar_elemente_impare(arr, mijloc + 1, dreapta)

# Combină rezultatele
return impare_stanga + impare_dreapta

# Exemplu de folosire
n = int(input("Introduceti numarul de elemente: "))

# Iesirea dacă restricțiile nu sunt îndeplinite
if not verificare_restrictii(n, []):
exit()

# Citirea elementelor șirului
arr = list(map(int, input("Introduceti elementele separate prin spatii: ").split()))

# Iesirea dacă restricțiile nu sunt îndeplinite
if not verificare_restrictii(n, arr):
exit()

# Calculul numărului de elemente impare
rezultat = numar_elemente_impare(arr, 0, n - 1)

# Afișarea rezultatului
print(rezultat)
</syntaxhighlight>

1150 - Verif Pare Div Imp

2023-12-03T16:39:50Z

Gabi: Pagină nouă: = Cerinţa = Se dă un şir cu <code>n</code> elemente, numere naturale. Folosind metoda Divide et Impera să se verifice dacă toate elementele şirului sunt pare. = Date de intrare = Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale şirului, separate prin spaţii. = Date de ieşire = Programul afișează pe ecran mesajul <code>DA</code>, dacă toate elementele şirului sunt pare, respectiv <code>NU</code> în caz contr...

= Cerinţa =
Se dă un şir cu <code>n</code> elemente, numere naturale. Folosind metoda Divide et Impera să se verifice dacă toate elementele şirului sunt pare.

= Date de intrare =
Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale şirului, separate prin spaţii.

= Date de ieşire =
Programul afișează pe ecran mesajul <code>DA</code>, dacă toate elementele şirului sunt pare, respectiv <code>NU</code> în caz contrar.

= Restricţii şi precizări =

* <code>1 ≤ n ≤ 100</code>
* elementele şirului vor fi mai mici decât <code>10000</code>

= Exemplul 1 =
Date de intrare
5
2 8 6 10 8
Date de ieșire
DA

== Exemplul 2 ==
Date de intrare
101
Date de ieșire
Eroare: Numărul de elemente trebuie să fie între 1 și 100.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare_restrictii(n, arr):
# Verifică restricția 1: 1 ≤ n ≤ 100
if not (1 <= n <= 100):
print("Eroare: Numărul de elemente trebuie să fie între 1 și 100.")
return False

# Verifică restricția 2: Elementele șirului vor fi mai mici decât 10000
if any(x >= 10000 for x in arr):
print("Eroare: Elementele șirului trebuie să fie mai mici decât 10000.")
return False

return True

def toate_elementele_pare(arr, stanga, dreapta):
if stanga == dreapta:
return arr[stanga] % 2 == 0

mijloc = (stanga + dreapta) // 2

# Verifică în stânga și dreapta
parte_stanga_pare = toate_elementele_pare(arr, stanga, mijloc)
parte_dreapta_pare = toate_elementele_pare(arr, mijloc + 1, dreapta)

# Combină rezultatele
return parte_stanga_pare and parte_dreapta_pare

# Exemplu de folosire
n = int(input("Introduceti numarul de elemente: "))

# Iesirea dacă restricțiile nu sunt îndeplinite
if not (1 <= n <= 100):
print("Eroare: Numărul de elemente trebuie să fie între 1 și 100.")
exit()

arr = list(map(int, input("Introduceti elementele separate prin spatii: ").split()))

# Iesirea dacă restricțiile nu sunt îndeplinite
if any(x >= 10000 for x in arr):
print("Eroare: Elementele șirului trebuie să fie mai mici decât 10000.")
exit()

# Continuă cu verificarea dacă toate elementele sunt pare
rezultat = toate_elementele_pare(arr, 0, n - 1)

# Afișează rezultatul
if rezultat:
print("DA, toate elementele sunt pare.")
else:
print("NU, nu toate elementele sunt pare.")

</syntaxhighlight>

1020 - Mat Prim

2023-12-03T16:32:02Z

Gabi: Pagină nouă: = Cerința = Se consideră un șir cu <code>n</code> elemente, numere naturale. Folosind metoda Divide et Impera, determinați cel mai mare element prim din acest șir. = Date de intrare = Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale șirului. = Date de ieșire = Programul va afișa pe ecran numărul <code>M</code>, cel mai mare element prim al șirului. = Restricții și precizări = * <code>1 ≤ n ≤ 1000</code...

= Cerința =
Se consideră un șir cu <code>n</code> elemente, numere naturale. Folosind metoda Divide et Impera, determinați cel mai mare element prim din acest șir.

= Date de intrare =
Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale șirului.

= Date de ieșire =
Programul va afișa pe ecran numărul <code>M</code>, cel mai mare element prim al șirului.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* elementele șirului vor fi mai mici decât <code>1.000.000</code>
* se garantează că în șir apare cel puțin un element prim
* se recomandă folosirea metodei Divide et Impera

= Exemplul 1 =
Intrare
6
4 1 8 4 3 5
Ieșire
5

= Exemplul 2 =
Intrare
4
4 4 4 4
Ieșire
Eroare: În șir trebuie să existe cel puțin un element prim.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def este_prim(numar):
if numar < 2:
return False
for i in range(2, int(numar**0.5) + 1):
if numar % i == 0:
return False
return True

def gaseste_cel_mai_mare_prim(sir, stanga, dreapta):
if stanga == dreapta:
return sir[stanga] if este_prim(sir[stanga]) else -1

mijloc = (stanga + dreapta) // 2

# Caută în stânga și dreapta
cel_mai_mare_prim_stanga = gaseste_cel_mai_mare_prim(sir, stanga, mijloc)
cel_mai_mare_prim_dreapta = gaseste_cel_mai_mare_prim(sir, mijloc + 1, dreapta)

# Combină rezultatele
return max(cel_mai_mare_prim_stanga, cel_mai_mare_prim_dreapta)

def verifica_restrictii(n, sir):
# Verifică restricția 1: 1 ≤ n ≤ 1000
if not (1 <= n <= 1000):
print("Eroare: Numărul de elemente trebuie să fie între 1 și 1000.")
return False

# Verifică restricția 2: Elementele șirului vor fi mai mici decât 1.000.000
if any(x >= 1000000 for x in sir):
print("Eroare: Elementele șirului trebuie să fie mai mici decât 1.000.000.")
return False

# Verifică restricția 3: Se garantează că în șir apare cel puțin un element prim
if all(not este_prim(x) for x in sir):
print("Eroare: În șir trebuie să existe cel puțin un element prim.")
return False

return True

def main():
# Exemplu de folosire în funcția principală
n = int(input("Introduceti numarul de elemente: "))

# Verifică restricțiile înainte de a continua
if not verifica_restrictii(n, []):
return

sir = []
for i in range(n):
element = int(input("Introduceti elementul {}: ".format(i + 1)))
sir.append(element)

if verifica_restrictii(n, sir):
rezultat = gaseste_cel_mai_mare_prim(sir, 0, n - 1)
print("Cel mai mare element prim din sir:", rezultat)

# Apelul funcției principale
if __name__ == "__main__":
main()
</syntaxhighlight>

1151 - Verif Egale Div Imp

2023-12-03T15:30:40Z

Gabi: Pagină nouă: = Cerinţa = Se dă un vector cu <code>n</code> elemente numere naturale. Folosind metoda Divide et Impera să se verifice dacă toate elementele vectorului sunt egale. = Date de intrare = Programul citește de la tastatură numărul <code>n</code>, apoi <code>n</code> numere naturale, reprezentând elementele vectorului. = Date de ieşire = Programul afișează pe ecran mesajul <code>DA</code>, dacă vectorul are toate elementele egale, sau <code>NU</code>, în caz contra...

= Cerinţa =
Se dă un vector cu <code>n</code> elemente numere naturale. Folosind metoda Divide et Impera să se verifice dacă toate elementele vectorului sunt egale.

= Date de intrare =
Programul citește de la tastatură numărul <code>n</code>, apoi <code>n</code> numere naturale, reprezentând elementele vectorului.

= Date de ieşire =
Programul afișează pe ecran mesajul <code>DA</code>, dacă vectorul are toate elementele egale, sau <code>NU</code>, în caz contrar.

= Restricţii şi precizări =

* <code>1 ≤ n ≤ 500</code>
* fiecare element al vectorului va avea cel mult patru cifre

= Exemplul 1 =
Date de intrare
7
6 6 6 6 4 6 6
Date de ieșire
NU

= Exemplul 2 =
Date de intrare
501
Date de ieșire
Numărul de elemente trebuie să fie între 1 și 500. Programul se încheie.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii_n(n):
if not 1 <= n <= 500:
print("Numărul de elemente trebuie să fie între 1 și 500. Programul se încheie.")
return False
return True

def verifica_restrictii_element(element):
if not 0 <= element < 10000:
print("Elementele vectorului trebuie să aibă cel mult patru cifre. Programul se încheie.")
return False
return True

def are_toate_elementele_egale(arr, left, right):
if left == right:
return True # Un singur element este întotdeauna "egal" cu el însuși

mid = (left + right) // 2

are_toate_left = are_toate_elementele_egale(arr, left, mid)
are_toate_right = are_toate_elementele_egale(arr, mid + 1, right)

return are_toate_left and are_toate_right and (arr[left] == arr[right])

def main():
# Citim numărul de elemente
n = int(input("Introduceți numărul de elemente (1 ≤ n ≤ 500): "))

# Verificăm restricția pentru n folosind funcția dedicată
if not verifica_restrictii_n(n):
return

# Citim elementele vectorului
arr = []
for i in range(n):
element = int(input(f"Introduceți elementul {i + 1} (elemente cu cel mult 4 cifre): "))

# Verificăm restricția pentru elementele vectorului folosind funcția dedicată
if not verifica_restrictii_element(element):
return

arr.append(element)

# Verificăm și afișăm rezultatul
rezultat = are_toate_elementele_egale(arr, 0, n - 1)
if rezultat:
print("DA")
else:
print("NU")

if __name__ == "__main__":
main()
</syntaxhighlight>

1019 - Maxim 6

2023-12-03T15:23:02Z

Gabi: Pagină nouă: = Cerința = Se consideră un șir cu <code>n</code> elemente, numere naturale. Folosind metoda Divide et Impera, determinați cel mai mare element din acest șir. = Date de intrare = Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale șirului. = Date de ieșire = Programul va afișa pe ecran numărul <code>M</code>, cel mai mare element al șirului. = Restricții și precizări = * <code>1 ≤ n ≤ 1000</code> * elemen...

= Cerința =
Se consideră un șir cu <code>n</code> elemente, numere naturale. Folosind metoda Divide et Impera, determinați cel mai mare element din acest șir.

= Date de intrare =
Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> elemente ale șirului.

= Date de ieșire =
Programul va afișa pe ecran numărul <code>M</code>, cel mai mare element al șirului.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* elementele șirului vor fi mai mici decât <code>1.000.000</code>
* se recomandă folosirea metodei Divide et Impera

= Exemplu1 =
Intrare
6
4 1 8 4 3 5
Ieșire
8

== Exemplul 2 ==
Intrare
1001
Ieșire
Numărul de elemente trebuie să fie între 1 și 1000. Programul se încheie.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def max_element_divide_conquer(arr, left, right):
if left == right:
return arr[left]

mid = (left + right) // 2

max_left = max_element_divide_conquer(arr, left, mid)
max_right = max_element_divide_conquer(arr, mid + 1, right)

return max(max_left, max_right)

def main():
# Citim numărul de elemente
n = int(input("Introduceți numărul de elemente (1 <= n <= 1000): "))

# Verificăm restricția pentru n
if not 1 <= n <= 1000:
print("Numărul de elemente trebuie să fie între 1 și 1000. Programul se încheie.")
return

# Citim elementele șirului
arr = []
for i in range(n):
element = int(input(f"Introduceți elementul {i + 1} (elemente < 1.000.000): "))

# Verificăm restricția pentru elementele șirului
if not 0 <= element < 1000000:
print("Elementele șirului trebuie să fie mai mici decât 1.000.000. Programul se încheie.")
return

arr.append(element)

# Calculăm și afișăm rezultatul
result = max_element_divide_conquer(arr, 0, n - 1)
print(f"Cel mai mare element din șir este: {result}")

if __name__ == "__main__":
main()

</syntaxhighlight>

2527 - Hanoi

2023-12-03T15:07:46Z

Gabi: Pagină nouă: == Enunț == Turnurile din Hanoi este un joc matematic sau, dacă vreți, un puzzle. Este format din trei tije <code>A</code>, <code>B</code> și <code>C</code> și un număr variabil de discuri, de diferite diametre. Inițial discurile sunt așezate în ordine descrescătoare a diametrelor pe tija <code>A</code>, de la vârf către bază, astfel încât să formeze un turn. Scopul jocului este acela de a muta toate discurile de pe tija <code>A</code> pe tija <code>C</code>...

== Enunț ==
Turnurile din Hanoi este un joc matematic sau, dacă vreți, un puzzle. Este format din trei tije <code>A</code>, <code>B</code> și <code>C</code> și un număr variabil de discuri, de diferite diametre. Inițial discurile sunt așezate în ordine descrescătoare a diametrelor pe tija <code>A</code>, de la vârf către bază, astfel încât să formeze un turn.

Scopul jocului este acela de a muta toate discurile de pe tija <code>A</code> pe tija <code>C</code> folosind ca tijă intermediară tija <code>B</code>, respectând următoarele reguli:

* la un moment dat doar un singur disc poate fi mutat
* fiecare mutare constă în luarea celui mai de sus disc de pe o tija și mutarea acestuia pe o altă tijă
* un disc cu diametrul mai mare nu poate fi poziționat deasupra unui disc cu diametrul mai mic.

= Cerința =
Dacă se cunoaște numărul <code>n</code> de discuri aflate pe tija <code>A</code>, să se determine șirul mutărilor necesare pentru ca toate discurile să fie mutate pe tija <code>C</code>.

= Date de intrare =
Fișierul de intrare <code>hanoiIN.txt</code> conține pe prima linie numărul natural nenul <code>n</code>, ce reprezintă numărul de discuri aflat pe tija <code>A</code>.

= Date de ieșire =
Fișierul de ieșire <code>hanoiOUT.txt</code> va conține pe prima linie numărul <code>m</code>, ce reprezintă numărul minim de mutări ce se efectuează. Pe următoarele <code>m</code> linii vor fi scrise mutările sub forma: ''tija sursă->tija destinație''.

= Restricții și precizări =

* <code>1 ≤ n ≤ 15</code>
* mutările vor fi scrise câte una pe linie, fără spații

= Exemplul 1 =
<code>hanoiIN.txt</code>
2
<code>hanoiOUt.txt</code>
3
A->B
A->C
B->C

== Exemplul 2 ==
<code>hanoiIN.txt</code>
16
<code>hanoiOUt.txt</code>
Restrictii neindeplinite.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n):
return 1 <= n <= 15

def hanoi(n, sursa, intermediar, destinatie, mutari):
if n == 1:
mutari.append(f"{sursa}->{destinatie}")
else:
hanoi(n-1, sursa, destinatie, intermediar, mutari)
mutari.append(f"{sursa}->{destinatie}")
hanoi(n-1, intermediar, sursa, destinatie, mutari)

def main():
with open("hanoiIN.txt", "r") as f_input, open("hanoiOUT.txt", "w") as f_output:
n = int(f_input.readline().strip())

if not verifica_restrictii(n):
f_output.write("Restrictii neindeplinite.\n")
return

mutari = []
hanoi(n, 'A', 'B', 'C', mutari)

f_output.write(str(len(mutari)) + "\n")
for mutare in mutari:
f_output.write(mutare + "\n")

if __name__ == "__main__":
main()
</syntaxhighlight>

1023 - Cmmdc 3

2023-12-03T14:41:01Z

Gabi: Pagină nouă: == Cerinţa == Se dă un sir cu <code>n</code> elemente, numere naturale nenule. Folosind metoda Divide et Impera, determinaţi cel mai mare divizor comun al elementelor acestui șir. == Date de intrare == Programul citește de la tastatură numărul <code>n</code>, iar cele <code>n</code> elemente ale șirului. == Date de ieşire == Programul afișează pe ecran numărul <code>X</code>, reprezentând cel mai mare divizor comun al elementelor. = Restricţii şi precizări...

== Cerinţa ==
Se dă un sir cu <code>n</code> elemente, numere naturale nenule. Folosind metoda Divide et Impera, determinaţi cel mai mare divizor comun al elementelor acestui șir.

== Date de intrare ==
Programul citește de la tastatură numărul <code>n</code>, iar cele <code>n</code> elemente ale șirului.

== Date de ieşire ==
Programul afișează pe ecran numărul <code>X</code>, reprezentând cel mai mare divizor comun al elementelor.

= Restricţii şi precizări =

* <code>1 ≤ n ≤ 1000</code>
* elementele șirului vor avea cel mult <code>9</code> cifre
* se recomandă folosirea metodei Divide et Impera
*

= Exemplul 1 =
Date de intrare
7
18 54 24 42 108 60 30
Date de ieșire
6

== Exemplul 2 ==
Date de intrare
1001
123
Numerele introduse nu respectă restricțiile.<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n, arr):
if 1 <= n <= 1000 and all(1 <= num <= 10**9 for num in arr):
return True
return False

def cmmd(x, y):
while y:
x, y = y, x % y
return x

def cmmd_divide_et_impera(arr, start, end):
if start == end:
return arr[start]
else:
mid = (start + end) // 2
left_cmmd = cmmd_divide_et_impera(arr, start, mid)
right_cmmd = cmmd_divide_et_impera(arr, mid + 1, end)
return cmmd(left_cmmd, right_cmmd)

def main():
n = int(input("Introduceți numărul n: "))
arr = list(map(int, input("Introduceți cele n elemente separate prin spațiu: ").split()))

if verifica_restrictii(n, arr):
rezultat = cmmd_divide_et_impera(arr, 0, n - 1)
print("Cel mai mare divizor comun:", rezultat)
else:
print("Numerele introduse nu respectă restricțiile.")

if __name__ == "__main__":
main()
</syntaxhighlight>

1865 - Summit

2023-12-03T14:34:49Z

Gabi: Pagină nouă: == Cerința == Se dă un şir <code>x</code> format din <code>n</code> numere naturale nenule. Pentru fiecare element <code>xi</code> din şir să se verifice dacă există un număr <code>k</code> astfel încât elementul <code>xi</code> să fie egal cu suma primelor <code>k</code> elemente din şir. == Date de intrare == Fișierul de intrare <code>summitIN.txt</code> conține pe prima linie numărul <code>n</code>, iar pe a doua linie <code>n</code> numere naturale separat...

== Cerința ==
Se dă un şir <code>x</code> format din <code>n</code> numere naturale nenule. Pentru fiecare element <code>xi</code> din şir să se verifice dacă există un număr <code>k</code> astfel încât elementul <code>xi</code> să fie egal cu suma primelor <code>k</code> elemente din şir.

== Date de intrare ==
Fișierul de intrare <code>summitIN.txt</code> conține pe prima linie numărul <code>n</code>, iar pe a doua linie <code>n</code> numere naturale separate prin spații.

== Date de ieșire ==
Fișierul de ieșire <code>summitOUT.txt</code> va conține pe linia <code>i</code> valoarea <code>k</code> dacă elementul <code>xi</code> este egal cu suma primelor <code>k</code> elemente din şir, sau <code>0</code> în caz contrar, pentru fiecare <code>i</code> de la <code>1</code> la <code>n</code>.

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

* <code>2 ≤ n ≤ 1.000.000</code>
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât <code>2.000.000.000</code>

== Exemplul 1 ==
<code>summitIN.txt</code>
3
1 2 3
<code>summitOUT.txt</code>
1
0
2

== Exemplul 2 ==
<code>summitIN.txt</code>
1
1
Numerele introduse nu respectă restricțiile.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n, nums):
return 2 <= n <= 1000000 and all(0 < x < 2000000000 for x in nums)

def verifica_summit(n, nums):
suma_partiala = [0] # Lista pentru suma parțială, începând cu 0

for i in range(n):
suma_partiala.append(suma_partiala[-1] + nums[i])

rezultate = []
for i in range(n):
k = 0
while k < n and suma_partiala[k] < nums[i]:
k += 1

if k < n and suma_partiala[k] == nums[i]:
rezultate.append(k)
else:
rezultate.append(0)

return rezultate

def main():
with open("summitIN.txt", "r") as f:
n = int(f.readline())
nums = list(map(int, f.readline().split()))

if verifica_restrictii(n, nums):
rezultate = verifica_summit(n, nums)

with open("summitOUT.txt", "w") as f:
for rez in rezultate:
f.write(str(rez) + "\n")
else:
print("Numerele introduse nu respectă restricțiile.")

if __name__ == "__main__":
main()
</syntaxhighlight>

3260 - Invers

2023-12-03T14:23:32Z

Gabi: Pagină nouă: == Cerința == Veșnicul Gigel vrea să dea la Facultatea de Informatică din Iași pentru că e #ceaMaiTare. De asta s-a apucat de probleme pe pbinfo și a dat peste următoarea problema ce i-a plăcut atât de mult încât vă provoacă și pe voi să o rezolvați: Se dă funcția și o valoare . Știind că funcția este strict crescătoare pe intervalul , se cere să se gasească pentru ce avem că (aproximare cu 8 zecimale). == Date de intrare == Se citește de l...

== Cerința ==
Veșnicul Gigel vrea să dea la Facultatea de Informatică din Iași pentru că e #ceaMaiTare. De asta s-a apucat de probleme pe pbinfo și a dat peste următoarea problema ce i-a plăcut atât de mult încât vă provoacă și pe voi să o rezolvați:

Se dă funcția și o valoare . Știind că funcția este strict crescătoare pe intervalul , se cere să se gasească pentru ce avem că (aproximare cu 8 zecimale).

== Date de intrare ==
Se citește de la tastatura valoarea .

== Date de ieșire ==
0<= x <1 afișat cu o aproximare de 8 zecimale precise.

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

* pentru orice 0<=y<2.7 vom avea ca 0<=x<1

== Exemplu 1 ==
Intrare 1.34

Ieșire 0.35083179

== Exemplu 2 ==
Intrare 3

Ieșire Valoarea lui y nu respectă restricțiile.<syntaxhighlight lang="python3" line="1">
import math

def f(x):
return math.sin(x) + math.sin(2*x) + x

def verifica_restrictie(y):
return 0 <= y <= 2.7

def aproximare_bisectie(y):
epsilon = 1e-8 # Precizia dorită
a, b = 0, 1 # Intervalul [0, 1)

while b - a > epsilon:
mid = (a + b) / 2
if f(mid) < y:
a = mid
else:
b = mid

return (a + b) / 2

def main():
y = float(input("Introduceți valoarea y: "))

if verifica_restrictie(y):
rezultat = aproximare_bisectie(y)
print(f"{rezultat:.8f}")
else:
print("Valoarea lui y nu respectă restricțiile.")

if __name__ == "__main__":
main()
</syntaxhighlight>

0968 - Copac

2023-12-03T13:40:52Z

Gabi: Pagină nouă: == Enunț == În grădina din palatul lui Făt-Frumos a răsărit tulpina fragedă a unui copăcel. Impresionat de gingăşia lui, Făt-Frumos dădu fuga la izvorul fermecat şi aduse nişte apă vie cu care udă copăcelul. A doua zi, surpriză mare! Copăcelului i-au crescut trei ramuri minunate: una de argint, una de aur şi alta de rubin. Făt-Frumos, fericit, dădu din nou fuga la izvorul fermecat şi aduse apă vie pentru copăcel. A treia zi, surpriză şi mai mare!...

== Enunț ==
În grădina din palatul lui Făt-Frumos a răsărit tulpina fragedă a unui copăcel. Impresionat de gingăşia lui, Făt-Frumos dădu fuga la izvorul fermecat şi aduse nişte apă vie cu care udă copăcelul.

A doua zi, surpriză mare! Copăcelului i-au crescut trei ramuri minunate: una de argint, una de aur şi alta de rubin. Făt-Frumos, fericit, dădu din nou fuga la izvorul fermecat şi aduse apă vie pentru copăcel.

A treia zi, surpriză şi mai mare! Ramura de argint s-a transformat în trei ramuri noi: una de argint, una de aur şi una de rubin. Ramura de aur s-a transformat în două ramuri noi: una de argint şi alta de rubin. Ramura de rubin s-a transformat în două ramuri noi: una de aur şi una de rubin.

Şi în a patra zi, Făt-Frumos observă că fiecare ramură de argint s-a transformat în trei ramuri noi: una de argint, una de aur şi una de rubin; fiecare ramură de aur s-a transformat în două ramuri noi: una de argint şi alta de rubin; fiecare ramură de rubin s-a transformat în două ramuri noi: una de aur şi una de rubin.

Copăcelul era mai bogat şi mai frumos. Strălucea ca un soare, lumina lui ajungând până la palatul Zmeului-Zmeilor.

Zmeul-Zmeilor se îndreptă ca fulgerul spre palatul lui Făt-Frumos. Vroia copacul. Dar cum să facă? Dacă s-ar lupta cu Făt-Frumos, ar pierde lupta. Mereu s-a întâmplat aşa. Se gândi, se gândi… şi exact când a ajuns în faţa lui Făt-Frumos i-a venit o idee spunându-i acestuia:

- Făt-Frumos, dacă îmi vei spune câte ramuri de argint, câte ramuri de aur şi câte ramuri de rubin va avea copacul peste <code>n</code> zile începând din ziua asta, atunci copacul va rămâne al tău. De nu, al meu va fi!

Ştiind că ramurile copacului se transformă şi în zilele următoare la fel ca în ziua a patra, ajutaţi-l pe Făt-Frumos să găsească răspunsul la întrebare astfel încât copacul să rămână al lui.

== Cerința ==
Scrieţi un program care citeşte un număr natural <code>n</code> şi care să determine şi să afişeze trei numere naturale reprezentând numărul de ramuri de argint, respectiv de aur şi de rubin pe care le va avea copacul peste <code>n</code> zile, în acestă ordine.

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

== Date de ieșire ==
Programul va afișa pe ecran cele trei numere, în ordinea cerută, separate prin exact un spațiu.

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

* <code>0 ≤ n ≤ 45</code>

== Exemplul 1 ==
Intrare 2

Ieșire 20 25 36

== Exemplul 2 ==
Intrare 46

Ieșire Numărul introdus nu respectă restricțiile (0 ≤ n ≤ 45).

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n):
return 0 <= n <= 45

def calculeaza_ramuri_copac(n):
if not verifica_restrictii(n):
print("Numărul introdus nu respectă restricțiile (0 ≤ n ≤ 45).")
return

if n == 0:
return 4, 5, 7

ramuri_argint = 4
ramuri_aur = 5
ramuri_rubin = 7

zi = 1

while zi <= n:
ramuri_argint_nou = ramuri_argint + ramuri_aur
ramuri_aur_nou = ramuri_argint + ramuri_rubin
ramuri_rubin_nou = ramuri_argint + ramuri_aur + ramuri_rubin

ramuri_argint, ramuri_aur, ramuri_rubin = ramuri_argint_nou, ramuri_aur_nou, ramuri_rubin_nou

zi += 1

return ramuri_argint, ramuri_aur, ramuri_rubin

def main():
n = int(input("Introduceți numărul n (0 ≤ n ≤ 45): "))
rezultate = calculeaza_ramuri_copac(n)
if rezultate:
print(*rezultate) # Afiseaza cele trei numere separate printr-un spatiu

if __name__ == "__main__":
main()
</syntaxhighlight>

0806 - Generare sir

2023-12-03T12:57:43Z

Gabi: Pagină nouă: ==Cerinţa== Se consideră şirul definit mai jos: fn= 1 daca n =1 fn= 1 + f(n-1) daca n e par fn= 1 + 2*f(n-2) dacă n altfel în care nu există doi termeni cu aceeași paritate aflați pe poziții consecutive: <code>1, 2, 3, 4, 7, 8, 15, 16 ....</code>. Pentru un număr natural <code>x</code>, termen al şirului dat, se cere să se afișeze pe ecran, în ordine strict descrescătoare, separați prin câte un spațiu, toţi termenii şirului care sunt mai mici sau...

==Cerinţa==
Se consideră şirul definit mai jos:

fn= 1 daca n =1

fn= 1 + f(n-1) daca n e par

fn= 1 + 2*f(n-2) dacă n altfel

în care nu există doi termeni cu aceeași paritate aflați pe poziții consecutive: <code>1, 2, 3, 4, 7, 8, 15, 16 ....</code>.

Pentru un număr natural <code>x</code>, termen al şirului dat, se cere să se afișeze pe ecran, în ordine strict descrescătoare, separați prin câte un spațiu, toţi termenii şirului care sunt mai mici sau egali cu <code>x</code>.

==Date de intrare==
Programul citeşte de la tastatură numărul <code>x</code>

==Date de ieşire==
Programul va afişa pe ecran în ordine strict descrescătoare, separați prin câte un spațiu, toţi termenii şirului care sunt mai mici sau egali cu <code>x</code>.

==Exemplul 1==
Date intrare 15

Date iesire 15 8 7 4 3 2 1

==Exemplul 2==
Date intrare 0

Numărul introdus nu respectă restricțiile.

==Rezolvare==
<syntaxhighlight lang="python3">
def verifica_restrictii(x):
return 1 <= x <= 1000000000

def genereaza_si_afiseaza_sir(x):
def f(n):
if n == 1:
return 1
elif n % 2 == 0:
return 1 + f(n - 1)
else:
return 1 + 2 * f(n - 2)

termeni_sir = []

# Generăm șirul până când obținem un termen mai mare decât x
n = 1
while f(n) <= x:
termeni_sir.append(f(n))
n += 1

# Afișăm termenii în ordine descrescătoare
termeni_sir.sort(reverse=True)

print(" ".join(map(str, termeni_sir)))

def main():
x = int(input("Introduceți numărul x: "))

if verifica_restrictii(x):
genereaza_si_afiseaza_sir(x)
else:
print("Numărul introdus nu respectă restricțiile.")

if __name__ == "__main__":
main()
</syntaxhighlight>