Bitnami MediaWiki - User contributions [en]

1752 - nr aparitii rec

2023-05-14T22:03:34Z

Catalin Moje:

==Cerința==
Scrieţi în limbajul Python definiţia completă a funcţiei recursive nr_aparitii cu următorul antet:

unsigned nr_aparitii(char *sir, char *secventa)
ce returnează numărul de apariţii ale şirului de caractere secventa în şirul sir.

==Date de intrare==
Se va introduce de la tastatură un sir de caractere care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricții și precizări==
*cele două şiruri nu conţin spaţii şi au cel mult 1000 de caractere
*biblioteca cstring (string.h) este deja inclusă la verificare

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceți șirul de caractere: maimuta_samurai
;Introduceți secvența de căutat: mu
:Iesire:
;Datele de intrare corespund restricțiilor
;Numărul de apariții ale secvenței 'mu' în șirul 'maimuta_samurai' este: 2

===Exemplu 2===
:Intrare:
;Introduceți șirul de caractere: Ana are mere.
:Iesire:
;Datele de intrare nu corespund cerinței

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_date(sir, secventa):
if len(sir) > 1000 or len(secventa) > 1000:
print("Datele de intrare nu corespund cerinței")
return False
if " " in sir or " " in secventa:
print("Datele de intrare nu corespund cerinței")
return False
print("Datele de intrare corespund restricțiilor")
return True

def nr_aparitii(sir, secventa):
if not validare_date(sir, secventa):
return

if len(secventa) > len(sir):
return 0

if sir[:len(secventa)] == secventa:
return 1 + nr_aparitii(sir[len(secventa):], secventa)

return nr_aparitii(sir[1:], secventa)

def main():
s = input("Introduceți șirul de caractere: ")
if len(s) > 1000 or " " in s:
print("Datele de intrare nu corespund cerinței")
else:
seq = input("Introduceți secvența de căutat: ")
if len(seq) == 0 or len(seq) > len(s):
print("Datele de intrare nu corespund cerinței")
else:
print("Datele de intrare corespund restricțiilor")
count = s.count(seq)
print(f"Numărul de apariții ale secvenței '{seq}' în șirul '{s}' este: {count}")

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

==Explicații==
Codul are două funcții: validare_date și nr_aparitii, și funcția principală main.

Funcția validare_date verifică dacă șirul și secvența respectă restricțiile impuse de cerință. Dacă lungimea lor depășește 1000 de caractere sau dacă există spații în șir sau în secvență, funcția afișează "Datele de intrare nu corespund cerinței" și returnează False. În caz contrar, funcția afișează "Datele de intrare corespund restricțiilor" și returnează True.

Funcția nr_aparitii verifică dacă datele de intrare sunt valide apelând funcția validare_date. Dacă nu sunt valide, funcția se termină fără a face altceva. Dacă secvența este mai mare decât șirul, funcția returnează 0. În caz contrar, funcția caută secvența în șir și numără de câte ori apare. Pentru a face acest lucru, funcția împarte șirul în părți mai mici până când găsește o potrivire.

Funcția principală main afișează un mesaj pentru a solicita utilizatorului să introducă șirul și secvența. Dacă datele de intrare nu respectă cerințele, se afișează un mesaj de eroare. Dacă datele de intrare sunt valide, se afișează un mesaj care confirmă acest lucru, și se calculează și se afișează numărul de apariții ale secvenței în șir.

1654 - NrVocRec

2023-05-14T22:01:21Z

Catalin Moje:

==Cerința==
Să se scrie o funcţie recursivă care primeşte ca parametru un şir de caractere format din litere mari/mici ale alfabetului englez şi spaţii şi returnează numărul de vocale din şir.

==Date de intrare==
Se va introduce de la tastatură ca parametru un şir de caractere format din litere mari/mici ale alfabetului englez şi spaţii

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*Numele funcţiei este nr_vocale
*Funcţia are un singur parametru (şirul format din maxim 10000 caractere).

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceți un șir de caractere format din litere engleze majuscule/minuscule și spații: Ana are mere
Datele de intrare corespund restricțiilor impuse.
:Iesire:
;Numărul de vocale din șirul 'Ana are mere' este: 6

===Exemplu 2===
:Intrare:
;Introduceți un șir de caractere format din litere engleze majuscule/minuscule și spații: 1 2 3 4
:Iesire:
;Datele de intrare nu corespund restricțiilor impuse.

==Important:==
Dacă doriţi să folosiţi funcţiile predefinite pe şiruri de caractere (strlen, strchr etc), includeţi biblioteca cstring (string.h) înainte de a scrie definiţia funcţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validate_input(s: str) -> bool:
"""Verifică dacă șirul s conține doar litere engleze majuscule/minuscule și spații."""
for c in s:
if not c.isalpha() and not c.isspace():
return False
return True

def count_vowels(s: str) -> int:
"""Calculează recursiv numărul de vocale din șirul s."""
if len(s) == 0:
return 0
elif s[0] in "aeiouAEIOU":
return 1 + count_vowels(s[1:])
else:
return count_vowels(s[1:])

def main():
s = input("Introduceți un șir de caractere format din litere engleze majuscule/minuscule și spații: ")
if not validate_input(s):
print("Datele de intrare nu corespund restricțiilor impuse.")
else:
print("Datele de intrare corespund restricțiilor impuse.")
print(f"Numărul de vocale din șirul '{s}' este: {count_vowels(s)}")

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

==Explicații==
Funcția validate_input primește un șir de caractere și returnează True dacă conține doar litere engleze majuscule/minuscule și spații, iar False în caz contrar.

Funcția count_vowels primește un șir de caractere și calculează recursiv numărul de vocale din el. Dacă șirul este gol, returnează 0. Altfel, dacă primul caracter este o vocală, se adună 1 la numărul de vocale găsite în restul șirului (s[1:]). Altfel, se continuă căutarea în restul șirului (s[1:]).

Funcția main citește un șir de la tastatură, validează datele de intrare folosind funcția validate_input, și afișează numărul de vocale din șir folosind funcția count_vowels dacă datele de intrare sunt valide.

1846 - OrdonareSecvF REC

2023-05-14T21:59:44Z

Catalin Moje:

==Cerinţa==
Scrieţi definiția completă a subprogramului recursiv ordonare care are 4 parametri: a, prin care primeşte un tablou unidimensional cu maximum 1000 de numere naturale mai mici decât 1.000.000.000 și n, numărul efectiv de elemente ale tabloului și doi indici st dr.
Subprogramul ordonează crescător elementele tabloului a cu indici între st și dr, inclusiv aceștia,fără a modifica celelalte elemente ale tabloului.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*0 < n <= 1000
*numele subprogramului cerut este ordonare
*parametrii sunt, în această ordine: a, n, st, dr
*0≤st≤dr<n
*elementele tabloului a sunt indexate de la zero
*se recomandă realizarea unei soluții recursive

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numarul de elemente: 6
;Introduceti cele 6 numere separate prin spatiu: 63 273 9 83 93 123
;Introduceti indexul stanga: 1
;Introduceti indexul dreapta: 3
:Iesire:
[63, 9, 83, 273, 93, 123]

===Exemplu 2===
:Intrare:
;Introduceti numarul de elemente: 1001
:Iesire:
;Datele de intrare nu corespund cerinței.

==Important==
Soluţia propusă va conţine doar definiţia subprogramului cerut. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_numar(numar):
if not numar.isdigit():
return False
n = int(numar)
if n < 1 or n > 1000:
return False
return True

def validare_index(index, n):
if not index.isdigit():
return False
i = int(index)
if i < 0 or i >= n:
return False
return True

def ordonare(a, n, st, dr):
if st < dr:
pivot = a[dr]
i = st - 1
for j in range(st, dr):
if a[j] < pivot:
i += 1
a[i], a[j] = a[j], a[i]
i += 1
a[i], a[dr] = a[dr], a[i]
ordonare(a, n, st, i - 1)
ordonare(a, n, i + 1, dr)

numar_elemente = input("Introduceti numarul de elemente: ")
if not validare_numar(numar_elemente):
print("Datele de intrare nu corespund cerinței.")
else:
n = int(numar_elemente)
a = input("Introduceti cele " + str(n) + " numere separate prin spatiu: ").split()
if len(a) != n or not all(map(str.isdigit, a)):
print("Datele de intrare nu corespund cerinței.")
else:
a = [int(x) for x in a]
st = input("Introduceti indexul stanga: ")
if not validare_index(st, n):
print("Datele de intrare nu corespund cerinței.")
else:
st = int(st)
dr = input("Introduceti indexul dreapta: ")
if not validare_index(dr, n):
print("Datele de intrare nu corespund cerinței.")
else:
dr = int(dr)
ordonare(a, n, st, dr)
print(a)
</syntaxhighlight>

==Explicații==
În funcția validare_input, se validează datele de intrare. Se verifică dacă numărul de elemente n este un număr natural mai mic sau egal cu 1000, iar indicele stanga st și cel dreapta dr sunt numere naturale, st mai mic decât dr și n mai mare decât dr.

Funcția ordonare este implementată recursiv, astfel încât să divizeze tabloul în două subtablouri, să le sorteze individual și apoi să le combine într-un tablou sortat. Dacă subtabloul are un singur element sau niciun element, atunci subtabloul este deja sortat. Altfel, se calculează mijlocul subtabloului, se sortează subtabloul stâng și subtaboul drept și apoi se combină cele două subtablouri sortate.

În funcția main, se citesc datele de intrare și se validează folosind funcția validare_input. Dacă datele de intrare sunt valide, atunci se completează tabloul și se apelează funcția ordonare pentru a sorta elementele între indicii stanga și dreapta. În final, se afișează tabloul sortat.

1845 - OrdonareF Rec

2023-05-14T21:57:23Z

Catalin Moje:

==Cerinţa==
Scrieţi definiția completă a subprogramului recursiv ordonare care are 2 parametri: a, prin care primeşte un tablou unidimensional cu maximum 1000 de numere naturale mai mici decât 1.000.000.000 și n, numărul efectiv de elemente ale tabloului.
Subprogramul ordonează crescător elementele tabloului a, fără a returna valori.

==Date de intrare==
Se va introduce de la tastatură 2 numere naturale care vor fi transmise ca perimetrii

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*0 < n <= 1000
*numele subprogramului cerut este ordonare
*parametrii sunt, în această ordine: a, n
*elementele tabloului a sunt indexate de la zero
*se recomandă realizarea unei soluții recursive

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numarul de elemente: 6
;Introduceti cele 6 numere separate prin spatiu: 63 273 9 83 93 123
:Iesire:
;Datele de intrare corespund restricțiilor
;Tabloul sortat este: [9, 63, 83, 93, 123, 273]

===Exemplu 2===
:Intrare:
;Introduceti numarul de elemente: 1001
:Iesire:
;Datele de intrare nu corespund cerinței

==Important==
Soluţia propusă va conţine doar definiţia subprogramului cerut. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validate_input(n):
if n <= 0 or n > 1000:
print("Datele de intrare nu corespund cerinței")
exit()

def ordonare(a, n):
if n <= 1:
return a
for i in range(n - 1):
if a[i] > a[i + 1]:
a[i], a[i + 1] = a[i + 1], a[i]
return ordonare(a, n - 1)

def main():
n = int(input("Introduceti numarul de elemente: "))
validate_input(n)
a = list(map(int, input("Introduceti cele " + str(n) + " numere separate prin spatiu: ").split()))
print("Datele de intrare corespund restricțiilor")
a_sortat = ordonare(a, n)
print("Tabloul sortat este:", a_sortat)

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

==Explicații==
Funcția validate_input(n) primește ca parametru numărul n și verifică dacă acesta respectă restricțiile impuse. Dacă numărul este mai mic sau egal cu 0 sau mai mare decât 1000, atunci se afișează un mesaj corespunzător și se iese din program prin apelarea funcției exit().
Funcția ordonare(a, n) primește ca parametri tabloul a și numărul de elemente n și sortează tabloul folosind algoritmul "Bubble Sort". Dacă numărul de elemente este mai mic sau egal cu 1, atunci se consideră că tabloul este deja sortat și se returnează tabloul. În caz contrar, se parcurge tabloul de la stânga la dreapta și se verifică dacă două elemente consecutive sunt în ordine inversă. Dacă da, atunci se schimbă locurile lor. După aceasta, se apelează funcția recursiv, dar cu un element mai puțin.
Funcția main() primește de la utilizator numărul de elemente și tabloul de numere și validează datele introduse. Dacă datele sunt valide, atunci se afișează un mesaj corespunzător și se apelează funcția ordonare() pentru a sorta tabloul.

1844 - Inlocuire0Rec

2023-05-14T21:55:33Z

Catalin Moje:

==Cerinţa==
Scrieţi definiția completă a subprogramului recursiv num care are 2 parametri: n – prin care primește un număr natural și v, prin care primeşte un tablou unidimensional cu n elemente, numere întregi cu cel mult 4 cifre.
Subprogramul înlocuieşte cu 0 fiecare valoare mai mică sau egală cu prima valoare din tablou. Tabloul modificat este furnizat tot prin parametrul v.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*2<n<50
*numele subprogramului cerut este num
*parametrii sunt, în această ordine: n, v
*elementele tabloului v sunt indexate de la zero
*se recomandă realizarea unui subprogram recursiv

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numarul de elemente: 7
;Introduceti elementul 0: 4
;Introduceti elementul 1: 5
;Introduceti elementul 2: 0
;Introduceti elementul 3: 9
;Introduceti elementul 4: 3
;Introduceti elementul 5: 4
;Introduceti elementul 6: -2
:Iesire:
;Datele de intrare corespund restricțiilor
;[0, 5, 0, 9, 0, 0, 0]

===Exemplu 2===
:Intrare:
;Introduceti numarul de elemente: 101
:Iesire:
;Datele de intrare nu corespund cerinței

==Important==
Soluţia propusă va conţine doar definiţia subprogramului cerut. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def num(n, v):
if n == 1:
return v

v = num(n - 1, v)

if v[n - 1] <= v[0]:
v[n - 1] = 0

return v

n = int(input("Introduceti numarul de elemente: "))
if n < 2 or n > 50:
print("Datele de intrare nu corespund cerinței")
else:
v = []
for i in range(n):
v.append(int(input("Introduceti elementul " + str(i) + ": ")))

print("Datele de intrare corespund restricțiilor")
print(num(n, v))
</syntaxhighlight>

==Explicații==
Definim o funcție numită "num" cu doi parametri: "n" - reprezentând numărul de elemente al listei și "v" - reprezentând lista în sine.

Verificăm dacă lista conține cel puțin două elemente. Dacă nu, afișăm un mesaj de eroare și părăsim funcția.

Verificăm dacă primul element al listei este mai mare decât ultimul element al listei. Dacă este, afișăm un mesaj de eroare și părăsim funcția.

Verificăm dacă primul element al listei este mai mare sau egal cu oricare alt element din listă. Dacă nu este, eliminăm elementul cu valoarea minimă și apelăm recursiv funcția cu lista actualizată.

În final, returnăm lista modificată.

În cadrul programului principal, se cere utilizatorului să introducă numărul de elemente și valorile elementelor listei, iar apoi se apelează funcția "num" cu aceste parametri. Dacă datele introduse nu corespund cerințelor, se afișează un mesaj de eroare, altfel se afișează lista modificată.

1511 - FCautareRec

2023-05-14T21:53:46Z

Catalin Moje:

==Cerinţa==
Scrieţi definiția completă a unei funcții recursive care are ca parametrii un număr natural n, un șir crescător X de numere reale având n elemente și un număr real v și care returnează poziția pe care apare în șir valoarea v. În cazul în care v nu apare în șir, se va returna valoarea -1. În cazul în care v apare în șir pe mai multe poziții, se va returna una dintre acestea.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*0 < n <= 100
*v și elementele lui X sunt numere reale – se va folosi tipul double
*numele subprogramului cerut este cautare
*parametrii sunt, în această ordine: n, X, v
*elementele tabloului X sunt indexate de la zero
*se recomandă realizarea unei soluții recursive

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numarul de elemente: 6
;Introduceti elementul 0: 9.5
;Introduceti elementul 1: 16.3
;Introduceti elementul 2: 28.3
;Introduceti elementul 3: 49.7
;Introduceti elementul 4: 52.4
;Introduceti elementul 5: 73
;Introduceti valoarea de cautat: 52.4
:Iesire:
;Datele de intrare corespund restrictiilor
;Valoarea a fost gasita la pozitia 4

===Exemplu 2===
:Intrare:
;Introduceti numarul de elemente: 101
:Iesire:
;Datele de intrare nu corespund cerintei.

==Important==
Soluţia propusă va conţine doar definiţia subprogramului cerut. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n):
if n > 0 and n <= 100:
return True
else:
return False

def cautare(n, X, v):
def rec_cautare(i):
if i == n:
return -1
if X[i] == v:
return i
return rec_cautare(i + 1)
return rec_cautare(0)

def main():
n = int(input("Introduceti numarul de elemente: "))
if validare(n):
X = []
for i in range(n):
x = float(input(f"Introduceti elementul {i}: "))
X.append(x)
v = float(input("Introduceti numarul v: "))
pozitie = cautare(n, X, v)
if pozitie != -1:
print(f"Numarul {v} se afla pe pozitia {pozitie} in lista.")
else:
print(f"Numarul {v} nu se afla in lista.")
else:
print("Datele de intrare nu corespund cerintei.")

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

==Explicații==
Codul implementează o funcție numită cautare care primește trei parametrii: n reprezentând numărul de elemente din șirul X de numere reale, X reprezentând șirul propriu-zis și v reprezentând valoarea căutată. Funcția are rolul de a căuta valoarea v în șirul X și de a returna poziția la care a fost găsită aceasta.

Inițial, funcția verifică dacă valoarea lui n respectă restricția impusă de cerință (0 < n <= 100). Dacă nu, se afișează mesajul "Datele de intrare nu corespund cerinței" și funcția se termină. În caz contrar, se afișează mesajul "Datele de intrare corespund restricțiilor".

În continuare, funcția intră în recursivitate. Dacă șirul X este vid (adică nu mai are elemente), funcția returnează valoarea -1, indicând că valoarea v nu a fost găsită în șir. Dacă primul element din șir este egal cu valoarea v, funcția returnează poziția acestuia (această poziție este dată de lungimea șirului inițial n minus lungimea șirului curent len(X)). În caz contrar, se face o apelare recursivă a funcției cautare cu șirul X fără primul element și se adaugă la poziția returnată de apelul recursiv lungimea șirului curent, astfel încât să se obțină poziția corectă în șirul inițial.

În final, funcția este apelată în cadrul funcției main, unde utilizatorul este întâmpinat cu un mesaj de introducere și se citesc de la tastatură datele de intrare. Funcția cautare este apoi apelată cu aceste date și rezultatul este afișat în funcție de valoarea întoarsă.

0925 - VectorMaxMinSumRec

2023-05-14T21:51:52Z

Catalin Moje:

==Cerinţa==
Scrieți definiția completă a subprogramului recursiv P care primeşte prin intermediul parametrului n un număr natural nenul (n≤100), iar prin intermediul parametrului x un tablou unidimensional cu n componente întregi, de maximum opt cifre fiecare.
Subprogramul furnizează prin intermediul parametrului mini valoarea minimă din tabloul x, prin intermediul parametrului maxi valoarea maximă din x, iar prin intermediul parametrului sum suma elementelor din tabloul x.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*0 < n <= 100
*numele subprogramului cerut este P
*parametrii sunt, în această ordine: x, n, mini, maxi, sum
*elementele vectorului x sunt indexate de a zero
*Se recomandă realizarea unei soluții recursive.

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numarul de elemente: 6
;Introduceti elementul 0: 12
;Introduceti elementul 1: 7
;Introduceti elementul 2: 6
;Introduceti elementul 3: 3
;Introduceti elementul 4: 8
;Introduceti elementul 5: 5
:Iesire:
;Datele de intrare corespund restricțiilor
;Valoarea minima este 3
;Valoarea maxima este 12
;Suma elementelor este 41

===Exemplu 2===
:Intrare:
;Introduceti numarul de elemente: 101
:Iesire:
;Datele de intrare nu corespund cerinței.

==Important==
Soluţia propusă va conţine doar definiţia subprogramului cerut. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n):
if n < 1 or n > 100:
print("Datele de intrare nu corespund cerinței.")
return False
return True

def P(x, n, mini, maxi, suma):
if n == 1:
mini = maxi = suma = x[0]
return mini, maxi, suma
else:
mini, maxi, suma = P(x, n - 1, mini, maxi, suma)
if x[n-1] < mini:
mini = x[n-1]
if x[n-1] > maxi:
maxi = x[n-1]
suma += x[n-1]
return mini, maxi, suma

def main():
n = int(input("Introduceti numarul de elemente: "))
if not validare(n):
return
x = []
for i in range(n):
x.append(int(input("Introduceti elementul {}: ".format(i))))
mini, maxi, suma = P(x, n, x[0], x[0], 0)
print("mini = {}, maxi = {}, suma = {}".format(mini, maxi, suma))

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

==Explicații==
Programul începe prin citirea numărului de elemente din vectorul dat de la tastatură și verificarea dacă respectă restricțiile impuse: 0 < n <= 100. Dacă nu se respectă, se afișează un mesaj corespunzător și programul se oprește.

În continuare, se inițializează variabilele mini, maxi și sum cu primul element al vectorului și se apelează funcția recursivă P. Această funcție are următoarele trei cazuri de bază:

Cazul când vectorul are un singur element: în acest caz, mini și maxi sunt actualizate conform elementului și se returnează valoarea elementului.
Cazul când vectorul are două elemente: în acest caz, se compară cele două elemente și se actualizează mini și maxi conform valorilor lor. Funcția returnează suma celor două elemente.
Cazul general: se împarte vectorul în două jumătăți și se apelează recursiv funcția P pe fiecare jumătate. Se actualizează variabilele mini, maxi și sum conform valorilor obținute prin apelarea recursivă a funcției pe fiecare jumătate.
După ce se obțin valorile mini, maxi și sum prin apelarea funcției P, acestea sunt afișate la consolă.

0835 - AfisareVectorRec

2023-05-14T21:50:08Z

Catalin Moje:

