Bitnami MediaWiki - User contributions [en]

0091 - Masini

2023-12-10T10:40:38Z

Gabii: am modificat la ex 2 masiniOUT.txt in loc de consola

== Enunț ==
În curtea unui atelier de reparaţii auto, sunt <code>n</code> maşini care trebuie sa fie reparate. Deoarece nu sunt suficienţi mecanici, în fiecare moment de timp se poate lucra doar la o singură maşină.

= Cerinţa =
Cunoscând timpul necesar pentru repararea fiecărei maşini, scrieţi un program care calculează numărul maxim de maşini care pot fi reparate într-un interval de timp <code>T</code>.

= Date de intrare =
Pe prima linie a fişierului <code>masiniIN.txt</code> se găsesc două numere naturale <code>n</code> şi <code>T</code> separate printr-un singur spaţiu, reprezentând numărul de maşini din curtea atelierului auto şi timpul total în care se va lucra.

Pe linia a doua, separate prin câte un spaţiu, se găsesc <code>n</code> numere naturale <code>t1</code>, <code>t2</code>, …, <code>tn</code>, reprezentând timpii necesari pentru repararea fiecărei maşini.

= Date de ieşire =
Pe prima linie a fişierului <code>masiniOUT.txt</code>se va găsi un număr natural <code>k</code>, reprezentând numărul maxim de maşini care pot fi reparate.

= Restricţii şi precizări =

* <code>1 < n, T <= 1000</code>
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici sau egale cu <code>100</code>

= Exemplul 1 =
<code>masiniIN.txt</code>
5 10
6 2 4 8 2
<code>masiniOUT.txt</code>
3

= Exemplul 2 =
<code>masiniIN.txt</code>
5 10000
6 2 4 8 2
<code>masiniOUT.txt</code>
Eroare: Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
import os

def numar_maxim_masini(n, T, timp_reparare):
timp_reparare.sort()

masini_reparate = 0
timp_total = 0

for timp in timp_reparare:
if timp_total + timp <= T:
masini_reparate += 1
timp_total += timp
else:
break

return masini_reparate

def citeste_date_intrare(nume_fisier):
if not os.path.exists(nume_fisier):
raise FileNotFoundError(f"Fișierul {nume_fisier} nu a fost găsit.")

with open(nume_fisier, "r") as f:
n, T = map(int, f.readline().split())

if not (1 <= n <= 1000 and 1 <= T <= 1000):
raise ValueError("Nu corespunde restricțiilor")

timp_reparare = list(map(int, f.readline().split()))
if any(timp > 100 for timp in timp_reparare):
raise ValueError("Nu corespunde restricțiilor")

return n, T, timp_reparare

try:
n, T, timp_reparare = citeste_date_intrare("masiniIN.txt")
except FileNotFoundError as e:
print(f"Eroare: {str(e)}")
exit(1)
except ValueError as e:
with open("masiniOUT.txt", "w", encoding="utf-8") as f_out:
f_out.write(f"Eroare: {str(e)}")
exit(1)

rezultat = numar_maxim_masini(n, T, timp_reparare)

# Scriere rezultat în fișierul masiniOUT.txt
with open("masiniOUT.txt", "w", encoding="utf-8") as f_out:
f_out.write(str(rezultat))

</syntaxhighlight>

0091 - Masini

2023-12-09T22:29:06Z

Gabii: am modificat sa apara in masiniOUT.txt

== Enunț ==
În curtea unui atelier de reparaţii auto, sunt <code>n</code> maşini care trebuie sa fie reparate. Deoarece nu sunt suficienţi mecanici, în fiecare moment de timp se poate lucra doar la o singură maşină.

= Cerinţa =
Cunoscând timpul necesar pentru repararea fiecărei maşini, scrieţi un program care calculează numărul maxim de maşini care pot fi reparate într-un interval de timp <code>T</code>.

= Date de intrare =
Pe prima linie a fişierului <code>masiniIN.txt</code> se găsesc două numere naturale <code>n</code> şi <code>T</code> separate printr-un singur spaţiu, reprezentând numărul de maşini din curtea atelierului auto şi timpul total în care se va lucra.

Pe linia a doua, separate prin câte un spaţiu, se găsesc <code>n</code> numere naturale <code>t1</code>, <code>t2</code>, …, <code>tn</code>, reprezentând timpii necesari pentru repararea fiecărei maşini.

= Date de ieşire =
Pe prima linie a fişierului <code>masiniOUT.txt</code>se va găsi un număr natural <code>k</code>, reprezentând numărul maxim de maşini care pot fi reparate.

= Restricţii şi precizări =

* <code>1 < n, T <= 1000</code>
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici sau egale cu <code>100</code>

= Exemplul 1 =
<code>masiniIN.txt</code>
5 10
6 2 4 8 2
<code>masiniOUT.txt</code>
3

= Exemplul 2 =
<code>masiniIN.txt</code>
5 10000
6 2 4 8 2
consola
Eroare: Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
import os

def numar_maxim_masini(n, T, timp_reparare):
timp_reparare.sort()

masini_reparate = 0
timp_total = 0

for timp in timp_reparare:
if timp_total + timp <= T:
masini_reparate += 1
timp_total += timp
else:
break

return masini_reparate

def citeste_date_intrare(nume_fisier):
if not os.path.exists(nume_fisier):
raise FileNotFoundError(f"Fișierul {nume_fisier} nu a fost găsit.")

with open(nume_fisier, "r") as f:
n, T = map(int, f.readline().split())

if not (1 <= n <= 1000 and 1 <= T <= 1000):
raise ValueError("Nu corespunde restricțiilor")

timp_reparare = list(map(int, f.readline().split()))
if any(timp > 100 for timp in timp_reparare):
raise ValueError("Nu corespunde restricțiilor")

return n, T, timp_reparare

try:
n, T, timp_reparare = citeste_date_intrare("masiniIN.txt")
except FileNotFoundError as e:
print(f"Eroare: {str(e)}")
exit(1)
except ValueError as e:
with open("masiniOUT.txt", "w", encoding="utf-8") as f_out:
f_out.write(f"Eroare: {str(e)}")
exit(1)

rezultat = numar_maxim_masini(n, T, timp_reparare)

# Scriere rezultat în fișierul masiniOUT.txt
with open("masiniOUT.txt", "w", encoding="utf-8") as f_out:
f_out.write(str(rezultat))

</syntaxhighlight>

3152 - combinari2

2023-12-09T22:18:58Z

Gabii: am adaugat explicatia

= Cerința =
Se citesc două numere naturale <code>n</code> și <code>m</code>. Afișați în ordine lexicografică toate submulțimile cu <code>m</code> elemente ale mulțimii <code>{1, 2, ..., n}</code> în care nu există două elemente pare alăturate.

= Date de intrare =
Programul citește de la tastatură numerele <code>n</code> și <code>m</code>.

= Date de ieșire =
Programul va afișa pe ecran submulțimile cerute, câte una pe fiecare rand și având elementele separate prin câte un spaţiu. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ m < n ≤ 20</code>

= Exemplul 1 =
Intrare
5 3
Ieșire
1 2 3
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
3 4 5

== Explicație ==
Numrele <code>2</code> și <code>4</code> nu apar pe poziții alăturate.

= Exemplul 2 =
Intrare
22 17
consola
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def este_input_valid(n, m):
return 1 <= m < n <= 20

def este_submultime_valida(submultime):
for i in range(len(submultime) - 1):
if submultime[i] % 2 == 0 and submultime[i + 1] % 2 == 0:
return False
return True

def genereaza_submultimi(n, m, submultime_curenta, index):
if len(submultime_curenta) == m:
if este_submultime_valida(submultime_curenta):
print(*submultime_curenta)
return

if index > n:
return

# Include elementul la index în submulțime
genereaza_submultimi(n, m, submultime_curenta + [index], index + 1)

# Sări peste elementul la index
genereaza_submultimi(n, m, submultime_curenta, index + 1)

if __name__ == "__main__":
n, m = map(int, input("Introduceți valorile pentru n și m (separate prin spațiu): ").split())

if not este_input_valid(n, m):
print("Nu corespunde restricțiilor")
else:
print(f"Submulțimile cu {m} elemente ale mulțimii {{1, 2, ..., {n}}} în care nu există două elemente pare alăturate sunt:")
genereaza_submultimi(n, m, [], 1)

</syntaxhighlight>

0317 - SumMax

2023-12-09T22:18:11Z

Gabii: am adaugat explicatia

= Cerinţa =
Se dă o matrice pătratică cu <code>n</code> lini şi <code>n</code> coloane şi elemente numere naturale distincte. Determinaţi cea mai mare sumă a <code>n</code> elemente din matrice, cu proprietatea că oricare două elemente se află pe linii şi coloane distincte.

= Date de intrare =
Fişierul de intrare <code>summaxIN.txt</code> conţine pe prima linie numărul <code>n</code>, iar pe următoarele <code>n</code> linii câte <code>n</code> numere naturale, separate prin spaţii, reprezentând elementele matricei.

= Date de ieşire =
Fişierul de ieşire <code>summaxOUT.txt</code> va conţine pe prima linie numărul <code>S</code>, reprezentând suma maximă determinată. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricţii şi precizări =

* <code>1 ≤ n ≤ 10</code>
* elementele matricei vor avea cel mult <code>4</code> cifre

= Exemplul 1 =
<code>summaxIN.txt</code>
4
12 16 5 4
11 14 6 7
8 2 3 17
10 9 13 15
<code>summaxOUT.txt</code>
57

== Explicație ==
<code>57=16+11+17+13</code>.

= Exemplul 2 =
<code>summaxIN.txt</code>
100000
consola
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def citeste_matrice(file_path):
with open(file_path, 'r', encoding='utf-8') as file:
n = int(file.readline().strip())
matrice = [list(map(int, file.readline().split())) for _ in range(n)]
return n, matrice

def scrie_rezultat(file_path, rezultat):
with open(file_path, 'w', encoding='utf-8') as file:
file.write(str(rezultat))

def verifica_restrictii(n, matrice):
if not (1 <= n <= 10):
return False

for linie in matrice:
for element in linie:
if not (0 <= element <= 9999):
return False

return True

def gaseste_suma_maxima(n, matrice):
elemente_sortate = sorted([(matrice[i][j], i, j) for i in range(n) for j in range(n)], reverse=True)

linii_selectate = set()
coloane_selectate = set()

suma_maxima = 0

for element, i, j in elemente_sortate:
if i not in linii_selectate and j not in coloane_selectate:
suma_maxima += element
linii_selectate.add(i)
coloane_selectate.add(j)

return suma_maxima

if __name__ == "__main__":
fisier_intrare = "summaxIN.txt"
fisier_iesire = "summaxOUT.txt"

n, matrice = citeste_matrice(fisier_intrare)

if verifica_restrictii(n, matrice):
rezultat = gaseste_suma_maxima(n, matrice)
if rezultat > 0:
scrie_rezultat(fisier_iesire, rezultat)
else:
scrie_rezultat( "Nu corespunde restrictiilor".encode('utf-8'))
else:
scrie_rezultat(fisier_iesire, "Nu corespunde restricțiilor".encode('utf-8').decode('utf-8'))

</syntaxhighlight>

2646 - impartire

2023-12-09T22:17:20Z

Gabii:

= Cerința =
Se dau <code>n</code> numere naturale, unde <code>n</code> este un număr par. Se grupează cele <code>n</code> numere în perechi şi pentru fiecare pereche de numere se află restul împărţirii unui număr din pereche la celălalt. Se cere să se afle valoarea minimă a sumei acestor resturi.

= Date de intrare =
Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> numere naturale, separate prin spații.

= Date de ieșire =
Programul va afișa pe ecran suma minimă a resturilor. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>2 ≤ n ≤ 18</code>
* cele <code>n</code> numere citite vor fi mai mici decât <code>1.000</code>

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

== Exemplul 2 ==
Intrare
20
consola
Numărul n nu corespunde restricțiilor.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare_restrictii(n, numbers):
# Verifică dacă n este un număr par și se află în intervalul [2, 18]
if n % 2 != 0 or n < 2 or n > 18:
return False, "Numărul n nu corespunde restricțiilor."

# Verifică restricțiile pentru numerele naturale
for num in numbers:
if num >= 1000:
return False, "Numerele nu corespund restricțiilor."

return True, ""

def calculeaza_suma_resturilor(permutare):
return sum(permutare[i] % permutare[i+1] for i in range(0, len(permutare), 2))

def backtracking(permutare, vizitate, n, numbers, suma_minima):
if len(permutare) == n:
suma = calculeaza_suma_resturilor(permutare)
suma_minima[0] = min(suma_minima[0], suma)
return

for i in range(n):
if not vizitate[i]:
permutare.append(numbers[i])
vizitate[i] = True

backtracking(permutare, vizitate, n, numbers, suma_minima)

permutare.pop()
vizitate[i] = False

def main():
# Citire număr n de la tastatură
n = int(input("Introduceți numărul n: "))

# Verificare restricții
valid, mesaj_eroare = verificare_restrictii(n, [])
if not valid:
print("Eroare:", mesaj_eroare)
return

# Citire cele n numere naturale de la tastatură
numbers = list(map(int, input("Introduceți cele {} numere naturale separate prin spații: ".format(n)).split()))

# Verificare restricții pentru numerele introduse
valid, mesaj_eroare = verificare_restrictii(n, numbers)
if not valid:
print("Eroare:", mesaj_eroare)
return

permutare = []
vizitate = [False] * n
suma_minima = [float('inf')]

backtracking(permutare, vizitate, n, numbers, suma_minima)

print("Suma minimă a resturilor este:", suma_minima[0])

if __name__ == "__main__":
main()

</syntaxhighlight>

2646 - impartire

2023-12-09T22:17:03Z

Gabii: am modificat codul

= Cerința =
Se dau <code>n</code> numere naturale, unde <code>n</code> este un număr par. Se grupează cele <code>n</code> numere în perechi şi pentru fiecare pereche de numere se află restul împărţirii unui număr din pereche la celălalt. Se cere să se afle valoarea minimă a sumei acestor resturi.