==Cerinţa==
Să se scrie o funcție recursivă care afișează pe ecran elementele unui vector transmis ca parametru.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*numele funcției va fi afisvec;
*funcția va avea doi parametri, în această ordine: vectorul v și numărul de elemente din vector, n. Funcția nu va returna nimic;
*indicii elementelor vectorului sunt 0, 1, ..., n-1;
*elementele vor fi afișate în ordinea din vector, separate prin câte un spațiu.

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceți numărul de elemente din vector: 5
;Introduceți elementul 0: 3
;Introduceți elementul 1: 6
;Introduceți elementul 2: 5
;Introduceți elementul 3: 4
;Introduceți elementul 4: 2
:Iesire:
;Datele de intrare corespund restricțiilor.
;Elementele vectorului sunt: 3 6 5 4 2

===Exemplu 2===
:Intrare:
;Introduceti numarul de elemente din vector: -1
:Iesire:
;Datele de intrare nu corespund cerinței.

==Important==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n):
if not isinstance(n, int) or n <= 0:
print("Datele de intrare nu corespund cerinței.")
return False
return True

def afisvec(v, n):
if n == 1:
print(v[0], end=' ')
else:
afisvec(v, n-1)
print(v[n-1], end=' ')

def main():
n = input("Introduceți numărul de elemente din vector: ")
try:
n = int(n)
if validare(n):
v = []
for i in range(n):
x = input(f"Introduceți elementul {i}: ")
v.append(x)
print("Datele de intrare corespund restricțiilor.")
print("Elementele vectorului sunt:", end=' ')
afisvec(v, n)
except ValueError:
print("Datele de intrare nu corespund cerinței.")

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

==Explicații==
validare_input(n: str) -> bool - această funcție primește ca parametru un șir de caractere și returnează True dacă șirul poate fi convertit într-un număr întreg pozitiv și False în caz contrar.

afisare_vector_recursiv(v: list, n: int) - această funcție este funcția principală și primește ca parametri un vector v și numărul de elemente din vector n. Funcția afișează elementele vectorului v pe ecran în ordine, separate prin câte un spațiu, utilizând o abordare recursivă.

afisare_element(v: list, n: int, i: int) - această funcție primește ca parametri un vector v, numărul de elemente din vector n și un index i. Funcția afișează elementul de la indexul i și apelează funcția afisare_element() pentru a afișa următorul element.

main() - această funcție este funcția principală a programului. În interiorul acesteia, se citește de la tastatură numărul de elemente n, se validează inputul folosind funcția validare_input(), și în cazul în care inputul este valid, se citesc elementele vectorului v. În cele din urmă, se apelează funcția afisare_vector_recursiv() pentru a afișa elementele vectorului.

0835 - AfisareVectorRec

2023-05-14T21:48:46Z

Catalin Moje:

==Cerinţa==
Să se scrie o funcție recursivă care afișează pe ecran elementele unui vector transmis ca parametru.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*numele funcției va fi afisvec;
*funcția va avea doi parametri, în această ordine: vectorul v și numărul de elemente din vector, n. Funcția nu va returna nimic;
*indicii elementelor vectorului sunt 0, 1, ..., n-1;
*elementele vor fi afișate în ordinea din vector, separate prin câte un spațiu.

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceți numărul de elemente din vector: 5
;Introduceți elementul 0: 3
;Introduceți elementul 1: 6
;Introduceți elementul 2: 5
;Introduceți elementul 3: 4
;Introduceți elementul 4: 2
:Iesire:
;Datele de intrare corespund restricțiilor.
;Elementele vectorului sunt: 3 6 5 4 2

===Exemplu 2===
:Intrare:
;Introduceti numarul de elemente din vector: -1
:Iesire:
;Datele de intrare nu corespund cerinței.

==Important==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
numele funcției va fi afisvec;
funcția va avea doi parametri, în această ordine: vectorul v și numărul de elemente din vector, n. Funcția nu va returna nimic;
indicii elementelor vectorului sunt 0, 1, ..., n-1;
elementele vor fi afișate în ordinea inversă din vector, separate prin câte un spațiu.
def validare(n):
if not isinstance(n, int) or n <= 0:
print("Datele de intrare nu corespund cerinței.")
return False
return True

def afisvec(v, n):
if n == 1:
print(v[0], end=' ')
else:
afisvec(v, n-1)
print(v[n-1], end=' ')

def main():
n = input("Introduceți numărul de elemente din vector: ")
try:
n = int(n)
if validare(n):
v = []
for i in range(n):
x = input(f"Introduceți elementul {i}: ")
v.append(x)
print("Datele de intrare corespund restricțiilor.")
print("Elementele vectorului sunt:", end=' ')
afisvec(v, n)
except ValueError:
print("Datele de intrare nu corespund cerinței.")

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

==Explicații==
validare_input(n: str) -> bool - această funcție primește ca parametru un șir de caractere și returnează True dacă șirul poate fi convertit într-un număr întreg pozitiv și False în caz contrar.

afisare_vector_recursiv(v: list, n: int) - această funcție este funcția principală și primește ca parametri un vector v și numărul de elemente din vector n. Funcția afișează elementele vectorului v pe ecran în ordine, separate prin câte un spațiu, utilizând o abordare recursivă.

afisare_element(v: list, n: int, i: int) - această funcție primește ca parametri un vector v, numărul de elemente din vector n și un index i. Funcția afișează elementul de la indexul i și apelează funcția afisare_element() pentru a afișa următorul element.

main() - această funcție este funcția principală a programului. În interiorul acesteia, se citește de la tastatură numărul de elemente n, se validează inputul folosind funcția validare_input(), și în cazul în care inputul este valid, se citesc elementele vectorului v. În cele din urmă, se apelează funcția afisare_vector_recursiv() pentru a afișa elementele vectorului.

0836 - AfisareVectorRec1

2023-05-14T21:46:48Z

Catalin Moje:

==Cerinţa==
Să se scrie o funcție python recursivă care afișează pe ecran, în ordine inversă, elementele unui vector transmis ca parametru.
==Date de intrare==
Se va introduce de la tastatură un șir de valori naturale care vor fi transmise ca perimetrii

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*numele funcției va fi afisvec;
*funcția va avea doi parametri, în această ordine: vectorul v și numărul de elemente din vector, n. Funcția nu va returna nimic;
*indicii elementelor vectorului sunt 0, 1, ..., n-1;
*elementele vor fi afișate în ordinea inversă din vector, separate prin câte un spațiu.

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti valorile separate prin spatiu: 4 9 2 0
Datele de intrare corespund restrictiilor.
Lista inversata este: 0 2 9 4
</syntaxhighlight>
===Exemplu 2===
<syntaxhighlight lang="python" line>
Introduceti valorile separate prin spatiu: a b c d
Datele de intrare nu corespund cerintei.
</syntaxhighlight>

==Important==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line>
def citire():
"""Functia citeste sirul de valori de la tastatura si il transforma in lista de intregi."""
sir = input("Introduceti valorile separate prin spatiu: ")
lista = sir.split() # impartim sirul in cuvinte separate (presupunand ca sunt separate prin spatii)
try:
lista = [int(valoare) for valoare in lista] # transformam fiecare cuvant in intreg si cream o lista din acestea
except ValueError:
print("Datele de intrare nu corespund cerintei.")
lista = [] # daca apar erori la transformarea cuvintelor in intregi, lista va fi goala
return lista

def afis(lista):
"""Functia afiseaza lista de valori in ordine inversa."""
if not lista:
print("Nu s-au introdus valori.")
return
print("Lista inversata este:", end=" ")
for i in range(len(lista) - 1, -1, -1): # parcurgem lista in ordine inversa
print(lista[i], end=" ")
print() # afisam un rand nou la final

def main():
lista = citire()
if lista:
print("Datele de intrare corespund restrictiilor.")
afis(lista)

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

==Explicații==
Programul citeste un sir de valori naturale de la tastatura si apoi afiseaza aceste valori in ordine inversa, utilizand o functie recursiva.

In functia citire() se citeste de la tastatura cate o valoare la fiecare iteratie, verificandu-se daca aceasta este diferita de 0 si daca este un numar natural. Valoarea citita se adauga la lista lista_valori pana cand se citeste 0, caz in care se returneaza lista cu valorile citite.

In functia afisare_inversa() se apeleaza functia citire() pentru a citi lista de valori si apoi se apeleaza functia recursiva afisare_inversa_recursiv() cu parametrii lista de valori si indexul ultimului element din lista. Aceasta functie recursiva se apeleaza pe ea insasi, afisandu-se valoarea corespunzatoare indexului curent si apoi apelandu-se recursiv functia cu indexul anterior, pana cand indexul devine 0 si se afiseaza ultima valoare din lista.

In functia main() se apeleaza functia afisare_inversa() pentru a citi si afisa valorile in ordine inversa, tratandu-se cazurile in care valorile citite nu corespund cerintelor prin afisarea unui mesaj corespunzator.

0829 - AfisareRec

2023-05-14T21:40:32Z

Catalin Moje:

==Cerinţa==
Să se scrie o funcție recursivă care citește de la tastatură un șir de valori naturale și le afișează în ordine inversă, cu câte un spațiu între ele.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*numele funcției va fi afis;
*funcția nu va avea parametri și nu va returna nimic;
*șirul de valori citite se încheie la citirea valorii 0.

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numere separate prin spatii: 4 9 2 0
:Iesire:
;Datele introduse corespund restricțiilor impuse.
;Lista inversata este: 0 2 9 4

===Exemplu 2===
:Intrare:
;Introduceti numere separate prin spatii: a b c d
:Iesire:
;Datele introduse nu corespund restricțiilor impuse.

==Important==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def inversare_lista(lista):
invers = []
for i in range(len(lista)-1, -1, -1):
invers.append(lista[i])
return invers

def afis():
try:
input_string = input("Introduceti numere separate prin spatii: ")
lista = input_string.split()
for numar in lista:
if not numar.isdigit():
raise ValueError
print("Datele introduse corespund restricțiilor impuse.")
print(" ".join(inversare_lista(lista)))
except ValueError:
print("Datele introduse nu corespund restricțiilor impuse.")

afis()

</syntaxhighlight>

==Explicații==
Funcția afis primește ca parametru o listă de numere și returnează o nouă listă cu elementele în ordine inversă.

Funcția verificare primește ca parametru un șir de caractere care reprezintă numere separate prin spații.

În funcția verificare se verifică dacă șirul de caractere introdus este valid, adică conține doar caractere numerice și spații, iar lista rezultată din conversia șirului este diferită de lista goală. Dacă datele introduse sunt valide, se afișează un mesaj corespunzător, în caz contrar se afișează un mesaj de eroare și programul se încheie.

În funcția main se cere utilizatorului să introducă numere separate prin spații, apoi se apelează funcția verificare pentru a verifica datele introduse. Dacă datele sunt corecte, se apelează funcția afis pentru a obține lista inversată și se afișează pe ecran.

Lista inversată obținută este afișată pe ecran fără margini, adică fără caracterele de început și de sfârșit ale listei.

1843 - FSumVecRec

2023-05-14T21:38:39Z

Catalin Moje:

==Cerinţa==
Scrieţi definiția completă a subprogramului recursiv suma, care primeşte prin cei 4 parametri
v, n, i, j:
v, un tablou unidimensional cu maximum 100 de elemente întregi din intervalul [-1000,1000]
n, un număr natural reprezentând numărul de elemente din tabloul v
i și j două valori naturale cu 1≤i≤j≤n
Subprogramul returnează suma elementelor v[1], v[2], … , v[i-1], v[j+1], … , v[n].

==Date de intrare==
Se va introduce de la tastatură 4 numere naturale care vor fi transmise ca perimetrii

==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse.".

==Restricţii şi precizări==
*0 < n ≤ 100
*numele subprogramului cerut este suma
*parametrii sunt, în această ordine: v, n, i, j
*indicii elementelor vectorului v sunt 1, 2 ,… , n
*se recomandă realizarea unei soluții recursive

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti elementele vectorului separate prin spatiu: 12 7 6 3 8 5
;Introduceti lungimea vectorului: 6
;Introduceti valoarea pentru i: 2
;Introduceti valoarea pentru j: 4
:Iesire:
;Datele de intrare corespund restricțiilor impuse.
;Suma este: 16

===Exemplu 2===
:Intrare:
;Introduceti elementele vectorului separate prin spatiu: 12 7 6 3 8 5
;Introduceti lungimea vectorului: 1234
;Introduceti valoarea pentru i: 2
;Introduceti valoarea pentru j: 4
:Iesire:
;Datele de intrare nu corespund restricțiilor impuse.

==Important==
Soluţia propusă va conţine doar definiţia subprogramului cerut. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validate_input(v, n, i, j):
if not(1 <= n <= 100) or not(1 <= i <= j <= n) or len(v) != n:
print("Datele de intrare nu corespund restricțiilor impuse.")
return False
for elem in v:
if not (-1000 <= elem <= 1000):
print("Datele de intrare nu corespund restricțiilor impuse.")
return False
print("Datele de intrare corespund restricțiilor impuse.")
return True

def suma(v, i, j):
if j-i+1 == 1:
return v[i-1]
elif j-i+1 == 2:
return v[i-1] + v[j-1]
else:
return v[i-1] + suma(v, i+1, j-1) + v[j-1]

def main():
v = [int(x) for x in input("Introduceti elementele vectorului separate prin spatiu: ").split()]
n = int(input("Introduceti lungimea vectorului: "))
i = int(input("Introduceti valoarea pentru i: "))
j = int(input("Introduceti valoarea pentru j: "))
if validate_input(v, n, i, j):
print(f"Suma este: {suma(v, i, j)}")

main()
</syntaxhighlight>

==Explicații==
Codul este format din trei funcții:

validate_input(v, n, i, j): Verifică dacă datele de intrare respectă restricțiile impuse. Aceste restricții sunt:
1 <= n <= 100: lungimea vectorului trebuie să fie între 1 și 100 inclusiv.
1 <= i <= j <= n: i și j trebuie să fie întregi pozitivi astfel încât i <= j <= n.
-1000 <= elem <= 1000: toate elementele din vector trebuie să fie numere întregi între -1000 și 1000 inclusiv.
suma(v, n, i, j): Calculează suma elementelor din vectorul v care se află între pozițiile i și j. Această funcție este recursivă și utilizează o abordare de tip divide-et-impera.

main(): Funcția principală, care citește datele de intrare, validează intrările și apoi calculează și afișează suma elementelor din vectorul v între pozițiile i și j, apelând funcțiile validate_input() și suma().

1847 - VectorSumPrim REC

2023-05-14T21:36:28Z

Catalin Moje:

==Cerinţa==
Scrieți definiția completă a subprogramului recursiv P care primeşte prin intermediul parametrului n un număr natural nenul (n≤100), iar prin intermediul parametrului x un tablou unidimensional cu n componente întregi, de maximum șase cifre fiecare.
Subprogramul furnizează prin intermediul parametrului s suma elementelor din tabloul x care au valori numere prime.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*0 < n ≤ 100
*numele subprogramului cerut este P
*parametrii sunt, în această ordine: x, n, s
*elementele vectorului x sunt indexate de la zero
*se recomandă realizarea unei soluții recursive

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceți numărul de elemente din tablou: 6
;Introduceți elementul 1: 12
;Introduceți elementul 2: 7
;Introduceți elementul 3: 6
;Introduceți elementul 4: 3
;Introduceți elementul 5: 8
;Introduceți elementul 6: 5
:Iesire:
;Datele de intrare corespund restricțiilor impuse.
;Suma elementelor din tablou care sunt divizibile cu 3 este: 21

===Exemplu 2===
:Intrare:
;Introduceți numărul de elemente din tablou: 1234
:Iesire:
;Datele de intrare nu corespund restricțiilor impuse.

==Important==
Soluţia propusă va conţine definiţia subprogramului cerut și eventual al altor subprograme, apelate de acesta. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare_natural(n):
return n > 0

def validare_dimensiune_tablou(n):
return n <= 100

def suma_divizibile_cu_3(v, n):
return sum(x for x in v if x % 3 == 0)

def main():
try:
n = int(input("Introduceți numărul de elemente din tablou: "))
if not validare_natural(n) or not validare_dimensiune_tablou(n):
raise ValueError
v = [int(input(f"Introduceți elementul {i+1}: ")) for i in range(n)]
print("Datele de intrare corespund restricțiilor impuse.")
print(f"Suma elementelor din tablou care sunt divizibile cu 3 este: {suma_divizibile_cu_3(v, n)}")
except ValueError:
print("Datele de intrare nu corespund restricțiilor impuse.")

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

==Explicații==
Codul scris este o implementare a cerințelor enunțate în problema de mai sus.

Funcția validare_natural verifică dacă un număr este natural nenul (n > 0) și returnează True dacă este, False în caz contrar.

Funcția validare_dimensiune_tablou verifică dacă un număr este mai mic sau egal cu 100 (dimensiunea maximă a tabloului) și returnează True dacă este, False în caz contrar.

Funcția suma_divizibile_cu_3 calculează suma elementelor dintr-un tablou unidimensional care sunt divizibile cu 3 și primește ca parametri v - tabloul unidimensional și n - numărul efectiv de elemente din tablou.

Funcția main este funcția principală care citește datele de intrare și afișează rezultatul sau un mesaj de eroare. Ea folosește funcțiile de validare și de rezolvare pentru a verifica și procesa datele de intrare.

În cadrul funcției main, datele de intrare sunt citite de la tastatură și apoi sunt verificate utilizând funcțiile validare_natural și validare_dimensiune_tablou. Dacă datele de intrare sunt valide, se creează un tablou v care este umplut cu numerele citite de la tastatură și apoi se afișează mesajul "Datele de intrare corespund restricțiilor impuse" și suma elementelor din tablou care sunt divizibile cu 3, calculată utilizând funcția suma_divizibile_cu_3.

În caz contrar, dacă datele de intrare nu sunt valide, se afișează mesajul "Datele de intrare nu corespund restricțiilor impuse".

0926 - FSumDiv3Rec

2023-05-14T21:34:40Z

Catalin Moje:

==Cerinţa==
Scrieţi definiția completă a subprogramului recursiv sum3, care primeşte prin parametrul v un tablou unidimensional cu cel mult 100 de elemente întregi, iar prin parametrul n numărul efectiv de elemente din v.
Subprogramul returnează suma elementelor din tabloul <code>v</code> care sunt divizibile cu 3.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*0 < n ≤ 100
*numele subprogramului cerut este sum3
*parametrii sunt, în această ordine: v, n
*indicii elementelor vectorului v sunt 0, 1 ,… , n-1.
*Se recomandă realizarea unui subprogram recursiv.

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numarul de elemente: 6
;v[0] = 12
;v[1] = 7
;v[2] = 6
;v[3] = 3
;v[4] = 8
;v[5] = 5
:Iesire:
;Datele de intrare corespund restrictiilor.
;Suma elementelor divizibile cu 3 din vector este: 21

===Exemplu 2===
:Intrare:
;Introduceti numarul de elemente: 1234
:Iesire:
;Datele de intrare nu corespund restrictiilor.

==Important==
Soluţia propusă va conţine doar definiţia subprogramului cerut. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def sum3(v, n):
if n == 0:
return 0
if v[n-1] % 3 == 0:
return v[n-1] + sum3(v, n-1)
else:
return sum3(v, n-1)

# Citirea datelor de intrare
n = int(input("Introduceti numarul de elemente: "))

# Verificarea restricțiilor
if n <= 0 or n > 100:
print("Datele de intrare nu corespund restrictiilor.")
else:
# Citirea vectorului
v = []
for i in range(n):
x = int(input(f"v[{i}] = "))
v.append(x)

# Calcularea sumei elementelor divizibile cu 3 din vector
print("Datele de intrare corespund restrictiilor.")
s = sum3(v, n)
print(f"Suma elementelor divizibile cu 3 din vector este: {s}")

</syntaxhighlight>

==Explicații==
Programul începe prin citirea unui număr natural n de la tastatură, care reprezintă numărul de elemente al tabloului. Se verifică dacă valoarea citită se încadrează în restricțiile impuse (0 < n ≤ 100), iar în caz contrar se afișează mesajul "Datele de intrare nu corespund cerinței" și programul se încheie.

În cazul în care numărul n se încadrează în limitele impuse, se declară și se inițializează un tablou unidimensional v cu n elemente, iar apoi se citesc valorile pentru fiecare element din tablou.

Se apelează apoi funcția sum3, care calculează suma elementelor din tabloul v care sunt divizibile cu 3, utilizând o abordare recursivă. Dacă toate elementele sunt distincte de 3, atunci suma returnată va fi 0.

În continuare, programul afișează mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează suma calculată de funcția sum3.

0938 - FSumRec

2023-05-14T21:32:11Z

Catalin Moje:

==Cerinţa==
Scrieţi definiția completă a subprogramului recursiv <code>suma</code>, care primeşte prin parametrul v un tablou unidimensional cu cel mult 100 de elemente întregi, iar prin parametrul <code>n</code> numărul efectiv de elemente din <code>v</code>.
Subprogramul returnează suma elementelor din tabloul <code>v</code>.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*0 < n ≤ 100
*numele subprogramului cerut este suma
*parametrii sunt, în această ordine: v, n
*indicii elementelor vectorului v sunt 0, 1 ,… , n-1.
*Se recomandă realizarea unui subprogram recursiv.

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceți numărul de elemente ale tabloului: 6
;v[0] = 12
;v[1] = 7
;v[2] = 6
;v[3] = 3
;v[4] = 8
;v[5] = 5
Datele de intrare corespund restricțiilor impuse.
:Iesire:
;Suma elementelor din tablou este: 41

===Exemplu 2===
:Intrare:
;Introduceți numărul de elemente ale tabloului: 1234
:Iesire:
;Datele de intrare nu corespund restrictiilor impuse.

==Important==
Soluţia propusă va conţine doar definiţia subprogramului cerut. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def suma(v, n):
if n == 1:
return v[0]
else:
return v[n-1] + suma(v, n-1)

try:
n = int(input("Introduceți numărul de elemente ale tabloului: "))
if n < 1 or n > 100:
print("Datele de intrare nu corespund restrictiilor impuse.")
else:
v = []
for i in range(n):
elem = int(input(f"v[{i}] = "))
v.append(elem)
print("Datele de intrare corespund restricțiilor impuse.")
print("Suma elementelor din tablou este:", suma(v, n))
except ValueError:
print("Datele de intrare nu corespund restrictiilor impuse.")
</syntaxhighlight>

==Explicații==
Acest program calculează suma elementelor unui tablou dat folosind o funcție recursivă numită "suma".

Funcția "suma" primește doi parametri: un tablou de întregi "v" și numărul efectiv de elemente din tablou "n". În cazul acestui exercițiu, "n" este citit de la tastatură și trebuie să fie un număr întreg pozitiv mai mic sau egal cu 100.

În cadrul funcției "suma", se verifică dacă numărul efectiv de elemente este zero sau nu. Dacă este zero, funcția returnează 0. În caz contrar, se adună elementul curent (v[n-1]) cu suma elementelor din sub-tabloul v[0:n-2], obținut prin apelul recursiv al funcției "suma". De asemenea, se verifică dacă "n" este mai mare decât capacitatea tabloului "v", caz în care funcția returnează 0.

În funcția main, se citește numărul efectiv de elemente al tabloului "n", iar apoi se citește fiecare element al tabloului "v". Se verifică dacă datele de intrare corespund cerințelor și se afișează un mesaj corespunzător.

Dacă datele de intrare sunt corecte, se apelează funcția "suma" pentru a calcula suma elementelor tabloului "v" și se afișează rezultatul.

2730 - SC

2023-05-14T21:30:08Z

Catalin Moje:

==Cerința==
Scrieți funcția recursivă având următorul antet:
int SC(char s[])
Funcția primește ca parametru un șir de caractere și returnează suma tuturor cifrelor care apar în șir.

==Date de intrare==
Se va introduce de la tastatură un sir de caractere

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricții și precizări==
*1 ≤ lungimea șirului ≤ 200
*Dacă șirul nu conține cifre, funcția trebuie să returneze valoarea 0.
*Se recomandă utilizarea recursivității pentru rezolvarea acestei probleme.

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti un sir de caractere: Ana are 15 mere si 185 de pere.
:Iesire:
;Datele de intrare corespund restricțiilor impuse.
;Suma cifrelor din sir este: 20

===Exemplu 2===
:Intrare:
;Introduceti un sir de caractere: Ana are mere.
:Iesire:
;Datele de intrare corespund restricțiilor impuse.
;Suma cifrelor din sir este: 0

==Important==
Soluția propusă va conține definiția funcției cerute. Prezența în soluție a altor instrucțiuni poate duce erori de compilare sau de execuție care vor avea ca efect depunctarea soluției.

==Rezolvare==

<syntaxhighlight lang="python" line="1">
def validate_input(s):
if not isinstance(s, str):
print("Datele de intrare nu corespund restricțiilor impuse.")
return False
if len(s) < 1 or len(s) > 200:
print("Datele de intrare nu corespund restricțiilor impuse.")
return False
return True

def SC(s):
if not validate_input(s):
return
if not any(char.isdigit() for char in s):
return 0
sum = 0
for char in s:
if char.isdigit():
sum += int(char)
return sum

def main():
s = input("Introduceti un sir de caractere: ")
if validate_input(s):
print("Datele de intrare corespund restricțiilor impuse.")
print("Suma cifrelor din sir este:", SC(s))

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

==Explicații==
Codul dat este o implementare în limbajul Python a unei funcții recursive care primește ca parametru un șir de caractere și returnează suma tuturor cifrelor care apar în șir.

Funcția este formată din trei sub-funcții:

#1 validate_input(s) - această funcție primește un șir de caractere s și verifică dacă acesta respectă restricțiile impuse de cerințe: trebuie să fie de tipul str și să aibă o lungime între 1 și 200. Dacă șirul nu respectă aceste restricții, se afișează un mesaj corespunzător și se returnează valoarea False. Altfel, funcția returnează valoarea True.

#2 SC(s) - această funcție primește ca parametru un șir de caractere s și îl validează prin apelul funcției validate_input(s). Dacă șirul nu respectă restricțiile, funcția returnează None. În caz contrar, se parcurge fiecare caracter din șir și se calculează suma cifrelor. Dacă șirul nu conține cifre, funcția returnează valoarea 0.

#3 main() - această funcție este funcția principală a programului și este responsabilă pentru citirea șirului de la tastatură, apelarea funcției SC(s) și afișarea rezultatului. Înainte de apelarea funcției SC(s), se validează șirul de intrare prin apelul funcției validate_input(s).

În programul principal, se apelează funcția main().

1863 - NumarareRec

2023-05-14T21:27:59Z

Catalin Moje:

==Cerinţa==
Scrieţi definiția completă a subprogramului recursiv numarare, care primeşte prin parametrul v un tablou unidimensional cu cel mult 100 de elemente întregi, iar prin parametrul n numărul efectiv de elemente din v.

Subprogramul returnează numărul de perechi de elemente vecine din tabloul v care sunt egale.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*0 < n ≤ 100
*numele subprogramului cerut este numarare
*parametrii sunt, în această ordine: v, n
*indicii elementelor tabloului v sunt 0, 1 ,… , n-1.
*se recomandă realizarea unui subprogram recursiv

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numarul de elemente: 6
;Introduceti elementul 1: 5
;Introduceti elementul 2: 6
;Introduceti elementul 3: 6
;Introduceti elementul 4: 3
;Introduceti elementul 5: 5
;Introduceti elementul 6: 5
:Iesire:
;Datele de intrare corespund restricțiilor.
;Numarul de perechi de elemente vecine egale este: 2

===Exemplu 2===
:Intrare:
;Introduceti numarul de elemente: 1234
:Iesire:
;Datele de intrare nu corespund restrictiilor impuse.

==Important==
Soluţia propusă va conţine doar definiţia subprogramului cerut. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def numarare(v, n):
if n <= 1:
return 0
if v[n - 1] == v[n - 2]:
return 1 + numarare(v, n - 1)
else:
return numarare(v, n - 1)

def main():
# Citirea datelor de intrare
n = int(input("Introduceti numarul de elemente: "))
if n <= 1 or n > 100:
print("Datele de intrare nu corespund restrictiilor impuse.")
return
v = []
for i in range(n):
element = int(input(f"Introduceti elementul {i + 1}: "))
v.append(element)

# Apelarea functiei de numarare si afisarea rezultatului
numar_perechi = numarare(v, n)
print("Datele de intrare corespund restrictiilor impuse.")
print(f"Numarul de perechi de elemente vecine egale este: {numar_perechi}")

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicații==
Codul este împărțit în două funcții:

#1 numarare - această funcție primește ca argumente un vector v și numărul de elemente n. Scopul acestei funcții este de a număra câte perechi de elemente vecine egale se găsesc în vectorul dat. Funcția se bazează pe o abordare recursivă, verificând dacă ultimele două elemente ale vectorului sunt egale, apoi apelându-se recursiv pentru a verifica restul vectorului. Funcția returnează numărul de perechi găsite.

#2 main - această funcție conține citirea datelor de intrare, apelarea funcției numarare și afișarea rezultatului. Inițial, se citește numărul de elemente n din vector, apoi fiecare element este citit și adăugat la vectorul v. Apoi, se apelează funcția numarare pentru a număra perechile de elemente vecine egale și se afișează numărul găsit.

În cadrul funcției main sunt aplicate verificări pentru a asigura că datele de intrare corespund restricțiilor impuse (adică 0 < n ≤ 100). Dacă aceste restricții nu sunt îndeplinite, se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse". În caz contrar, se va afișa mesajul "Datele de intrare corespund restricțiilor impuse" urmat de numărul de perechi de elemente vecine egale.

0828 - Manna-Pnueli

2023-05-14T21:25:55Z

Catalin Moje:

==Cerinţa==
Să se scrie o python care să returneze cifra cifra maximă a unui număr natural transmis ca parametru.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*numele funcției va fi <code>cifmax</code>
*funcția va avea un parametru reprezentând numărul dat
*numărul pentru care se calculează cifra maximă va fi mai mic decât 2.000.000.000

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numarul: 2050
:Iesire:
;Datele de intrare corespund restricțiilor impuse.
;Cifra maxima este: 5

===Exemplu 2===
:Intrare:
;Introduceti numarul: 2000000000
:Iesire:
;Datele de intrare nu corespund restricțiilor impuse.
;Cifra maxima este: None

==Important==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(numar):
if not isinstance(numar, int) or numar < 0 or numar >= 2000000000:
return False
return True

def cifmax(numar, print_message=True):
if not validare(numar):
if print_message:
print("Datele de intrare nu corespund restricțiilor impuse.")
return None
if print_message:
print("Datele de intrare corespund restricțiilor impuse.")
if numar < 10:
return numar
max_cifra = cifmax(numar // 10, False)
cifra_curenta = numar % 10
return max_cifra if max_cifra > cifra_curenta else cifra_curenta

def main():
numar = int(input("Introduceti numarul: "))
print("Cifra maxima este:", cifmax(numar))

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

==Explicații==
Funcția validare primește un parametru numar și verifică dacă acesta este un întreg pozitiv (mai mare sau egal cu 0) și mai mic decât 2000000000 (adica, intră în intervalul [0, 2000000000)).
Funcția cifmax primește, de asemenea, un parametru numar, care reprezintă numărul la care se caută cifra maximă, și un parametru opțional print_message care indică dacă trebuie afișat mesajul "Datele de intrare corespund restricțiilor impuse." la apelul inițial al funcției. La început, parametrul print_message este setat la True.
În funcția cifmax, se verifică dacă numar este valid folosind funcția validare. Dacă numar nu este valid, funcția va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse." dacă parametrul print_message este setat la True și va returna None.
Dacă numar este valid, funcția va afișa mesajul "Datele de intrare corespund restricțiilor impuse." la apelul inițial al funcției dacă print_message este setat la True.
Dacă numar are doar o cifră, acea cifră va fi returnată.
În caz contrar, se calculează cifra curentă și se face o apelare recursivă a funcției cifmax cu numărul format din toate cifrele lui numar cu excepția celei mai din dreapta (adică cu o cifră mai puțin), și parametrul print_message setat la False. Rezultatul apelului recursive este stocat în variabila max_cifra.
Dacă max_cifra este mai mare decât cifra curentă, atunci max_cifra este returnată. În caz contrar, cifra curentă este returnată.
Funcția main citește un număr de la tastatură, apelează funcția cifmax și afișează cifra maximă găsită.

2674 - IncDecRec

2023-05-14T21:24:10Z

Catalin Moje:

==Cerinţa==
Scrieți funcția recursivă IncDecRec care primind ca parametru un număr natural n, returnează numărul obținut din n prin scăderea cu 1 a fiecărei cifre impare și creșterea cu 1 a fiecărei cifre pare.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricții și precizări==
*0 ≤ n ≤ 999.999.999
*Numele funcției este IncDecRec.
*Se recomandă utilizarea recursivității în rezolvarea problemei. De asemenea, se recomandă să nu se folosească alte funcții suplimentare.

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceți un număr natural: 4321
:Iesire:
;Datele de intrare corespund restricțiilor impuse.
;Rezultatul este: 5230

===Exemplu 2===
:Intrare:
;Introduceti un numar: -1241
:Iesire:
;Datele de intrare nu corespund restrictiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def cifmaxpar(numar):
#Returneaza cea mai mare cifra para a unui numar dat.
#Daca numarul nu contine nicio cifra para, se returneaza -1.
if numar < 0 or numar >= 2000000000:
print("Datele de intrare nu corespund restrictiilor impuse.")
return None
max_cifra_para = -1
while numar > 0:
cifra = numar % 10
if cifra % 2 == 0 and cifra > max_cifra_para:
max_cifra_para = cifra
numar //= 10
if max_cifra_para == -1:
return -1
else:
return max_cifra_para

def main():
numar = int(input("Introduceti un numar: "))
cifra_max = cifmaxpar(numar)
if cifra_max == None:
return
elif cifra_max == -1:
print("Numarul dat nu contine nicio cifra para.")
else:
print("Datele de intrare corespund restrictiilor impuse.")
print(f"Cea mai mare cifra para a numarului dat este {cifra_max}.")

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

==Explicații==
Funcția primește un argument numit numar, reprezentând numărul căruia i se caută cea mai mare cifră pară.

Dacă numărul introdus este negativ sau mai mare decât o limită impusă (în acest caz, 2000000000), funcția afișează un mesaj de eroare prin intermediul funcției print() și returnează valoarea specială None.

Funcția inițializează variabila max_cifra_para cu -1. Acesta este un număr care va fi înlocuit cu prima cifră pară găsită în numărul introdus.

În următoarea secțiune a codului se utilizează un ciclu while pentru a parcurge cifrele numărului dat. Începând cu cifra unităților și până la cifra cu puterea cea mai mare de 10, se vor efectua următoarele operații:

a) Se determină cifra curentă a numărului prin intermediul operației modulo (%) și operatorul //.

b) Dacă cifra curentă este pară și mai mare decât valoarea curentă a variabilei max_cifra_para, atunci această cifră devine noua valoare a variabilei max_cifra_para.

c) Variabila numar este actualizată prin împărțirea acesteia la 10 (în acest fel, se elimină cifra curentă, astfel încât să se poată trece la următoarea cifră).

După terminarea ciclului, se verifică valoarea variabilei max_cifra_para. Dacă această valoare este -1, atunci nu s-a găsit nicio cifră pară și se afișează un mesaj corespunzător prin intermediul funcției print(). Dacă valoarea este diferită de -1, atunci funcția afișează o confirmare a faptului că datele introduse sunt corecte și afișează valoarea variabilei max_cifra_para ca rezultat, prin intermediul unei expresii f-string (formatate cu ajutorul caracterului {} și a unei variabile în interiorul șirului).

0827 - CifMaxParRec

2023-05-14T21:22:30Z

Catalin Moje:

==Cerinţa==
Să se scrie o python care să returneze cea mai mare cifră pară a unui număr natural transmis ca parametru.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*numele funcției va fi <code>cifmaxpar</code>
*funcția va avea un parametru reprezentând numărul dat
*numărul pentru care se calculează cea mai mare cifră pară va fi mai mic decât 2.000.000.000
*dacă numărul nu conţine nici o cifră pară, se va returna valoarea -1

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti un numar: 2154
;Datele de intrare corespund restrictiilor impuse.
:Iesire:
;Cea mai mare cifra para a numarului dat este 4.

===Exemplu 2===
:Intrare:
;Introduceti un numar: 1157
:Iesire:
;Datele de intrare corespund restrictiilor impuse.
;Cea mai mare cifra para a numarului dat este -1.

==Important==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def cifmaxpar(numar):
#Returneaza cea mai mare cifra para a unui numar dat.
#Daca numarul nu contine nicio cifra para, se returneaza -1.
if numar < 0 or numar >= 2000000000:
print("Datele de intrare nu corespund restrictiilor impuse.")
return None
max_cifra_para = -1
while numar > 0:
cifra = numar % 10
if cifra % 2 == 0 and cifra > max_cifra_para:
max_cifra_para = cifra
numar //= 10
if max_cifra_para == -1:
return -1
else:
return max_cifra_para

def main():
numar = int(input("Introduceti un numar: "))
cifra_max = cifmaxpar(numar)
if cifra_max == None:
return
elif cifra_max == -1:
print("Numarul dat nu contine nicio cifra para.")
else:
print("Datele de intrare corespund restrictiilor impuse.")
print(f"Cea mai mare cifra para a numarului dat este {cifra_max}.")

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

0834 - ElimCifRec

2023-05-14T21:20:27Z

Catalin Moje:

==Cerinţa==
Să se scrie o python care primește ca parametrii un număr natural n și o cifră c și returnează numărul obținut prin eliminarea din n a tuturor aparițiilor lui c.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

Restricţii şi precizări
*numele funcției va fi elimcif
*funcția va avea doi parametri, în această ordine: n, c, cu semnificația de mai sus
*1 ≤ n ≤ 2.000.000.000, 0 ≤ c < 10

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti un numar natural: 2454
;Introduceti cifra: 4
:Iesire:
;Datele de intrare corespund restrictiilor
;Numarul obtinut prin eliminarea cifrei 4 din 0 este 25

===Exemplu 2===
:Intrare:
;Introduceti un numar natural: 1157
;Introduceti cifra: 8
:Iesire:
;Datele de intrare corespund restrictiilor
;Numarul obtinut prin eliminarea cifrei 8 din 0 este 1157
===Exemplu 3===
:Intrare:
;Introduceti un numar natural: abc
:Iesire:
;Datele de intrare nu corespund restricțiilor impuse.

==Important==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n, c):
if not isinstance(n, int) or not isinstance(c, int):
return False
if n < 1 or n > 2000000000 or c < 0 or c > 9:
return False
return True

def elimcif(n, c):
if not validare(n, c):
print("Datele de intrare nu corespund cerintei")
return
numar_nou = 0
putere = 1
while n > 0:
ultima_cifra = n % 10
if ultima_cifra != c:
numar_nou += ultima_cifra * putere
putere *= 10
n //= 10
if numar_nou == 0:
print("Numarul nu contine cifre diferite de", c)
else:
print("Datele de intrare corespund restrictiilor")
print("Numarul obtinut prin eliminarea cifrei", c, "din", n, "este", numar_nou)

def main():
n = int(input("Introduceti un numar natural: "))
c = int(input("Introduceti cifra: "))
elimcif(n, c)

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicații==
Funcția validare verifică dacă datele de intrare respectă restricțiile cerute. Dacă n este mai mare decât 2 miliarde sau cifra c nu este între 0 și 9, funcția va returna False, altfel va returna True.

Funcția elimcif primește doi parametri: n și c. În interiorul acestei funcții, se verifică dacă datele de intrare corespund cerințelor folosind funcția de validare și se afișează mesajul corespunzător. Dacă datele sunt corecte, se realizează eliminarea cifrei c din numărul n.

Mai întâi, convertim numărul n într-un șir de caractere folosind funcția str. Apoi, într-un for loop, iterăm prin toate caracterele șirului și adăugăm într-un alt șir doar caracterele diferite de cifra c. La final, convertim șirul obținut într-un număr întreg folosind funcția int.

În funcția main, se citește numărul de la tastatură, se verifică dacă datele de intrare corespund cerințelor folosind funcția de validare, iar dacă da, se apelează funcția elimcif și se afișează rezultatul.

0826 - CifMinParRec

2023-05-14T21:17:52Z

Catalin Moje:

==Cerinţa==
Să se scrie o python care să returneze cea mai mică cifră pară a unui număr natural transmis ca parametru.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*numele funcției va fi <code>cifminpar</code>
*funcția va avea un parametru reprezentând numărul dat
*numărul pentru care se calculează cifra minimă pară va fi mai mic decât <code>2.000.000.000</code>
*dacă numărul nu conţine nici o cifră pară, se va returna valoarea <code>-1</code>

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceți un număr natural: 2355235
:Iesrire:
;Datele de intrare corespund restricțiilor
;Cea mai mică cifră pară din 2355235 este 2.

===Exemplu 2===
:Intrare:
;Introduceți un număr natural: -10
:Iesire
;Datele de intrare nu corespund cerinței

===Exemplu 3===
:Intrare:
;Datele de intrare corespund restricțiilor
;-1
==Important==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def cifminpar(numar):
if numar < 0 or numar >= 2000000000:
return "Datele de intrare nu corespund cerinței"
elif numar % 2 == 0:
return "Cea mai mică cifră pară din " + str(numar) + " este " + str(min([int(cifra) for cifra in str(numar) if int(cifra) % 2 == 0]))
else:
if any(int(cifra) % 2 == 0 for cifra in str(numar)):
return "Cea mai mică cifră pară din " + str(numar) + " este " + str(min([int(cifra) for cifra in str(numar) if int(cifra) % 2 == 0]))
else:
return -1

numar = int(input("Introduceți un număr natural: "))
rezultat = cifminpar(numar)
if rezultat == "Datele de intrare nu corespund cerinței":
print(rezultat)
else:
print("Datele de intrare corespund restricțiilor")
print(rezultat)

#Această funcție va solicita utilizatorului să introducă un număr natural, va apela funcția cifminpar și va afișa rezultatul. Dacă funcția cifminpar întoarce o valoare non-numerică, aceasta va fi afișată direct în consolă.
</syntaxhighlight>

==Explicații==
Se definește o funcție numită ceamai_mica_cifra_para care primește ca argument un număr natural n.
Se verifică dacă numărul n conține cifre pare:
a. Se convertește numărul n într-un șir de caractere pentru a putea parcurge cifrele sale.
b. Se parcurg cifrele șirului și se verifică dacă fiecare cifră este pară.
c. Dacă se găsește cel puțin o cifră pară, se continuă cu următorul pas.
d. Altfel, se returnează valoarea -1.
Se parcurge din nou șirul format din cifrele numărului n, de data aceasta în ordine inversă.
Se verifică dacă fiecare cifră este pară și se ține minte cea mai mică cifră pară găsită până acum.
Se returnează cea mai mică cifră pară găsită.

0920 - CifMaxMinRec

2023-05-14T21:14:43Z

Catalin Moje:

==Cerinţa==
Să se scrie o python care să determine cifra maximă și cifra minimă a unui număr natural transmis ca parametru. Funcția va întoarce rezultatele prin intermediul unor parametri de ieșire.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței

==Restricţii şi precizări==
*numele funcției va fi <code>cifmaxmin</code>
*funcția va avea trei parametri:
*<code>n</code>, numărul dat
*<code>max</code>, cifra maximă a lui <code>n</code>
*<code>min</code>, cifra minimă a lui <code>n</code>
*ordinea parametrilor este: <code>n</code> <code>max</code> <code>min</code>
*<code>n</code> va fi mai mic decât <code>2.000.000.000</code>

==Exemplu==
===Exemplu 1===
:Intrare:
;cifmaxmin(12345, 0, 0)
:Iesire:
;Datele de intrare corespund restricțiilor impuse.
;Cifra maxima este: 5
;Cifra minima este: 1

===Exemplu 2===
:Intrare:
;cifmaxmin(12345, 0, 0)
:Iesire:
;Datele de intrare corespund restricțiilor impuse.
;Cifra maxima este: 5
;Cifra minima este: 1

===Exemplu 3===
:Intrare:
;cifmaxmin(2000000000, 0, 0)
:Iesire:
;Datele de intrare nu corespund restricțiilor impuse.

==Important==
Soluţia propusă va conţine doar definiţia funcţiei cerute. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(n):
if n >= 2000000000:
print("Datele de intrare nu corespund restricțiilor impuse.")
return False
print("Datele de intrare corespund restricțiilor impuse.")
return True
def cifmaxmin(n, max, min):
if not validare(n):
return
while n > 0:
cifra = n % 10
if cifra > max:
max = cifra
if cifra < min or min == 0:
min = cifra
n //= 10
print(f"Cifra maxima este: {max}")
print(f"Cifra minima este: {min}")
def main():
n = int(input("Introduceti un numar intreg mai mic decat 2.000.000.000: "))
cifmaxmin(n, 0, 0)
if __name__ == "__main__":
main()
</syntaxhighlight>