= Date de intrare =
Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> numere naturale, separate prin spații.

= Date de ieșire =
Programul va afișa pe ecran suma minimă a resturilor. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>2 ≤ n ≤ 18</code>
* cele <code>n</code> numere citite vor fi mai mici decât <code>1.000</code>

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

== Exemplul 2 ==
Intrare
20
consola
Nu n nu corespunde restricțiilor.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare_restrictii(n, numbers):
# Verifică dacă n este un număr par și se află în intervalul [2, 18]
if n % 2 != 0 or n < 2 or n > 18:
return False, "Numărul n nu corespunde restricțiilor."

# Verifică restricțiile pentru numerele naturale
for num in numbers:
if num >= 1000:
return False, "Numerele nu corespund restricțiilor."

return True, ""

def calculeaza_suma_resturilor(permutare):
return sum(permutare[i] % permutare[i+1] for i in range(0, len(permutare), 2))

def backtracking(permutare, vizitate, n, numbers, suma_minima):
if len(permutare) == n:
suma = calculeaza_suma_resturilor(permutare)
suma_minima[0] = min(suma_minima[0], suma)
return

for i in range(n):
if not vizitate[i]:
permutare.append(numbers[i])
vizitate[i] = True

backtracking(permutare, vizitate, n, numbers, suma_minima)

permutare.pop()
vizitate[i] = False

def main():
# Citire număr n de la tastatură
n = int(input("Introduceți numărul n: "))

# Verificare restricții
valid, mesaj_eroare = verificare_restrictii(n, [])
if not valid:
print("Eroare:", mesaj_eroare)
return

# Citire cele n numere naturale de la tastatură
numbers = list(map(int, input("Introduceți cele {} numere naturale separate prin spații: ".format(n)).split()))

# Verificare restricții pentru numerele introduse
valid, mesaj_eroare = verificare_restrictii(n, numbers)
if not valid:
print("Eroare:", mesaj_eroare)
return

permutare = []
vizitate = [False] * n
suma_minima = [float('inf')]

backtracking(permutare, vizitate, n, numbers, suma_minima)

print("Suma minimă a resturilor este:", suma_minima[0])

if __name__ == "__main__":
main()

</syntaxhighlight>

3923 - back abc2

2023-12-09T21:46:27Z

Gabii: am adaugat explicatia

= Cerința =
Se citesc două numere naturale <code>n</code> și <code>m</code>. Afișați în ordine lexicografică toate cuvintele care sunt formate din <code>m</code> litere distincte folosind primele <code>n</code> litere mari din alfabet.

= Date de intrare =
Programul citește de la tastatură numerele <code>n</code> și <code>m</code>, separate prin spații.

= Date de ieșire =
Programul va afișa pe ecran pe linii separate cuvintele cerute. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>0 ≤ n ≤ 26</code>, <code>0 ≤ m ≤ 5</code>
* <code>m ≤ n</code>

= Exemplul 1 =
Intrare
4 3
Ieșire
ABC
ABD
ACB
ACD
ADB
ADC
BAC
BAD
BCA
BCD
BDA
BDC
CAB
CAD
CBA
CBD
CDA
CDB
DAB
DAC
DBA
DBC
DCA
DCB

== Explicație ==
Primele 4 litere mari sunt {A,B,C,D} și se formează cuvinte cu 3 litere distincte.

= Exemplul 2 =
Intrare
4 3
consola
Nu corespunde restricțiilor.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
import itertools

def check_restrictions(n, m):
if 0 <= n <= 26 and 0 <= m <= 5 and m <= n:
return True
else:
print("Nu corespunde restricțiilor.")
return False

def generate_words(n, m):
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
letters = alphabet[:n]

# Generăm toate permutările posibile de lungime m folosind literele primele n din alfabet
permutations = itertools.permutations(letters, m)

# Afisăm cuvintele în ordine lexicografică
for word in sorted(permutations):
print(''.join(word))

# Citim numerele n și m de la tastatură
n, m = map(int, input("Introduceți valorile lui n și m (separate prin spațiu): ").split())

# Verificăm restricțiile folosind funcția check_restrictions
if check_restrictions(n, m):
generate_words(n, m)
</syntaxhighlight>

3996 - back abc3

2023-12-09T21:45:35Z

Gabii: am adaugat explicatia

= Cerința =
Se citește un număr natural <code>n</code>. Afișați în ordine lexicografică toate cuvintele care sunt formate din <code>n</code> litere mari, care au literele ordonate alfabetic strict crescător și în care numărul de vocale este mai mare decât numărul de consoane.

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

= Date de ieșire =
Programul va afișa pe ecran pe linii separate cuvintele cerute. Cuvintele se vor afișa în ordine lexicografică. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 9</code>.

= Exemplul 1 =
Intrare
3
Ieșire
ABE
ABI
ABO
ABU
ACE
ACI
ACO
ACU
ADE
ADI
ADO
ADU
AEF
AEG
AEH
AEI
AEJ
AEK
AEL
AEM
AEN
AEO
AEP
AEQ
AER
AES
AET
AEU
AEV
...
IUW
IUX
IUY
IUZ
JOU
KOU
LOU
MOU
NOU
OPU
OQU
ORU
OSU
OTU
OUV
OUW
OUX
OUY
OUZ

== Explicație ==
Pentru n=3 se obțin 220 de cuvinte.

== Exemplul 2 ==
Intrare
10
consola
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
from itertools import permutations

def numara_vocale_consoane(cuvant):
# Calculează numărul de vocale și consoane din cuvânt
vocale = sum(1 for litera in cuvant if litera in "AEIOU")
consoane = len(cuvant) - vocale
return vocale, consoane

def genereaza_cuvinte(n):
# Verifică restricțiile pentru n
if not (1 <= n <= 9):
print("Nu corespunde restricțiilor")
return

# Generează toate permutările de litere de lungime n cu litere mari
litere = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
toate_permutarile = [''.join(p) for p in permutations(litere, r=n)]

# Filtrează permutările pentru a îndeplini condițiile
cuvinte_valide = [cuvant for cuvant in toate_permutarile if cuvant == ''.join(sorted(cuvant)) and numara_vocale_consoane(cuvant)[0] > numara_vocale_consoane(cuvant)[1]]

# Afișează cuvintele în ordine lexicografică
for cuvant_valid in sorted(cuvinte_valide):
print(cuvant_valid)

# Citirea numărului n de la tastatură
n = int(input("Introduceți un număr natural n: "))

# Apelarea funcției cu verificare restricții și afișarea cuvintelor cerute
genereaza_cuvinte(n)

</syntaxhighlight>

3922 - back abc1

2023-12-09T21:44:53Z

Gabii: am adaugat explicatia

= Cerința =
Se citesc două numere naturale <code>n</code> și <code>m</code>. Afișați în ordine lexicografică toate cuvintele care sunt formate din <code>m</code> litere folosind primele <code>n</code> litere mari din alfabet și care au literele ordonate alfabetic strict crescător.

= Date de intrare =
Programul citește de la tastatură numerele <code>n</code> și <code>m</code>, separate prin spații.

= Date de ieșire =
Programul va afișa pe ecran pe linii separate cuvintele cerute. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 26</code>, <code>0 ≤ m ≤ 10</code>
* <code>m ≤ n</code>

= Exemplul 1 =
Intrare
5 3
Ieșire
ABC
ABD
ABE
ACD
ACE
ADE
BCD
BCE
BDE
CDE

== Explicație ==
Primele 5 litere mari sunt {A,B,C,D,E} și se formează cuvinte cu 3 litere având literele ordonate alfabetic.

== Exemplul 2 ==
Intrare
5 7
consola
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
from itertools import combinations

def generate_words(n, m):
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
letters = alphabet[:n]

for combination in combinations(letters, m):
word = ''.join(sorted(combination))
print(word)

def check_restrictions(n, m):
if 1 <= n <= 26 and 0 <= m <= 10 and m <= n:
return True
else:
print("Nu corespunde restricțiilor")
return False

# Citirea datelor de intrare
n, m = map(int, input("Introduceți n și m (separate prin spații): ").split())

# Verificarea restricțiilor și generarea cuvintelor
if check_restrictions(n, m):
generate_words(n, m)

</syntaxhighlight>

3988 - permnk

2023-12-09T21:44:15Z

Gabii: am adaugat explicatia

= Cerința =
Se dau numerele naturale <code>n</code> si <code>k</code>. Sa se genereze in ordine lexicografică toate permutările mulțimii <code>{1,2,...,n}</code> cu proprietatea că diferența în modul dintre oricare două numere alăturate din permutare este de cel mult <code>k</code>.

= Date de intrare =
Programul citește de pe prima linie numărul <code>n</code>, iar de pe a doua linie numărul <code>k</code>.

= Date de ieșire =
Programul va afișa pe ecran, pe câte o linie, în ordine lexicografică, permutările cerute.

= Restricții și precizări =

* <code>1 ≤ k ≤ n ≤ 9</code>

= Exemplul 1 =
Intrare
4
2
Ieșire
1 2 3 4
1 2 4 3
1 3 2 4
1 3 4 2
2 1 3 4
2 4 3 1
3 1 2 4
3 4 2 1
4 2 1 3
4 2 3 1
4 3 1 2
4 3 2 1

== Explicație ==
Lipsesc permutările în care <code>1</code> și <code>4</code> sunt alăturate, deoarece diferența lor în modul este mai mare decât <code>2</code>.

== Exemplul 2 ==
Intrare
5
7
consola
Restricții neîndeplinite. Asigurați-vă că
1 <= k <= n <= 9.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def este_permutare_valida(permutare, k):
for i in range(1, len(permutare)):
if abs(permutare[i] - permutare[i-1]) > k:
return False
return True

def genereaza_permutari(n, k, permutare_curenta):
if len(permutare_curenta) == n:
if este_permutare_valida(permutare_curenta, k):
print(" ".join(map(str, permutare_curenta)))
return

for numar in range(1, n + 1):
if numar not in permutare_curenta:
genereaza_permutari(n, k, permutare_curenta + [numar])

def verifica_restrictii(n, k):
return 1 <= k <= n <= 9

if __name__ == "__main__":
n = int(input("Introduceți n: "))
k = int(input("Introduceți k: "))

if verifica_restrictii(n, k):
genereaza_permutari(n, k, [])
else:
print("Restricții neîndeplinite. Asigurați-vă că 1 <= k <= n <= 9.")

</syntaxhighlight>

3154 - anagrame pfv

2023-12-09T21:43:20Z

Gabii: am adaugat explicatia

= Cerința =
Se citește de la tastatură un cuvânt <code>s</code> format din cel mult <code>11</code> litere mici distincte. Să se genereze în ordine alfabetică și să se afișeze toate anagramele cuvântului <code>s</code> în care vocalele sunt puncte fixe.

= Date de intrare =
Programul citește de la tastatură cuvântul <code>s</code>.

= Date de ieșire =
Programul va afișa pe ecran pe rânduri separate anagramele cuvântului citit în care vocalele rămân pe pozițiile inițiale.

= Restricții și precizări =

* cuvântul <code>s</code> are cel mult <code>11</code> caractere și este format din litere mici distincte

= Exemplul 1 =
Intrare
dorel
Ieșire
doler
dorel
loder
lored
rodel
roled

== Explicație ==
Anagramele sunt afișate în ordine lexicografică, iar literele <code>o</code> și <code>e</code> rămân pe pozițiile inițiale.

== Exemplul 2 ==
Intrare
guadalahara
consola
Cuvântul trebuie să aibă cel mult 11 litere distincte.

== Rezultat ==
<syntaxhighlight lang="python3" line="1">
from itertools import permutations

def este_vocala(caracter):
return caracter in "aeiou"

def valideaza_cuvant(cuvant):
return len(cuvant) <= 11 and len(set(cuvant)) == len(cuvant)

def genereaza_anagrame(cuvant):
vocale = [caracter for caracter in cuvant if este_vocala(caracter)]
consoane = [caracter for caracter in cuvant if not este_vocala(caracter)]

vocale_unice = set(vocale)
pozitii_vocale = {vocala: [i for i, caracter in enumerate(cuvant) if caracter == vocala] for vocala in vocale_unice}

anagrame = set()

for consoane_permutate in set(permutations(consoane)):
anagrama_curenta = list(consoane_permutate)

for vocala in vocale_unice:
for pozitie in pozitii_vocale[vocala]:
anagrama_curenta.insert(pozitie, vocala)

anagrame.add("".join(anagrama_curenta))

return sorted(anagrame)

def main():
cuvant = input("Introduceți cuvântul s: ").lower()

if valideaza_cuvant(cuvant):
anagrame = genereaza_anagrame(cuvant)

for anagrama in anagrame:
print(anagrama)

else:
print("Cuvântul trebuie să aibă cel mult 11 litere distincte.")

if __name__ == "__main__":
main()

</syntaxhighlight>

3906 - suma perm cif

2023-12-09T21:42:13Z

Gabii: am adaugat explicatia

= Cerința =
Scrieți un program care citește un număr natural <code>n</code> cu cifre distincte și care să calculeze și să afișeze suma <code>S</code> a tuturor numerelor obținute prin rearanjarea cifrelor lui <code>n</code>.

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

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

= Restricții și precizări =

* <code>n</code> are cel mult <code>9</code> cifre și are cifrele distincte.

= Exemplul 1 =
Intrare
123
Ieșire
1332

== Explicație ==
Numere obținute din <code>123</code> prin amestecarea cifrelor sunt <code>123</code>, <code>132</code>, <code>213</code>, <code>231</code>, <code>312</code> și <code>321</code>, iar suma lor este <code>1332</code>.

== Exemplul 2 ==
Intrare
1323
consola
Cifrele trebuie să fie distincte.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
from itertools import permutations

def calculate_sum_of_permutations(n):
# Convertim numărul într-o listă de cifre
digits = [int(digit) for digit in str(n)]