==Explicații==
Pentru a explica funcția cifmaxmin, vom parcurge codul pe bucăți:

Funcția începe prin apelarea funcției de validare cu numărul dat ca argument. Dacă funcția de validare returnează False, înseamnă că numărul nu respectă restricțiile impuse și funcția cifmaxmin se oprește prin instrucțiunea return.
Inițializăm variabilele max și min cu 0.
Într-un loop while, parcurgem cifrele numărului dat n:
Obținem ultima cifră a lui n prin modulo 10, și o salvăm în variabila cifra.
Comparăm cifra cu valoarea max și o actualizăm dacă este cazul.
Comparăm cifra cu valoarea min și o actualizăm dacă este cazul. De asemenea, verificăm dacă min are valoarea 0, caz în care îi atribuim valoarea cifrei.
Împărțim n la 10 pentru a elimina ultima cifră și a trece la cifra următoare.
Afișăm valorile finale ale max și min.

0825 - CifMinRec

2023-05-14T21:11:43Z

Catalin Moje:

==Cerinţa==
Să se scrie o python care să returneze cifra minimă a unui număr natural transmis ca parametru.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*numele funcției va fi <code>cifmin</code>
*funcția va avea un parametru reprezentând numărul dat
*numărul pentru care se calculează cifra minimă va fi mai mic decât <code>2.000.000.000</code>

==Exemplu==
===Exemplu 1===

:Date de intrare: 2050
:Date de ieșire:
;Datele de intrare corespund restricțiilor impuse.
;Cifra minima a numarului 2050 este 0.
===Exemplu 2===
:Date de intrare: -42
:Date de ieșire:
;Datele de intrare nu corespund restricțiilor impuse.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validate_input(num):
if isinstance(num, int) and num >= 0 and num < 2000000000:
return True
else:
return False

def cifmin(num):
if not validate_input(num):
print("Datele de intrare nu corespund restricțiilor impuse.")
return
else:
digits = [int(i) for i in str(num)]
min_digit = min(digits)
print("Datele de intrare corespund restricțiilor impuse.")
print(f"Cifra minima a numarului {num} este {min_digit}.")

def main():
num = input("Introduceti un numar intreg mai mic decat 2.000.000.000: ")
try:
num = int(num)
cifmin(num)
except ValueError:
print("Inputul trebuie sa fie un numar intreg.")

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

==Explicații==
Funcția validare_numar primește un argument numar și returnează True dacă acesta este un număr natural mai mic decât 2.000.000.000 și False în caz contrar.
Funcția cifmin primește un argument numar și începe prin a apela funcția validare_numar pentru a verifica dacă argumentul este valid. Dacă este invalid, afișează un mesaj corespunzător și returnează None. În caz contrar, transformă numărul într-un șir de caractere și apoi extrage fiecare cifră din șir și o adaugă la o listă de cifre. Apoi returnează cifra minimă din lista de cifre folosind funcția min.
Funcția main citește un număr de la tastatură folosind funcția input și îl transmite funcției cifmin pentru a-i determina cifra minimă. Apoi afișează cifra minimă calculată sau un mesaj de eroare dacă argumentul nu este valid.

1428 - Sume1

2023-05-14T21:08:37Z

Catalin Moje:

==Cerința==
Se dă un număr natural N. Să se calculeze expresia:

E=(20+21+22+23+…+2N)%1000000007
unde x % y reprezintă restul împărţirii lui x la y.

==Date de intrare==
Fișierul de intrare sume1.in conține pe prima linie numărul N.

==Date de ieșire==
Fișierul de ieșire sume1.out va conține pe prima linie rezultatul expresiei E.

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

*1 ≤ N ≤ 1017
*1000000007 este număr prim.
*Pentru 30% din teste, N ≤ 106

==Exemplu==
===Exemplu1===
:Intrare:
;sume1.in
:4
:Iesire:
;sume1.out
:Datele introduse sunt corecte!
:31

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare(N):
if N < 1 or N > 10 ** 17:
return False
return True

def rezolvare(N):
mod = 1000000007
S = 0
for i in range(N+1):
S += 2**i
E = S % mod
return E

def main():
with open("sume1.in", "r") as f:
N = int(f.readline().strip())

if not validare(N):
print("Datele introduse sunt incorecte!")
return

S = rezolvare(N)

with open("sume1.out", "w") as f:
f.write("Datele introduse sunt corecte!\n")
f.write(str(S))

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicații ==

Codul se descompune în următoarele etape:

#Se deschide fișierul "sume1.in" și se citeste valoarea lui N de pe prima linie.
#Se validează valoarea lui N: trebuie să fie un număr întreg pozitiv și mai mic sau egal cu 10^17. Dacă N nu respectă aceste condiții, se afișează mesajul "Datele introduse sunt incorecte!" și se oprește executarea programului. Altfel, se continuă executarea programului.
#Se calculează valoarea lui S, care reprezintă suma primei progresii geometrice cu raportul 2 și cu primul termen 2 la puterea N+1. Formula utilizată este (2^(N+1))-2.
#Se calculează valoarea lui E, care reprezintă suma primei progresii aritmetice cu primul termen S și cu diferența 20. Formula utilizată este S+20.
#Se deschide fișierul "sume1.out" și se scrie mesajul "Datele introduse sunt corecte!" pe prima linie, urmat de valoarea lui E pe a doua linie.
#Executia programului se termină.

2251 - Pereti

2023-05-14T21:07:31Z

Catalin Moje:

==Enunț==
Localitatea Târgovişte este în plină modernizare. Primăria decide să inventarieze toate clădirile din oraş pentru a renova faţadele acestora. În acest sens analizează harta oraşului şi constată că toţi pereţii sunt aşezaţi doar pe direcţia Nord Sud sau Est Vest. Pereţii vizibili de către turiști sunt doar aceia la care se poate ajunge din exteriorul orașului prin deplasarea pe cele două direcţii date, în oricare din cele patru sensuri (N, E, S, V). Harta oraşului este întocmită pe un caroiaj format din pătrate cu latura 1.

==Cerința==
Cunoscându-se harta oraşului, determinaţi lungimea pereţilor vizibili ce urmează a fi zugrăviţi.

==Date de intrare==
Fișierul de intrare pereti.in are pe prima linie dimensiunile m (numărul de linii), n (numărul de coloane) ale hărţii. Pe fiecare dintre următoarele m linii există n numere naturale de la 0 la 15, separate prin câte un spaţiu, cu semnificaţia: reprezentarea binară a numărului pe 4 cifre semnifică, începând de la stânga spre dreapta, existenţa unui perete spre direcţiile N, E, S, V. (1- există perete, 0 – nu există perete, explicaţii în figura de mai jos). De exemplu valoarea 13 se reprezintă în binar 1101, deci în mod corespunzător, de la stânga spre dreapta, vom avea pereţi spre N, E şi V.

==Date de ieșire==
Fișierul de ieșire pereti.out va conţine pe prima linie numărul natural k reprezentând lungimea pereților ce vor fi zugrăviți.

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

*1 ≤ m, n ≤ 100
*Pereţii aflaţi la marginea hărţii sunt pereţi vizibili.
*Datele de intrare sunt considerate corecte.

==Exemplu==
===Exemplu1===
:Intrare:
;pereti.in
;5 4
;0 6 13 1
;4 15 5 1
;0 14 7 1
;4 15 9 0
;0 12 5 7
:Iesire:
;pereti.out
;22

==Rezolvare==
<syntaxhighlight lang="python" line="1">

from collections import deque

def validate_input(m, n, harta):
if not (1 <= m <= 100 and 1 <= n <= 100):
return False
for linie in harta:
for valoare in linie:
if not (0 <= valoare <= 15):
return False
return True

def rezolvare(m, n, harta):
# lista cu directiile in care se poate merge
directii = [(0, 1), (1, 0), (0, -1), (-1, 0)]
# codurile pentru peretii dintre directiile din lista
coduri = [1, 2, 4, 8]

pereti = 0
for i in range(m):
for j in range(n):
for idx, d in enumerate(directii):
# verifica daca pozitia vecina este valida
if i + d[0] >= 0 and i + d[0] < m and j + d[1] >= 0 and j + d[1] < n:
# verifica daca peretele face parte din perimetrul exterior
if i == 0 and idx == 3 or i == m - 1 and idx == 1 or j == 0 and idx == 2 or j == n - 1 and idx == 0:
continue
# calculeaza codul peretelui dintre cele doua pozitii
p1 = harta[i][j]
p2 = harta[i + d[0]][j + d[1]]
cod = coduri[idx]
if p1 & cod == 0 and p2 & coduri[(idx + 2) % 4] == 0:
# daca cele doua pereti sunt nevopsiti, ii vopsim
pereti += 2
harta[i][j] += cod
harta[i + d[0]][j + d[1]] += coduri[(idx + 2) % 4]

# Afisare harta si variabile de debug
for linie in harta:
print(linie)
print(pereti)

# returneaza numarul de pereti vopsiti
return pereti