# Verificăm dacă cifrele sunt distincte
if len(digits) != len(set(digits)):
raise ValueError("Cifrele trebuie să fie distincte.")

# Generăm toate permutările cifrelor
all_permutations = permutations(digits)

# Calculăm suma permutărilor și le afișăm
total_sum = 0
for perm in all_permutations:
perm_number = int(''.join(map(str, perm)))
total_sum += perm_number

return total_sum

def validate_n(n):
# Verificăm restricțiile
return 1 <= n <= 10**9 - 1

def main():
try:
n = int(input("Introduceți un număr cu cifre distincte: "))

# Verificăm restricțiile utilizând funcția separată
if not validate_n(n):
print("Numărul trebuie să fie mai mic decât 10^9.")
return

# Calculăm suma și o afișăm
result = calculate_sum_of_permutations(n)
print(f"Suma tuturor numerelor obținute prin rearanjarea cifrelor lui {n} este: {result}")

except ValueError as e:
print(e)

if __name__ == "__main__":
main()

</syntaxhighlight>

2141 - Exp

2023-12-09T21:39:51Z

Gabii: radical de ordin m din (x1⋅x2⋅…⋅xn) radicalul nu l pot pune =]

== Enunț ==
Se dă un şir de <code>n</code> numere naturale nenule <code>x1</code>, <code>x2</code>, …, <code>xn</code> şi un număr natural <code>m</code>.

= Cerința =
Să se verifice dacă valoarea expresiei radical de ordin m din (x1⋅x2⋅…⋅xn) este un număr natural. În caz afirmativ să se afișeze acest număr descompus în factori primi.

= Date de intrare =
Fișierul de intrare <code>expIN.txt</code> conține pe prima linie <code>m</code>, pe linia a doua <code>n</code>, iar pe linia a treia numerele <code>x1</code>, <code>x2</code>, …, <code>xn</code> separate între ele prin câte un spațiu.

= Date de ieșire =
În fișierul de ieșire <code>expOUt.txt</code> se va scrie pe prima linie cifra <code>0</code>, dacă valoarea expresiei nu este un număr natural, respectiv <code>1</code> dacă este un număr natural. Dacă valoarea expresiei este un număr natural pe următoarele linii se vor scrie perechi de forma <code>p e</code> (<code>p</code> este factor prim care apare în descompunere la puterea <code>e>=1</code>). Aceste perechi se vor scrie în ordine crescătoare după primul număr (adică <code>p</code>).

= Restricții și precizări =

* <code>0 < n < 5000</code>
* <code>0 < xi</code> <code>< 30.001</code>, pentru orice <code>i=1..n</code>
* <code>m</code> poate fi una din cifrele <code>2</code>, <code>3</code>, <code>4</code>.

= Exemplul 1: =
<code>expIN.txt</code>
2
4
32 81 100 18
<code>expOUt.txt</code>
1
2 4
3 3
5 1

= Exemplul 2: =
<code>expIN.txt</code>
6
6
45 5 44 23 32 32
consola:
Eroare: Numărul m trebuie să fie una din cifrele 2, 3, 4.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def respecta_restrictiile(m, n, xi):
if not (0 < n < 5000):
print("Eroare: Numărul de elemente n trebuie să fie între 0 și 5000.")
return False

if not (0 < m < 5):
print("Eroare: Numărul m trebuie să fie una din cifrele 2, 3, 4.")
return False

if not all(0 < x < 30001 for x in xi):
print("Eroare: Elementele xi trebuie să fie în intervalul (0, 30001).")
return False

return True

def este_numar_natural(n):
return n == int(n) and n > 0

def descompunere_in_factori_primi(numar):
factori_primi = []
divizor = 2

while divizor <= numar:
putere = 0
while numar % divizor == 0:
numar //= divizor
putere += 1
if putere > 0:
factori_primi.append((divizor, putere))
divizor += 1

return factori_primi

def main():
with open("expIN.txt", "r") as f:
m = int(f.readline().strip())
n = int(f.readline().strip())
xi = list(map(int, f.readline().split()))

if not respecta_restrictiile(m, n, xi):
return

# Restul codului pentru calcule și scrierea în fișier rămâne neschimbat
produs = 1
for x in xi:
produs *= x

radical_m = produs ** (1/m)

with open("expOUT.txt", "w") as f:
if este_numar_natural(radical_m):
f.write("1\n")
factori_primi = descompunere_in_factori_primi(int(radical_m))
for factor, putere in factori_primi:
f.write(f"{factor} {putere}\n")
else:
f.write("0\n")

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

1148 -Exista Impare Div Imp

2023-12-09T21:36:04Z

Gabii: Am uitat sa dau save =]

= 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 impare.

= 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ă şirul conţine elemente impare, 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
NU

== Exemplul 2 ==
Date de intrare
101
Consola
Valoarea nu respecta conditiile. Incercati din nou.

== Rezolvare ==
<syntaxhighlight lang="python3">
def exista_element_impar(arr, stanga, dreapta):
if stanga == dreapta:
# Caz de bază: un singur element
return arr[stanga] % 2 == 1

mijloc = (stanga + dreapta) // 2

# Verifică dacă există elemente impare în ambele părți
exista_stanga = exista_element_impar(arr, stanga, mijloc)
exista_dreapta = exista_element_impar(arr, mijloc + 1, dreapta)

# Returnează True dacă există elemente impare în cel puțin una dintre părți
return exista_stanga or exista_dreapta

# Funcție pentru verificarea valorii lui n
def verifica_n(valoare):
return 1 <= valoare <= 100

# Funcție pentru verificarea valorii lui x
def verifica_x(valoare):
return valoare <= 10000

# Funcție pentru citirea unui număr întreg într-un interval specificat
def citeste_numar(mesaj, functie_verificare):
while True:
try:
numar = int(input(mesaj))
if functie_verificare(numar):
return numar
else:
print(f"Valoarea nu respecta conditiile. Incercati din nou.")
except ValueError:
print("Introduceti un numar valid.")

# Citirea datelor de intrare
while True:
n = citeste_numar("Introduceti numarul de elemente (1 <= n <= 100): ", verifica_n)
if verifica_n(n):
break
else:
print("Numarul de elemente nu respecta conditiile. Incercati din nou.")

arr = []

# Reading array elements
print("Introduceti cele {} elemente ale sirului:".format(n), end=" ")
for i in range(n):
element = citeste_numar(f"Introduceti elementul {i + 1} al sirului: ", verifica_x)
arr.append(element)

# Verificarea și afișarea rezultatului
rezultat = exista_element_impar(arr, 0, n - 1)
if rezultat:
print("DA")
else:
print("NU")
</syntaxhighlight>

1020 - Mat Prim

2023-12-09T21:28:30Z

Gabii: am modificat codul

= 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("Nu respectă condiția lui n")
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: "))

# Inițializează un șir gol pentru a colecta elementele
sir = []

# Colectează elementele șirului
for i in range(n):
element = int(input("Introduceti elementul {}: ".format(i + 1)))
sir.append(element)

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

# Continuă cu restul codului
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>

0968 - Copac

2023-12-09T20:35:55Z

Gabii:

== 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 ==

* 0 ≤ n ≤ 45

== Exemplul 1 ==
Intrare
2
Ieșire
20 25 36

== Explicație ==
Copacul va avea peste n=2 zile: 20 ramuri de argint, 25 ramuri de aur, 36 ramuri de rubin

== Exemplul 2 ==
Intrare 46

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

= Explicație =
Copacul va avea peste <code>n=10</code> zile: <code>13001</code> ramuri de argint, <code>16212</code> ramuri de aur, <code>23427</code> ramuri de rubin

== 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>

3260 - Invers

2023-12-09T20:33:10Z

Gabii:

== 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 f(x)=sin(x) + sin(2*x) + x și o valoare y. Știind că funcția este strict crescătoare pe intervalul [0,1), se cere să se gasească pentru ce x∈[0,1) avem că f(x)≈y (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

== Exemplul 1 ==
Intrare:
1.34

Ieșire:
0.35083179

== Explicație ==
Considerand f(x)=sin(x)+sin(2∗x)+x avem ca:

• f(0.35083177) = 1.33999994

• f(0.35083178) = 1.33999998

• f(0.35083179) = 1.34000001

• f(0.35083180) = 1.34000005

După cum se observă, valoarea cea mai apropiată de în aproximarea cu 8 zecimale este , valoare ce este considerată a fi corectă (deși imprecisă, este cea mai apropiată valoare ce ar putea fi dată lui x pentru ca ).

== Exemplul 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>

0806 - Generare sir

2023-12-09T20:29:56Z

Gabii:

==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>.

= Restricţii şi precizări =

* 1 ≤ x ≤ 1.000.000.000

==Exemplul 1==
Date intrare
15
Date iesire
15 8 7 4 3 2 1

==Exemplul 2==
Date intrare
0
Cerința
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>

0968 - Copac

2023-12-09T20:29:23Z

Gabii:

== 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 ==

* 0 ≤ n ≤ 45

== Explicație ==
Copacul va avea peste n=2 zile: 20 ramuri de argint, 25 ramuri de aur, 36 ramuri de rubin

== 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>

0968 - Copac

2023-12-09T20:28:03Z

Gabii:

== 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>

== Explicație ==
Copacul va avea peste n=2 zile: 20 ramuri de argint, 25 ramuri de aur, 36 ramuri de rubin

== 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>

0968 - Copac

2023-12-09T20:27:27Z

Gabii:

== 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>

== Explicație ==
<code>Copacul va avea peste n=2 zile: 20 ramuri de argint, 25 ramuri de aur, 36 ramuri de rubin</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-09T20:24:07Z

Gabii:

==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>.

= Restricţii şi precizări =

* <code>1 ≤ x ≤ 1.000.000.000</code>

==Exemplul 1==
Date intrare
15
Date iesire
15 8 7 4 3 2 1

==Exemplul 2==
Date intrare
0
Cerința
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>

0091 - Masini

2023-12-04T22:54:26Z

Gabii: Pagină nouă: == Enunț == În curtea unui atelier de reparaţii auto, sunt <code>n</code> maşini care trebuie sa fie reparate. Deoarece nu sunt suficienţi mecanici, în fiecare moment de timp se poate lucra doar la o singură maşină. = Cerinţa = Cunoscând timpul necesar pentru repararea fiecărei maşini, scrieţi un program care calculează numărul maxim de maşini care pot fi reparate într-un interval de timp <code>T</code>. = Date de intrare = Pe prima linie a fişierului <co...

== Enunț ==
În curtea unui atelier de reparaţii auto, sunt <code>n</code> maşini care trebuie sa fie reparate. Deoarece nu sunt suficienţi mecanici, în fiecare moment de timp se poate lucra doar la o singură maşină.

= Cerinţa =
Cunoscând timpul necesar pentru repararea fiecărei maşini, scrieţi un program care calculează numărul maxim de maşini care pot fi reparate într-un interval de timp <code>T</code>.

= Date de intrare =
Pe prima linie a fişierului <code>masiniIN.txt</code> se găsesc două numere naturale <code>n</code> şi <code>T</code> separate printr-un singur spaţiu, reprezentând numărul de maşini din curtea atelierului auto şi timpul total în care se va lucra.

Pe linia a doua, separate prin câte un spaţiu, se găsesc <code>n</code> numere naturale <code>t1</code>, <code>t2</code>, …, <code>tn</code>, reprezentând timpii necesari pentru repararea fiecărei maşini.

= Date de ieşire =
Pe prima linie a fişierului <code>masiniOUT.txt</code>se va găsi un număr natural <code>k</code>, reprezentând numărul maxim de maşini care pot fi reparate.

= Restricţii şi precizări =

* <code>1 < n, T <= 1000</code>
* numerele de pe a doua linie a fişierului de intrare vor fi mai mici sau egale cu <code>100</code>

= Exemplul 1 =
<code>masiniIN.txt</code>
5 10
6 2 4 8 2
<code>masiniOUT.txt</code>
3

= Exemplul 2 =
<code>masiniIN.txt</code>
5 10000
6 2 4 8 2
consola
Eroare: Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
import os

def numar_maxim_masini(n, T, timp_reparare):
# Sortează timpurile de reparare în ordine crescătoare
timp_reparare.sort()

masini_reparate = 0
timp_total = 0

# Parcurge mașinile și adaugă timpul de reparare la timp_total
for timp in timp_reparare:
if timp_total + timp <= T:
masini_reparate += 1
timp_total += timp
else:
break

return masini_reparate

def citeste_date_intrare(nume_fisier):
if not os.path.exists(nume_fisier):
raise FileNotFoundError(f"Fișierul {nume_fisier} nu a fost găsit.")

with open(nume_fisier, "r") as f:
# Citire n și T
n, T = map(int, f.readline().split())

# Verificare restricții pentru n și T
if not (1 <= n <= 1000 and 1 <= T <= 1000):
raise ValueError("Nu corespunde restricțiilor")

# Citire și verificare timp_reparare
timp_reparare = list(map(int, f.readline().split()))
if any(timp > 100 for timp in timp_reparare):
raise ValueError("Nu corespunde restricțiilor")

return n, T, timp_reparare

# Citire date de intrare și verificare restricții
try:
n, T, timp_reparare = citeste_date_intrare("masiniIN.txt")
except FileNotFoundError as e:
print(f"Eroare: {str(e)}")
exit(1)
except ValueError as e:
print(f"Eroare: {str(e)}")
exit(1)

# Calculare rezultat
rezultat = numar_maxim_masini(n, T, timp_reparare)

# Scriere rezultat în fișierul masiniOUT.txt
with open("masiniOUT.txt", "w") as f_out:
f_out.write(str(rezultat))

</syntaxhighlight>

3689 - 2gen

2023-12-04T22:01:30Z

Gabii: Pagină nouă: = Cerința = Se <code>n</code> și <code>m</code> numere naturale. Afișați în ordine lexicografică toate șirurile de lungime <code>m</code> care conțin numere de la <code>1</code> la <code>n</code> și fiecare valoare apare de maxim două ori. = Date de intrare = Fișierul de intrare <code>2genIN.txt</code> conține pe prima linie numerele <code>n</code> și <code>m</code> separate prin spațiu. = Date de ieșire = Fișierul de ieșire <code>2genOUT.txt</code> va con...

= Cerința =
Se <code>n</code> și <code>m</code> numere naturale. Afișați în ordine lexicografică toate șirurile de lungime <code>m</code> care conțin numere de la <code>1</code> la <code>n</code> și fiecare valoare apare de maxim două ori.

= Date de intrare =
Fișierul de intrare <code>2genIN.txt</code> conține pe prima linie numerele <code>n</code> și <code>m</code> separate prin spațiu.

= Date de ieșire =
Fișierul de ieșire <code>2genOUT.txt</code> va conține câte o soluție pe linie. Numerele de pe aceeași linie se separă prin spații. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 6</code>
* <code>1 ≤ m ≤ 6</code>

= Exemplul 1 =
<code>2genIN.txt</code>
4 3
<code>2genOUT.txt</code>
1 1 2
1 1 3
1 1 4
1 2 1
1 2 2
1 2 3
1 2 4
1 3 1
1 3 2
1 3 3
1 3 4
1 4 1
1 4 2
1 4 3
1 4 4
2 1 1
2 1 2
2 1 3
2 1 4
2 2 1
2 2 3
2 2 4
2 3 1
2 3 2
2 3 3
2 3 4
2 4 1
2 4 2
2 4 3
2 4 4
3 1 1
3 1 2
3 1 3
3 1 4
3 2 1
3 2 2
3 2 3
3 2 4
3 3 1
3 3 2
3 3 4
3 4 1
3 4 2
3 4 3
3 4 4
4 1 1
4 1 2
4 1 3
4 1 4
4 2 1
4 2 2
4 2 3
4 2 4
4 3 1
4 3 2
4 3 3
4 3 4
4 4 1
4 4 2
4 4 3

== Exemplul 2 ==
<code>2genIN.txt</code>
7 7
consola
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def genereaza_siruri(n, m):
def backtracking(sir_partial):
if len(sir_partial) == m:
solutii.append(sir_partial.copy())
return

for numar in range(1, n + 1):
if folosit[numar] < 2:
sir_partial.append(numar)
folosit[numar] += 1

backtracking(sir_partial)

sir_partial.pop()
folosit[numar] -= 1

solutii = []
folosit = {numar: 0 for numar in range(1, n + 1)}
backtracking([])

return solutii

def main():
# Citire date de intrare
with open("2genIN.txt", "r") as fisier_intrare:
n, m = map(int, fisier_intrare.readline().split())

# Verificare restricții
if not (1 <= n <= 6 and 1 <= m <= 6):
print("Nu corespunde restricțiilor")
return

# Generare șiruri
siruri = genereaza_siruri(n, m)

# Scriere rezultate în fișierul de ieșire
with open("2genOUT.txt", "w") as fisier_iesire:
if siruri:
for sir in siruri:
fisier_iesire.write(" ".join(map(str, sir)) + "\n")
else:
fisier_iesire.write("Nu corespunde restricțiilor\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

1288 - CifreGen1

2023-12-04T21:23:38Z

Gabii: Pagină nouă: = Cerința = Se dau două numere <code>n m</code>. Să se genereze toate numerele cu exact <code>n</code> cifre mai mici decât <code>m</code>. = Date de intrare = Programul citește de la tastatură numerele <code>n m</code>. = Date de ieșire = Programul va afișa pe ecran numerele generate, câte unul pe linie, în ordine crescătoare. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor". = Restricții și precizări...

= Cerința =
Se dau două numere <code>n m</code>. Să se genereze toate numerele cu exact <code>n</code> cifre mai mici decât <code>m</code>.

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

= Date de ieșire =
Programul va afișa pe ecran numerele generate, câte unul pe linie, în ordine crescătoare. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 7</code>
* <code>0 < m < 6</code>

= Exemplul 1 =
Intrare
3 2
Ieșire
100
101
110
111

= Exemplul 2 =
Intrare
12 14
consola
"Nu corespunde restricțiilor"

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n, m):
"""
Verifică dacă valorile lui n și m satisfac restricțiile.

:param n: Numărul de cifre dorit în numerele generate
:param m: Limita superioară pentru cifrele din numere
:return: True dacă restricțiile sunt îndeplinite, False în caz contrar
"""
return 1 <= n <= 7 and 0 < m < 10

def genereaza_numere_backtracking(n, m, numar_curent=0):
"""
Generează și afișează numerele cu exact n cifre, unde fiecare cifră este strict mai mică decât m, folosind backtracking.

:param n: Numărul de cifre dorit în numerele generate
:param m: Limita superioară pentru cifrele din numere
:param numar_curent: Numărul curent construit prin adăugarea de cifre
"""
if n == 0:
print(numar_curent)
return
for cifra in range(m):
if numar_curent == 0 and cifra == 0:
continue # Evităm să începem cu zero pentru a păstra exact n cifre
genereaza_numere_backtracking(n - 1, m, numar_curent * 10 + cifra)

# Citirea datelor de intrare
n, m = map(int, input("Introduceți n și m, separate prin spațiu: ").split())

# Verificarea restricțiilor
if verifica_restrictii(n, m):
# Apelul funcției pentru a începe generarea
genereaza_numere_backtracking(n, m)
else:
print("Nu corespunde restricțiilor. Introduceți valori valide pentru n și m.")

</syntaxhighlight>

1287 - CifreGen

2023-12-04T21:05:39Z

Gabii:

= Cerința =
Se dau două cifre <code>a b</code> și un număr <code>n</code>. Să se genereze toate numerele cu exact <code>n</code> cifre cuprinse între <code>a</code> și <code>b</code>.

= Date de intrare =
Programul citește de la tastatură numerele <code>a b n</code>.

= Date de ieșire =
Programul va afișa pe ecran numerele generate, câte unul pe linie, în ordine crescătoare. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 8</code>
* <code>0 < a < b < 10</code>

= Exemplul 1 =
Intrare
3 5 3
Ieșire
333
334
335
343
344
345
353
354
355
433
434
435
443
444
445
453
454
455
533
534
535
543
544
545
553
554
555

= Exemplul 2 =
Intrare
5 3 10
consola
"Nu corespunde restricțiilor".

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_restrictions(a, b, n):
if 1 <= n <= 8 and 0 < a < b < 10:
return True
else:
print("Nu corespunde restricțiilor")
return False

# Citirea datelor de intrare
a = int(input("Introduceți a: "))
b = int(input("Introduceți b: "))
n = int(input("Introduceți n: "))

# Validarea restricțiilor
if validate_restrictions(a, b, n):
# Generarea și afișarea numerelor
def generate_numbers(current_number, remaining_digits):
if remaining_digits == 0:
print(current_number)
return
for digit in range(a, b+1):
generate_numbers(current_number * 10 + digit, remaining_digits - 1)

for starting_digit in range(a, b+1):
generate_numbers(starting_digit, n - 1)

</syntaxhighlight>

1287 - CifreGen

2023-12-04T21:04:51Z

Gabii: Pagină nouă: = Cerința = Se dau două cifre <code>a b</code> și un număr <code>n</code>. Să se genereze toate numerele cu exact <code>n</code> cifre cuprinse între <code>a</code> și <code>b</code>. = Date de intrare = Programul citește de la tastatură numerele <code>a b n</code>. = Date de ieșire = Programul va afișa pe ecran numerele generate, câte unul pe linie, în ordine crescătoare. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespun...

= Cerința =
Se dau două cifre <code>a b</code> și un număr <code>n</code>. Să se genereze toate numerele cu exact <code>n</code> cifre cuprinse între <code>a</code> și <code>b</code>.

= Date de intrare =
Programul citește de la tastatură numerele <code>a b n</code>.

= Date de ieșire =
Programul va afișa pe ecran numerele generate, câte unul pe linie, în ordine crescătoare. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 8</code>
* <code>0 < a < b < 10</code>

= Exemplul 1 =
Intrare
3 5 3
Ieșire
333
334
335
343
344
345
353
354
355
433
434
435
443
444
445
453
454
455
533
534
535
543
544
545
553
554
555

= Exemplul 2 =
Intrare
3 5 3
consola
"Nu corespunde restricțiilor".

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_restrictions(a, b, n):
if 1 <= n <= 8 and 0 < a < b < 10:
return True
else:
print("Nu corespunde restricțiilor")
return False

# Citirea datelor de intrare
a = int(input("Introduceți a: "))
b = int(input("Introduceți b: "))
n = int(input("Introduceți n: "))

# Validarea restricțiilor
if validate_restrictions(a, b, n):
# Generarea și afișarea numerelor
def generate_numbers(current_number, remaining_digits):
if remaining_digits == 0:
print(current_number)
return
for digit in range(a, b+1):
generate_numbers(current_number * 10 + digit, remaining_digits - 1)

for starting_digit in range(a, b+1):
generate_numbers(starting_digit, n - 1)

</syntaxhighlight>

0201 - SubmDiv

2023-12-04T20:11:41Z

Gabii: Pagină nouă: = Cerinţa = Să se determine toate submulţimile cu <code>m</code> elemente ale mulţimii divizorilor unui număr natural <code>x</code> dat. = Date de intrare = Fişierul de intrare <code>submdivIN.txt</code> conţine pe prima linie numerele <code>x</code> şi <code>m</code>,cu semnificaţia din enunţ. = Date de ieşire = Fişierul de ieşire <code>submdivOUT.txt</code> va conţine pe fiecare linie câte o submulţime determinată. Aceste submulţimi for fi afişate în...

= Cerinţa =
Să se determine toate submulţimile cu <code>m</code> elemente ale mulţimii divizorilor unui număr natural <code>x</code> dat.

= Date de intrare =
Fişierul de intrare <code>submdivIN.txt</code> conţine pe prima linie numerele <code>x</code> şi <code>m</code>,cu semnificaţia din enunţ.

= Date de ieşire =
Fişierul de ieşire <code>submdivOUT.txt</code> va conţine pe fiecare linie câte o submulţime determinată. Aceste submulţimi for fi afişate în ordine lexicografică. Pentru fiecare submulţime se vor afişa elementele în ordine crescătoare, separate printr-un spaţiu. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricţii şi precizări =

* <code>1 ≤ m ≤ 6</code>
* <code>1 ≤ x ≤ 1000</code>
* dacă nu există soluţie, pe prima linie a fişierului <code>submdivOUT.txt</code> se va afişa mesajul <code>fara solutie</code>

= Exemplul 1 =
<code>submdivIN.txt</code>
45 4
<code>submdivOUT.txt</code>
1 3 5 9
1 3 5 15
1 3 5 45
1 3 9 15
1 3 9 45
1 3 15 45
1 5 9 15
1 5 9 45
1 5 15 45
1 9 15 45
3 5 9 15
3 5 9 45
3 5 15 45
3 9 15 45
5 9 15 45

= Exemplul 2 =
<code>submdivIN.txt</code>
45 4
<code>submdivOUT.txt</code>
Nu corespunde restrictiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare_restricții(x, m):
if 1 <= m <= 6 and 1 <= x <= 1000:
return True
return False

def genereaza_submultimi(arr, m, curent, index, rezultat):
if m == 0:
rezultat.append(curent.copy())
return
if index == len(arr):
return
curent.append(arr[index])
genereaza_submultimi(arr, m - 1, curent, index + 1, rezultat)
curent.pop()
genereaza_submultimi(arr, m, curent, index + 1, rezultat)

def divizori_submultime(x, m):
divizori = [i for i in range(1, x + 1) if x % i == 0]
rezultat = []
genereaza_submultimi(divizori, m, [], 0, rezultat)
return sorted(rezultat) # Sortează submulțimile în ordine lexicografică

def scrie_submultimi_in_fisier(submultimi, fisier_iesire):
with open(fisier_iesire, 'w') as fisier:
if not submultimi:
fisier.write("fara solutie\n")
else:
for submultime in submultimi:
fisier.write(" ".join(map(str, submultime)) + "\n")

if __name__ == "__main__":
# Citirea datelor din fișierul de intrare
with open("submdivIN.txt", 'r') as fisier_intrare:
x, m = map(int, fisier_intrare.readline().split())

# Verificare restricții
if not verificare_restricții(x, m):
with open("submdivOUT.txt", 'w') as fisier_iesire:
fisier_iesire.write("Nu corespunde restrictiilor\n")
else:
# Generarea submulțimilor de divizori
submultimi = divizori_submultime(x, m)

# Scrierea rezultatelor în fișierul de ieșire
scrie_submultimi_in_fisier(submultimi, "submdivOUT.txt")

</syntaxhighlight>

3160 - cifre c

2023-12-04T19:43:31Z

Gabii: Pagină nouă: = Cerința = Se citesc un număr natural <code>n</code> având cifrele diferite două câte două și o cifră <code>c</code>. Afișați în ordine descrescătoare numerele formate din <code>c</code> cifre distincte care se pot obține din cifrele lui <code>n</code> și care au cifrele ordonate crescător. = Date de intrare = Programul citește de la tastatură numele <code>n</code> și <code>c</code>. = Date de ieșire = Programul va afișa pe ecran numerele cerute, câte...

= Cerința =
Se citesc un număr natural <code>n</code> având cifrele diferite două câte două și o cifră <code>c</code>. Afișați în ordine descrescătoare numerele formate din <code>c</code> cifre distincte care se pot obține din cifrele lui <code>n</code> și care au cifrele ordonate crescător.

= Date de intrare =
Programul citește de la tastatură numele <code>n</code> și <code>c</code>.

= Date de ieșire =
Programul va afișa pe ecran numerele cerute, câte unul pe fiecare rând. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 1.000.000.000</code>, <code>1 < c < 9</code>
* <code>n</code> are cifrele distincte
* <code>c</code> este mai mic decât numărul de cifre ale lui <code>n</code>

= Exemplul 1 =
Intrare
4618 3
Ieșire
468
168
148
146

= Exemplul 2 =
Intrare
4618 3
consola
"Nu corespunde restricțiilor".

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restricții(n, c):
if not (1 <= n <= 1000000000 and 1 < c < 9):
return False

cifre_n = set(str(n))
return len(cifre_n) == len(str(n)) and c < len(cifre_n)

def genereaza_numere(n, c):
cifre_n = sorted(str(n))
rezultat = []

def backtrack(start, path):
if len(path) == c:
rezultat.append(int(''.join(path)))
return

for i in range(start, len(cifre_n)):
backtrack(i + 1, path + [cifre_n[i]])

backtrack(0, [])
return rezultat

# Citirea datelor de intrare
try:
n, c = input("Introduceți un număr natural n și un număr c (separate prin spațiu): ").split()
n = int(n)
c = int(c)

if verifica_restricții(n, c):
rezultate = genereaza_numere(n, c)

if rezultate:
print("Numerele cerute (ordonate descrescător):")
for rezultat in sorted(rezultate, reverse=True):
print(rezultat)
else:
print("Nu există numere conform cerințelor.")
else:
print("Nu corespunde restricțiilor.")
except ValueError:
print("Introduceți numere valide.")

</syntaxhighlight>

3247 - subimp1

2023-12-04T19:36:20Z

Gabii: Pagină nouă: = Cerința = Se citește un număr natural <code>n</code>. Afișați în ordine lexicografică toate submulțimile mulțimii <code>{1, 2, ..., n}</code> care sunt formate dintr-un număr impar de elemente. = Date de intrare = Programul citește de la tastatură numărul <code>n</code>. = Date de ieșire = Programul va afișa pe ecran submulțimile cerute, câte una pe fiecare rand și având elementele separate prin câte un spaţiu. În cazul în care restricțiile nu sunt...

= Cerința =
Se citește un număr natural <code>n</code>. Afișați în ordine lexicografică toate submulțimile mulțimii <code>{1, 2, ..., n}</code> care sunt formate dintr-un număr impar de elemente.

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

= Date de ieșire =
Programul va afișa pe ecran submulțimile cerute, câte una pe fiecare rand și având elementele separate prin câte un spaţiu. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 19</code>

= Exemplul 1 =
Intrare
4
Ieșire
1
1 2 3
1 2 4
1 3 4
2
2 3 4
3
4

= Exemplul 1 =
Intrare
4
consola
"Nu corespunde restricțiilor"

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restricții(n):
return 1 <= n <= 19

def generare_submultimi(curent, start, end, rezultat):
if start > end:
return

for i in range(start, end + 1):
curent.append(i)
rezultat.append(list(curent))
generare_submultimi(curent, i + 1, end, rezultat)
curent.pop()

def afisare_submultimi_impare(n):
# Verificare restricții folosind funcția separată
if verifica_restricții(n):
submultimi = []
generare_submultimi([], 1, n, submultimi)

print("Submulțimile cu un număr impar de elemente:")
for submultime in submultimi:
if len(submultime) % 2 == 1:
print(*submultime)
else:
print("Nu corespunde restricțiilor.")

# Citirea datelor de intrare
try:
n = int(input("Introduceți un număr natural n: "))
afisare_submultimi_impare(n)
except ValueError:
print("Introduceți un număr valid.")

</syntaxhighlight>

3152 - combinari2

2023-12-04T19:31:07Z

Gabii: Pagină nouă: = Cerința = Se citesc două numere naturale <code>n</code> și <code>m</code>. Afișați în ordine lexicografică toate submulțimile cu <code>m</code> elemente ale mulțimii <code>{1, 2, ..., n}</code> în care nu există două elemente pare alăturate. = Date de intrare = Programul citește de la tastatură numerele <code>n</code> și <code>m</code>. = Date de ieșire = Programul va afișa pe ecran submulțimile cerute, câte una pe fiecare rand și având elementele s...

= Cerința =
Se citesc două numere naturale <code>n</code> și <code>m</code>. Afișați în ordine lexicografică toate submulțimile cu <code>m</code> elemente ale mulțimii <code>{1, 2, ..., n}</code> în care nu există două elemente pare alăturate.

= Date de intrare =
Programul citește de la tastatură numerele <code>n</code> și <code>m</code>.

= Date de ieșire =
Programul va afișa pe ecran submulțimile cerute, câte una pe fiecare rand și având elementele separate prin câte un spaţiu. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ m < n ≤ 20</code>

= Exemplul 1 =
Intrare
5 3
Ieșire
1 2 3
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
3 4 5

= Exemplul 2 =
Intrare
22 17
consola
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def este_input_valid(n, m):
return 1 <= m < n <= 20

def este_submultime_valida(submultime):
for i in range(len(submultime) - 1):
if submultime[i] % 2 == 0 and submultime[i + 1] % 2 == 0:
return False
return True

def genereaza_submultimi(n, m, submultime_curenta, index):
if len(submultime_curenta) == m:
if este_submultime_valida(submultime_curenta):
print(*submultime_curenta)
return

if index > n:
return

# Include elementul la index în submulțime
genereaza_submultimi(n, m, submultime_curenta + [index], index + 1)

# Sări peste elementul la index
genereaza_submultimi(n, m, submultime_curenta, index + 1)

if __name__ == "__main__":
n, m = map(int, input("Introduceți valorile pentru n și m (separate prin spațiu): ").split())

if not este_input_valid(n, m):
print("Nu corespunde restricțiilor")
else:
print(f"Submulțimile cu {m} elemente ale mulțimii {{1, 2, ..., {n}}} în care nu există două elemente pare alăturate sunt:")
genereaza_submultimi(n, m, [], 1)

</syntaxhighlight>

0204 - Siruri

2023-12-04T19:22:14Z

Gabii: Pagină nouă: = Cerinţa = Se citesc două numere naturale nenule <code>n</code> și <code>m</code>. Să se determine toate şirurile cu <code>m</code> elemente din mulţimea <code>{1,2,..,n}</code>, ordonate strict crescător, cu proprietatea că oricare două elemente consecutive în şir au diferenţa mai mică sau egală cu cu <code>2</code>. = Date de intrare = Fişierul de intrare <code>siruriIN.txt</code> conţine pe prima linie numerele <code>n</code> și <code>m</code>, separate...

= Cerinţa =
Se citesc două numere naturale nenule <code>n</code> și <code>m</code>. Să se determine toate şirurile cu <code>m</code> elemente din mulţimea <code>{1,2,..,n}</code>, ordonate strict crescător, cu proprietatea că oricare două elemente consecutive în şir au diferenţa mai mică sau egală cu cu <code>2</code>.

= Date de intrare =
Fişierul de intrare <code>siruriIN.txt</code> conţine pe prima linie numerele <code>n</code> și <code>m</code>, separate printr-un spațiu.

= Date de ieşire =
Fişierul de ieşire <code>siruriOUT.txt</code> va conţine pe fiecare linie câte <code>m</code> valori, separate prin câte un spaţiu, reprezentând elementele unui şir. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricţii şi precizări =

* <code>1 ≤ m ≤ n ≤ 15</code>
* şirurile vor fi afişate în ordine lexicografică

= Exemplul 1 =
<code>siruriIN.txt</code>
5 3
<code>siruriOUT.txt</code>
1 2 3
1 2 4
1 3 4
1 3 5
2 3 4
2 3 5
2 4 5
3 4 5

= Exemplul 2 =
<code>siruriIN.txt</code>
8 9
<code>siruriOUT.txt</code>
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def genereaza_siruri(n, m, sir_curent, start):
if len(sir_curent) == m:
return [sir_curent.copy()]

siruri = []
for i in range(start, n + 1):
if not sir_curent or abs(sir_curent[-1] - i) <= 2:
sir_curent.append(i)
siruri.extend(genereaza_siruri(n, m, sir_curent, i + 1))
sir_curent.pop()

return siruri

def main():
with open("siruriIN.txt", "r") as fisier_intrare:
n, m = map(int, fisier_intrare.readline().split())

if not (1 <= m <= n <= 15):
with open("siruriOUT.txt", "w", encoding="utf-8") as fisier_iesire:
fisier_iesire.write("Nu corespunde restricțiilor\n")
return

siruri_generate = genereaza_siruri(n, m, [], 1)

with open("siruriOUT.txt", "w", encoding="utf-8") as fisier_iesire:
if not siruri_generate:
fisier_iesire.write("Nu corespunde restricțiilor\n")
else:
for sir in sorted(siruri_generate):
fisier_iesire.write(" ".join(map(str, sir)) + "\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

0197 - Combinari

2023-12-04T18:43:25Z

Gabii: Pagină nouă: = Cerinţa = Se citesc două numere naturale nenule <code>n</code> și <code>k</code>. Să se afişeze, în ordine lexicografică, submulțimile de câte <code>k</code> elemente ale mulţimii <code>{1,2,..,n}</code>. = Date de intrare = Fişierul de intrare <code>combinariIN.txt</code> conţine pe prima linie numerele <code>n</code> și <code>k</code>, separate printr-un spatiu. = Date de ieşire = Fişierul de ieşire <code>combinariOUT.txt</code> va conţine pe fiecare li...

= Cerinţa =
Se citesc două numere naturale nenule <code>n</code> și <code>k</code>. Să se afişeze, în ordine lexicografică, submulțimile de câte <code>k</code> elemente ale mulţimii <code>{1,2,..,n}</code>.

= Date de intrare =
Fişierul de intrare <code>combinariIN.txt</code> conţine pe prima linie numerele <code>n</code> și <code>k</code>, separate printr-un spatiu.

= Date de ieşire =
Fişierul de ieşire <code>combinariOUT.txt</code> va conţine pe fiecare linie câte <code>k</code> valori, separate prin câte un spaţiu, reprezentând elementele unei submulțimi.

= Restricţii şi precizări =

* <code>1 ≤ k ≤ n ≤ 15</code>
* elementele fiecărei submulţimi vor fi afişate în ordine crescătoare

= Exemplul 1 =
<code>combinariIN.txt</code>
4 2
<code>combinariOUT.txt</code>
1 2
1 3
1 4
2 3
2 4
3 4

= Exemplul 2 =
<code>combinariIN.txt</code>
4 2
consola
"Nu corespunde restricțiilor"

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def generate_combinations(n, k, current_combination, start, result):
if k == 0:
result.append(current_combination[:])
return

for i in range(start, n + 1):
current_combination.append(i)
generate_combinations(n, k - 1, current_combination, i + 1, result)
current_combination.pop()

def generate_and_write_combinations(input_file, output_file):
try:
with open(input_file, 'r') as file:
n, k = map(int, file.readline().split())

if not (1 <= k <= n <= 15):
raise ValueError("Nu corespunde restricțiilor")

result = []
generate_combinations(n, k, [], 1, result)

with open(output_file, 'w') as file:
for combination in result:
file.write(' '.join(map(str, combination)) + '\n')
except ValueError as e:
with open(output_file, 'w') as file:
file.write(str(e) + '\n')

if __name__ == "__main__":
generate_and_write_combinations("combinariIN.txt", "combinariOUT.txt")

</syntaxhighlight>

3159 - numere124

2023-12-04T18:36:54Z

Gabii: Pagină nouă: = Cerința = Se citesc un număr natural <code>n</code> având cifrele diferite două câte două și o cifră <code>c</code>. Afișați în ordine crescătoare numerele formate din <code>c</code> cifre distincte care se pot obține din cifrele lui <code>n</code>. = Date de intrare = Programul citește de la tastatură numerele <code>n</code> și <code>c</code>. = Date de ieșire = Programul va afișa pe ecran numerele cerute, câte unul pe fiecare rând. În cazul în care...

= Cerința =
Se citesc un număr natural <code>n</code> având cifrele diferite două câte două și o cifră <code>c</code>. Afișați în ordine crescătoare numerele formate din <code>c</code> cifre distincte care se pot obține din cifrele lui <code>n</code>.

= Date de intrare =
Programul citește de la tastatură numerele <code>n</code> și <code>c</code>.

= Date de ieșire =
Programul va afișa pe ecran numerele cerute, câte unul pe fiecare rând. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 1.000.000.000</code>, <code>1 < c < 9</code>
* <code>n</code> are cifrele distincte
* <code>c</code> este mai mic decât numărul de cifre ale lui <code>n</code>

= Exemplu 1 =
Intrare
2576 2
Ieșire
25
26
27
52
56
57
62
65
67
72
75
76

= Exemplul 2 =
Intrare
2576 2
consola

"Nu corespunde restricțiilor"

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
from itertools import permutations

def verifica_restrictii(n, c):
# Verifică restricțiile
if not (1 <= n <= 1000000000 and 1 < c < 9):
return False

# Verifică dacă n are cifre distincte
cifre = set(str(n))
if len(cifre) != len(str(n)):
return False

# Verifică dacă c este mai mic decât numărul de cifre ale lui n
if c >= len(str(n)):
return False

return True

def generare_numere(n, c):
# Verifică restricțiile
if not verifica_restrictii(n, c):
print("Nu corespunde restricțiilor")
return

# Restul codului pentru generarea și afișarea numerelor
cifre = list(str(n))
permutari = list(permutations(cifre, c))

for perm in sorted(permutari):
numar = int("".join(perm))
print(numar)

# Citeste input-ul de la tastatură
input_data = input("Introduceti n si c separate prin spatiu: ")
n, c = map(int, input_data.split())

# Apelul funcției
generare_numere(n, c)

</syntaxhighlight>

3910 - Aranjamente1

2023-12-04T18:24:00Z

Gabii: Pagină nouă: = Cerința = Se citesc trei numere naturale <code>a b n</code>. Să se afișeze, în ordine lexicografică, șirurile cu <code>n</code> elemente distincte din mulțimea <code>{a, a + 1, ..., b}</code>. = Date de intrare = Programul citește de la tastatură numerele <code>a b n</code>. = Date de ieșire = Programul va afișa pe ecran șirurile cerute, fiecare pe câte o linie. Elementele fiecărui șir vor fi separate prin câte un spațiu. În cazul în care restricțiile...

= Cerința =
Se citesc trei numere naturale <code>a b n</code>. Să se afișeze, în ordine lexicografică, șirurile cu <code>n</code> elemente distincte din mulțimea <code>{a, a + 1, ..., b}</code>.

= Date de intrare =
Programul citește de la tastatură numerele <code>a b n</code>.

= Date de ieșire =
Programul va afișa pe ecran șirurile cerute, fiecare pe câte o linie. Elementele fiecărui șir vor fi separate prin câte un spațiu. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ a < b ≤ 1.000.000.000</code>
* <code>1≤ n ≤ b - a < 8</code>

= Exemplul 1 =
Intrare
4 6 2
Ieșire
4 5
4 6
5 4
5 6
6 4
6 5

= Exemplul 2 =
Intrare
6 8 3
consola

Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
from itertools import permutations

def verificare_restrictii(a, b, n):
if not(1 <= a < b <= 1000000000) or not(1 <= n <= b - a < 8):
print("Nu corespunde restricțiilor")
return False
return True

def afisare_permutari(a, b, n):
if not verificare_restrictii(a, b, n):
return

# Generarea tuturor permutărilor distincte de lungime n
permutari = list(permutations(range(a, b + 1), n))

# Afișarea permutărilor
for permutare in permutari:
print(*permutare)

# Citirea datelor de intrare
a, b, n = map(int, input("Introduceți trei numere naturale separate prin spațiu (a b n): ").split())

# Apelarea funcției pentru afișarea permutărilor sau mesaj de eroare
afisare_permutari(a, b, n)

</syntaxhighlight>

0196 - Aranjamente

2023-12-04T18:13:17Z

Gabii: Pagină nouă: = Cerinţa = Se citesc două numere naturale nenule <code>n</code> și <code>k</code>. Să se afişeze, în ordine lexicografică, aranjamentele de câte <code>k</code> elemente ale mulţimii <code>{1,2,..,n}</code>. = Date de intrare = Fişierul de intrare <code>aranjamenteIN.txt</code> conţine pe prima linie numerele <code>n</code> și <code>k</code>, separate printr-un spatiu. = Date de ieşire = Fişierul de ieşire <code>aranjamenteOUT.txt</code> va conţine pe fiecar...

= Cerinţa =
Se citesc două numere naturale nenule <code>n</code> și <code>k</code>. Să se afişeze, în ordine lexicografică, aranjamentele de câte <code>k</code> elemente ale mulţimii <code>{1,2,..,n}</code>.

= Date de intrare =
Fişierul de intrare <code>aranjamenteIN.txt</code> conţine pe prima linie numerele <code>n</code> și <code>k</code>, separate printr-un spatiu.

= Date de ieşire =
Fişierul de ieşire <code>aranjamenteOUT.txt</code> va conţine pe fiecare linie câte <code>k</code> valori, separate prin câte un spaţiu, reprezentând elementele unei aranjări. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricţii şi precizări =

* <code>0 < k < n < 9</code>

= Exemplul 1 =
<code>aranjamenteIN.txt</code>
4 2
<code>aranjamenteOUT.txt</code>
1 2
1 3
1 4
2 1
2 3
2 4
3 1
3 2
3 4
4 1
4 2
4 3

= Exemplul 2 =
<code>aranjamenteIN.txt</code>
4 5
consola
"Nu corespunde restricțiilor"

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n, k):
if not (0 < k < n < 9):
print("Nu corespunde restricțiilor.")
return False
return True

def genereaza_aranjamente(n, k, aranjament_curent, numere_folosite, fisier_output):
if len(aranjament_curent) == k:
fisier_output.write(" ".join(map(str, aranjament_curent)) + "\n")
return

for i in range(1, n + 1):
if i not in numere_folosite:
numere_folosite.add(i)
genereaza_aranjamente(n, k, aranjament_curent + [i], numere_folosite, fisier_output)
numere_folosite.remove(i)

def main():
# Citirea datelor de intrare din fișier
with open("aranjamenteIN.txt", "r") as fisier_intrare:
n, k = map(int, fisier_intrare.readline().split())

# Verificarea restricțiilor
if not verifica_restrictii(n, k):
return

# Deschiderea fișierului de ieșire pentru scriere
with open("aranjamenteOUT.txt", "w") as fisier_iesire:
# Inițializarea listei de elemente și a setului de numere folosite
aranjament_curent = []
numere_folosite = set()

# Generarea aranjamentelor și scrierea lor în fișierul de ieșire
genereaza_aranjamente(n, k, aranjament_curent, numere_folosite, fisier_iesire)

if __name__ == "__main__":
main()

</syntaxhighlight>

0317 - SumMax

2023-12-04T18:01:16Z

Gabii: Pagină nouă: = Cerinţa = Se dă o matrice pătratică cu <code>n</code> lini şi <code>n</code> coloane şi elemente numere naturale distincte. Determinaţi cea mai mare sumă a <code>n</code> elemente din matrice, cu proprietatea că oricare două elemente se află pe linii şi coloane distincte. = Date de intrare = Fişierul de intrare <code>summaxIN.txt</code> conţine pe prima linie numărul <code>n</code>, iar pe următoarele <code>n</code> linii câte <code>n</code> numere natural...

= Cerinţa =
Se dă o matrice pătratică cu <code>n</code> lini şi <code>n</code> coloane şi elemente numere naturale distincte. Determinaţi cea mai mare sumă a <code>n</code> elemente din matrice, cu proprietatea că oricare două elemente se află pe linii şi coloane distincte.

= Date de intrare =
Fişierul de intrare <code>summaxIN.txt</code> conţine pe prima linie numărul <code>n</code>, iar pe următoarele <code>n</code> linii câte <code>n</code> numere naturale, separate prin spaţii, reprezentând elementele matricei.

= Date de ieşire =
Fişierul de ieşire <code>summaxOUT.txt</code> va conţine pe prima linie numărul <code>S</code>, reprezentând suma maximă determinată. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricţii şi precizări =

* <code>1 ≤ n ≤ 10</code>
* elementele matricei vor avea cel mult <code>4</code> cifre

= Exemplul 1 =
<code>summaxIN.txt</code>
4
12 16 5 4
11 14 6 7
8 2 3 17
10 9 13 15
<code>summaxOUT.txt</code>
57

= Exemplul 2 =
<code>summaxIN.txt</code>
100000
consola
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def citeste_matrice(file_path):
with open(file_path, 'r', encoding='utf-8') as file:
n = int(file.readline().strip())
matrice = [list(map(int, file.readline().split())) for _ in range(n)]
return n, matrice

def scrie_rezultat(file_path, rezultat):
with open(file_path, 'w', encoding='utf-8') as file:
file.write(str(rezultat))

def verifica_restrictii(n, matrice):
if not (1 <= n <= 10):
return False

for linie in matrice:
for element in linie:
if not (0 <= element <= 9999):
return False

return True

def gaseste_suma_maxima(n, matrice):
elemente_sortate = sorted([(matrice[i][j], i, j) for i in range(n) for j in range(n)], reverse=True)

linii_selectate = set()
coloane_selectate = set()

suma_maxima = 0

for element, i, j in elemente_sortate:
if i not in linii_selectate and j not in coloane_selectate:
suma_maxima += element
linii_selectate.add(i)
coloane_selectate.add(j)

return suma_maxima

if __name__ == "__main__":
fisier_intrare = "summaxIN.txt"
fisier_iesire = "summaxOUT.txt"

n, matrice = citeste_matrice(fisier_intrare)

if verifica_restrictii(n, matrice):
rezultat = gaseste_suma_maxima(n, matrice)
if rezultat > 0:
scrie_rezultat(fisier_iesire, rezultat)
else:
scrie_rezultat( "Nu corespunde restrictiilor".encode('utf-8'))
else:
scrie_rezultat(fisier_iesire, "Nu corespunde restricțiilor".encode('utf-8').decode('utf-8'))

</syntaxhighlight>

2646 - impartire

2023-12-04T17:30:12Z

Gabii: Pagină nouă: = Cerința = Se dau <code>n</code> numere naturale, unde <code>n</code> este un număr par. Se grupează cele <code>n</code> numere în perechi şi pentru fiecare pereche de numere se află restul împărţirii unui număr din pereche la celălalt. Se cere să se afle valoarea minimă a sumei acestor resturi. = Date de intrare = Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> numere naturale, separate prin spații. = Date de ieșire...

= Cerința =
Se dau <code>n</code> numere naturale, unde <code>n</code> este un număr par. Se grupează cele <code>n</code> numere în perechi şi pentru fiecare pereche de numere se află restul împărţirii unui număr din pereche la celălalt. Se cere să se afle valoarea minimă a sumei acestor resturi.

= Date de intrare =
Programul citește de la tastatură numărul <code>n</code>, iar apoi cele <code>n</code> numere naturale, separate prin spații.

= Date de ieșire =
Programul va afișa pe ecran suma minimă a resturilor. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>2 ≤ n ≤ 18</code>
* cele <code>n</code> numere citite vor fi mai mici decât <code>1.000</code>

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

== Exemplul 2 ==
Intrare
20
consola
Nu corespunde restricțiilor.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def citeste_numar_intre_limite(mesaj, limita_inferioara, limita_superioara):
while True:
try:
valoare = int(input(mesaj))
if limita_inferioara <= valoare <= limita_superioara:
return valoare
else:
print("Nu corespunde restricțiilor.")
except ValueError:
print("Nu corespunde restricțiilor.")

# Citirea numărului de elemente
n = citeste_numar_intre_limite("Introduceti numarul de elemente (n): ", 2, 18)

# Inițializarea listei pentru stocarea numerelor
numere = []

# Citirea elementelor și adăugarea lor în listă
for i in range(n):
numar = citeste_numar_intre_limite(f"Introduceti numarul {i + 1}: ", 0, 999)
numere.append(numar)

# Calculul sumei minime a resturilor
suma_minima = 0
for i in range(0, n, 2):
if numere[i] < numere[i + 1]:
rest = numere[i] % numere[i + 1]
elif numere[i] > numere[i + 1]:
rest = numere[i + 1] % numere[i]
else:
print("Nu corespunde restricțiilor.")
exit(1)
suma_minima += rest

# Afișarea rezultatului
print(f"Suma minima a resturilor este: {suma_minima}")

</syntaxhighlight>

2205 - permrep

2023-12-04T17:16:41Z

Gabii: Pagină nouă: == Enunț == Se consideră un cuvânt <code>C</code> format din litere mici, nu neapărat distincte. = Cerința = Să se afișeze în ordine lexicografică toate cuvintele distincte formate cu exact aceleași caractere ca și <code>C</code>. = Date de intrare = Fișierul de intrare <code>permrepIN.txt</code> conține pe prima linie cuvântul <code>C</code>. = Date de ieșire = Fișierul de ieșire <code>permrepOUT.txt</code> va conține pe câte o linie un cuvânt care are...

== Enunț ==
Se consideră un cuvânt <code>C</code> format din litere mici, nu neapărat distincte.

= Cerința =
Să se afișeze în ordine lexicografică toate cuvintele distincte formate cu exact aceleași caractere ca și <code>C</code>.

= Date de intrare =
Fișierul de intrare <code>permrepIN.txt</code> conține pe prima linie cuvântul <code>C</code>.

= Date de ieșire =
Fișierul de ieșire <code>permrepOUT.txt</code> va conține pe câte o linie un cuvânt care are exact aceleași litere ca și <code>C</code>. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* Cuvântul <code>C</code> va avea lungimea de cel mult <code>9</code>

= Exemplul 1 =
<code>permrepIN.txt</code>
mama
<code>permrepOUT.txt</code>
aamm
amam
amma
maam
mama
mmaa

= Exemplul 2 =
<code>permrepIN.txt</code>
Pneumonomie
consola
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def genereaza_permutari(cuvant):
if len(cuvant) == 0:
return ['']

litera = cuvant[0]
permutari_rest = genereaza_permutari(cuvant[1:])
rezultat = set()

for perm in permutari_rest:
for i in range(len(perm) + 1):
rezultat.add(perm[:i] + litera + perm[i:])

return list(rezultat)

def main():
# Citire cuvânt din fișierul de intrare
with open('permrepIN.txt', 'r') as intrare:
cuvant = intrare.readline().strip()

# Verificare lungime cuvânt
if len(cuvant) > 9:
print("Nu corespunde restricțiilor")
return

# Generare și sortare lexicografică a permutărilor cuvântului
permutari = genereaza_permutari(cuvant)
permutari.sort()

# Scriere în fișierul de ieșire
with open('permrepOUT.txt', 'w') as iesire:
for perm in permutari:
iesire.write(perm + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

3923 - back abc2

2023-12-04T17:04:36Z

Gabii: Pagină nouă: = Cerința = Se citesc două numere naturale <code>n</code> și <code>m</code>. Afișați în ordine lexicografică toate cuvintele care sunt formate din <code>m</code> litere distincte folosind primele <code>n</code> litere mari din alfabet. = Date de intrare = Programul citește de la tastatură numerele <code>n</code> și <code>m</code>, separate prin spații. = Date de ieșire = Programul va afișa pe ecran pe linii separate cuvintele cerute. În cazul în care restric...

= Cerința =
Se citesc două numere naturale <code>n</code> și <code>m</code>. Afișați în ordine lexicografică toate cuvintele care sunt formate din <code>m</code> litere distincte folosind primele <code>n</code> litere mari din alfabet.

= Date de intrare =
Programul citește de la tastatură numerele <code>n</code> și <code>m</code>, separate prin spații.

= Date de ieșire =
Programul va afișa pe ecran pe linii separate cuvintele cerute. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>0 ≤ n ≤ 26</code>, <code>0 ≤ m ≤ 5</code>
* <code>m ≤ n</code>

= Exemplu: =
Intrare
4 3
Ieșire
ABC
ABD
ACB
ACD
ADB
ADC
BAC
BAD
BCA
BCD
BDA
BDC
CAB
CAD
CBA
CBD
CDA
CDB
DAB
DAC
DBA
DBC
DCA
DCB

= Exemplu: =
Intrare
4 3
consola
Nu corespunde restricțiilor.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
import itertools

def check_restrictions(n, m):
if 0 <= n <= 26 and 0 <= m <= 5 and m <= n:
return True
else:
print("Nu corespunde restricțiilor.")
return False

def generate_words(n, m):
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
letters = alphabet[:n]

# Generăm toate permutările posibile de lungime m folosind literele primele n din alfabet
permutations = itertools.permutations(letters, m)

# Afisăm cuvintele în ordine lexicografică
for word in sorted(permutations):
print(''.join(word))

# Citim numerele n și m de la tastatură
n, m = map(int, input("Introduceți valorile lui n și m (separate prin spațiu): ").split())

# Verificăm restricțiile folosind funcția check_restrictions
if check_restrictions(n, m):
generate_words(n, m)
</syntaxhighlight>

4008 - back 11

2023-12-04T16:56:59Z

Gabii: Pagină nouă: = Cerința = Se citește un număr natural <code>n</code>. Afișați în ordine crescătoare toate numerele care sunt formate din <code>n</code> cifre distincte și care au mai multe cifre pare decât cifre impare. = Date de intrare = Programul citește de la tastatură numerul <code>n</code>. = Date de ieșire = Programul va afișa pe ecran pe linii separate numerele cerute. Numerele se vor afișa în ordine strict crescătoare În cazul în care restricțiile nu sunt în...

= Cerința =
Se citește un număr natural <code>n</code>. Afișați în ordine crescătoare toate numerele care sunt formate din <code>n</code> cifre distincte și care au mai multe cifre pare decât cifre impare.

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

= Date de ieșire =
Programul va afișa pe ecran pe linii separate numerele cerute. Numerele se vor afișa în ordine strict crescătoare

În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 8</code>.

= Exemplu: =
Intrare
3
Ieșire
102
104
106
108
120
124
126
128
140
142
146
148
160
162
164
168
180
182
184
186
201
203
204
205
206
207
...
894
896
902
904
906
908
920
924
926
928
940
942
946
948
960
962
964
968
980
982
984
986

= Exemplu: =
Intrare
3
Ieșire
Nu corespunde restricțiilor.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def numere_crescatoare(n):
if not (1 <= n <= 8):
print("Nu corespunde restricțiilor.")
return None

rezultate = []

def are_mai_multe_cifre_pare(numar):
cifre = [int(cifra) for cifra in str(numar)]
cifre_pare = sum(1 for cifra in cifre if cifra % 2 == 0)
cifre_impare = len(cifre) - cifre_pare
return cifre_pare >= cifre_impare # Am modificat condiția pentru a include și 0

def genereaza_numere(prefix, cifre_disponibile):
if len(prefix) == n:
if are_mai_multe_cifre_pare(int(prefix)):
rezultate.append(int(prefix))
return

for cifra in cifre_disponibile:
if prefix or cifra != '0': # Evită adăugarea 0 la început
urmatoarele_cifre = cifre_disponibile.replace(cifra, '')
genereaza_numere(prefix + cifra, urmatoarele_cifre)

cifre_disponibile = ''.join(map(str, range(10))) # Cifrele disponibile de la 0 la 9
genereaza_numere('', cifre_disponibile)

return sorted(rezultate)

# Citirea valorii de la tastatură cu verificare pentru restricții
try:
n = int(input("Introduceți numărul n: "))
rezultate = numere_crescatoare(n)
if rezultate is not None:
print(f"Numerele cu {n} cifre distincte, cu mai multe cifre pare decât cifre impare sunt:")
for rezultat in rezultate:
print(rezultat)
except ValueError:
print("Introduceți un număr valid.")

</syntaxhighlight>

3996 - back abc3

2023-12-04T16:47:19Z

Gabii: Pagină nouă: = Cerința = Se citește un număr natural <code>n</code>. Afișați în ordine lexicografică toate cuvintele care sunt formate din <code>n</code> litere mari, care au literele ordonate alfabetic strict crescător și în care numărul de vocale este mai mare decât numărul de consoane. = Date de intrare = Programul citește de la tastatură numerul <code>n</code>. = Date de ieșire = Programul va afișa pe ecran pe linii separate cuvintele cerute. Cuvintele se vor afișa...

= Cerința =
Se citește un număr natural <code>n</code>. Afișați în ordine lexicografică toate cuvintele care sunt formate din <code>n</code> litere mari, care au literele ordonate alfabetic strict crescător și în care numărul de vocale este mai mare decât numărul de consoane.

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

= Date de ieșire =
Programul va afișa pe ecran pe linii separate cuvintele cerute. Cuvintele se vor afișa în ordine lexicografică. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 9</code>.

= Exemplul 1 =
Intrare
3
Ieșire
ABE
ABI
ABO
ABU
ACE
ACI
ACO
ACU
ADE
ADI
ADO
ADU
AEF
AEG
AEH
AEI
AEJ
AEK
AEL
AEM
AEN
AEO
AEP
AEQ
AER
AES
AET
AEU
AEV
...
IUW
IUX
IUY
IUZ
JOU
KOU
LOU
MOU
NOU
OPU
OQU
ORU
OSU
OTU
OUV
OUW
OUX
OUY
OUZ

== Exemplul 2 ==
Intrare
10
consola
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
from itertools import permutations

def numara_vocale_consoane(cuvant):
# Calculează numărul de vocale și consoane din cuvânt
vocale = sum(1 for litera in cuvant if litera in "AEIOU")
consoane = len(cuvant) - vocale
return vocale, consoane

def genereaza_cuvinte(n):
# Verifică restricțiile pentru n
if not (1 <= n <= 9):
print("Nu corespunde restricțiilor")
return

# Generează toate permutările de litere de lungime n cu litere mari
litere = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
toate_permutarile = [''.join(p) for p in permutations(litere, r=n)]

# Filtrează permutările pentru a îndeplini condițiile
cuvinte_valide = [cuvant for cuvant in toate_permutarile if cuvant == ''.join(sorted(cuvant)) and numara_vocale_consoane(cuvant)[0] > numara_vocale_consoane(cuvant)[1]]

# Afișează cuvintele în ordine lexicografică
for cuvant_valid in sorted(cuvinte_valide):
print(cuvant_valid)

# Citirea numărului n de la tastatură
n = int(input("Introduceți un număr natural n: "))

# Apelarea funcției cu verificare restricții și afișarea cuvintelor cerute
genereaza_cuvinte(n)

</syntaxhighlight>

3922 - back abc1

2023-12-04T16:33:39Z

Gabii: Pagină nouă: = Cerința = Se citesc două numere naturale <code>n</code> și <code>m</code>. Afișați în ordine lexicografică toate cuvintele care sunt formate din <code>m</code> litere folosind primele <code>n</code> litere mari din alfabet și care au literele ordonate alfabetic strict crescător. = Date de intrare = Programul citește de la tastatură numerele <code>n</code> și <code>m</code>, separate prin spații. = Date de ieșire = Programul va afișa pe ecran pe linii separa...

= Cerința =
Se citesc două numere naturale <code>n</code> și <code>m</code>. Afișați în ordine lexicografică toate cuvintele care sunt formate din <code>m</code> litere folosind primele <code>n</code> litere mari din alfabet și care au literele ordonate alfabetic strict crescător.

= Date de intrare =
Programul citește de la tastatură numerele <code>n</code> și <code>m</code>, separate prin spații.

= Date de ieșire =
Programul va afișa pe ecran pe linii separate cuvintele cerute. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Nu corespunde restricțiilor".

= Restricții și precizări =

* <code>1 ≤ n ≤ 26</code>, <code>0 ≤ m ≤ 10</code>
* <code>m ≤ n</code>

= Exemplul 1 =
Intrare
5 3
Ieșire
ABC
ABD
ABE
ACD
ACE
ADE
BCD
BCE
BDE
CDE

== Exemplul 2 ==
Intrare
5 7
consola
Nu corespunde restricțiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
from itertools import combinations

def generate_words(n, m):
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
letters = alphabet[:n]

for combination in combinations(letters, m):
word = ''.join(sorted(combination))
print(word)

def check_restrictions(n, m):
if 1 <= n <= 26 and 0 <= m <= 10 and m <= n:
return True
else:
print("Nu corespunde restricțiilor")
return False

# Citirea datelor de intrare
n, m = map(int, input("Introduceți n și m (separate prin spații): ").split())

# Verificarea restricțiilor și generarea cuvintelor
if check_restrictions(n, m):
generate_words(n, m)

</syntaxhighlight>

3988 - permnk

2023-12-04T13:33:19Z

Gabii: Pagină nouă: = Cerința = Se dau numerele naturale <code>n</code> si <code>k</code>. Sa se genereze in ordine lexicografică toate permutările mulțimii <code>{1,2,...,n}</code> cu proprietatea că diferența în modul dintre oricare două numere alăturate din permutare este de cel mult <code>k</code>. = Date de intrare = Programul citește de pe prima linie numărul <code>n</code>, iar de pe a doua linie numărul <code>k</code>. = Date de ieșire = Programul va afișa pe ecran, pe c...

= Cerința =
Se dau numerele naturale <code>n</code> si <code>k</code>. Sa se genereze in ordine lexicografică toate permutările mulțimii <code>{1,2,...,n}</code> cu proprietatea că diferența în modul dintre oricare două numere alăturate din permutare este de cel mult <code>k</code>.

= Date de intrare =
Programul citește de pe prima linie numărul <code>n</code>, iar de pe a doua linie numărul <code>k</code>.

= Date de ieșire =
Programul va afișa pe ecran, pe câte o linie, în ordine lexicografică, permutările cerute.

= Restricții și precizări =

* <code>1 ≤ k ≤ n ≤ 9</code>

= Exemplul 1 =
Intrare
4
2
Ieșire
1 2 3 4
1 2 4 3
1 3 2 4
1 3 4 2
2 1 3 4
2 4 3 1
3 1 2 4
3 4 2 1
4 2 1 3
4 2 3 1
4 3 1 2
4 3 2 1

== Exemplul 2 ==
Intrare
5
7
consola
Restricții neîndeplinite. Asigurați-vă că
1 <= k <= n <= 9.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def este_permutare_valida(permutare, k):
for i in range(1, len(permutare)):
if abs(permutare[i] - permutare[i-1]) > k:
return False
return True

def genereaza_permutari(n, k, permutare_curenta):
if len(permutare_curenta) == n:
if este_permutare_valida(permutare_curenta, k):
print(" ".join(map(str, permutare_curenta)))
return

for numar in range(1, n + 1):
if numar not in permutare_curenta:
genereaza_permutari(n, k, permutare_curenta + [numar])

def verifica_restrictii(n, k):
return 1 <= k <= n <= 9

if __name__ == "__main__":
n = int(input("Introduceți n: "))
k = int(input("Introduceți k: "))

if verifica_restrictii(n, k):
genereaza_permutari(n, k, [])
else:
print("Restricții neîndeplinite. Asigurați-vă că 1 <= k <= n <= 9.")

</syntaxhighlight>

3158 - numere123

2023-12-04T13:14:36Z

Gabii: Pagină nouă: = Cerința = Se citește un număr natural <code>n</code> având cifrele diferite două câte două. Afișați în ordine crescătoare numerele care se pot obține din cifrele lui <code>n</code> și care au același număr de cifre ca <code>n</code>. = Date de intrare = Programul citește de la tastatură numărul <code>n</code>. = Date de ieșire = Programul va afișa pe ecran numerele cerute, câte unul pe fiecare rând. = Restricții și precizări = * <code>1 ≤ n...

= Cerința =
Se citește un număr natural <code>n</code> având cifrele diferite două câte două. Afișați în ordine crescătoare numerele care se pot obține din cifrele lui <code>n</code> și care au același număr de cifre ca <code>n</code>.

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

= Date de ieșire =
Programul va afișa pe ecran numerele cerute, câte unul pe fiecare rând.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1.000.000.000</code>
* <code>n</code> are toate cifrele distincte

= Exemplul 2 =
Intrare
483
Ieșire
348
384
438
483
834
843

= Exemplul 2 =
Intrare
443
consola
Numărul trebuie să fie între 1 și 1.000.000.000 și să aibă cifre distincte.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def are_restrictii(n):
return 1 <= n <= 1000000000 and len(set(str(n))) == len(str(n))

def permuteaza_cifrele(cifre):
if len(cifre) == 1:
return [cifre]

permutari = []
for i in range(len(cifre)):
cifre_ramase = cifre[:i] + cifre[i + 1:]
for p in permuteaza_cifrele(cifre_ramase):
permutari.append([cifre[i]] + p)

return permutari

def main():
n = int(input("Introduceți un număr n cu cifre distincte: "))

if not are_restrictii(n):
print("Numărul trebuie să fie între 1 și 1.000.000.000 și să aibă cifre distincte.")
return

cifre_str = str(n)
cifre_lista = [int(cifra) for cifra in cifre_str]
toate_permutările = permuteaza_cifrele(cifre_lista)

număr_cifre_n = len(cifre_lista)

numere_rezultate = []
for permutare in toate_permutările:
if permutare[0] != 0: # Evităm numerele cu zero în frunte
număr = int(''.join(map(str, permutare)))
if len(str(număr)) == număr_cifre_n:
numere_rezultate.append(număr)

numere_rezultate.sort()

print("Numerele în ordine crescătoare cu aceleași cifre ca și n:")
for număr in numere_rezultate:
print(număr)

if __name__ == "__main__":
main()

</syntaxhighlight>

3154 - anagrame pfv

2023-12-04T12:51:26Z

Gabii: Pagină nouă: = Cerința = Se citește de la tastatură un cuvânt <code>s</code> format din cel mult <code>11</code> litere mici distincte. Să se genereze în ordine alfabetică și să se afișeze toate anagramele cuvântului <code>s</code> în care vocalele sunt puncte fixe. = Date de intrare = Programul citește de la tastatură cuvântul <code>s</code>. = Date de ieșire = Programul va afișa pe ecran pe rânduri separate anagramele cuvântului citit în care vocalele rămân pe po...

= Cerința =
Se citește de la tastatură un cuvânt <code>s</code> format din cel mult <code>11</code> litere mici distincte. Să se genereze în ordine alfabetică și să se afișeze toate anagramele cuvântului <code>s</code> în care vocalele sunt puncte fixe.

= Date de intrare =
Programul citește de la tastatură cuvântul <code>s</code>.

= Date de ieșire =
Programul va afișa pe ecran pe rânduri separate anagramele cuvântului citit în care vocalele rămân pe pozițiile inițiale.

= Restricții și precizări =

* cuvântul <code>s</code> are cel mult <code>11</code> caractere și este format din litere mici distincte

= Exemplul 1 =
Intrare
dorel
Ieșire
doler
dorel
loder
lored
rodel
roled

== Exemplul 2 ==
Intrare
guadalahara
consola
Cuvântul trebuie să aibă cel mult 11 litere distincte.

== Rezultat ==
<syntaxhighlight lang="python3" line="1">
from itertools import permutations

def este_vocala(caracter):
return caracter in "aeiou"

def valideaza_cuvant(cuvant):
return len(cuvant) <= 11 and len(set(cuvant)) == len(cuvant)

def genereaza_anagrame(cuvant):
vocale = [caracter for caracter in cuvant if este_vocala(caracter)]
consoane = [caracter for caracter in cuvant if not este_vocala(caracter)]

vocale_unice = set(vocale)
pozitii_vocale = {vocala: [i for i, caracter in enumerate(cuvant) if caracter == vocala] for vocala in vocale_unice}

anagrame = set()

for consoane_permutate in set(permutations(consoane)):
anagrama_curenta = list(consoane_permutate)

for vocala in vocale_unice:
for pozitie in pozitii_vocale[vocala]:
anagrama_curenta.insert(pozitie, vocala)

anagrame.add("".join(anagrama_curenta))

return sorted(anagrame)

def main():
cuvant = input("Introduceți cuvântul s: ").lower()

if valideaza_cuvant(cuvant):
anagrame = genereaza_anagrame(cuvant)

for anagrama in anagrame:
print(anagrama)

else:
print("Cuvântul trebuie să aibă cel mult 11 litere distincte.")

if __name__ == "__main__":
main()

</syntaxhighlight>

3916 - elim m

2023-12-04T12:45:28Z

Gabii: Pagină nouă: = Cerința = Scrieți un program care citește două numere naturale <code>n</code> și <code>m</code> și care afișează cel mai mare număr care se poate obține eliminând din <code>n</code> exact <code>m</code> cifre, unde <code>m</code> este mai mic decât numărul de cifre ale lui <code>n</code>. Cifrele rămase în <code>n</code> nu-și pot schimba ordinea. = Date de intrare = Programul citește de la tastatură numerele <code>n</code> și <code>m</code>. = Date de...

= Cerința =
Scrieți un program care citește două numere naturale <code>n</code> și <code>m</code> și care afișează cel mai mare număr care se poate obține eliminând din <code>n</code> exact <code>m</code> cifre, unde <code>m</code> este mai mic decât numărul de cifre ale lui <code>n</code>. Cifrele rămase în <code>n</code> nu-și pot schimba ordinea.

= Date de intrare =
Programul citește de la tastatură numerele <code>n</code> și <code>m</code>.

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

= Restricții și precizări =

* <code>n</code> are cel mult <code>17</code> cifre.
* <code>m</code> este mai mic decât numărul de cifre ale lui <code>n</code>.
* <code>m</code> este număr nenul.

= Exemplul 1 =
Intrare
3452234 4
Ieșire
544

= Exemplul 2 =
Intrare
58435983264732647264912647362498236496324723684 21
Consola
Introduceți numere valide conform restricțiilor.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def valideaza_restricții(n, m):
return 0 < m < len(str(n)) <= 17 and n >= 0

def cel_mai_mare_numar(n, m):
cifre = [int(cifra) for cifra in str(n)]

cifre.sort(reverse=True)
cifre = cifre[:-m]

rezultat = int(''.join(map(str, cifre)))
return rezultat

def main():
try:
n = int(input("Introduceți n: "))
m = int(input("Introduceți m: "))

if not valideaza_restricții(n, m):
print("Introduceți numere valide conform restricțiilor.")
return

if len(str(n)) > 17:
print("Numărul introdus depășește lungimea maximă admisă de 17 cifre.")
return

rezultat = cel_mai_mare_numar(n, m)
print(f"Cel mai mare număr obținut eliminând exact {m} cifre din {n} este: {rezultat}")

except ValueError:
print("Introduceți numere valide.")

if __name__ == "__main__":
main()

</syntaxhighlight>

3149 - anagrame vocale

2023-12-04T12:31:12Z

Gabii: Pagină nouă: = Cerința = Se citește un cuvânt format din cel puțin două și cel mult zece caractere litere mici distincte care conține cel puțin două vocale. Afișați în ordine lexicografică anagramele cuvântului citit care au proprietatea că încep și se termină cu o vocală. = Date de intrare = Programul citește de la tastatură șirul de caractere. = Date de ieșire = Programul va afișa pe ecran anagramele cerute, câte una pe un rând. = Restricții și precizări...

= Cerința =
Se citește un cuvânt format din cel puțin două și cel mult zece caractere litere mici distincte care conține cel puțin două vocale. Afișați în ordine lexicografică anagramele cuvântului citit care au proprietatea că încep și se termină cu o vocală.

= Date de intrare =
Programul citește de la tastatură șirul de caractere.

= Date de ieșire =
Programul va afișa pe ecran anagramele cerute, câte una pe un rând.

= Restricții și precizări =

* numărul de caractere ale șirului dat este cuprins între <code>2</code> și <code>10</code>;
* cuvântul dat este format din litere mici distincte și conține cel puțin două vocale;
* vocalele sunt <code>a</code>, <code>e</code>, <code>i</code>, <code>o</code>, <code>u</code>;

= Exemplul 1 =
Intrare
alin
Ieșire
alni
anli
ilna
inla

== Exemplul 1 ==
Intrare
arc
consola
Cuvântul trebuie să aibă între 2 și 10 litere mici distincte și să conțină cel puțin două vocale.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def este_anagrama_valida(cuvant):
# Verificăm dacă cuvântul începe și se termină cu o vocală
return cuvant[0] in 'aeiou' and cuvant[-1] in 'aeiou'

def genereaza_anagrame(curent, ramase, rezultat):
if not ramase:
if este_anagrama_valida(curent):
rezultat.append(curent)
return

for i in range(len(ramase)):
genereaza_anagrame(curent + ramase[i], ramase[:i] + ramase[i+1:], rezultat)

def valideaza_cuvant(cuvant):
# Verificăm restricțiile
return 2 <= len(cuvant) <= 10 and len(set(cuvant)) == len(cuvant) and sum(1 for char in cuvant if char in 'aeiou') >= 2

def main():
try:
# Citim cuvântul de la tastatură
cuvant = input("Introduceți un cuvânt: ")

# Verificăm restricțiile utilizând funcția separată
if not valideaza_cuvant(cuvant):
print("Cuvântul trebuie să aibă între 2 și 10 litere mici distincte și să conțină cel puțin două vocale.")
return

# Inițializăm o listă pentru a stoca anagramele rezultate
anagrame = []

# Generăm anagramele cuvântului care încep și se termină cu o vocală
genereaza_anagrame('', cuvant, anagrame)

# Sortăm și afișăm anagramele
for anagrama in sorted(anagrame):
print(anagrama)

except Exception as e:
print(f"A intervenit o eroare: {e}")

if __name__ == "__main__":
main()

</syntaxhighlight>

3915 - anagrame cv

2023-12-04T12:25:25Z

Gabii: Pagină nouă: = Cerința = Se citește de la tastatură un cuvânt <code>s</code> format din cel mult <code>11</code> litere mici distincte. Să se genereze în ordine alfabetică și să se afișeze toate anagramele cuvântului <code>s</code> în care nu există două vocale alăturate și nici două consoane alăturate. = Date de intrare = Programul citește de la tastatură cuvântul <code>s</code>. = Date de ieșire = Programul va afișa pe ecran pe rânduri separate anagramele cuvâ...

= Cerința =
Se citește de la tastatură un cuvânt <code>s</code> format din cel mult <code>11</code> litere mici distincte. Să se genereze în ordine alfabetică și să se afișeze toate anagramele cuvântului <code>s</code> în care nu există două vocale alăturate și nici două consoane alăturate.

= Date de intrare =
Programul citește de la tastatură cuvântul <code>s</code>.

= Date de ieșire =
Programul va afișa pe ecran pe rânduri separate anagramele cuvântului citit în care vocalele și consoanele alternează (nu există două vocale alăturate și nici două consoane alăturate).

= Restricții și precizări =

* cuvântul <code>s</code> are cel mult <code>11</code> caractere și este format din litere mici distincte
* dacă nu există soluții, atunci se va afișa mesajul <code>IMPOSIBIL</code>.

= Exemplu: =
Intrare
cosmina
Ieșire
caminos
camison
camonis
camosin
canimos
canisom
canomis
canosim
casimon
casinom
casomin
casonim
cimanos
cimason
cimonas
cimosan
cinamos
cinasom
cinomas
cinosam
...
sonimac
(în total 144 de anagrame)

= Exemplu: =
Intrare
cosmin
Ieșire
IMPOSIBIL

== Exemplu: ==
Intrare
ana
consola
Cuvântul trebuie să aibă cel mult 11 litere mici distincte.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def sunt_alternante(cuvant):
# Verificăm dacă vocalele și consoanele alternează în cuvânt
for i in range(1, len(cuvant)):
if (cuvant[i-1] in 'aeiou' and cuvant[i] in 'aeiou') or (cuvant[i-1] not in 'aeiou' and cuvant[i] not in 'aeiou'):
return False
return True

def genereaza_anagrame_alternante(curent, ramase, rezultat):
if not ramase:
if sunt_alternante(curent):
rezultat.append(curent)
return

for i in range(len(ramase)):
genereaza_anagrame_alternante(curent + ramase[i], ramase[:i] + ramase[i+1:], rezultat)

def valideaza_cuvant(cuvant):
# Verificăm restricțiile
return 1 <= len(cuvant) <= 11 and len(set(cuvant)) == len(cuvant) and cuvant.islower()

def main():
try:
# Citim cuvântul de la tastatură
cuvant = input("Introduceți un cuvânt: ")

# Verificăm restricțiile utilizând funcția separată
if not valideaza_cuvant(cuvant):
print("Cuvântul trebuie să aibă cel mult 11 litere mici distincte.")
return

# Inițializăm o listă pentru a stoca anagramele rezultate
anagrame = []

# Generăm anagramele cuvântului în care vocalele și consoanele alternează
genereaza_anagrame_alternante('', cuvant, anagrame)

# Sortăm și afișăm anagramele sau afișăm mesajul IMPOSIBIL dacă nu există soluții
if anagrame:
for anagrama in sorted(anagrame):
print(anagrama)
else:
print("IMPOSIBIL")

except Exception as e:
print(f"A intervenit o eroare: {e}")

if __name__ == "__main__":
main()

</syntaxhighlight>

0194 - Anagrame1

2023-12-04T12:13:04Z

Gabii: Pagină nouă: == Enunț == Se numește ''anagramă'' a unui cuvânt dat, un alt cuvânt ce conține toate literele primului, eventual în altă ordine. = Cerinţa = Se dă un cuvânt din cel mult <code>8</code> litere distincte. Să se afișeze, în ordine alfabetică, toate anagramele acestui cuvânt. = Date de intrare = Fişierul de intrare <code>anagrameIN.txt</code> conţine pe pe prima linie un cuvânt <code>S</code>, format din cel mult <code>8</code> litere distincte ale alfabetu...

== Enunț ==
Se numește ''anagramă'' a unui cuvânt dat, un alt cuvânt ce conține toate literele primului, eventual în altă ordine.

= Cerinţa =
Se dă un cuvânt din cel mult <code>8</code> litere distincte. Să se afișeze, în ordine alfabetică, toate anagramele acestui cuvânt.

= Date de intrare =
Fişierul de intrare <code>anagrameIN.txt</code> conţine pe pe prima linie un cuvânt <code>S</code>, format din cel mult <code>8</code> litere distincte ale alfabetului englez.

= Date de ieşire =
Fişierul de ieşire <code>anagrameOUT.txt</code> va conţine toate anagramele cuvântului <code>S</code>, fiecare pe o linie, în ordine alfabetică.

= Exemplul 1 =
<code>anagrameIN.txt</code>

cal

<code>anagrameOUT.txt</code>
acl
alc
cal
cla
lac
lca

== Exemplul 2 ==
<code>anagrameIN.txt</code>
4tal
consola
Cuvântul trebuie să aibă între 1 și 8 litere și să nu conțină numere.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
from itertools import permutations

def generate_anagrams(word):
# Generăm toate permutările cuvântului
all_permutations = permutations(word)

# Sortăm permutările în ordine alfabetică
sorted_anagrams = sorted(set(''.join(perm) for perm in all_permutations))

return sorted_anagrams

def validate_word(word):
# Verificăm restricțiile
return 1 <= len(word) <= 8 and word.isalpha()

def main():
try:
# Citim cuvântul din fișierul de intrare
with open("anagrameIN.txt", "r") as file:
word = file.readline().strip()

# Verificăm restricțiile utilizând funcția separată
if not validate_word(word):
print("Cuvântul trebuie să aibă între 1 și 8 litere și să nu conțină numere.")
return

# Generăm anagramele
anagrams = generate_anagrams(word)

# Scriem anagramele în fișierul de ieșire
with open("anagrameOUT.txt", "w") as file:
for anagram in anagrams:
file.write(anagram + '\n')

except Exception as e:
print(f"A intervenit o eroare: {e}")

if __name__ == "__main__":
main()

</syntaxhighlight>