def main():
with open("pereti.in") as f:
m, n = map(int, f.readline().split())
harta = []
for i in range(m):
harta.append(list(map(int, f.readline().split())))
lungime = rezolvare(m, n, harta)
with open("pereti.out", "w") as f:
f.write(str(lungime) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicații ==
Funcția rezolvare primește dimensiunile labirintului m și n și o matrice harta reprezentând labirintul cu m linii și n coloane. Scopul funcției este de a determina numărul total de pereți ce trebuie vopsiți astfel încât să se poată ieși din labirint.

În primul rând, se definesc toate direcțiile posibile în care se poate mișca în labirint, reprezentate sub forma unei liste de tupluri de forma (dx, dy) cu dx și dy reprezentând deplasarea pe axa OX, respectiv OY.

În continuare, se parcurge fiecare celulă din labirint și se verifică dacă există un perete nevopsit între aceasta și fiecare celulă vecină. Pentru fiecare astfel de perete, se calculează codul acestuia și se verifică dacă peretele corespunzător din celula vecină este și el nevopsit. Dacă aceste condiții sunt îndeplinite, atunci cele două perete sunt vopsite și numărul total de pereti vopsiți este incrementat cu 2.

În final, se afișează matricea harta și numărul total de pereti vopsiți, iar apoi acesta este returnat.

În funcția main, se deschide fișierul de intrare pereti.in și se citesc dimensiunile labirintului și matricea harta. Se apelează funcția rezolvare și se obține numărul de pereti vopsiți, care este apoi scris în fișierul de ieșire pereti.out.

3487 - Dealuri

2023-05-14T21:05:50Z

Catalin Moje:

Sursa: [https://www.pbinfo.ro/probleme/3658/nrtriplete NrTriplete]
----
==Cerinţă==
Fie un șir de numere oarecare. Un subșir de numere se numește deal dacă valorile din care este alcătuit sunt în ordine crescătoare. După fiecare deal urmează o prăpastie – o valoare mai mică decât precedenta – de unde poate începe un nou deal.

Fiind data o secvență oarecare de numere ce se termină cu valoarea zero, să se afișeze valorile din care este alcătuit fiecare deal în ordine inversă apariției. Dupa ce s-a terminat primul deal în ordinea dorită, se va afișa al doilea, apoi al treilea, etc.
==Date de intrare==
Programul va citi de la tastatură mai multe valori, până la intâlnirea valorii 0.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa se vor afișa dealurie în ordine inversă celei de introducere, separate prin exact un spațiu.. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*Un deal nu are mai mult de 10.000 de elemente.
*Valorile din care sunt formate dealurile sunt numere naturale nenune mai mici decât 263.
==Exemple==
===Exemplul 1===
:Intrare
:Introduceti numerele separate prin spatiu: 1 2 5 3 7 2 4 8 123456789101112 4 0
:Ieșire
:Datele de intrare sunt valide!
:5 2 1 7 3 123456789101112 8 4 2 4

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(lst):
for i in lst:
if not i.isdigit():
print("Datele de intrare sunt invalide!")
return False
print("Datele de intrare sunt valide!")
return True

def rezolvare(lst):
deals = []
deal = []
for i in lst:
if i == 0:
break
if len(deal) == 0 or i > deal[-1]:
deal.append(i)
else:
deals.append(deal[::-1])
deal = [i]
if len(deal) > 0:
deals.append(deal[::-1])
return [num for deal in deals for num in deal]

def main():
lst = input("Introduceti numerele separate prin spatiu: ").split()
if validare(lst):
deals = rezolvare(list(map(int, lst)))
print(" ".join(str(num) for num in deals))

if __name__ == '__main__':
main()

</syntaxhighlight>
==Explicație rezolvare==

#1 Funcția de validare
Funcția validare() verifică dacă datele de intrare sunt valide, adică respectă restricțiile specificate în enunțul problemei. În cazul acestei probleme, singura restricție este ca numerele să fie naturale nenule, dar și mai mici decât 2^63, deci nu am implementat o validare complexă. Dacă datele sunt valide, se afișează mesajul "Datele de intrare sunt valide!", iar funcția returnează valoarea True. Dacă datele nu sunt valide, se afișează mesajul "Datele de intrare sunt invalide!" și funcția returnează valoarea False.

#2 Funcția de rezolvare
Funcția rezolvare() primește un șir de numere și îl parcurge, identificând dealurile și afișându-le în ordinea cerută. Pentru aceasta, am folosit un buclă while care se execută până când se întâlnește valoarea 0 (semnificând sfârșitul șirului). În interiorul buclei, am inițializat o variabilă deal cu primul număr din șir. Apoi am parcurs șirul până am găsit o prăpastie (adica un număr mai mic decât precedenta). În momentul în care am găsit prăpastia, am afișat dealul curent în ordine inversă și am inițializat o nouă variabilă deal cu numărul găsit. După ce am parcurs întregul șir, mai rămâne de afișat ultimul deal, care nu a fost afișat în bucla while, deoarece nu a fost urmat de nicio prăpastie.

#3 Funcția main
Funcția main() primește input-ul de la utilizator, îl validează folosind funcția validare(), și apoi îl prelucrează folosind funcția rezolvare(). În final, afișează soluția pe o singură linie, separată prin spații.

3487 - Dealuri

2023-05-14T21:05:27Z

Catalin Moje:

Sursa: [https://www.pbinfo.ro/probleme/3658/nrtriplete NrTriplete]
----
==Cerinţă==
Fie un șir de numere oarecare. Un subșir de numere se numește deal dacă valorile din care este alcătuit sunt în ordine crescătoare. După fiecare deal urmează o prăpastie – o valoare mai mică decât precedenta – de unde poate începe un nou deal.

Fiind data o secvență oarecare de numere ce se termină cu valoarea zero, să se afișeze valorile din care este alcătuit fiecare deal în ordine inversă apariției. Dupa ce s-a terminat primul deal în ordinea dorită, se va afișa al doilea, apoi al treilea, etc.
==Date de intrare==
Programul va citi de la tastatură mai multe valori, până la intâlnirea valorii 0.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt corecte!", apoi se va afișa se vor afișa dealurie în ordine inversă celei de introducere, separate prin exact un spațiu.. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt corecte!".
==Restricţii şi precizări==
*Un deal nu are mai mult de 10.000 de elemente.
*Valorile din care sunt formate dealurile sunt numere naturale nenune mai mici decât 263.
==Exemple==
===Exemplul 1===
:Intrare
:Introduceti numerele separate prin spatiu: 1 2 5 3 7 2 4 8 123456789101112 4 0
:Ieșire
:Datele de intrare sunt valide!
:5 2 1 7 3 123456789101112 8 4 2 4

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare(lst):
for i in lst:
if not i.isdigit():
print("Datele de intrare sunt invalide!")
return False
print("Datele de intrare sunt valide!")
return True

def rezolvare(lst):
deals = []
deal = []
for i in lst:
if i == 0:
break
if len(deal) == 0 or i > deal[-1]:
deal.append(i)
else:
deals.append(deal[::-1])
deal = [i]
if len(deal) > 0:
deals.append(deal[::-1])
return [num for deal in deals for num in deal]

def main():
lst = input("Introduceti numerele separate prin spatiu: ").split()
if validare(lst):
deals = rezolvare(list(map(int, lst)))
print(" ".join(str(num) for num in deals))

if __name__ == '__main__':
main()

</syntaxhighlight>
==Explicație rezolvare==

#Funcția de validare
Funcția validare() verifică dacă datele de intrare sunt valide, adică respectă restricțiile specificate în enunțul problemei. În cazul acestei probleme, singura restricție este ca numerele să fie naturale nenule, dar și mai mici decât 2^63, deci nu am implementat o validare complexă. Dacă datele sunt valide, se afișează mesajul "Datele de intrare sunt valide!", iar funcția returnează valoarea True. Dacă datele nu sunt valide, se afișează mesajul "Datele de intrare sunt invalide!" și funcția returnează valoarea False.

#Funcția de rezolvare
Funcția rezolvare() primește un șir de numere și îl parcurge, identificând dealurile și afișându-le în ordinea cerută. Pentru aceasta, am folosit un buclă while care se execută până când se întâlnește valoarea 0 (semnificând sfârșitul șirului). În interiorul buclei, am inițializat o variabilă deal cu primul număr din șir. Apoi am parcurs șirul până am găsit o prăpastie (adica un număr mai mic decât precedenta). În momentul în care am găsit prăpastia, am afișat dealul curent în ordine inversă și am inițializat o nouă variabilă deal cu numărul găsit. După ce am parcurs întregul șir, mai rămâne de afișat ultimul deal, care nu a fost afișat în bucla while, deoarece nu a fost urmat de nicio prăpastie.

#Funcția main
Funcția main() primește input-ul de la utilizator, îl validează folosind funcția validare(), și apoi îl prelucrează folosind funcția rezolvare(). În final, afișează soluția pe o singură linie, separată prin spații.

0841 - Bomber

2023-05-14T21:04:40Z

Catalin Moje:

==Cerința==
Se consideră un poligon militar, pe care este stabilit un sistem de axe de coordonate xOy. Se dau n bombe, numerotate de la 1 la n, pentru fiecare cunoscându-se coordonatele x y și puterea de distrugere p. La explozia unei bombe de putere p se va distruge totul în interiorul și pe cercul de centru x y și rază p, iar dacă există alte bombe în această zonă, vor exploda la rândul lor.

Dându-se numărul de ordine I al unei bombe care explodează, să se determine câte bombe rămân intacte la finalul șirului de explozii declanșate.

==Date de intrare==
ișierul de intrare bomber.in conține pe prima linie numerele n I, fiecare dintre următoarele n linii conține câte trei numere x y p, cu semnificația din enunț.

==Date de ieșire==
Fișierul de ieșire bomber.out va conține pe prima linie numărul C, reprezentând numărul de bombe rămase neexplodate.

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

*1 ≤ n ≤ 100
*1 ≤ I ≤ n
*coordonatele x y sunt numere întregi, iar puterile p sunt numere naturale
*-200 ≤ x , y ≤ 200
* 1 ≤ p ≤ 30

==Exemplu==
===Exemplu1===
:Intrare:
;bomber.in
;9 5
;0 3 2
;-1 1 3
;1 4 1
;3 4 4
;-1 -2 3
;3 1 3
;0 -4 2
;3 -2 5
;4 -1 2

;bomber.out
;4

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare(n, i, bombe):
# Verifica daca valorile de intrare sunt valide
if not 1 <= n <= 100:
return False
if not 1 <= i <= n:
return False
for x, y, p in bombe:
if not -200 <= x <= 200 or not -200 <= y <= 200:
return False
if not 1 <= p <= 30:
return False
return True

def rezolvare(n, i, bombe):
# Initializeaza lista de bombe explodate cu bomba i
explodate = [i]
while True:
# Gaseste bombele care trebuie sa explodeze in runda curenta
de_explodat = []
for j, (x, y, p) in enumerate(bombe, start=1):
if j not in explodate and any((x-x0)**2 + (y-y0)**2 <= p0**2 for x0, y0, p0 in (bombe[k-1] for k in explodate)):
de_explodat.append(j)
# Iesirea din bucla while daca nu mai exista bombe de explodat
if not de_explodat:
break
# Adauga bombele care trebuie sa explodeze la lista de bombe explodate
explodate += de_explodat
# Returneaza numarul de bombe neexplodate
return n - len(explodate)

def main():
# Citeste valorile de intrare din fisierul bomber.in
with open('bomber.in') as f:
n, i = map(int, f.readline().split())
bombe = [tuple(map(int, line.split())) for line in f]

# Valideaza datele de intrare
if not validare(n, i, bombe):
print('Date de intrare invalide')
return

# Rezolva problema si afiseaza rezultatul in fisierul bomber.out
with open('bomber.out', 'w') as f:
f.write(str(rezolvare(n, i, bombe)) + '\n')

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicații ==
În primul rând, codul nostru are nevoie de 3 funcții: validare(), rezolvare() și main(). În funcția validare() se va verifica dacă datele de intrare sunt valide, adică respectă constrângerile problemei. În funcția rezolvare() se va realiza logica necesară pentru a determina numărul de bombe care rămân neexplodate la final. În funcția main() se va apela cele două funcții de mai sus, precum și citirea datelor de intrare și scrierea rezultatului în fișierul de ieșire.

Pasul 1: Validarea datelor de intrare
În funcția validare() se va citi numărul total de bombe, n, și numărul bombei care va exploda prima, i. Dacă datele de intrare nu sunt valide, se va afișa un mesaj corespunzător și se va opri programul. În caz contrar, se va returna True.

Pasul 2: Rezolvarea problemei
În funcția rezolvare() se vor citi coordonatele și puterile de distrugere ale tuturor bombelor, apoi se va construi o listă bombs cu informațiile despre fiecare bombă. Fiecare element din listă va fi o pereche de forma (x, y, p, alive), unde x și y sunt coordonatele bombelor, p este puterea de distrugere a bombei, iar alive este o variabilă booleană care indică dacă bomba este încă în viață sau a fost deja distrusă de o altă bombă.

Apoi se va parcurge lista de bombe și se va verifica dacă fiecare bombă este în raza de acțiune a bombei i care a fost declanșată prima. Dacă da, se va seta variabila alive a respectivei bombe pe False, pentru a indica că aceasta a fost distrusă. Apoi se va parcurge din nou lista de bombe și se va verifica dacă o bombă distrusă poate afecta și alte bombe care se află în raza sa de acțiune. Acest proces se va repeta până când nu mai există nicio bombă care să fi fost distrusă într-o iterație.

La final, se va returna numărul de bombe rămase în viață.

Pasul 3: Citirea datelor de intrare și scrierea rezultatului
În funcția main() se va apela funcția validare() pentru a verifica datele de intrare, apoi se va citi numărul total de bombe, n, și numărul bombei care va exploda prima, i. Apoi se vor citi coordonatele și puterile de distrugere ale tuturor bombelor. După aceea se va apela funcția rezolvare() pentru a determina numărul de bombe rămase în viață, iar rezultatul va fi scris în fișier

1576 - zona3

2023-05-14T21:02:59Z

Catalin Moje:

==Cerința==
Se consideră o matrice cu n linii și m coloane. Spunem că o poziție este liberă dacă elementul de pe linia i și coloana j este egal cu 0 și 1 în caz contrar. Spunem despre mai multe elemente ocupate că formează o zonă, dacă elementele se învecinează pe cele patru direcții (sus, jos, dreapta, stânga).

Calculați pentru fiecare zonă numărul de elemente și afișați noua matrice formată prin înlocuirea elementelor egale cu 1 cu numărul de elemente pe care îl are zona din care face parte elementul respectiv.

==Date de intrare==
e pe prima linie a fișierului zona3.in se citesc două numere naturale n și m. Următoarele n linii conțin câte m valori 0 sau 1.

==Date de ieșire==
Scrieți în fișierul zona3.out matricea care rezultă din operațiile specificate în cerință.

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

*2 ≤ n, m ≤ 100

==Exemplu==
===Exemplu1===
:Intrare:
;zona3.in
;6 8
;1 1 0 0 1 1 1 0
;0 0 0 1 1 1 0 0
;1 1 0 0 0 1 0 0
;0 0 0 0 1 1 0 0
;1 1 0 1 0 0 0 1
:Iesire:
;zona3.out
;2 2 0 0 7 7 7 0
;0 0 0 7 7 7 0 0
;8 8 0 0 0 7 0 0
;0 8 8 8 8 0 0 0
;0 0 0 0 8 8 0 0
;2 2 0 1 0 0 0 1

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare(n, m, matrice):
# validarea datelor de intrare
if not (2 <= n <= 100 and 2 <= m <= 100):
raise ValueError("Dimensiunile matricei trebuie sa fie cuprinse intre 2 si 100")
if not all(len(linie) == m for linie in matrice):
raise ValueError("Toate liniile matricei trebuie sa aiba aceeasi lungime")
for linie in matrice:
for element in linie:
if element not in (0, 1):
raise ValueError("Matricea trebuie sa contina doar elemente 0 sau 1")

def rezolvare(n, m, matrice):
# implementarea cerintei
def calculeaza_zona(i, j):
# calculeaza dimensiunea zonei din care face parte elementul de pe pozitia (i, j)
if matrice[i][j] != 1:
return 0
zona = 0
stack = [(i, j)]
while stack:
x, y = stack.pop()
if matrice[x][y] == 1:
zona += 1
matrice[x][y] = -1
if x > 0 and matrice[x - 1][y] == 1:
stack.append((x - 1, y))
if x < n - 1 and matrice[x + 1][y] == 1:
stack.append((x + 1, y))
if y > 0 and matrice[x][y - 1] == 1:
stack.append((x, y - 1))
if y < m - 1 and matrice[x][y + 1] == 1:
stack.append((x, y + 1))
return zona

# calculeaza dimensiunea fiecarei zone si inlocuieste valorile cu numarul de elemente din zona
for i in range(n):
for j in range(m):
if matrice[i][j] == 1:
zona = calculeaza_zona(i, j)
for x in range(n):
for y in range(m):
if matrice[x][y] == -1:
matrice[x][y] = zona
matrice[i][j] = zona

return matrice

def main():
# citim datele de intrare
with open("zona3.in", "r") as f:
n, m = map(int, f.readline().split())
matrice = [list(map(int, f.readline().split())) for _ in range(n)]

# validam datele de intrare
validare(n, m, matrice)

# rezolvam problema
rezultat = rezolvare(n, m, matrice)

# afisam rezultatul in fisierul de iesire
with open("zona3.out", "w") as f:
for linie in rezultat:
f.write(" ".join(str(x) for x in linie))
f.write("\n")

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicații ==
Codul citeste datele din fisierul "zona3.in", care contine o matrice de 0 si 1 de dimensiune n x m. Scopul este de a gasi toate zonele formate din 1 si de a inlocui fiecare element 1 cu numarul de elemente din zona din care face parte.

#1 In functia validare se verifica daca datele de intrare sunt in limitele impuse de cerinta: n si m sunt intre 2 si 100. Daca aceasta conditie nu este indeplinita, functia arunca o exceptie cu mesajul corespunzator.

#2 Functia rezolvare are doua obiective principale: sa gaseasca zonele formate din 1 si sa inlocuiasca fiecare element 1 cu numarul de elemente din zona din care face parte. Acest lucru se realizeaza prin parcurgerea matricei si identificarea tuturor elementelor care sunt egale cu 1. Dupa aceea, se calculeaza numarul de elemente din zona din care face parte fiecare element 1 si se inlocuieste valoarea cu aceasta. Pentru a gasi numarul de elemente dintr-o zona, se foloseste o functie auxiliara gaseste_zona, care cauta toate elementele vecine ale unui element 1 si le adauga intr-o zona. Procesul continua pana cand nu mai exista niciun element vecin de adaugat.

#3 Functia main citeste datele de intrare, verifica daca sunt valide, aplica functia rezolvare si afiseaza matricea rezultata in fisierul "zona3.out".

1369 - Parcela

2023-05-14T21:01:20Z

Catalin Moje:

==Cerința==
Cerința
Se dau n și m reprezentând dimensiunile unui tablou bidimensional format din elementele 0 si 1. Se definește o parcelă ca fiind o grupare de elemente vecine cu valoarea 1, condiția de vecinătate dintre două elemente fiind ca, luat unul dintre ele ca referință, celălalt să fie deasupra, dedesupt, în stânga sau în dreapta acestuia. Parcele se numerotează parcurgând matricea de sus în jos și de la stânga la dreapta, astfel:

primul element din matrice egal cu 1 face parte din parcela numărul 1
primul element din matrice care este egal cu 1 și nu face face parte din parcela 1 face parte din parcela 2;
primul element din matrice care este egal cu 1 și nu face face parte din parcelele 1 și 2 face parte din parcela 3;
etc.
Să se determine numărul de parcele nr, aria maximă a unei parcele amax și respectiv numărul parcelei cu arie maximă pmax.

==Date de intrare==
Fișierul de intrare parcela.in conține pe prima linie numerele n și m, iar pe a doua linie un tablou bidimensional cu n×m elemente.

==Date de ieșire==
Fișierul de ieșire parcela.out va conține pe prima linie numerele nr amax pmax cu semnificațiile din enunț, separate prin câte un spațiu.

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

*1 ≤ n,m ≤ 100

==Exemplu==
===Exemplu1===
:Intrare:
;parcela.in
;5 6
;0 1 1 1 0 1
;0 0 1 0 0 1
;0 1 0 0 0 1
;0 0 0 0 1 1
;1 1 1 0 0 1
:Iesire:
;parcela.out
;4 6 2

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare(n: int, m: int, matrice: list[list[int]]) -> bool:
if n < 1 or m < 1 or n > 100 or m > 100:
return False
if len(matrice) != n:
return False
for linie in matrice:
if len(linie) != m:
return False
for element in linie:
if element != 0 and element != 1:
return False
return True

def rezolvare(n: int, m: int, matrice: list[list[int]]) -> tuple[int, int, int]:
nr_parcele = 0
max_aria = 0
parcela_max_aria = 0
parcurs = [[False for _ in range(m)] for _ in range(n)]

def parcurgere(linie: int, coloana: int, numar_parcela: int):
if linie < 0 or coloana < 0 or linie >= n or coloana >= m:
return
if matrice[linie][coloana] == 0 or parcurs[linie][coloana]:
return
nonlocal nr_parcele
nonlocal max_aria
nonlocal parcela_max_aria
nr_parcele += 1
aria = 0
coada = [(linie, coloana)]
while coada:
x, y = coada.pop(0)
if x < 0 or y < 0 or x >= n or y >= m:
continue
if matrice[x][y] == 0 or parcurs[x][y]:
continue
parcurs[x][y] = True
aria += 1
if aria > max_aria:
max_aria = aria
parcela_max_aria = numar_parcela
coada.append((x - 1, y))
coada.append((x + 1, y))
coada.append((x, y - 1))
coada.append((x, y + 1))

for i in range(n):
for j in range(m):
if matrice[i][j] == 1 and not parcurs[i][j]:
parcurgere(i, j, nr_parcele + 1)

return nr_parcele, max_aria, parcela_max_aria

if __name__ == '__main__':
with open('parcela.in', 'r') as f:
n, m = map(int, f.readline().split())
matrice = [list(map(int, f.readline().split())) for _ in range(n)]

if not validare(n, m, matrice):
with open('parcela.out', 'w') as f:
f.write("Date de intrare invalide.")
else:
nr_parcele, max_aria, parcela_max_aria = rezolvare(n, m, matrice)
with open('parcela.out', 'w') as f:
f.write(f"{nr_parcele} {max_aria} {parcela_max_aria}")

</syntaxhighlight>

==Explicații ==
Acest cod rezolvă problema numită "Parcela", în care trebuie să determinăm numărul de parcele de teren și aria maxima a unei parcele dintr-o matrice 2D cu valori de 0 și 1. Mai precis, programul citeste datele de intrare din fișierul "parcela.in", validează datele, determină numărul de parcele, aria maximă și numărul parcelei cu aria maximă, și afișează aceste valori în fișierul "parcela.out".

#1 Funcția validare primește 3 argumente: n - numărul de linii al matricei, m - numărul de coloane al matricei, și matrice - matricea propriu-zisă. Această funcție validează datele de intrare, verificând dacă dimensiunile matricei sunt valide și dacă toate valorile matricei sunt 0 sau 1.

#2 Funcția rezolvare primește aceeași 3 argumente ca și funcția validare, și calculează numărul de parcele, aria maximă și numărul parcelei cu aria maximă. Pentru a face acest lucru, funcția folosește o metodă de parcurgere a matricei, care verifică fiecare celulă din matrice și verifică dacă aceasta face parte dintr-o parcelă sau nu. Pentru fiecare parcelă găsită, funcția calculează aria acesteia, și ține evidența parcelei cu aria maximă.

#3 În funcția main, programul citeste datele de intrare din fișierul "parcela.in", validează datele folosind funcția validare, și, dacă datele sunt valide, calculează valorile dorite folosind funcția rezolvare. Dupa ce valorile sunt calculate, acestea sunt afișate în fișierul "parcela.out".

1507 - grupuri

2023-05-14T20:59:52Z

Catalin Moje:

==Cerința==
Scrieţi un program care citeşte din fişierul de intrare un număr natural n şi o matrice pătratică A de dimensiune n x n, elementele acesteia putând avea doar valorile 0 sau 1. Două elemente A[i1][j1] şi A[i2][j2] sunt adiacente dacă sunt “vecine” pe o aceeaşi linie sau coloană: (i1 = i2 şi |j1-j2|=1) sau (j1=j2 şi |i1-i2|=1). Un grup reprezintă fie un singur element al matricii având valoarea 1, neadiacent cu niciun alt element cu valoarea 1, fie o mulţime de elemente având valoarea 1, fiecare dintre ele fiind adiacent cu cel puţin un alt element din mulţimea respectivă şi neadiacent cu niciun alt element din alt grup. Programul afişează în fişierul de ieşire numărul de grupuri conţinute de matrice.

==Date de intrare==
Fișierul de intrare grupuri.in conține pe prima linie numărul n, iar pe următoarele n linii câte n numere naturale 0 sau 1, reprezentând elementele matricei A.

==Date de ieșire==
Fișierul de ieșire grupuri.out va conține pe prima linie numărul de grupuri prezente în matricea din fişierul de intrare.
==Restricții și precizări==

*2 ≤ n ≤ 100

==Exemplu==
===Exemplu1===
:Intrare:
;grupuri.in
;4
;1 0 0 1
;0 0 1 1
;0 1 0 1
;1 1 0 0
:Iesire:
;grupuri.out
;3

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare(n: int, a: list[list[int]]) -> bool:
# Verificăm dacă matricea are dimensiunea n x n
if len(a) != n:
return False
for i in range(n):
# Verificăm dacă fiecare linie are dimensiunea n și dacă fiecare element are valoarea 0 sau 1
if len(a[i]) != n or any(val != 0 and val != 1 for val in a[i]):
return False
return True

def dfs(a: list[list[int]], i: int, j: int, visited: set[tuple[int, int]]) -> None:
# Adăugăm elementul (i, j) la grup și îl marcam ca vizitat
visited.add((i, j))
# Căutăm toate elementele cu valoarea 1 adiacente cu elementul (i, j) și le adăugăm la grup
for di, dj in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
ni, nj = i + di, j + dj
if 0 <= ni < len(a) and 0 <= nj < len(a) and a[ni][nj] == 1 and (ni, nj) not in visited:
dfs(a, ni, nj, visited)

def rezolvare(n: int, a: list[list[int]]) -> int:
groups = 0
visited = set()
for i in range(n):
for j in range(n):
if a[i][j] == 1 and (i, j) not in visited:
# Am găsit un nou grup de elemente cu valoarea 1
dfs(a, i, j, visited)
groups += 1
return groups

def main() -> None:
with open("grupuri.in", "r") as fin, open("grupuri.out", "w") as fout:
n = int(fin.readline())
a = [list(map(int, fin.readline().split())) for _ in range(n)]
if not validare(n, a):
fout.write("Matricea de intrare nu este valida\n")
return
fout.write(str(rezolvare(n, a)) + "\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicații ==
#1 Funcția validare verifică dacă matricea dată este validă, adică dacă are dimensiunea n x n și dacă toate elementele sale sunt 0 sau 1. Funcția returnează True dacă matricea este validă și False în caz contrar.

#2 Funcția dfs implementează o căutare în adâncime (DFS) pentru a identifica toate elementele din același grup cu elementul (i, j). Funcția primește matricea dată a, poziția inițială a elementului (i, j), și un set de tupluri visited care conține toate pozițiile marcate ca vizitate în timpul căutării. Funcția parcurge toate elementele adiacente cu (i, j) care au valoarea 1 și le adaugă la grup și le marchează ca vizitate, apoi apelează recursiv dfs pe fiecare element adiacent, pentru a adăuga toate elementele din același grup.

#3Funcția principală rezolvare implementează algoritmul de rezolvare a problemei, care primește matricea dată și returnează numărul de grupuri de elemente cu valoarea 1 din matrice. Algoritmul utilizează o metodă greedy pentru a căuta fiecare grup de elemente cu valoarea 1. Algoritmul parcurge fiecare element din matrice și, dacă găsește un element cu valoarea 1 care nu a fost deja adăugat la un grup, apelează funcția dfs pentru a identifica toate elementele din același grup cu elementul respectiv.

#4 Funcția main citeste datele din fișierul grupuri.in, apelează funcția validare pentru a verifica dacă matricea de intrare este validă, apoi apelează funcția rezolvare pentru a număra grupurile de elemente cu valoarea 1. Dacă matricea nu este validă, scrie un mesaj de eroare în fișierul de ieșire grupuri.out, în caz contrar scrie numărul de grupuri de elemente cu valoarea 1 în fișierul grupuri.out.

#5 În ultima linie, __name__ =="main" verifică dacă fișierul curent este fișierul principal, apoi apelează funcția main dacă acesta este cazul.

1507 - grupuri

2023-05-14T20:59:11Z

Catalin Moje:

==Cerința==
Scrieţi un program care citeşte din fişierul de intrare un număr natural n şi o matrice pătratică A de dimensiune n x n, elementele acesteia putând avea doar valorile 0 sau 1. Două elemente A[i1][j1] şi A[i2][j2] sunt adiacente dacă sunt “vecine” pe o aceeaşi linie sau coloană: (i1 = i2 şi |j1-j2|=1) sau (j1=j2 şi |i1-i2|=1). Un grup reprezintă fie un singur element al matricii având valoarea 1, neadiacent cu niciun alt element cu valoarea 1, fie o mulţime de elemente având valoarea 1, fiecare dintre ele fiind adiacent cu cel puţin un alt element din mulţimea respectivă şi neadiacent cu niciun alt element din alt grup. Programul afişează în fişierul de ieşire numărul de grupuri conţinute de matrice.

==Date de intrare==
Fișierul de intrare grupuri.in conține pe prima linie numărul n, iar pe următoarele n linii câte n numere naturale 0 sau 1, reprezentând elementele matricei A.

==Date de ieșire==
Fișierul de ieșire grupuri.out va conține pe prima linie numărul de grupuri prezente în matricea din fişierul de intrare.
==Restricții și precizări==

*2 ≤ n ≤ 100

==Exemplu==
===Exemplu1===
:Intrare:
;grupuri.in
;4
;1 0 0 1
;0 0 1 1
;0 1 0 1
;1 1 0 0
:Iesire:
;grupuri.out
;3

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare(n: int, a: list[list[int]]) -> bool:
# Verificăm dacă matricea are dimensiunea n x n
if len(a) != n:
return False
for i in range(n):
# Verificăm dacă fiecare linie are dimensiunea n și dacă fiecare element are valoarea 0 sau 1
if len(a[i]) != n or any(val != 0 and val != 1 for val in a[i]):
return False
return True

def dfs(a: list[list[int]], i: int, j: int, visited: set[tuple[int, int]]) -> None:
# Adăugăm elementul (i, j) la grup și îl marcam ca vizitat
visited.add((i, j))
# Căutăm toate elementele cu valoarea 1 adiacente cu elementul (i, j) și le adăugăm la grup
for di, dj in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
ni, nj = i + di, j + dj
if 0 <= ni < len(a) and 0 <= nj < len(a) and a[ni][nj] == 1 and (ni, nj) not in visited:
dfs(a, ni, nj, visited)

def rezolvare(n: int, a: list[list[int]]) -> int:
groups = 0
visited = set()
for i in range(n):
for j in range(n):
if a[i][j] == 1 and (i, j) not in visited:
# Am găsit un nou grup de elemente cu valoarea 1
dfs(a, i, j, visited)
groups += 1
return groups

def main() -> None:
with open("grupuri.in", "r") as fin, open("grupuri.out", "w") as fout:
n = int(fin.readline())
a = [list(map(int, fin.readline().split())) for _ in range(n)]
if not validare(n, a):
fout.write("Matricea de intrare nu este valida\n")
return
fout.write(str(rezolvare(n, a)) + "\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicații ==
#1 Funcția validare verifică dacă matricea dată este validă, adică dacă are dimensiunea n x n și dacă toate elementele sale sunt 0 sau 1. Funcția returnează True dacă matricea este validă și False în caz contrar.

#2 Funcția dfs implementează o căutare în adâncime (DFS) pentru a identifica toate elementele din același grup cu elementul (i, j). Funcția primește matricea dată a, poziția inițială a elementului (i, j), și un set de tupluri visited care conține toate pozițiile marcate ca vizitate în timpul căutării. Funcția parcurge toate elementele adiacente cu (i, j) care au valoarea 1 și le adaugă la grup și le marchează ca vizitate, apoi apelează recursiv dfs pe fiecare element adiacent, pentru a adăuga toate elementele din același grup.

Funcția principală rezolvare implementează algoritmul de rezolvare a problemei, care primește matricea dată și returnează numărul de grupuri de elemente cu valoarea 1 din matrice. Algoritmul utilizează o metodă greedy pentru a căuta fiecare grup de elemente cu valoarea 1. Algoritmul parcurge fiecare element din matrice și, dacă găsește un element cu valoarea 1 care nu a fost deja adăugat la un grup, apelează funcția dfs pentru a identifica toate elementele din același grup cu elementul respectiv.

#3 Funcția main citeste datele din fișierul grupuri.in, apelează funcția validare pentru a verifica dacă matricea de intrare este validă, apoi apelează funcția rezolvare pentru a număra grupurile de elemente cu valoarea 1. Dacă matricea nu este validă, scrie un mesaj de eroare în fișierul de ieșire grupuri.out, în caz contrar scrie numărul de grupuri de elemente cu valoarea 1 în fișierul grupuri.out.

#4 În ultima linie, __name__ =="main" verifică dacă fișierul curent este fișierul principal, apoi apelează funcția main dacă acesta este cazul.

0844 - Croco1

2023-05-14T20:57:08Z

Catalin Moje:

==Cerința==
Se dă o matrice cu n linii și m coloane și elemente 0 sau 1, care reprezintă harta unui lac, în care 0 înseamnă uscat, iar 1 înseamnă apă.

Se dorește plasarea pe fiecare zonă cu uscat a unui crocodil sau a unui elefant astfel încât să nu fie două animale din aceeași specie în zone învecinate. În plus, se dorește ca numărul de crocodil să fie cât mai mare.

Să se determine câți crocodili și câți elefanți se pot plasa pe lac, astfel încât numărul de crocodili să fie cât mai mare.

==Date de intrare==
ișierul de intrare croco1.in conține pe prima linie numerele n m. Următoarele n linii conțin câte m elemente, 0 sau 1, cu semnificația din enunț.

==Date de ieșire==
Fișierul de ieșire croco1.out va conține pe prima linie numerele C E, reprezentând numărul de crocodili, respectiv numărul de elefanți care pot fi plasați în condițiile precizate, astfel încât numărul de crocodili să fie cât mai mare.

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

*≤ n , m ≤ 100

==Exemplu==
===Exemplu1===
:Intrare:
;croco1.in
;3 5
;0 0 0 1 0
;0 0 1 0 0
;1 0 0 1 0
:Iesire:
;croco1.out
;7 4

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def valideaza_matrice(matrice):
for linie in matrice:
if len(linie) != len(matrice[0]):
return False
for element in linie:
if element != 0 and element != 1:
return False
return True

def rezolva_crocodili(matrice):
nr_crocodili = 0
nr_elefanti = 0
directii = [(0, -1), (-1, 0), (0, 1), (1, 0)]
for i in range(len(matrice)):
for j in range(len(matrice[0])):
if matrice[i][j] == 0:
poate_fi_croc = True
for dx, dy in directii:
x, y = i + dx, j + dy
if 0 <= x < len(matrice) and 0 <= y < len(matrice[0]):
if matrice[x][y] == 2:
poate_fi_croc = False
break
if poate_fi_croc:
matrice[i][j] = 2
nr_crocodili += 1
nr_elefanti = sum(linie.count(0) for linie in matrice)
return nr_crocodili, nr_elefanti

def main():
with open("croco1.in") as f:
n, m = map(int, f.readline().split())
matrice = [list(map(int, f.readline().split())) for _ in range(n)]
if not valideaza_matrice(matrice):
print("Matricea data nu este valida.")
return
nr_crocodili, nr_elefanti = rezolva_crocodili(matrice)
with open("croco1.out", "w") as f:
f.write(f"{nr_crocodili} {nr_elefanti}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicații ==
#1 Funcția validare() verifică dacă matricea dată este validă conform cerințelor problemei și returnează False dacă matricea nu respectă restricțiile sau conține elemente care nu sunt 0 sau 1.
#2 Funcția rezolva_crocodili() implementează algoritmul greedy pentru a plasa crocodili în zonele de uscat ale matricei. Algoritmul începe parcurgerea matricei de la stânga sus și verifică dacă fiecare element este 0 (adica este uscat). Dacă este, atunci verifică dacă elementul poate fi ocupat de un crocodil. Un element poate fi ocupat de un crocodil dacă toate elementele vecine imediate ale sale (în sus, jos, stânga și dreapta) nu sunt ocupate de crocodili. Dacă elementul poate fi ocupat de un crocodil, atunci se marchează elementul ca fiind ocupat de un crocodil și se crește numărul de crocodili cu 1. După ce s-au plasat toți crocodilii, numărul de elefanți se poate determina prin numărarea elementelor rămase neocupate din matrice.

#3 Funcția main() deschide fișierul de intrare, citește dimensiunile matricei și matricea însăși, validează matricea cu ajutorul funcției validare(), rezolvă problema cu ajutorul funcției rezolva_crocodili(), și scrie rezultatele în fișierul de ieșire.

0840 - Croco

2023-05-14T20:54:36Z

Catalin Moje:

==Cerința==
Se dă o matrice cu n linii și m coloane și elemente 0 sau 1, care reprezintă harta unui lac, în care 1 înseamnă uscat, iar 0 înseamnă apă.

Să se plaseze pe fiecare zonă cu uscat un crocodil sau un elefant astfel încât să nu fie două animale din aceeași specie în zone învecinate.

==Date de intrare==
Fișierul de intrare croco.in conține pe prima linie numerele n m. Următoarele n linii conțin câte m elemente, 0 sau 1, cu semnificația din enunț.

==Date de ieșire==
Fișierul de ieșire croco.out va conține n linii, fiecare cu câte m caractere din mulțimea {A, C, E}, separate prin câte un spațiu, după cum în zona corespunzătoare a lacului este apa, crocodil sau elefant.

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

*1 ≤ n , m ≤ 100
*se acceptă orice soluție corectă

==Exemplu==
===Exemplu1===
:Intrare:
;croco.in
;3 5
;1 1 1 0 1
;1 1 0 1 1
;0 1 1 0 1
:Iesire:
;croco.out
;C E C A C
;E C A C E
;A E C A C

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def valideaza_intrare(n, m, matrice):
if not (1 <= n <= 100 and 1 <= m <= 100):
return False
for i in range(n):
if len(matrice[i]) != m:
return False
for j in range(m):
if matrice[i][j] not in ['0', '1']:
return False
return True

def rezolva(n, m, matrice):
animale = ['C', 'E']
animal_curent = 0
rezultat = [['' for _ in range(m)] for _ in range(n)]

for i in range(n):
for j in range(m):
if matrice[i][j] == '0':
rezultat[i][j] = 'A'
else:
for animal in animale:
if (i > 0 and rezultat[i-1][j] == animal) or \
(j > 0 and rezultat[i][j-1] == animal) or \
(i < n-1 and rezultat[i+1][j] == animal) or \
(j < m-1 and rezultat[i][j+1] == animal):
continue
else:
rezultat[i][j] = animal
break
else:
animal_curent = (animal_curent + 1) % 2
rezultat[i][j] = animale[animal_curent]

return rezultat

def afiseaza_rezultat(rezultat):
with open('croco.out', 'w') as f:
for row in rezultat:
f.write(' '.join(row) + '\n')

if __name__ == '__main__':
with open('croco.in', 'r') as f:
n, m = map(int, f.readline().strip().split())
matrice = [list(f.readline().strip().split()) for _ in range(n)]

if not valideaza_intrare(n, m, matrice):
print('Date invalide!')
else:
rezultat = rezolva(n, m, matrice)
afiseaza_rezultat(rezultat)

</syntaxhighlight>

==Explicații ==
În prima parte a codului, avem funcția validate_input(n, m, matrix) care primește dimensiunile matricei și matricea însăși și verifică dacă intrările sunt valide. Această funcție verifică dacă n și m sunt între 1 și 100, iar matricea este o matrice binară de dimensiune n x m. Dacă intrările sunt invalide, funcția returnează False, altfel returnează True.

#1 În funcția solve(n, m, matrix), începem prin a defini lista animals care conține animalele pe care le putem atribui unei celule: C și E. Variabila current_animal este folosită pentru a urmări ultima animală atribuită și pentru a alterna între cele două animale. Lista rezultat result este inițializată cu caracterele goale.

#2 Următorul pas este de a parcurge matricea, de la stânga la dreapta și de sus în jos. Dacă întâlnim o celulă cu valoarea 0, atribuim caracterul A în acea celulă. În caz contrar, verificăm celulele din jurul acelei celule pentru a vedea dacă am mai atribuit deja același animal. Dacă am făcut-o, trecem la următoarea celulă. Dacă nu, alegem animalul opus ultimului animal atribuit și îl atribuim acelei celule. Acest lucru se face pentru a asigura faptul că animalele sunt atribuite alternativ.

Dacă nu se poate atribui nici unul dintre cele două animale, schimbăm animalul și încercăm din nou. Dacă după schimbarea animalului nu putem atribui niciunul dintre cele două animale, înseamnă că am epuizat ambele opțiuni și atribuim celula cu caracterul A.

#3 În final, funcția solve() returnează matricea rezultat result.

#4 Funcția print_result(result) primește matricea rezultat și o afișează pe ecran într-un format ușor de citit, unde fiecare linie a matricei este afișată pe o linie separată, iar fiecare element dintr-o linie este separat prin un singur spațiu.

#5 În blocul if __name__ == '__main__':, citim datele de intrare din fișierul "croco.in" și le verificăm folosind funcția validate_input(). Dacă datele sunt valide, apelăm funcția solve() pentru a obține matricea rezultat și apoi afișăm matricea rezultat folosind funcția print_result(). În loc să afișăm matricea pe ecran, o scriem în fișierul "croco.out".

0838 - Iesire

2023-05-14T20:52:07Z

Catalin Moje:

==Cerința==
Se dă planul unei clădiri pătrate formate din n*n camere, sub forma unei matrice cu n linii și n coloane și elemente 0 sau 1. Camerele marcate cu 0 sunt libere, cel marcate cu 1 sunt inaccesibile și fiecare cameră are o pereche de coordonate, de forma I J, reprezentând linia și coloană pe care este situată camera. Dintr-o cameră liberă se poate trece în altă cameră liberă, cu condiția să se învecineze pe linie sau pe coloană.

Administratorul clădirii primește o listă cu coordonatele a m camere pentru care s-au găsit potențiali chiriași. Nu pot fi închiriate decât camerele libere și accesibile din exteriorul clădirii – adică să existe o succesiune de camere învecinate care începe pe o latură a clădirii și se încheie la camera respectivă.

Pentru fiecare dintre camerele din listă, verificați dacă poate fi închiriată sau nu.
==Date de intrare==
Fișierul de intrare iesire.in conține pe prima linie numerele n m. Următoarele n linii conțin câte n elemente, 0 sau 1, cu semnificația din enunț. Următoarele m linii conțin câte două numere X Y, reprezentând coordonatele unei camere din listă.

==Date de ieșire==
Fișierul de ieșire iesire.out va conține m linii; fiecare dintre ele va conține mesajul da, dacă camera corespunzătoare din listă poate fi închiriată, respectiv nu în caz contrar.

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

*1 ≤ n ≤ 100
*1 ≤ m ≤ 10
*1 ≤ x,y ≤ n

==Exemplu==
===Exemplu1===
:Intrare:
;alpinisti.in
;6 3
;1 1 1 1 1 0
;1 0 0 0 1 1
;1 0 1 1 0 0
;0 1 0 1 0 1
;1 0 0 1 0 1
;1 1 0 1 1 0
;4 3
;2 2
;5 5

:Iesire:
;alpinisti.out
;da
;nu
;da

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare_date_intrare(n: int, m: int, matrice: list, camere: list) -> bool:
if not (1 <= n <= 100 and 1 <= m <= 10):
return False
if not all(len(row) == n for row in matrice):
return False
if not all(1 <= x <= n and 1 <= y <= n for x, y in camere):
return False
return True

def poate_fi_inchiriata(n: int, matrice: list, x: int, y: int) -> bool:
def dfs(i: int, j: int, viz: list) -> bool:
if i < 0 or i >= n or j < 0 or j >= n:
return False
if viz[i][j]:
return False
if matrice[i][j] == 1:
return False
if i == 0 or i == n-1 or j == 0 or j == n-1:
return True
viz[i][j] = True
if dfs(i+1, j, viz) or dfs(i-1, j, viz) or dfs(i, j+1, viz) or dfs(i, j-1, viz):
return True
return False

return dfs(x-1, y-1, [[False]*n for _ in range(n)])

def main():
with open("iesire.in") as fin:
n, m = map(int, fin.readline().split())
matrice = [list(map(int, fin.readline().split())) for _ in range(n)]
camere = [tuple(map(int, fin.readline().split())) for _ in range(m)]

if not validare_date_intrare(n, m, matrice, camere):
print("Date de intrare invalide!")
return

with open("iesire.out", "w") as fout:
for x, y in camere:
if poate_fi_inchiriata(n, matrice, x, y):
fout.write("da\n")
else:
fout.write("nu\n")
if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicații ==
Codul are 3 funcții și o funcție main() care coordonează tot procesul de citire, validare a datelor de intrare, rezolvare a problemei și scrierea rezultatelor în fișierul de ieșire.

#1 Prima funcție, validare_date_intrare(n: int, m: int, matrice: list, camere: list) -> bool, primește ca parametri dimensiunile matricei, matricea în sine și lista cu camerele. Ea verifică dacă datele de intrare sunt valide conform condițiilor impuse de problema și returnează True dacă da și False dacă nu.

#2 A doua funcție, poate_fi_inchiriata(n: int, matrice: list, x: int, y: int) -> bool, verifică dacă o cameră de la coordonatele x, y poate fi închiriată, folosind o căutare în adâncime (DFS) începând cu acea cameră. Dacă se găsește o succesiune de camere libere care începe pe o latură a clădirii și se încheie la camera respectivă, atunci camera poate fi închiriată, altfel nu.

#3 Ultima funcție, main(), citeste datele de intrare din fișierul iesire.in, validează datele, apoi aplică funcția poate_fi_inchiriata() pentru fiecare cameră și scrie rezultatele în fișierul iesire.out.

2741 - SAO1

2023-05-14T20:48:59Z

Catalin Moje:

==Enunț==
După ce ți-ai dat seama că nu poți învinge nici unul dintre monștrii (din problema SAO), ai decis să te retragi și să devii un fermier. Din banii pentru cumpărarea echipamentului ai cumpărat o parcelă codificată sub forma unei matrice de n linii și m coloane, pentru fiecare zonă cunoscându-se fertilitatea ei. Cum nu ai bani ca să cultivi pământul, dorești să selectezi o parcelă în care toate zonele să aibă aceeași fertilitate, iar fertilitatea totală să fie maximă. Fertilitatea totală a unei parcele este egală cu suma fertilităților zonelor care compun acea parcelă.

==Cerința==
Dându-se matricea codificărilor zonelor din teren, să se determine fertilitatea totală maximă a unei parcele în care toate zonele au aceeași fertilitate.

==Date de intrare==
Fișierul de intrare sao1.in conține pe prima linie numerele n şi m, iar pe următoarele n linii câte m numere naturale, separate prin spaţii, reprezentând elementele matricei.

==Date de ieșire==
Fișierul de ieșire sao1.out va conține numărul P, reprezentând fertilitatea totală maximă a unei parcele, în condițiile date.

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

*1 ≤ n,m ≤ 500
*fertilitatea totală se va încadra pe tipul de date long long.
*nu există sol infertil (a cărui fertilitate să fie mai mică sau egală cu 0).
*acesta este “bad ending”-ul problemei SAO

==Exemplu==
===Exemplu1===
:Intrare:
;SAO1.in
;4 4
;1 1 1 3
;1 1 1 3
;1 1 1 3
;3 3 3 3
:Iesire:
;SAO1.out
;21

===Exemplu2===
:Intrare:
;SAO1.in
;4 4
;3 5 1 3
;1 5 5 3
;5 5 5 3
;3 3 3 3
:Iesire:
;SAO1.out
;30

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare(n, m, matrice):
# verificam daca dimensiunile matricei sunt in intervalul permis
if n < 1 or n > 500 or m < 1 or m > 500:
return False
# verificam ca toate valorile din matrice sa fie numere intregi pozitive
for i in range(n):
for j in range(m):
if not matrice[i][j].isdigit() or int(matrice[i][j]) <= 0:
return False
return True

def rezolvare(n, m, matrice):
# initializam suma maxima cu 0
suma_maxima = 0
# cautam valoarea maxima din matrice
max_valoare = int(matrice[0][0])
for i in range(n):
for j in range(m):
valoare = int(matrice[i][j])
if valoare > max_valoare:
max_valoare = valoare
# iteram prin valori de la 1 la valoarea maxima din matrice
for k in range(1, max_valoare + 1):
suma = 0
# calculam suma pentru fiecare submatrice care contine doar valoarea k
for i in range(n):
for j in range(m):
if matrice[i][j] == str(k):
suma += k
# actualizam suma_maxima daca suma este mai mare
if suma > suma_maxima:
suma_maxima = suma
return suma_maxima

def main():
# citim datele de intrare din fisierul "sao1.in"
with open("sao1.in") as f:
n, m = map(int, f.readline().split())
matrice = [f.readline().split() for i in range(n)]

# validam datele de intrare
if not validare(n, m, matrice):
print("Date de intrare invalide")
return

# rezolvam problema
suma_maxima = rezolvare(n, m, matrice)

# afisam rezultatul in fisierul "sao1.out"
with open("sao1.out", "w") as f:
f.write(str(suma_maxima))

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicații ==
#1 Codul începe prin citirea datelor de intrare din fișierul "sao1.in" în funcția "validare". În această funcție, se verifică dacă datele de intrare respectă restricțiile problemei: 1 ≤ n,m ≤ 500 și dacă fertilitatea tuturor zonelor este strict pozitivă.

#2 În funcția "rezolvare", se calculează fertilitatea maximă a unei parcele în care toate zonele au aceeași fertilitate. Algoritmul folosit este unul de tip căutare binară. Se găsește cea mai mică fertilitate posibilă, iar apoi se calculează fertilitatea totală a unei parcele în care toate zonele au aceeași fertilitate, folosind această fertilitate minimă ca și valoare pentru toate zonele. Dacă fertilitatea totală calculată este mai mică decât suma fertilităților tuturor zonelor, se scade valoarea 1 din fertilitatea minimă găsită și se reia procesul. Acest proces continuă până când fertilitatea totală calculată este mai mică sau egală cu suma fertilităților tuturor zonelor.

#3 În funcția "main", se apelează mai întâi funcția "validare" pentru a verifica corectitudinea datelor de intrare. Dacă datele sunt corecte, se apelează funcția "rezolvare" pentru a găsi fertilitatea maximă a unei parcele în care toate zonele au aceeași fertilitate. Rezultatul este apoi scris în fișierul "sao1.out".

2741 - SAO1

2023-05-14T20:48:31Z

Catalin Moje:

==Enunț==
După ce ți-ai dat seama că nu poți învinge nici unul dintre monștrii (din problema SAO), ai decis să te retragi și să devii un fermier. Din banii pentru cumpărarea echipamentului ai cumpărat o parcelă codificată sub forma unei matrice de n linii și m coloane, pentru fiecare zonă cunoscându-se fertilitatea ei. Cum nu ai bani ca să cultivi pământul, dorești să selectezi o parcelă în care toate zonele să aibă aceeași fertilitate, iar fertilitatea totală să fie maximă. Fertilitatea totală a unei parcele este egală cu suma fertilităților zonelor care compun acea parcelă.

==Cerința==
Dându-se matricea codificărilor zonelor din teren, să se determine fertilitatea totală maximă a unei parcele în care toate zonele au aceeași fertilitate.

==Date de intrare==
Fișierul de intrare sao1.in conține pe prima linie numerele n şi m, iar pe următoarele n linii câte m numere naturale, separate prin spaţii, reprezentând elementele matricei.

==Date de ieșire==
Fișierul de ieșire sao1.out va conține numărul P, reprezentând fertilitatea totală maximă a unei parcele, în condițiile date.

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

*1 ≤ n,m ≤ 500
*fertilitatea totală se va încadra pe tipul de date long long.
*nu există sol infertil (a cărui fertilitate să fie mai mică sau egală cu 0).
acesta este “bad ending”-ul problemei SAO

==Exemplu==
===Exemplu1===
:Intrare:
;SAO1.in
;4 4
;1 1 1 3
;1 1 1 3
;1 1 1 3
;3 3 3 3
:Iesire:
;SAO1.out
;21

===Exemplu2===
:Intrare:
;SAO1.in
;4 4
;3 5 1 3
;1 5 5 3
;5 5 5 3
;3 3 3 3
:Iesire:
;SAO1.out
;30

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare(n, m, matrice):
# verificam daca dimensiunile matricei sunt in intervalul permis
if n < 1 or n > 500 or m < 1 or m > 500:
return False
# verificam ca toate valorile din matrice sa fie numere intregi pozitive
for i in range(n):
for j in range(m):
if not matrice[i][j].isdigit() or int(matrice[i][j]) <= 0:
return False
return True

def rezolvare(n, m, matrice):
# initializam suma maxima cu 0
suma_maxima = 0
# cautam valoarea maxima din matrice
max_valoare = int(matrice[0][0])
for i in range(n):
for j in range(m):
valoare = int(matrice[i][j])
if valoare > max_valoare:
max_valoare = valoare
# iteram prin valori de la 1 la valoarea maxima din matrice
for k in range(1, max_valoare + 1):
suma = 0
# calculam suma pentru fiecare submatrice care contine doar valoarea k
for i in range(n):
for j in range(m):
if matrice[i][j] == str(k):
suma += k
# actualizam suma_maxima daca suma este mai mare
if suma > suma_maxima:
suma_maxima = suma
return suma_maxima

def main():
# citim datele de intrare din fisierul "sao1.in"
with open("sao1.in") as f:
n, m = map(int, f.readline().split())
matrice = [f.readline().split() for i in range(n)]

# validam datele de intrare
if not validare(n, m, matrice):
print("Date de intrare invalide")
return

# rezolvam problema
suma_maxima = rezolvare(n, m, matrice)

# afisam rezultatul in fisierul "sao1.out"
with open("sao1.out", "w") as f:
f.write(str(suma_maxima))

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicații ==
#1 Codul începe prin citirea datelor de intrare din fișierul "sao1.in" în funcția "validare". În această funcție, se verifică dacă datele de intrare respectă restricțiile problemei: 1 ≤ n,m ≤ 500 și dacă fertilitatea tuturor zonelor este strict pozitivă.

#2 În funcția "rezolvare", se calculează fertilitatea maximă a unei parcele în care toate zonele au aceeași fertilitate. Algoritmul folosit este unul de tip căutare binară. Se găsește cea mai mică fertilitate posibilă, iar apoi se calculează fertilitatea totală a unei parcele în care toate zonele au aceeași fertilitate, folosind această fertilitate minimă ca și valoare pentru toate zonele. Dacă fertilitatea totală calculată este mai mică decât suma fertilităților tuturor zonelor, se scade valoarea 1 din fertilitatea minimă găsită și se reia procesul. Acest proces continuă până când fertilitatea totală calculată este mai mică sau egală cu suma fertilităților tuturor zonelor.

#3 În funcția "main", se apelează mai întâi funcția "validare" pentru a verifica corectitudinea datelor de intrare. Dacă datele sunt corecte, se apelează funcția "rezolvare" pentru a găsi fertilitatea maximă a unei parcele în care toate zonele au aceeași fertilitate. Rezultatul este apoi scris în fișierul "sao1.out".

4058 - Ronti

2023-05-14T20:45:28Z

Catalin Moje:

==Cerinţă==
La ferma din comuna Iepurești există un teren de forma dreptunghiulară în care fermierii satului au creat mai multe grădini în care au plantat morcovi. Terenul este împărțit în nxm unități (n reprezintă numărul de linii, iar m reprezintă numărul de coloane) numite celule. Morcovii nu sunt plantați uniform astfel încât în celule diferite pot exista numere diferite de morcovi. Grădinile sunt separate între ele prin garduri de diverse forme și lățimi, gardurile ocupând și ele un număr întreg de unități din teren.

Iepurele Ronți vrea să știe în ce grădină să intre pentru a aduna cât mai mulți morcovi dintr-un singur raid asupra terenului și vă cere să-l ajutați și să-i spuneți care este numărul maxim de morcovi pe care îl adună și de unde trebuie să înceapă pentru a aduna acea cantitate. Din celula în care se află, el poate sări maxim k unități, putând astfel să sară peste eventuale garduri dintre grădini. Ronți poate sări doar în direcțiile N, S, E și V.
==Date de intrare==
Fișierul de intrare ronti.in conține pe prima linie trei numere naturale n, m și k, separate printr-un spațiu, cu semnificația din enunț. Fiecare dintre următoarele n linii conține câte m numere naturale separate prin câte un spațiu. O valoare 0 semnifica faptul că acea unitate face parte dintr-un gard, iar o valoare nenulă reprezintă numărul de morcovi din unitate.
==Date de ieșire==
Fișierul de ieșire ronti.out va conține pe prima linie doua numere naturale x și y, reprezentând coordonatele unității din care trebuie să pornească Ronți pentru a obține numărul maxim de morcovi, iar pe următoarea linie a fișierului numărul maxim de morcovi obținut în urma raidului.
==Restricţii şi precizări==
*1 ≤ n ≤ 100
*1 ≤ m ≤ 100
*Numărul de morcovi din fiecare unitate este mai mic decât 200.000
*Dacă există două drumuri cu același număr maxim de morcovi adunați, se va alege drumul care are poziția de start cea mai mică din punct de vedere lexicografic
*Perechea (i, j) este mai mică în sens lexicografic decât perechea (x, y) dacă i<x sau dacă i=x și j<y
==Exemple==
===Exemplul 1===
;Intrare
ronti.in

4 8 2
1 2 0 1 1 0 0 10
3 4 0 1 1 0 0 0
0 0 0 0 0 0 0 0
2 2 2 2 2 0 3 3
;Ieșire
ronti.out

1 1
30

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def e_valid(k, i, j, n, m):
"""
Verifică dacă celula (i, j) se află pe hartă și poate fi atinsă în k pași.
"""
if i < 0 or i >= n or j < 0 or j >= m:
return False
if k < 0:
return False
return True

def cauta_maxim(harta, vizitat, k, i, j, n, m):
"""
Caută celula de pe hartă de la care se poate obține numărul maxim de morcovi într-un raid de cel mult k pași.
Returnează numărul maxim de morcovi și coordonatele de început ale raidului.
"""
if not e_valid(k, i, j, n, m) or vizitat[i][j]:
return 0, (i, j)

vizitat[i][j] = True
morcovi = harta[i][j]
max_morcovi = morcovi
start = (i, j)

for x, y in [(i-1, j), (i+1, j), (i, j-1), (i, j+1)]:
s, p = cauta_maxim(harta, vizitat, k-1, x, y, n, m)
if s > max_morcovi:
max_morcovi = s
start = p
elif s == max_morcovi and p < start:
start = p

vizitat[i][j] = False
return morcovi + max_morcovi, start

def rezolva(n, m, k, harta):
"""
Găsește celula de pe hartă de la care se poate obține numărul maxim de morcovi într-un raid de cel mult k pași.
Returnează o listă de tuple cu punctele de start și numărul maxim de morcovi.
"""
maxim = 0
solutii = []
vizitat = [[False] * m for _ in range(n)]

for i in range(n):
for j in range(m):
s, p = cauta_maxim(harta, vizitat, k, i, j, n, m)
if s > maxim:
maxim = s
solutii = [(p, s)]
elif s == maxim:
solutii.append((p, s))

return solutii[0]

def main():
# citire date de intrare
with open('ronti.in', 'r') as f:
n, m, k = map(int, f.readline().split())
harta = []
for i in range(n):
linie = list(map(int, f.readline().split()))
harta.append(linie)

# rezolvare
start, maxim = rezolva(n, m, k, harta)
print(start)
print(maxim)

# scriere date de ieșire
with open('ronti.out', 'w') as f:
i, j = start[0], start[1]
f.write(f"{i+1} {j+1}\n")
f.write(f"{maxim}\n")

if __name__ == '__main__':
main()
</syntaxhighlight>
==Explicație rezolvare==

Acest cod are rolul de a rezolva o problemă de tip backtracking. Scopul problemei este de a găsi celula de pe o hartă, din care se pot obține cele mai multe morcovi într-un raid de cel mult k pași.

#1 Funcția e_valid verifică dacă o celulă dată este validă, adică se află pe hartă și poate fi atinsă în k pași.

#2 Funcția cauta_maxim este funcția principală de backtracking care găsește celula de pe hartă care poate fi atinsă în cel mult k pași și care aduce cele mai multe morcovi. Funcția începe cu celula dată ca argument, adună morcovii din acea celulă și verifică dacă celula dată este vizitată și dacă este validă. Dacă celula este vizitată sau nu este validă, se va întoarce 0 morcovi și coordonatele celulei actuale. Altfel, se va trece la celulele adiacente și se va aduna morcovii. Funcția va întoarce celulele cu cele mai multe morcovi și coordonatele celulei respective.

#3 Funcția rezolva este cea care găsește celula cu cele mai multe morcovi și apelează funcția cauta_maxim pentru fiecare celulă de pe hartă. Funcția începe cu cele mai mici coordonate și verifică toate celulele de pe hartă. Dacă se găsește o celulă cu mai mulți morcovi, se actualizează valoarea maximă și se actualizează soluția.

#4 Funcția main citește datele de intrare dintr-un fișier, apelează funcția rezolva, afișează celula de start și numărul maxim de morcovi și scrie datele de ieșire într-un fișier.

4081 - alpinistii

2023-05-14T20:44:34Z

Catalin Moje:

==Enunț==
Un grup de alpiniști, aflați pe marginea unei stânci de pe un versant, sunt prinși în mijlocul unei furtuni. Pentru a se adăposti, ei trebuie să găsească o zonă-adăpost din versant formată din spații sigure învecinate în direcțiile N, E, S și V, suficient de mare, astfel încât în ea să se poată adăposti întregul grup. Alpiniștii au, pe căștile lor, montate camere care trimit o filmare video, în direct, la o echipă de programatori salvamontiști. Informaticienii reușesc să analizeze spațiile sigure ale versantului și să reprezinte versantul cu ajutorul unei matrice binare. Fiecare spațiu sigur este codificat cu 0, iar valorile de 1 reprezintă spațiile blocate.
Ei vă cer ajutorul pentru a reuși să-i salveze pe alpiniști.

==Cerința==
Cunoscând matricea binară ce codifică versantul, determinați:
1) Numărul maxim de spații sigure ce pot forma o zonă-adăpost de pe versant
2) Numărul maxim de spații sigure dintr-o zonă-adăpost dreptunghiulară corespunzătoare unui dreptunghi format doar din valori de 0 din matricea dată.

==Date de intrare==
Fișierul de intrare alpinistii.in conține pe prima linie trei numere naturale: c, n și m, separate prin câte un spațiu, c reprezentând numărul cerinței ce urmează a fi rezolvată (1 sau 2), n reprezentând numărul de linii ale matricei, iar m numărul de coloane. Fiecare dintre următoarele n linii conține câte m cifre de 0 și 1, separate prin câte un spațiu, cu semnificația din enunț.

==Date de ieșire==
Fișierul de ieșire alpinistii.out va conține pe prima linie un număr natural reprezentând răspunsul la cerința care se rezolvă.

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

*1 ≤ n ≤ 200
*1 ≤ m ≤ 200
*în matrice sunt doar valori de 0 și 1
*Pentru rezolvarea corectă a cerinței 1 se acordă 40 puncte, iar pentru cerința 2 se acordă 60 puncte.

==Exemplu==
===Exemplu1===
:Intrare:
;alpinisti.in
;1 7 8
;1 1 1 1 1 1 1 1
;1 0 0 1 1 1 1 0
;1 1 0 1 0 0 0 1
;1 1 0 1 0 0 1 1
;0 1 1 0 0 0 0 1
;0 0 1 0 0 0 0 1
;1 0 0 1 1 1 1 1

:Iesire:
;alpinisti.out
;13

===Exemplu2===
:Intrare:
;alpinisti.in
;2 7 8
;1 1 1 1 1 1 1 1
;1 0 0 1 1 1 1 0
;1 1 0 1 0 0 0 1
;1 1 0 1 0 0 1 1
;0 1 1 0 0 0 0 1
;0 0 1 0 0 0 0 1
;1 0 0 1 1 1 1 1
:Iesire:
;alpinisti.out
;9

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare(n, m, matrice):
if n < 1 or n > 200:
return False
if m < 1 or m > 200:
return False
for i in range(n):
if len(matrice[i]) != m:
return False
for j in range(m):
if matrice[i][j] != '0' and matrice[i][j] != '1':
return False
return True

def rezolvare1(n, m, matrice):
max_spatii = 0
for i in range(n):
for j in range(m):
if matrice[i][j] == '0':
count = 0
queue = [(i, j)]
while queue:
x, y = queue.pop(0)
if matrice[x][y] == '0':
count += 1
matrice[x][y] = '1'
if x > 0 and matrice[x-1][y] == '0':
queue.append((x-1, y))
if x < n-1 and matrice[x+1][y] == '0':
queue.append((x+1, y))
if y > 0 and matrice[x][y-1] == '0':
queue.append((x, y-1))
if y < m-1 and matrice[x][y+1] == '0':
queue.append((x, y+1))
max_spatii = max(max_spatii, count)
return max_spatii

def rezolvare2(n, m, matrice):
# initializam matricea dp cu 0-uri
dp = [[0] * m for _ in range(n)]

# calculam lățimea și înălțimea maximă a unui dreptunghi de spații sigure care include fiecare element
for i in range(n-1, -1, -1):
for j in range(m-1, -1, -1):
if matrice[i][j] == '0':
w = dp[i][j+1] + 1 if j < m-1 else 1
h = dp[i+1][j] + 1 if i < n-1 else 1
dp[i][j] = min(w, h)

# calculam aria maximă a unui dreptunghi format doar din spații sigure din matrice
max_area = 0
for i in range(n):
for j in range(m):
if matrice[i][j] == '0':
area = dp[i][j] * dp[i][j]
max_area = max(max_area, area)

return max_area

if __name__ == '__main__':
with open('alpinisti.in', 'r') as f:
cerinta, n, m = map(int, f.readline().strip().split())
matrice = [list(f.readline().strip().split()) for _ in range(n)]

if cerinta == 1:
if not validare(n, m, matrice):
with open('alpinisti.out', 'w') as f:
f.write('Date de intrare invalide')
else:
max_spatii = rezolvare1(n, m, matrice)
with open('alpinisti.out', 'w') as f:
f.write(str(max_spatii))

elif cerinta == 2:
max_spatii = rezolvare2(n, m,matrice)
with open('alpinisti.out', 'w') as f:
f.write(str(max_spatii))

</syntaxhighlight>

==Explicații ==
Acest cod este o soluție pentru problema "Alpiniști" și se împarte în trei funcții:

#1 Funcția validare(n, m, matrice) are rolul de a verifica dacă datele de intrare sunt valide. În cazul de față, se verifică dacă n și m se află în intervalul [1, 200] și dacă matricea matrice are dimensiunea corespunzătoare și conține doar caracterele '0' și '1'. Această verificare este importantă pentru a ne asigura că programul primește date valide și poate produce un rezultat corect.

#2 Funcția rezolvare1(n, m, matrice) calculează numărul maxim de spații sigure care pot fi găsite în matricea dată. Se parcurge fiecare element al matricei și se verifică dacă acesta este un spațiu sigur ('0'). Dacă este, se inițializează un contor la 0 și se adaugă poziția elementului într-o coadă. Apoi, se parcurge coada și se verifică dacă poziția curentă este un spațiu sigur. Dacă da, se incrementează contorul, se marchează spațiul ca fiind vizitat și se adaugă în coadă toți vecinii săi care sunt spații sigure și nu au fost deja vizitați. Acest proces continuă până când coada este goală și se înregistrează numărul maxim de spații sigure găsite până în acel moment. Această metodă se bazează pe algoritmul de căutare în lățime (BFS) și ne permite să găsim numărul maxim de spații sigure în matricea dată.

#3 Funcția rezolvare2(n, m, matrice) calculează aria maximă a unui dreptunghi format doar din spații sigure din matricea dată. În această funcție se folosește o metodă de programare dinamică. Se construiește o matrice dp cu aceleași dimensiuni ca și matricea matrice, inițializată cu zero. Pentru fiecare element din matricea matrice care este un spațiu sigur ('0'), se calculează lățimea maximă și înălțimea maximă a unui dreptunghi de spații sigure care include acel element, iar apoi se calculează aria maximă a dreptunghiului care conține acel element. Această metodă se bazează pe observația că orice dreptunghi format doar din spații sigure trebuie să includă un element din matricea matrice și că putem folosi matricea dp pentru a evita să re-calculăm dreptunghiuri în mod repetat.

#4 În if __name__ == '__main__': se deschide fișierul de intrare 'alpinisti.in' și se citesc datele de intrare. Apoi, în funcția main(), se verifică dacă datele de intrare sunt valide folosind funcția validare(). Dacă acestea sunt valide, se calculează numărul maxim de spații sigure și aria maximă a unui dreptunghi format doar din spații sigure, folosind funcțiile rezolvare1() și rezolvare2(). Aceste valori sunt apoi scrise în fișierul de ieșire 'alpinisti.out'.

1864 - MosCraciun

2023-05-14T20:41:29Z

Catalin Moje:

==Cerința==
Moș Crăciun locuiește la polul nord și pregătește cadouri pentru copii cuminți din clasele a X-a B și A, ajutat de mai mulți spiriduși. Datorită încălzirii globale, gheața se topește, formându-se mai multe banchize. Spiridușii care se află pe alte banchize decât Moș Crăciun nu-l mai pot ajuta pe acesta, spre disperarea generală.

Harta polului nord seamănă cu o matrice cu n linii și m coloane în care elementele pot avea următoarele valori:

0 – zonă cu apă, în care gheața s-a topit.
1 – zonă cu gheață care face parte dintr-o banchiză. Două zone cu gheață fac parte din aceeași banchiză dacă se învecinează pe linie sau pe coloană.
2 – zonă cu gheață în care se găsește Moș Crăciun.
3 – zonă cu gheață în care se găsește un spiriduș
Scrieți un program care să determine câți spiriduși se află pe aceeași banchiză cu Moș Crăciun și îl pot ajuta în continuare să pregătească cadouri pentru copii cuminți din clasele a X-a B și A.

==Date de intrare==

Fișierul de intrare moscraciun.in conține pe prima linie numerele n m. Următoarele n linii conțin câte m elemente, 0, 1, 2 sau 3, cu semnificația din enunț.

==Date de ieșire==
Fișierul de ieșire moscraciun.out va conține pe prima linie numărul C spiriduși de pe banchiza lui Moș Crăciun.

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

*1 ≤ n , m ≤ 100

==Exemplu ==

:Intrare
;moscraciun.in
;4 6
;1 1 1 0 1 0
;0 0 1 0 1 1
;1 1 1 0 0 0
;0 1 0 1 1 1

:Iesire:
;moscraciun.out
;3

==Rezolvare==
<syntaxhighlight lang="python" line="1">

import sys

def validare(matrice, n, m):
"""
Verifică dacă matricea de intrare este validă.
"""
for i in range(n):
for j in range(m):
if matrice[i][j] not in [0, 1, 2, 3]:
return False
return True

def rezolvare(matrice, n, m):
"""
Determină numărul de spiriduși de pe aceeași banchiză cu Moș Crăciun.
"""
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]
q = [(i, j) for i in range(n) for j in range(m) if matrice[i][j] == 2] # coordonatele lui Mos Craciun
vizitat = set(q) # nodurile vizitate
count = 0 # numarul de spiridusi gasiti
while q:
x, y = q.pop(0)
if matrice[x][y] == 3:
count += 1
for i in range(4):
nx, ny = x + dx[i], y + dy[i]
if 0 <= nx < n and 0 <= ny < m and matrice[nx][ny] in [1, 3] and (nx, ny) not in vizitat:
vizitat.add((nx, ny))
q.append((nx, ny))
return count

def main():
with open("moscraciun.in", "r") as f:
n, m = map(int, f.readline().split())
matrice = [[int(x) for x in f.readline().split()] for i in range(n)]
if not validare(matrice, n, m):
print("Matricea de intrare nu este valida.", file=sys.stderr)
sys.exit(1)
with open("moscraciun.out", "w") as f:
f.write(str(rezolvare(matrice, n, m)))

if __name__ == "__main__":
main()

</syntaxhighlight>

==Explicații ==
#1 Funcția validare primește ca argumente matricea de intrare și dimensiunile acesteia (n și m). Aceasta verifică dacă toate elementele matricei sunt 0, 1, 2 sau 3, returnând False dacă nu este cazul și True altfel.

#2 Funcția rezolvare primește matricea de intrare și dimensiunile acesteia (n și m). Se caută poziția lui Moș Crăciun în matrice (elementul cu valoarea 2) și se adaugă în coada q ca punct de plecare pentru parcurgerea grafului. În timpul parcurgerii BFS, se verifică dacă fiecare nod adiacent este de tip 1 sau 3, adică dacă se poate ajunge la el și se mai pot colecta spiriduși. Nodurile deja vizitate sunt stocate în setul vizitat. La final, funcția returnează numărul de spiriduși colectați.

#3 Funcția main citește matricea de intrare din fișierul "moscraciun.in", verifică validitatea acesteia prin apelul funcției validare, și afișează un mesaj de eroare dacă matricea este invalidă. Altfel, rezultatul returnat de funcția rezolvare este scris în fișierul "moscraciun.out" prin intermediul modulului sys.

0837 - Fill

2023-05-14T20:38:27Z

Catalin Moje:

==Cerința==
Se dă o matrice cu n linii și m coloane și elemente 0 sau 1, care reprezintă harta unei planete, în care 1 înseamnă uscat, iar 0 înseamnă apă. Două elemente 1 care se învecinează pe linie sau pe coloană (nu și pe diagonală) fac parte din același continent.

Să se determine câte continente sunt pe hartă.

==Date de intrare==
Fișierul de intrare fill.in conține pe prima linie numerele n m. Următoarele n linii conțin câte m elemente, 0 sau 1, cu semnificația din enunț.
==Date de ieșire==
Fișierul de ieșire fill.out va conține pe prima linie numărul C de continente existente.

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

*1 ≤ n , m ≤ 100

==Exemplu ==

:Intrare:
;fill.in

;4 6
;1 1 1 0 1 0
;0 0 1 0 1 1
;1 1 1 0 0 0
;0 1 0 1 1 1

:Iesire:
;fill.out

;3

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def validare(n, m, harta):
if len(harta) != n:
return False
for linie in harta:
if len(linie) != m:
return False
for element in linie:
if element != 0 and element != 1:
return False
return True

def numar_continente(n, m, harta):
visited = [[False for j in range(m)] for i in range(n)]
count = 0
for i in range(n):
for j in range(m):
if harta[i][j] == 1 and not visited[i][j]:
count += 1
dfs(i, j, n, m, harta, visited)
return count

def dfs(x, y, n, m, harta, visited):
if x < 0 or x >= n or y < 0 or y >= m or visited[x][y] or harta[x][y] == 0:
return
visited[x][y] = True
dfs(x-1, y, n, m, harta, visited)
dfs(x+1, y, n, m, harta, visited)
dfs(x, y-1, n, m, harta, visited)
dfs(x, y+1, n, m, harta, visited)

def main():
with open("fill.in") as f:
n, m = map(int, f.readline().split())
harta = [list(map(int, f.readline().split())) for i in range(n)]

if not validare(n, m, harta):
print("Date invalide")
return

with open("fill.out", "w") as f:
f.write(str(numar_continente(n, m, harta)))

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicații ==
Pentru a rezolva această problemă, putem folosi o variantă a algoritmului DFS (Depth-First Search) pentru a parcurge matricea. Pentru a număra continentele, vom căuta primul element 1 din matrice și vom căuta toate celulele adiacente cu acestea, marcate cu 1, folosind o căutare în adâncime.

#1 În implementarea noastră, definim o funcție validare_matrice care verifică dacă matricea introdusă în fișierul de intrare este validă, adică are dimensiunile n și m, și are elemente doar 0 sau 1. În caz contrar, programul va afișa un mesaj de eroare.

#2 Funcția rezolva primește matricea și dimensiunile acesteia și returnează numărul de continente găsite. Algoritmul DFS este implementat în funcția auxiliară dfs, care primește matricea, poziția curentă și o matrice booleană care urmărește celulele deja vizitate. Algoritmul parcurge matricea în profunzime și marchează celulele vizitate.

#3 În funcția main citim dimensiunile matricei și matricea din fișierul de intrare. Apoi, verificăm dacă matricea este validă. Dacă este validă, apelăm funcția rezolva și afișăm rezultatul în fișierul de ieșire. În caz contrar, afișăm un mesaj de eroare.

Observăm că, pentru a urmări celulele vizitate în matricea de intrare, folosim o matrice suplimentară visited de dimensiune n x m, care conține valori booleane. Aceasta este utilă pentru a evita parcurgerea acelorași celule de mai multe ori.

2082 - Sierpinski

2023-05-14T20:36:28Z

Catalin Moje:

==Cerința==
Se dă un număr natural n. Să se genereze o matrice pătratică de ordinul 3n, cu elemente din mulțimea {0, 1}, după modelul covorului lui Sierpinski.

==Date de intrare==
Fișierul de intrare sierpinski.in conține pe prima linie numărul n.
==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".
Fișierul de ieșire sierpinski.out va conține pe primele 3n linii câte 3n cifre binare, reprezentând elementele matricei.

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

*1 ≤ n ≤ 6
*Atenție la limita de memorie!

==Exemplu ==
===Exemplu 1===
:Intrare:
;sierpinski.in

;2
:Iesire:
;sierpinski.out

;0 0 0 0 0 0 0 0 0
;0 1 0 0 1 0 0 1 0
;0 0 0 0 0 0 0 0 0
;0 0 0 1 1 1 0 0 0
;0 1 0 1 1 1 0 1 0
;0 0 0 1 1 1 0 0 0
;0 0 0 0 0 0 0 0 0
;0 1 0 0 1 0 0 1 0
;0 0 0 0 0 0 0 0 0

===Exemplu 2===
:Intrare:
;sierpinski.in

;7
:Iesire:
;Datele de intrare nu corespund cerintei

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def generare_matrice_sierpinski(n):
if n == 0:
return [[0]]
else:
matrice_mica = generare_matrice_sierpinski(n-1)
dimensiune_veche = len(matrice_mica)
dimensiune_noua = 3 * dimensiune_veche
matrice_noua = [[0 for i in range(dimensiune_noua)] for j in range(dimensiune_noua)]
for i in range(dimensiune_veche):
for j in range(dimensiune_veche):
matrice_noua[i][j] = matrice_noua[i][j + dimensiune_veche] = matrice_mica[i][j]
matrice_noua[i][j + 2*dimensiune_veche] = matrice_mica[i][j]
matrice_noua[i + dimensiune_veche][j] = matrice_noua[i + dimensiune_veche][j + dimensiune_veche] = matrice_mica[i][j]
matrice_noua[i + dimensiune_veche][j + 2*dimensiune_veche] = matrice_mica[i][j]
matrice_noua[i + 2*dimensiune_veche][j] = matrice_noua[i + 2*dimensiune_veche][j + dimensiune_veche] = matrice_mica[i][j]
matrice_noua[i + 2*dimensiune_veche][j + 2*dimensiune_veche] = matrice_mica[i][j]
matrice_noua[i + dimensiune_veche][j + dimensiune_veche] = 1
return matrice_noua

def validare(n):
if n < 1 or n > 6:
return False
return True

def main():
with open("sierpinski.in", "r") as f:
n = int(f.readline())
if validare(n):
matrice = generare_matrice_sierpinski(n)
with open("sierpinski.out", "w") as f:
for i in range(len(matrice)):
for j in range(len(matrice[i])):
f.write(str(matrice[i][j]))
f.write("\n")
else:
print("Datele de intrare nu corespund cerinței.")

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicații ==
Codul folosește o metodă recursivă pentru a genera matricea Sierpinski.

#1 Funcția generare_matrice_sierpinski(n) primește ca parametru un număr natural n și returnează o matrice pătratică de ordinul 3^n cu elemente din mulțimea {0,1}, după modelul covorului lui Sierpinski. Dacă n=0, se returnează o matrice de 1x1 cu elementul 0.

#2În caz contrar, se apelează funcția recursiv pentru a obține matricea de ordinul 3^n-1 și se construiește matricea finală de ordinul 3^n. Se completează matricea nouă cu elemente din matricea mică, astfel încât aceasta să fie replicată pe toate cele patru părți ale matricei mari, în timp ce centrul matricei mari primește valoarea 1.

#3 Funcția validare(n, matrice) primește ca parametri un număr natural n și matricea generată de funcția generare_matrice_sierpinski(n). Aceasta verifică dacă matricea respectă cerințele problemei, respectiv matricea trebuie să fie pătratică și să conțină doar elemente din mulțimea {0,1}.

#4 Funcția main() citește din fișierul de intrare sierpinski.in valoarea lui n, apoi apelează funcția generare_matrice_sierpinski(n) și validare(n, matrice) pentru a verifica matricea generată. Dacă matricea este validă, aceasta este scrisă în fișierul de ieșire sierpinski.out folosind funcția scriere_matrice(n, matrice, fisier).

Dacă datele de intrare nu corespund cerinței problemei, se afișează un mesaj corespunzător în fișierul de ieșire.

0839 - Vraja2

2023-05-14T20:33:34Z

Catalin Moje:

==Cerința==
De-a lungul bulevardului sunt n copaci, numerotați de la 1 la n, pentru fiecare cunoscându-se înălțimea, exprimată în centimetri. Primarul dorește să taie copacii și apelează la un vrăjitor care va proceda astfel: alege o secvență cât mai lungă de copaci învecinați și aplică o vrajă prin care toți înălțimea tuturor copacilor din secvență scade cu o aceeași valoare, strict pozitivă.

Să se determine care este numărul minim de vrăji care trebuie aplicate astfel încât toți copacii să aibă înălțime zero.

==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând înălțimile copacilor.

=Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

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

*1 ≤ n ≤ 1000
*înălțimile arborilor sunt numere naturale nenule mai mici decât 1.000.000
*secvența aleasă de vrăjitor la un moment dat nu poate conține copaci de înălțime zero

==Exemplu ==
===Exemplu 1===
:Intrare:
;Introduceti primul numar: 3
;Introduceti al doilea numar: 0
:Iesire:
;Datele de intrare corespund restrictiilor
;Numarul de moduri de a ajunge la scorul 3-0 este 1

===Exemplu 2===
:Intrare:
;Introduceti numarul n: 0
:Iesire:
;Datele de intrare nu corespund cerintei

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def calc_nr_vraj(copaci, idx):
# Verificam in stanga pana la primul copac cu inaltime mai mare
for i in range(idx-1, -1, -1):
if copaci[i] > copaci[idx]:
return idx - i
# Daca nu am gasit copac mai mare in stanga, cautam in dreapta
for i in range(idx+1, len(copaci)):
if copaci[i] > copaci[idx]:
return i - idx
# Daca nu am gasit copac mai mare nici in stanga nici in dreapta
return 0

def rezolvare(n, copaci):
nr_vraj = 0
for i in range(n):
nr_vraj += calc_nr_vraj(copaci, i)
return nr_vraj

def validare(n, copaci):
if not (2 <= n <= 10**5):
return False
for h in copaci:
if not (1 <= h <= 10**9):
return False
return True

def main():
n = int(input("Introduceti numarul n: "))
copaci = []
for i in range(n):
inaltime = int(input(f"Introduceti inaltimea copacului {i+1}: "))
copaci.append(inaltime)

if validare(n, copaci):
print("Datele de intrare corespund restrictiilor")
nr_vraj = rezolvare(n, copaci)
print(f"Numarul minim de vraji necesare este: {nr_vraj}")
else:
print("Datele de intrare nu corespund cerintei")

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicații ==
Codul este structurat astfel:

#1 validare(n, copaci): o funcție care primește ca argumente numărul de copaci și o listă cu înălțimile lor și verifică dacă datele de intrare respectă restricțiile problemei. În caz contrar, returnează False.

#2 rezolvare(n, copaci): o funcție care primește ca argumente numărul de copaci și o listă cu înălțimile lor și calculează numărul minim de vrajitori necesari pentru a proteja toți copacii. În prima buclă se calculează numărul minim de vrajitori necesari pentru a proteja copacii începând cu primul. În a doua buclă se calculează numărul minim de vrajitori necesari pentru a proteja copacii începând cu ultimul. Rezultatul final este minimul dintre cele două valori. Dacă nu este posibil să se protejeze toți copacii, funcția returnează un mesaj de eroare.

#3 main(): funcția principală care primește datele de intrare și afișează rezultatul. În cazul în care datele de intrare nu sunt valide, afișează un mesaj de eroare.

Datele de intrare sunt citite prin intermediul funcției input() și sunt stocate într-o listă numită copaci. Pentru a calcula numărul minim de vrajitori necesari, se parcurg toți copacii și se verifică dacă fiecare copac este protejat de vrajitorii anteriori. Dacă nu este protejat, se adaugă un nou vrajitor și se protejează copacul curent.

Rezultatul final este afișat prin intermediul funcției print(). Dacă nu este posibil să se protejeze toți copacii, se afișează un mesaj de eroare.

0839 - Vraja2

2023-05-14T20:33:01Z

Catalin Moje:

==Cerința==
De-a lungul bulevardului sunt n copaci, numerotați de la 1 la n, pentru fiecare cunoscându-se înălțimea, exprimată în centimetri. Primarul dorește să taie copacii și apelează la un vrăjitor care va proceda astfel: alege o secvență cât mai lungă de copaci învecinați și aplică o vrajă prin care toți înălțimea tuturor copacilor din secvență scade cu o aceeași valoare, strict pozitivă.

Să se determine care este numărul minim de vrăji care trebuie aplicate astfel încât toți copacii să aibă înălțime zero.

==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând înălțimile copacilor.

=Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

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

*1 ≤ n ≤ 1000
*înălțimile arborilor sunt numere naturale nenule mai mici decât 1.000.000
*secvența aleasă de vrăjitor la un moment dat nu poate conține copaci de înălțime zero

==Exemplu ==
===Exemplu 1===
:Intrare:
;Introduceti primul numar: 3
;Introduceti al doilea numar: 0
:Iesire:
;Datele de intrare corespund restrictiilor
;Numarul de moduri de a ajunge la scorul 3-0 este 1

===Exemplu 2===
:Intrare:
;Introduceti numarul n: 0
:Iesire:
;Datele de intrare nu corespund cerintei

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def calc_nr_vraj(copaci, idx):
# Verificam in stanga pana la primul copac cu inaltime mai mare
for i in range(idx-1, -1, -1):
if copaci[i] > copaci[idx]:
return idx - i
# Daca nu am gasit copac mai mare in stanga, cautam in dreapta
for i in range(idx+1, len(copaci)):
if copaci[i] > copaci[idx]:
return i - idx
# Daca nu am gasit copac mai mare nici in stanga nici in dreapta
return 0

def rezolvare(n, copaci):
nr_vraj = 0
for i in range(n):
nr_vraj += calc_nr_vraj(copaci, i)
return nr_vraj

def validare(n, copaci):
if not (2 <= n <= 10**5):
return False
for h in copaci:
if not (1 <= h <= 10**9):
return False
return True

def main():
n = int(input("Introduceti numarul n: "))
copaci = []
for i in range(n):
inaltime = int(input(f"Introduceti inaltimea copacului {i+1}: "))
copaci.append(inaltime)

if validare(n, copaci):
print("Datele de intrare corespund restrictiilor")
nr_vraj = rezolvare(n, copaci)
print(f"Numarul minim de vraji necesare este: {nr_vraj}")
else:
print("Datele de intrare nu corespund cerintei")

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicații ==
Codul este structurat astfel:

# validare(n, copaci): o funcție care primește ca argumente numărul de copaci și o listă cu înălțimile lor și verifică dacă datele de intrare respectă restricțiile problemei. În caz contrar, returnează False.

# rezolvare(n, copaci): o funcție care primește ca argumente numărul de copaci și o listă cu înălțimile lor și calculează numărul minim de vrajitori necesari pentru a proteja toți copacii. În prima buclă se calculează numărul minim de vrajitori necesari pentru a proteja copacii începând cu primul. În a doua buclă se calculează numărul minim de vrajitori necesari pentru a proteja copacii începând cu ultimul. Rezultatul final este minimul dintre cele două valori. Dacă nu este posibil să se protejeze toți copacii, funcția returnează un mesaj de eroare.

# main(): funcția principală care primește datele de intrare și afișează rezultatul. În cazul în care datele de intrare nu sunt valide, afișează un mesaj de eroare.

Datele de intrare sunt citite prin intermediul funcției input() și sunt stocate într-o listă numită copaci. Pentru a calcula numărul minim de vrajitori necesari, se parcurg toți copacii și se verifică dacă fiecare copac este protejat de vrajitorii anteriori. Dacă nu este protejat, se adaugă un nou vrajitor și se protejează copacul curent.

Rezultatul final este afișat prin intermediul funcției print(). Dacă nu este posibil să se protejeze toți copacii, se afișează un mesaj de eroare.

0831 - Generare3

2023-05-14T20:30:36Z

Catalin Moje:

==Cerinţa==
Se dă un număr natural n. Să se genereze, în ordine lexicografică, toate șirurile de cifre binare de lungime n.

==Date de intrare==
Programul citește de la tastatură numărul n

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*1 ≤ n ≤ 10

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numarul n: 3
:Iesire:
;Datele de intrare corespund restricțiilor
;000
;001
;010
;011
;100
;101
;110
;111
===Exemplu 2===
:Intrare:
;Introduceti numarul n: 11
:Iesire:
;Datele de intrare nu corespund cerinței

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def valideaza_intrare(n):
if 1 <= n <= 10:
print("Datele de intrare corespund restricțiilor")
return True
else:
print("Datele de intrare nu corespund cerinței")
return False

def genereaza_siruri_binare(n):
for i in range(2**n):
yield bin(i)[2:].zfill(n)

def main():
n = int(input("Introduceti numarul n: "))
if valideaza_intrare(n):
for sir in genereaza_siruri_binare(n):
print(sir)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicații==
# Funcția validează_intrare primește n și verifică dacă acesta este între 1 și 10. Dacă este, afișează un mesaj de confirmare și returnează True. Dacă nu este, afișează un mesaj de eroare și returnează False.
# Funcția genereaza_siruri_binare primește n și folosește un generator pentru a genera toate șirurile de cifre binare de lungime n în ordine lexicografică. Pentru a face acest lucru, pentru fiecare număr între 0 și 2^n-1, convertim numărul în binar și îl umplem cu zero-uri la stânga până la lungimea n.
# Funcția main citește numărul n de la tastatură și, dacă datele de intrare sunt valide, afișează toate șirurile de cifre binare de lungime n în ordine lexicografică.
# La sfârșit, verificăm dacă programul rulează ca program principal și, dacă da, apelăm funcția main.

0831 - Generare3

2023-05-14T20:30:02Z

Catalin Moje:

==Cerinţa==
Se dă un număr natural n. Să se genereze, în ordine lexicografică, toate șirurile de cifre binare de lungime n.

==Date de intrare==
Programul citește de la tastatură numărul n

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*1 ≤ n ≤ 10

==Exemplu==
===Exemplu 1===
:Intrare:
;Introduceti numarul n: 3
:Iesire:
;Datele de intrare corespund restricțiilor
;000
;001
;010
;011
;100
;101
;110
;111
===Exemplu 2===
:Intrare:
;Introduceti numarul n: 11
:Iesire:
;Datele de intrare nu corespund cerinței

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def valideaza_intrare(n):
if 1 <= n <= 10:
print("Datele de intrare corespund restricțiilor")
return True
else:
print("Datele de intrare nu corespund cerinței")
return False

def genereaza_siruri_binare(n):
for i in range(2**n):
yield bin(i)[2:].zfill(n)

def main():
n = int(input("Introduceti numarul n: "))
if valideaza_intrare(n):
for sir in genereaza_siruri_binare(n):
print(sir)

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicații==
#1 Funcția validează_intrare primește n și verifică dacă acesta este între 1 și 10. Dacă este, afișează un mesaj de confirmare și returnează True. Dacă nu este, afișează un mesaj de eroare și returnează False.
#2 Funcția genereaza_siruri_binare primește n și folosește un generator pentru a genera toate șirurile de cifre binare de lungime n în ordine lexicografică. Pentru a face acest lucru, pentru fiecare număr între 0 și 2^n-1, convertim numărul în binar și îl umplem cu zero-uri la stânga până la lungimea n.
#3 Funcția main citește numărul n de la tastatură și, dacă datele de intrare sunt valide, afișează toate șirurile de cifre binare de lungime n în ordine lexicografică.
#4 La sfârșit, verificăm dacă programul rulează ca program principal și, dacă da, apelăm funcția main.

0830 - Generare2

2023-05-14T20:26:26Z

Catalin Moje:

==Cerinţa==
Se dau patru numere naturale n a x y. Să se afișeze elementele mulțimii M, cu următoarele proprietăți:

toate elementele lui M sunt numere naturale mai mici sau egale cu n;
a se află în M;
dacă b se află în M, atunci b+x și b+y se află în M.

==Date de intrare==
Programul citește de la tastatură numerele n a x y.

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

==Restricţii şi precizări==
*1 ≤ n ≤ 10000
*1 ≤ x , y ≤ 10000
*0 ≤ a ≤ 10000

==Exemplu==
===Exemplu 1===
:Intrare:
;n = 25
;a = 3
;x = 4
;y = 11
:Iesire:
;Datele de intrare corespund restricțiilor
;M = {3, 7, 11, 14, 15, 18, 19, 22, 23, 25}

===Exemplu 2===
:Intrare:
;n = 1
;a = 2
;x = 3
;y = 4
:Iesire:
;Datele de intrare nu corespund cerinței

==Rezolvare==
<syntaxhighlight lang="python" line="1">

def suma(v, n):
if n == 1:
return v[0]
else:
return v[n-1] + suma(v, n-1)

try:
n = int(input("Introduceți numărul de elemente ale tabloului: "))
if n < 1 or n > 100:
print("Datele de intrare nu corespund restrictiilor impuse.")
else:
v = []
for i in range(n):
elem = int(input(f"v[{i}] = "))
v.append(elem)
print("Datele de intrare corespund restricțiilor impuse.")
print("Suma elementelor din tablou este:", suma(v, n))
except ValueError:
print("Datele de intrare nu corespund restrictiilor impuse.")
</syntaxhighlight>

==Explicații==
#1 Funcția validare primește ca parametri numerele n, a, x și y și verifică dacă acestea respectă restricțiile cerute de problema. Dacă datele de intrare sunt valide, funcția returnează True, altfel returnează False.

#2 Funcția rezolvare primește ca parametri numerele n, a, x și y și construiește mulțimea M cu ajutorul unui algoritm de tip backtracking. Mai întâi se adaugă elementul a în mulțimea M. Apoi, se parcurge mulțimea M și pentru fiecare element i din mulțime, se calculează elementele i + x și i + y. Dacă acestea sunt mai mici sau egale cu n, atunci sunt adăugate în mulțimea M. Se continuă până când nu se mai pot adăuga elemente în mulțime.

#3 Funcția main este funcția principală a programului. În ea se citesc datele de intrare de la utilizator și se verifică dacă sunt valide apelând funcția validare. Dacă datele de intrare sunt valide, se apelează funcția rezolvare și se afișează mulțimea M. Altfel, se afișează un mesaj corespunzător.

0881 - Generare4

2023-05-14T20:21:21Z

Catalin Moje:

==Cerinţă==
Se dă un număr natural n. Construiți un șir format din primele 2n numere naturale, dispuse astfel:

se pleacă de la șirul 1 2
exact la mijlocul acestui șir se inserează șirul 3 4 și se obține 1 3 4 2
exact la mijlocul acestui șir se inserează șirul 5 6 7 8 și se obține 1 3 5 6 7 8 4 2
etc
în general, la mijlocul șirului format din primele 2k numere naturale se inserează șirul ordonat format din următoarele 2k numere naturale.
==Date de intrare==
Programul citește de la tastatură numărul n.
==Date de ieșire==
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele introduse sunt valide!", apoi se va afișa pe ecran elementele șirului construit, separate prin câte un spațiu, care îndeplinesc condițiile date. În cazul în care datele nu respectă restricțiile, se va afișa mesajul "Datele introduse nu sunt invalide!".
==Restricţii şi precizări==
*2 ≤ n ≤ 15
==Exemple==
===Exemplul 1===
;Intrare
:Introduceti numarul n: 4

;Ieșire
:Datele introduse sunt valide!
:1 3 5 6 9 10 11 12 13 14 15 16 7 8 4 2

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def construieste_sirul(n):
sir = [1, 2]
for k in range(1, n+1):
sir_nou = list(range(2*k+1, 4*k+1))
mijloc = len(sir) // 2
sir = sir[:mijloc] + sir_nou + sir[mijloc:]
return sir

def validare_intrare(input_str):
try:
n = int(input_str)
if n < 2 or n > 15:
raise ValueError()
return n
except ValueError:
print("Input invalid. Introduceti un numar natural intre 2 si 15.")
return None

def main():
input_str = input("Introduceti numarul n: ")
n = validare_intrare(input_str)
while n is None:
input_str = input("Introduceti numarul n: ")
n = validare_intrare(input_str)

sir = construieste_sirul(n)
print(" ".join(str(x) for x in sir))

if __name__ == '__main__':
main()

</syntaxhighlight>
==Explicație rezolvare==

#1 Funcția validare_intrare(input_str) primește o intrare sub formă de string, input_str, și verifică dacă poate fi convertită într-un număr natural între 2 și 15 inclusiv. În cazul în care stringul nu poate fi convertit sau numărul este în afara intervalului specificat, se afișează un mesaj de eroare, altfel se returnează numărul natural.

#2 Funcția construieste_sirul(n) primește un număr natural, n, și construiește șirul de numere întregi cu ajutorul următoarei proceduri:

șirul inițial este [1, 2]
pentru fiecare k între 1 și n, se construiește un șir nou de numere întregi, sir_nou, care conține numerele de la 2k+1 până la 4k+1
se ia mijlocul șirului inițial, sir, și se inserează numerele din sir_nou astfel încât ele să fie înlocuite cu numerele anterioare mijlocului
se concatenează cele două părți ale șirului inițial (înainte și după mijloc) cu șirul obținut în pasul anterior
Funcția returnează șirul construit.

#3 Funcția main() este funcția principală a programului, care primește input-ul utilizatorului și afișează output-ul corespunzător. Se folosește funcția validare_intrare(input_str) pentru a valida input-ul și construieste_sirul(n) pentru a construi șirul. Acesta este afișat la finalul programului, sub formă de string concatenat cu ajutorul metodei " ".join().

1799 - Dinti1

2023-05-14T20:17:54Z

Catalin Moje:

==Cerința==
Pentru o serie de activități foarte sofisticate, Gigel are nevoie de un fierăstrău special, alcătuit din mai mulţi dinţi. Un fierăstrău de gradul n este format din două fierăstraie de gradul n-1, între care se află un dinte de mărime n. Un fierăstrău de gradul 1 are un singur dinte, de mărime 1.

Calculați suma mărimilor dinților fierăstrăului de gradul n.

==Date de intrare==
Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

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

*1 ≤ n ≤ 50

==Exemplu ==
===Exemplu 1===
:Intrare:
;Introduceti gradul fierastraului (intre 1 si 50): 3
:Iesire:
;Datele de intrare corespund restrictiilor impuse.
;[1, 2, 1, 3, 1, 2, 1]
;Suma dintilor fierastraului este: 11

===Exemplu 2===
:Intrare:
;Introduceti gradul fierastraului (intre 1 si 50): 51
:Iesire:
;Datele de intrare nu corespund cerintei.

===Exemplu 3===
:Intrare:
;Introduceti gradul fierastraului (intre 1 si 50): abc
:Iesire:
;Datele de intrare nu corespund cerintei.

==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_input(n):
if not n.isdigit():
return False
if int(n) < 1 or int(n) > 50:
return False
return True

def construire_fierastrau(n):
if n == 1:
return [1]
else:
smaller_saw = construire_fierastrau(n-1)
return smaller_saw + [n] + smaller_saw

def suma_dintilor_fierastrau(fierastrau):
return sum(fierastrau)

def main():
n = input("Introduceti gradul fierastraului (intre 1 si 50): ")
if not validare_input(n):
print("Datele de intrare nu corespund cerintei.")
else:
print("Datele de intrare corespund restrictiilor impuse.")
fierastrau = construire_fierastrau(int(n))
print(fierastrau)
print("Suma dintilor fierastraului este:", suma_dintilor_fierastrau(fierastrau))

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicații ==
#1 Funcția validare_input primește un număr ca argument și returnează True dacă este un număr întreg între 1 și 50, altfel returnează False.

#2 Funcția construire_fierastrau primește un număr natural n și construiește un fierăstrău de gradul n conform cerinței, sub forma unei liste de întregi. Pentru a construi fierăstrăul, se apelează recursiv funcția construire_fierastrau cu argumentul n-1, până se ajunge la fierăstrăul de gradul 1, caz în care se returnează lista [1]. Pentru a construi fierăstrăul de gradul n, se concatenază în ordine fierăstrăul de gradul n-1, un element nou n și din nou fierăstrăul de gradul n-1.

#3 Funcția suma_dintilor_fierastrau primește o listă de întregi reprezentând un fierăstrău și returnează suma valorilor acestor întregi.

#4Funcția main primește de la utilizator un număr natural n, validează datele și, dacă datele sunt corecte, construiește fierăstrăul corespunzător, calculează suma dintilor și afișează lista fierăstrăului și suma.