Bitnami MediaWiki - User contributions [en]

15324

2024-12-11T10:10:25Z

Ghisa Catalin:

'''E:15324 (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Determinați cifrele nenule <math>x</math> și <math>y</math> pentru care <math>\frac{y^3}{x^3} - \frac{\overline{xy}}{x} = 2\left(\frac{\overline{xy}}{x} - 16\right)</math>.''

'''Soluție.''' Avem:

<math>\frac{y^3}{x^3} - 3\frac{y}{x} + 32 = 0</math> și, cum <math>\frac{\overline{xy}}{x} = \frac{10x + y}{x} = 10 + \frac{y}{x}</math>, obținem:

<math>\frac{y^3}{x^3} - 3\frac{y}{x} + 2 = 0</math>. Notăm <math>\frac{y}{x} = t > 0</math> și obținem ecuația <math>t^3 - 3t + 2 = 0</math> cu soluțiile:

<math>t = 1</math> și <math>t = -2</math>. Din <math>\frac{y}{x} = 1</math> obținem <math>x = y</math>, de unde perechile de cifre posibile sunt:

<math>(1,1), (2,2), (3,3), (4,4), (5,5), (6,6), (7,7), (8,8)</math> sau <math>(9,9)</math>.

15324

2024-12-11T10:08:53Z

Ghisa Catalin: Created page with "'''E:15324 (Cristina Vijdeluc și Mihai Vijdeluc)''' ''Determinați cifrele nenule <math>x</math> și <math>y</math> pentru care <math>\frac{y^3}{x^3} - \frac{xy}{x} = 2\left(\frac{xy}{x} - 16\right)</math>.'' '''Soluție.''' Avem: <math>\frac{y^3}{x^3} - 3\frac{y}{x} + 32 = 0</math> și, cum <math>\frac{xy}{x} = \frac{10x + y}{x} = 10 + \frac{y}{x}</math>, obținem: <math>\frac{y^3}{x^3} - 3\frac{y}{x} + 2 = 0</math>. Notăm <math>\frac{y}{x} = t > 0</math> și obț..."

'''E:15324 (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Determinați cifrele nenule <math>x</math> și <math>y</math> pentru care <math>\frac{y^3}{x^3} - \frac{xy}{x} = 2\left(\frac{xy}{x} - 16\right)</math>.''

'''Soluție.''' Avem:

<math>\frac{y^3}{x^3} - 3\frac{y}{x} + 32 = 0</math> și, cum <math>\frac{xy}{x} = \frac{10x + y}{x} = 10 + \frac{y}{x}</math>, obținem:

<math>\frac{y^3}{x^3} - 3\frac{y}{x} + 2 = 0</math>. Notăm <math>\frac{y}{x} = t > 0</math> și obținem ecuația <math>t^3 - 3t + 2 = 0</math> cu soluțiile:

<math>t = 1</math> și <math>t = -2</math>. Din <math>\frac{y}{x} = 1</math> obținem <math>x = y</math>, de unde perechile de cifre posibile sunt:

<math>(1,1), (2,2), (3,3), (4,4), (5,5), (6,6), (7,7), (8,8)</math> sau <math>(9,9)</math>.

15323

2024-12-11T10:05:59Z

Ghisa Catalin:

'''E:15323 (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Arătați că există o infinitate de numere naturale diferite <math>a</math> și <math>b</math> pentru care <math>4a^2 - 2022ab + 2018b^2 = 0</math>.''

'''Soluție.''' Relația se scrie:

<math>4a^2 - 4ab - 2018ab + 2018b^2 = 0</math>

sau

<math>4a(a - b) - 2018b(a - b) = 0</math>.

Cum <math>a \neq b</math>, putem împărți prin <math>2(a - b)</math> și obținem:

<math>2a - 1009b = 0</math>.

Orice pereche de forma <math>(1009k, 2k)</math>, unde <math>k</math> este un număr natural, este soluție a acestei ecuații.

15323

2024-12-11T10:05:15Z

Ghisa Catalin:

**E:15323 (Cristina Vijdeluc și Mihai Vijdeluc)**

*Arătați că există o infinitate de numere naturale diferite a și b pentru care 4a² - 2022ab + 2018b² = 0.*

**Soluție**

Relația se scrie:

4a² - 4ab - 2018ab + 2018b² = 0

sau

4a(a - b) - 2018b(a - b) = 0.

Cum a ≠ b, putem împărți prin 2(a - b) și obținem:

2a - 1009b = 0.

Orice pereche de forma (1009k, 2k), unde k este un număr natural, este soluție a acestei ecuații.

15323

2024-12-11T10:03:00Z

Ghisa Catalin:

15323

2024-12-11T10:02:22Z

Ghisa Catalin:

'''E:15323 (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Arătați că există o infinitate de numere naturale diferite <math>a</math> și <math>b</math> pentru care <math>4a^2 - 2022ab + 2018b^2 = 0</math>.''

'''Soluție.''' Relația se scrie:

<math>4a^2 - 4ab - 2018ab + 2018b^2 = 0</math>

sau

<math>4a(a-b) - 2018b(a-b) = 0.</math>

Cum <math>a \neq b</math>, putem împărți prin <math>2(a-b)</math> și obținem:

<math>2a - 1009b = 0.</math>

Orice pereche de forma <math>(1009k, 2k)</math>, unde <math>k</math> este un număr natural, este soluție a acestei ecuații.

15323

2024-12-11T10:01:53Z

Ghisa Catalin:

'''E:15323 (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Arătați că există o infinitate de numere naturale diferite a și b pentru care <math>4a^2 - 2022ab + 2018b^2 = 0</math>.''

'''Soluție.''' Relația se scrie

<math>4a^2 - 4ab - 2018ab + 2018b^2 = 0</math>

sau

<math>4a(a - b) - 2018b(a - b) = 0.</math>

Cum <math>a \neq b</math> putem împărți prin <math>2(a - b)</math> și obținem <math>2a - 1009b = 0.</math> Orice pereche de forma <math>(1009k, 2k)</math>, unde <math>k</math> este număr natural este soluție a acestei ecuații.

15323

2024-12-11T10:01:05Z

Ghisa Catalin:

'''E:15323 (Cristina Vijdeluc și Mihai Vijdeluc)'''

''Arătați că există o infinitate de numere naturale diferite a și b pentru care <math>4a^2 - 2022ab + 2018b^2 = 0</math>.''

15323

2024-12-11T10:00:24Z

Ghisa Catalin:

'''E:15323 (Cristina Vijdeluc și Mihai Vijdeluc)'''
''Arătați că există o infinitate de numere naturale diferite a și b pentru care <math>4a^2 - 2022ab + 2018b^2 = 0</math>.''

15323

2024-12-11T09:57:34Z

Ghisa Catalin:

'''E:15323 (Cristina Vijdeluc și Mihai Vijdeluc)'''

15323

2024-12-11T09:57:21Z

Ghisa Catalin: Created page with "<nowiki>'''</nowiki>E:15323 (Cristina Vijdeluc și Mihai Vijdeluc)<nowiki>'''</nowiki>"

<nowiki>'''</nowiki>E:15323 (Cristina Vijdeluc și Mihai Vijdeluc)<nowiki>'''</nowiki>

0096 - Palindrom Maxim

2023-12-26T14:37:57Z

Ghisa Catalin:

== Cerinţa ==
Să se scrie un program care citește o propoziție și determină cuvântul '''palindrom'' de lungime maximă.
== Date de intrare ==
Programul citește de la tastatură o propoziție alcătuită din litere mici sau mari ale alfabetului englez, cifre, semne de punctuație și spații.
== Date de ieșire ==
Programul afișează pe ecran cel mai lung cuvânt palindrom.
== Restricţii şi precizări ==
* propoziția va conține cel mult '''255''' de caractere;
* cuvintele conțin doar litere și/sau cifre și conțin cel mult '''20''' de caractere;
* dacă în propoziție există mai multe cuvinte palindrom de lungime maximă, se va afișa primul dintre ele;
* semnele de punctuație din propoziție pot fi ''':;.,'''
* nu se face distincție între literele mari și cele mici;
* pentru toate testele date există soluție
== Exemplul 1 ==
; Intrare
121 prieteni analizeaza Un capac; aeriSIrea radar
; Iesire
Datele de intrare corespund restrictiilor impuse
aeriSIrea
 

== Exemplul 2 ==
; Intrare
121 prieteni analizeazacevafoarteinteresant Un capac; aeriSIrea radar
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
import string

def main():
# Citirea propoziției de la tastatură
propozitie = input().strip()

# Verifică dacă propoziția respectă restricțiile
if len(propozitie) > 255:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(len(cuvant) > 20 for cuvant in propozitie.split()):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Eliminarea semnelor de punctuație din propoziție
propozitie = propozitie.translate(str.maketrans('', '', string.punctuation))

# Căutarea celui mai lung cuvânt palindrom
cuvinte = propozitie.split()
cuvinte_palindrom = [cuvant for cuvant in cuvinte if cuvant.lower() == cuvant.lower()[::-1]]
cuvant_maxim = max(cuvinte_palindrom, key=len) if cuvinte_palindrom else "nu exista"

# Afișarea cuvântului obținut
print(cuvant_maxim)

if __name__ == "__main__":
main()

</syntaxhighlight>
==Explicatie==
În propoziție sunt '''4''' cuvinte palindrom: '''121, capac, aeriSIrea, radar.''' Dintre acestea, cel mai lung este '''aeriSIrea'''.

0846 - Dubluri

2023-12-26T14:35:17Z

Ghisa Catalin:

== Cerinţa ==
Se dă un șir de caractere ce conține doar litere mici ale alfabetului englez. Să se afișeze cel mai lung subșir care apare de cel puțin două ori în șirul dat.
== Date de intrare ==
Programul citește de la tastatură șirul dat.
== Date de ieșire ==
Programul va afișa pe ecran cel mai lung subșir cu cel puțin două apariții.
== Restricţii şi precizări ==
* șirul dat are cel mult '''255''' caractere
* dacă există mai multe subșiruri de lungime maximă care apar de cel puțin două ori, se va afișa primul în ordine lexicografică.
* pentru toate datele de test există cel puțin un subșir din cel puțin două caractere, care se repetă
== Exemplul 1 ==
; Intrare
cbddccdaaddccaaddbccbbdbddd
; Iesire
Datele de intrare corespund restrictiilor impuse
aadd
 

== Exemplul 2 ==
; Intrare
Bunaziua
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de caractere de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 255:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(not caracter.islower() for caracter in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Căutarea celui mai lung subșir care apare de cel puțin două ori
lungime_maxima = 0
subșir_maxim = ''
for i in range(len(sir)):
for j in range(i+2, len(sir)+1):
subșir = sir[i:j]
if sir.count(subșir) >= 2 and len(subșir) > lungime_maxima:
lungime_maxima = len(subșir)
subșir_maxim = subșir
elif len(subșir) == lungime_maxima and subșir < subșir_maxim:
subșir_maxim = subșir

# Afișarea subșirului obținut
print(subșir_maxim)

if __name__ == "__main__":
main()

</syntaxhighlight>
== Explicatie ==
Sirul '''aadd''' apare de două ori șirul dat. Niciun șir de lungime mai mare nu apare de cel puțin două ori. Să observăm că și șirul '''ddcc''' apare de două ori, dar ele este mai mare decât '''aadd''', în ordinea lexicografică.

0973 - Cuvinte 1

2023-12-26T14:34:04Z

Ghisa Catalin:

== Cerinţa ==
Se dă o propoziție care conține numai litere mici ale alfabetului englez și spații. Să se afișeze cuvintele din propoziție care conțin numai vocale.
== Date de intrare ==
Programul citește de la tastatură șirul dat.
== Date de ieșire ==
Programul va afișa pe ecran cuvintele cerute, în ordinea din propoziție, câte un cuvânt pe linie.
== Restricţii şi precizări ==
* propoziția va conține cel mult '''255''' de caractere
== Exemplu 1 ==
; Intrare
ei pazesc o oaie
; Iesire
Datele de intrare corespund restrictiilor impuse
ei
o
oaie
 
== Exemplu 2 ==
; Intrare
Ei pazesc o oaie
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea propoziției de la tastatură
propozitie = input().strip()

# Verifică dacă propoziția respectă restricțiile
if len(propozitie) > 255 or any(not caracter.islower() and not caracter.isspace() for caracter in propozitie):
print("Datele de intrare nu corespund restrictiilor impuse")
return
else:
print("Datele de intrare corespund restrictiilor impuse")

# Afișarea cuvintelor din propoziție care conțin numai vocale
vocale = set('aeiou')
cuvinte = propozitie.split()
for cuvant in cuvinte:
if set(cuvant).issubset(vocale):
print(cuvant)

if __name__ == "__main__":
main()

</syntaxhighlight>

0887 - Nr Anagrame

2023-12-13T15:48:16Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se dă un şir de caractere ce conţine cuvinte formate din litere mici ale alfabetului englez, separate prin unul sau mai multe spații. Să se determine câte cuvinte din sir sunt anagrame ale ultimului cuvânt, fără a fi identice cu acesta == Date de intrare == Programul va citi de la tastatură şirul dat. == Date de ieșire == Programul va afişa pe ecran un număr '''C''', reprezentând valoarea cerută. == Restricţii şi precizări == * șirul dat va...

== Cerinţa ==
Se dă un şir de caractere ce conţine cuvinte formate din litere mici ale alfabetului englez, separate prin unul sau mai multe spații. Să se determine câte cuvinte din sir sunt anagrame ale ultimului cuvânt, fără a fi identice cu acesta
== Date de intrare ==
Programul va citi de la tastatură şirul dat.
== Date de ieșire ==
Programul va afişa pe ecran un număr '''C''', reprezentând valoarea cerută.
== Restricţii şi precizări ==
* șirul dat va conține cel mult 255 caractere, litere mici ale alfabetului englez și spații
== Exemplu 1 ==
; Intrare
arc ingrat din granit car argint arc rating rac argint
; Iesire
Datele de intrare corespund restrictiilor impuse
3
 
== Exemplu 2 ==
; Intrare
ARC ingrat din granit car argint arc rating rac argint
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 255 or not all(c.islower() or c.isspace() for c in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Separarea șirului în cuvinte
cuvinte = sir.split()

# Obținerea ultimului cuvânt și a anagramei sale
ultimul_cuvant = cuvinte[-1]
anagrama = sorted(ultimul_cuvant)

# Calcularea numărului de cuvinte care sunt anagrame ale ultimului cuvânt, dar nu sunt identice cu acesta
numar_cuvinte = sum(sorted(cuvant) == anagrama and cuvant != ultimul_cuvant for cuvant in cuvinte[:-1])

# Afișarea numărului de cuvinte
print(numar_cuvinte)

if __name__ == "__main__":
main()

</syntaxhighlight>

2592 - Afis Simetric

2023-12-13T15:44:18Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se dau '''n''' șiruri de caractere care conțin cuvinte formate doar din litere mici și mari ale alfabetului englez, separate prin câte un singur spațiu. Să se afișeze un nou șir format din primul cuvânt al fiecărui șir în ordinea citirii, al doilea cuvânt al fiecărui șir în ordinea citirii, etc. Dacă șirurile nu au același număr de cuvinte, se continuă acest proces, până când fiecare șir ajunge la final, tot în ordinea citirii. == Dat...

== Cerinţa ==
Se dau '''n''' șiruri de caractere care conțin cuvinte formate doar din litere mici și mari ale alfabetului englez, separate prin câte un singur spațiu.

Să se afișeze un nou șir format din primul cuvânt al fiecărui șir în ordinea citirii, al doilea cuvânt al fiecărui șir în ordinea citirii, etc. Dacă șirurile nu au același număr de cuvinte, se continuă acest proces, până când fiecare șir ajunge la final, tot în ordinea citirii.
== Date de intrare ==
Se citește de la tastatură pe prima linie numărul '''n''', iar pe următoarele '''n''' linii cele '''n''' șiruri de caractere.
== Date de ieșire ==
Programul va afișa pe ecran șirul rezultat conform cerinței.
== Restricţii şi precizări ==
* 1 &les; n &les; 10
* fiecare șir are maximum '''1000''' de caractere
== Exemplu 1 ==
; Intrare
3
ana are mere
el are
ea are pere prune
; Iesire
Datele de intrare corespund restrictiilor impuse
ana el ea are are are mere pere prune
 
== Exemplu 2 ==
; Intrare
-1
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea numărului de șiruri de la tastatură
n = int(input().strip())

# Verificarea dacă numărul de șiruri respectă restricțiile
if not 1 <= n <= 10:
print("Datele de intrare nu corespund restrictiilor impuse")
return

# Citirea șirurilor de la tastatură și separarea lor în cuvinte
siruri = [input().strip().split() for _ in range(n)]

# Verificarea dacă șirurile respectă restricțiile
if any(len(sir) > 1000 or not all(cuvant.isalpha() for cuvant in sir) for sir in siruri):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Crearea unui nou șir format din cuvintele fiecărui șir în ordinea citirii
sir_nou = []
for i in range(max(len(sir) for sir in siruri)):
for sir in siruri:
if i < len(sir):
sir_nou.append(sir[i])

# Afișarea noului șir
print(' '.join(sir_nou))

if __name__ == "__main__":
main()

</syntaxhighlight>

0799 - Eliminare Litera

2023-12-13T15:39:16Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Să se scrie un program care citește un șir de caractere în care cuvintele sunt formate numai din litere mici ale alfabetului englez și sunt separate prin câte un spațiu și elimină litera din mijloc a fiecărui cuvânt cu număr impar de litere (cel puțin trei). == Date de intrare == Programul citește de la tastatură un șir de cel mult '''100''' caractere == Date de ieșire == Programul afișează pe ecran textul obţinut, iar dacă nu există niciu...

== Cerinţa ==
Să se scrie un program care citește un șir de caractere în care cuvintele sunt formate numai din litere mici ale alfabetului englez și sunt separate prin câte un spațiu și elimină litera din mijloc a fiecărui cuvânt cu număr impar de litere (cel puțin trei).
== Date de intrare ==
Programul citește de la tastatură un șir de cel mult '''100''' caractere
== Date de ieșire ==
Programul afișează pe ecran textul obţinut, iar dacă nu există niciun cuvânt modificat, afișează pe ecran mesajul '''nu exista'''.
== Exemplu 1 ==
; Intrare
pictura prin aceea arata o pace profunda
; Iesire
Datele de intrare corespund restrictiilor impuse
picura prin acea arta o pace profunda
 
== Exemplu 2 ==
; Intrare
Loremipsumdolorsitamet,consecteturadipiscingelit.Vestibulumeuismodnequeeumetusrhoncus,neciaculispurussollicitudin.Quisquecondimentum,lacusidsuscipitvestibulum,odiosemegestasnunc,velaliquetpuruseratnecelit.

; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 100 or not all(c.islower() or c.isspace() for c in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Separarea șirului în cuvinte
cuvinte = sir.split()

# Crearea unei liste pentru a stoca cuvintele modificate
cuvinte_modificate = []

# Parcurgerea cuvintelor și eliminarea literei din mijloc a fiecărui cuvânt cu număr impar de litere
for cuvant in cuvinte:
if len(cuvant) % 2 == 1 and len(cuvant) >= 3:
mijloc = len(cuvant) // 2
cuvant_nou = cuvant[:mijloc] + cuvant[mijloc + 1:]
cuvinte_modificate.append(cuvant_nou)
else:
cuvinte_modificate.append(cuvant)

# Verificarea dacă există cuvinte modificate
if cuvinte_modificate == cuvinte:
print("nu exista")
else:
print(" ".join(cuvinte_modificate))

if __name__ == "__main__":
main()

</syntaxhighlight>

0810 - Nr A

2023-12-13T15:33:17Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se dă un şir de caractere ce conţine cuvinte formate din litere mici ale alfabetului englez, separate prin unul sau mai multe spații. Înaintea primului cuvânt nu există spații, și nici după ultimul. Să se determine numărul de cuvinte din șir în care apare litera '''a'''. == Date de intrare == Programul va citi de la tastatură şirul dat. == Date de ieșire == Programul va afişa pe ecran numărul de cuvinte determinat. == Restricţii şi preciză...

== Cerinţa ==
Se dă un şir de caractere ce conţine cuvinte formate din litere mici ale alfabetului englez, separate prin unul sau mai multe spații. Înaintea primului cuvânt nu există spații, și nici după ultimul. Să se determine numărul de cuvinte din șir în care apare litera '''a'''.
== Date de intrare ==
Programul va citi de la tastatură şirul dat.
== Date de ieșire ==
Programul va afişa pe ecran numărul de cuvinte determinat.
== Restricţii şi precizări ==
* șirul dat va conține cel mult '''70''' caractere, litere mici ale alfabetului englez și spații
== Exemplu 1 ==
; Intrare
voi sustine examenul la informatica
; Iesire
Datele de intrare corespund restrictiilor impuse
3
 
== Exemplu 2 ==
; Intrare
voi sustine examenul LA informatica
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 70 or not all(c.islower() or c.isspace() for c in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Separarea șirului în cuvinte
cuvinte = sir.split()

# Calcularea numărului de cuvinte care conțin litera 'a'
numar_cuvinte = sum('a' in cuvant for cuvant in cuvinte)

# Afișarea numărului de cuvinte
print(numar_cuvinte)

if __name__ == "__main__":
main()

</syntaxhighlight>

0232 - Eliminare Numere

2023-12-13T15:27:38Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Să se scrie un program care citeşte de la tastatură un şir de cel mult '''100''' de caractere,format din cuvinte şi numere, separate prin unul sau mai multe spații. Cuvintele sunt formate numai din litere ale alfabetului englez. Toate numerele sunt reale, pozitive şi sunt formate numai din parte întreagă sau din parte întreagă şi parte fracționară, separate prin punctul zecimal (.). Programul va elimina din şir toate numerele care au parte frac...

== Cerinţa ==
Să se scrie un program care citeşte de la tastatură un şir de cel mult '''100''' de caractere,format din cuvinte şi numere, separate prin unul sau mai multe spații. Cuvintele sunt formate numai din litere ale alfabetului englez. Toate numerele sunt reale, pozitive şi sunt formate numai din parte întreagă sau din parte întreagă şi parte fracționară, separate prin punctul zecimal (.).

Programul va elimina din şir toate numerele care au parte fracționară.
== Date de intrare ==
Programul citeşte de la tastatură un şir de cel mult '''100''' caractere.
== Date de ieșire ==
Programul afişează pe ecran şirul obţinut prin eliminarea numerelor care au parte fracționară.
== Exemplu 1 ==
; Intrare
Reprezentat cu 4 zecimale PI este 3.1415 si e este 2.7182
; Iesire
Datele de intrare corespund restrictiilor impuse
Reprezentat cu 4 zecimale PI este si e este
 
== Exemplu 2 ==
; Intrare
Loremipsumdolorsitamet,consecteturadipiscingelit.Vestibulumeuismodnequeeumetusrhoncus,neciaculispurussollicitudin.Quisquecondimentum,lacusidsuscipitvestibulum,odiosemegestasnunc,velaliquetpuruseratnecelit.
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
import re

def main():
# Citirea șirului de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 100:
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Crearea unui pattern regex pentru a găsi numerele cu parte fracționară
pattern = r'\b\d+\.\d+\b'

# Înlocuirea numerelor cu parte fracționară cu un șir gol
sir_nou = re.sub(pattern, '', sir)

# Afișarea noului șir
print(sir_nou)

if __name__ == "__main__":
main()

</syntaxhighlight>

0200 - Eliminare Subsir 1

2023-12-13T15:23:24Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se dau două şiruri de caractere '''s''' şi '''t'''. Să se elimine din '''s''' toate apariţiile lui '''t'''. == Date de intrare == Programul citește de la tastatură cele două şiruri, '''s''', respectiv '''t''', separate prin caracterul '''NewLine'''. == Date de ieșire == Programul afișează pe ecran şirul '''s''', obţinut după transformarea cerută. == Restricţii şi precizări == * cele două şiruri conţin cel mult '''255''' caractere. == Exemp...

== Cerinţa ==
Se dau două şiruri de caractere '''s''' şi '''t'''. Să se elimine din '''s''' toate apariţiile lui '''t'''.
== Date de intrare ==
Programul citește de la tastatură cele două şiruri, '''s''', respectiv '''t''', separate prin caracterul '''NewLine'''.
== Date de ieșire ==
Programul afișează pe ecran şirul '''s''', obţinut după transformarea cerută.
== Restricţii şi precizări ==
* cele două şiruri conţin cel mult '''255''' caractere.
== Exemplu 1 ==
; Intrare
ana si mariana canta la nai
na
; Iesire
Datele de intrare corespund restrictiilor impuse
ana si mariana canta la i
 
== Exemplu 2 ==
; Intrare
Loremipsumdolorsitamet,consecteturadipiscingelit.Nullafacilisi.Vestibulumeuismodnequeeumetusrhoncus,neciaculispurussollicitudin.Quisquecondimentum,lacusidsuscipitvestibulum,odiosemegestasnunc,velaliquetpuruseratnecelit.Nullamelementumleoacorcicongue,infringillanisleuismod.Sedaliquet,elit eupellentesqueaccumsanjusitocursuslacus,idhendreritnisl.

; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirurilor de la tastatură
s = input().strip()
t = input().strip()

# Verifică dacă șirurile respectă restricțiile
if len(s) > 255 or len(t) > 255:
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Găsirea ultimei apariții a lui t în s
pozitie = s.rfind(t)

# Verificarea dacă t a fost găsit în s
if pozitie != -1:
# Eliminarea ultimei apariții a lui t din s
s_nou = s[:pozitie] + s[pozitie + len(t):]
else:
s_nou = s

# Afișarea noului șir
print(s_nou)

if __name__ == "__main__":
main()

</syntaxhighlight>

0199 - Eliminare Subsir

2023-12-13T15:19:35Z

== Cerinţa ==
Se dau două şiruri de caractere '''s''' şi '''t'''. Să se elimine din '''s''' toate apariţiile lui '''t'''.
== Date de intrare ==
Programul citește de la tastatură cele două şiruri, '''s''', respectiv '''t''', separate prin caracterul '''NewLine'''.
== Date de ieșire ==
Programul afișează pe ecran şirul '''s''', obţinut după transformarea cerută.
== Restricţii şi precizări ==
* cele două şiruri conţin cel mult '''255''' caractere.
* aparițiile șirului '''t''' în '''s''' nu se suprapun
== Exemplu 1 ==
; Intrare
ana si mariana canta la nai
na
; Iesire
Datele de intrare corespund restrictiilor impuse
a si maria canta la i
 
== Exemplu 2 ==
; Intrare
Loremipsumdolorsitamet,consecteturadipiscingelit.Nullafacilisi.Vestibulumeuismodnequeeumetusrhoncus,neciaculispurussollicitudin.Quisquecondimentum,lacusidsuscipitvestibulum,odiosemegestasnunc,velaliquetpuruseratnecelit.Nullamelementumleoacorcicongue,infringillanisleuismod.Sedaliquet,elit eupellentesqueaccumsanjusitocursuslacus,idhendreritnisl.

; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirurilor de la tastatură
s = input().strip()
t = input().strip()

# Verifică dacă șirurile respectă restricțiile
if len(s) > 255 or len(t) > 255:
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Eliminarea tuturor aparițiilor lui t din s
s_nou = s.replace(t, '')

# Afișarea noului șir
print(s_nou)

if __name__ == "__main__":
main()

</syntaxhighlight>

0188 - Inlocuire Cuvant

2023-12-13T15:12:47Z

Ghisa Catalin: Pagină nouă: Se dau două cuvinte '''a''' şi '''b''' şi o propoziţie '''s''' formată numai din litere mici ale alfabetului englez şi spaţii. == Cerinţa == Să se modifice '''s''', înlocuind fiecare apariţie a cuvântului '''a''' cu cuvântul '''b'''. == Date de intrare == Fişierul de intrare '''inlocuirecuvantin.txt''' conţine pe prima linie cuvintele '''a''' şi '''b''', separate printr-un spaţiu, iar pe a doua linie propoziţia '''s'''. == Date de ieșire == Fişierul de ie...

Se dau două cuvinte '''a''' şi '''b''' şi o propoziţie '''s''' formată numai din litere mici ale alfabetului englez şi spaţii.
== Cerinţa ==
Să se modifice '''s''', înlocuind fiecare apariţie a cuvântului '''a''' cu cuvântul '''b'''.
== Date de intrare ==
Fişierul de intrare '''inlocuirecuvantin.txt''' conţine pe prima linie cuvintele '''a''' şi '''b''', separate printr-un spaţiu, iar pe a doua linie propoziţia '''s'''.
== Date de ieșire ==
Fişierul de ieşire '''inlocuirecuvantout.txt''' va conţine pe prima linie propoziţia '''s''', modificată în conformitate cu cerinţa.
== Restricţii şi precizări ==
* propoziţia '''s''' va avea cel mult '''100''' caractere
* cuvintele '''a''' şi '''b''' vor avea cel mult '''10''' caractere
* cuvintele sunt formate numai din litere mici ale alfabetului englez
== Exemplu 1 ==
; inlocuirecuvantin.txt
dar insa
dar nu trebuie dar e mai bine astfel
; inlocuirecuvantout.txt
Datele de intrare corespund restrictiilor impuse
insa nu trebuie insa e mai bine astfel
 
== Exemplu 2 ==
; inlocuirecuvantin.txt
dar neînsemnând
dar nu trebuie dar e mai bine astfel
; inlocuirecuvantout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea cuvintelor și a propoziției din fișierul 'inlocuirecuvant.in'
with open('inlocuirecuvantin.txt', 'r') as f:
a, b = f.readline().strip().split()
s = f.readline().strip()

# Verifică dacă cuvintele și propoziția respectă restricțiile
if len(a) > 10 or len(b) > 10 or len(s) > 100 or not (a.isalpha()
and b.isalpha() and all(c.isalpha() or c.isspace() for c in s)):
result = "Datele de intrare nu corespund restrictiilor impuse"
else:
result = "Datele de intrare corespund restrictiilor impuse"

# Înlocuirea fiecărei apariții a cuvântului a cu cuvântul b în propoziție
s_noua = s.replace(a, b)
result += "\n" + s_noua

# Scrierea rezultatului în fișierul 'inlocuirecuvant.out'
with open('inlocuirecuvantout.txt', 'w') as f:
f.write(result)

if __name__ == "__main__":
main()

</syntaxhighlight>

0156 - Eliminare 1

2023-12-13T14:59:41Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Scrieţi un program care citeşte de la tastatură un şir de cel mult 50 de caractere (cifre, litere ale alfabetului englez şi spaţii; şirul conţine cel puţin o literă), apoi construieşte în memorie şi afişează pe ecran şirul de caractere obţinut din şirul citit prin eliminarea tuturor caracterelor care nu sunt litere. == Date de intrare == Programul citeşte de la tastatură un şir de cel mult 50 de caractere. == Date de ieșire == Programul va...

== Cerinţa ==
Scrieţi un program care citeşte de la tastatură un şir de cel mult 50 de caractere (cifre, litere ale alfabetului englez şi spaţii; şirul conţine cel puţin o literă), apoi construieşte în memorie şi afişează pe ecran şirul de caractere obţinut din şirul citit prin eliminarea tuturor caracterelor care nu sunt litere.
== Date de intrare ==
Programul citeşte de la tastatură un şir de cel mult 50 de caractere.
== Date de ieșire ==
Programul va afişa pe ecran şirul obţinut din şirul citit prin eliminarea tuturor caracterelor care nu sunt litere.
== Exemplu 1 ==
; Intrare
Pe 12 mergem la munte
; Iesire
Datele de intrare corespund restrictiilor impuse
Pemergemlamunte
 
== Exemplu 2 ==
; Intrare
Loremipsumdolorsitamet,consecteturadipiscingelit.Vestibulumeuismodnequeeumetusrhoncus.
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 50 or not any(caracter.isalpha() for caracter in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Crearea unui nou șir prin eliminarea tuturor caracterelor care nu sunt litere
sir_nou = ''.join(caracter for caracter in sir if caracter.isalpha())

# Afișarea noului șir
print(sir_nou)

if __name__ == "__main__":
main()

</syntaxhighlight>

2686 - ASCII Comp

2023-12-13T14:41:27Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Numim '''cuvânt''' un șir de caractere care nu conține spații și conține cel puțin o literă. Numim '''valoarea ASCII''' a unui cuvânt suma codurilor ASCII ale caracterelor care fac parte din acel cuvânt. Se dă un șir de caractere, care conține litere mici și mari ale alfabetului englez, spații, cifre și alte simboluri. Să se afișeze pe câte un rând valoarea ASCII și cuvintele care au acea valoare, în ordinea crescătoare a valorilor ASCII...

== Cerinţa ==
Numim '''cuvânt''' un șir de caractere care nu conține spații și conține cel puțin o literă. Numim '''valoarea ASCII''' a unui cuvânt suma codurilor ASCII ale caracterelor care fac parte din acel cuvânt.

Se dă un șir de caractere, care conține litere mici și mari ale alfabetului englez, spații, cifre și alte simboluri. Să se afișeze pe câte un rând valoarea ASCII și cuvintele care au acea valoare, în ordinea crescătoare a valorilor ASCII. Cuvintele cu aceeași valoare a codurilor ASCII sunt afișate pe aceeași linie cu spații între ele în ordinea în care apar în șir.
== Date de intrare ==
Programul citește de la tastatură șirul de caractere.
== Date de ieșire ==
Programul va afișa pe ecran pe câte un rând valoarea ASCII și cuvintele care au acea valoare separate printr-un spațiu, în ordine crescătoare a valorilor codurilor ASCII. Dacă nu există niciun cuvânt în șirul dat se va afișa '''NU EXISTA'''.
== Restricţii şi precizări ==
* șirul de caractere va avea maximum 255 de caractere.
== Exemplu 1 ==
; Intrare
ana rem abc ad01 22222,
; Iesire
Datele de intrare corespund restrictiilor impuse
294 abc ad01
304 ana
324 rem
 
== Exemplu 2 ==
; Intrare
Loremipsumdolorsitamet,consecteturadipiscingelit.Nullafacilisi.Vestibulumeuismodnequeeumetusrhoncus,neciaculispurussollicitudin.Quisquecondimentum,lacusidsuscipitvestibulum,odiosemegestasnunc,velaliquetpuruseratnecelit.Nullamelementumleoacorcicongue,infringillanisleuismod.Sedaliquet,elit eupellentesqueaccumsanjusitocursuslacus,idhendreritnisl.
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 255:
print("Datele de intrare nu corespund restrictiilor impuse")
return

# Separarea șirului în cuvinte
cuvinte = sir.split()

# Crearea unui dicționar pentru a stoca cuvintele și valorile lor ASCII
valori_ascii = {}

# Calcularea valorii ASCII pentru fiecare cuvânt și adăugarea acestuia în dicționar
for cuvant in cuvinte:
if any(caracter.isalpha() for caracter in cuvant):
valoare_ascii = sum(ord(caracter) for caracter in cuvant)
if valoare_ascii not in valori_ascii:
valori_ascii[valoare_ascii] = []
valori_ascii[valoare_ascii].append(cuvant)

# Verificarea dacă există cuvinte în dicționar
if not valori_ascii:
print("NU EXISTA")
return

print("Datele de intrare corespund restrictiilor impuse")

# Afișarea valorilor ASCII și a cuvintelor în ordine crescătoare a valorilor ASCII
for valoare in sorted(valori_ascii):
print(valoare, ' '.join(valori_ascii[valoare]))

if __name__ == "__main__":
main()

</syntaxhighlight>

== Explicatie ==
'''ana''' are valoarea '''304''', '''rem''' are valoarea '''324''', '''abc''' și '''ad01''' au valoarea '''294''', iar '''22222''', nu este cuvânt pentru ca nu conține nicio literă; s-au afișat cuvintele în ordine crescătoare a codurilor '''ASCII'''.

0137 - Afisare Litere

2023-12-13T14:35:38Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Să se scrie un program care citește un șir de caractere și afișează o singură dată literele mici din șir în ordinea în care apar în șir. == Date de intrare == Programul citește de la tastatură o un șir de cel mult '''255''' caractere. == Date de ieșire == Programul afișează pe ecran, separate prin câte un spațiu, literele mici din sir, în ordinea în care apar în șir. == Restricţii şi precizări == * șirul va conține cel puțin o lit...

== Cerinţa ==
Să se scrie un program care citește un șir de caractere și afișează o singură dată literele mici din șir în ordinea în care apar în șir.
== Date de intrare ==
Programul citește de la tastatură o un șir de cel mult '''255''' caractere.
== Date de ieșire ==
Programul afișează pe ecran, separate prin câte un spațiu, literele mici din sir, în ordinea în care apar în șir.
== Restricţii şi precizări ==
* șirul va conține cel puțin o literă mică
== Exemplu 1 ==
; Intrare
Ana are mere
; Iesire
Datele de intrare corespund restrictiilor impuse
n a r e m
 
== Exemplu 2 ==
; Intrare
ANA ARE MERE
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 255 or not any(caracter.islower() for caracter in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Crearea unui set pentru a stoca literele mici unice
litere_unice = set()

# Parcurgerea șirului și adăugarea literelor mici unice în set
for caracter in sir:
if caracter.islower() and caracter not in litere_unice:
litere_unice.add(caracter)
print(caracter, end=' ')

if __name__ == "__main__":
main()

</syntaxhighlight>

2953 - Inserare Char

2023-12-13T14:29:23Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Scrieți un program care citește un cuvânt cu cel mult '''15''' litere mici ale alfabetului englez și apoi un text cu cel mult '''255''' de caractere (cuvinte formate din litere mici ale alfabetului englez separate prin unul sau mai multe spații) și care afișează șirul obținut prin inserarea în text a caracterului '''?''' după fiecare apariție a cuvântului citit. Dacă în text nu apare cuvântul citit, se va afișa mesajul '''NU APARE'''. == Date...

== Cerinţa ==
Scrieți un program care citește un cuvânt cu cel mult '''15''' litere mici ale alfabetului englez și apoi un text cu cel mult '''255''' de caractere (cuvinte formate din litere mici ale alfabetului englez separate prin unul sau mai multe spații) și care afișează șirul obținut prin inserarea în text a caracterului '''?''' după fiecare apariție a cuvântului citit. Dacă în text nu apare cuvântul citit, se va afișa mesajul '''NU APARE'''.
== Date de intrare ==
Fișierul de intrare '''inserarecharin.txt''' conține pe prima linie un cuvânt, iar pe a doua linie un text.
== Date de ieșire ==
Fișierul de ieșire '''inserarecharout.txt''' va conține textul modificat prin inserarea caracterului '''?''' după fiecare apariție a cuvântului citit, sau mesajul '''NU APARE'''
== Restricţii şi precizări ==
* textul va avea cel mult 255 de caractere litere mici din alfabetul englez și spații;
* cuvântul va avea cel mult 15 caractere, doar litere mici ale alfabetului englez.
== Exemplu 1 ==
; inserarecharin.txt
examenul
examenul de bacalaureat si examenul de atestat
; inserarecharout.txt
Datele de intrare corespund restrictiilor impuse
examenul? de bacalaureat si examenul? de atestat
 
== Exemplu 2 ==
; inserarecharin.txt
EXAMENUL
examenul de bacalaureat si examenul de atestat
; inserarecharout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea cuvântului și a textului din fișierul 'inserarechar.in'
with open('inserarecharin.txt', 'r') as f:
cuvant = f.readline().strip()
text = f.readline().strip()

# Verifică dacă cuvântul și textul respectă restricțiile
if len(cuvant) > 15 or len(text) > 255:
result = "Datele de intrare nu corespund restrictiilor impuse"
elif any(not caracter.islower() and not caracter.isspace() for caracter in cuvant + text):
result = "Datele de intrare nu corespund restrictiilor impuse"
else:
result = "Datele de intrare corespund restrictiilor impuse"

# Inserarea caracterului '?' după fiecare apariție a cuvântului citit în text
cuvinte = text.split()
cuvinte_noi = [cuv + '?' if cuv == cuvant else cuv for cuv in cuvinte]
text_nou = ' '.join(cuvinte_noi)

# Verifică dacă cuvântul citit apare în text și adaugă rezultatul la variabila 'result'
if cuvant in cuvinte:
result += "\n" + text_nou
else:
result += "\nNU APARE"

# Scrierea rezultatului în fișierul 'inserarechar.out'
with open('inserarecharout.txt', 'w') as f:
f.write(result)

if __name__ == "__main__":
main()

</syntaxhighlight>

0136 - Numarare Cuvinte

2023-12-13T14:19:18Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Să se scrie un program care citește o propoziție și determină numărul de cuvinte din propoziție care încep și se termină cu vocală. == Date de intrare == Programul citește de la tastatură o propoziție. == Date de ieșire == Programul afișează pe ecran valoarea cerută. == Restricţii şi precizări == * propoziția va conține cel mult '''150''' de caractere; * propoziția conține doar litere ale alfabetului englez și spații * se consideră v...

== Cerinţa ==
Să se scrie un program care citește o propoziție și determină numărul de cuvinte din propoziție care încep și se termină cu vocală.
== Date de intrare ==
Programul citește de la tastatură o propoziție.
== Date de ieșire ==
Programul afișează pe ecran valoarea cerută.
== Restricţii şi precizări ==
* propoziția va conține cel mult '''150''' de caractere;
* propoziția conține doar litere ale alfabetului englez și spații
* se consideră vocale caracterele din mulțimea '''{a,e,i,o,u,A,E,I,O,U}'''
== Exemplu 1 ==
; Intrare
Eratostene a sugerat ca anii bisecti se repeta la fiecare patru ani
; Iesire
Datele de intrare corespund restrictiilor impuse
4
 
== Exemplu 2 ==
; Intrare
Catalin1234!
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea propoziției de la tastatură
propozitie = input().strip()

# Verifică dacă propoziția respectă restricțiile
if len(propozitie) > 150:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(not caracter.isalpha() and not caracter.isspace() for caracter in propozitie):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Determinarea numărului de cuvinte din propoziție care încep și se termină cu vocală
vocale = 'aeiouAEIOU'
cuvinte = propozitie.split()
cuvinte_vocale = [cuvant for cuvant in cuvinte if cuvant[0] in vocale and cuvant[-1] in vocale]

# Afișarea numărului de cuvinte care încep și se termină cu vocală
print(len(cuvinte_vocale))

if __name__ == "__main__":
main()

</syntaxhighlight>

== Explicatie ==
Cuvintele din propoziție care respectă proprietatea precizată sunt: '''Eratostene, a, anii, ani'''.

2673 - Swap Cuv

2023-12-13T14:14:06Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se dă un şir de caractere care conține cuvinte formate din litere mici și mari ale alfabetului englez. Cuvintele sunt separate prin orice caractere imprimabile care nu sunt litere (cu codurile ASCII mai mari sau egale cu 32). Să se afișeze cuvintele pe cate o linie în felul următor: ; Primul Ultimul Al Doilea Penultimul ... == Date de intrare == Programul citește de la tastatură șirul dat. == Date de ieșire == Programul va afișa pe ecran cate...

== Cerinţa ==
Se dă un şir de caractere care conține cuvinte formate din litere mici și mari ale alfabetului englez. Cuvintele sunt separate prin orice caractere imprimabile care nu sunt litere (cu codurile ASCII mai mari sau egale cu 32). Să se afișeze cuvintele pe cate o linie în felul următor:
;
Primul
Ultimul
Al Doilea
Penultimul
...
== Date de intrare ==
Programul citește de la tastatură șirul dat.
== Date de ieșire ==
Programul va afișa pe ecran cate o linie cuvintele în funcție de cerintă.
== Restricţii şi precizări ==
* propoziția va conține cel mult 255 de caractere
== Exemplu 1 ==
; Intrare
divide and conquer / devide et impera.
; Iesire
Datele de intrare corespund restrictiilor impuse
divide
impera
and
et
conquer
devide
 
== Exemplu 2 ==
; Intrare
Loremipsumdolorsitamet,consecteturadipiscingelit.Nullafacilisi.Vestibulumeuismodnequeeumetusrhoncus,neciaculispurussollicitudin.Quisquecondimentum,lacusidsuscipitvestibulum,odiosemegestasnunc,velaliquetpuruseratnecelit.Nullamelementumleoacorcicongue,infringillanisleuismod.Sedaliquet,elit eupellentesqueaccumsanjusitocursuslacus,idhendreritnisl.
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
import re

def main():
# Citirea șirului de caractere de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 255:
print("Datele de intrare nu corespund restrictiilor impuse")
return

# Afișarea mesajului de confirmare
print("Datele de intrare corespund restrictiilor impuse")

# Separarea cuvintelor din șir
cuvinte = re.findall(r'\b\w+\b', sir)

# Afișarea cuvintelor în ordinea cerută
i = 0
j = len(cuvinte) - 1
while i <= j:
if i == j:
print(cuvinte[i])
else:
print(cuvinte[i])
print(cuvinte[j])
i += 1
j -= 1

if __name__ == "__main__":
main()

</syntaxhighlight>

0110 - Eliminare

2023-12-13T14:00:41Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Să se scrie un program care citeşte de la tastatură un cuvânt şi afişează pe ecran toate cuvintele care se pot obţine prin eliminarea unei singure litere din cuvântul citit. == Date de intrare == Programul citeşte de la tastatură un cuvânt de cel mult '''100''' caractere. == Date de ieșire == Programul afişează pe ecran toate cuvintele care se pot obţine prin eliminarea unei singure litere din cuvântul citit, fiecare pe o linie == Restricţii...

== Cerinţa ==
Să se scrie un program care citeşte de la tastatură un cuvânt şi afişează pe ecran toate cuvintele care se pot obţine prin eliminarea unei singure litere din cuvântul citit.
== Date de intrare ==
Programul citeşte de la tastatură un cuvânt de cel mult '''100''' caractere.
== Date de ieșire ==
Programul afişează pe ecran toate cuvintele care se pot obţine prin eliminarea unei singure litere din cuvântul citit, fiecare pe o linie
== Restricţii şi precizări ==
* cuvântul citit este alcătuit din litere mici ale alfabetului englez
* primul cuvânt afişat va fi cel obţinut prin eliminarea primei litere, al doilea va fi cel obţinut prin eliminarea celei de-a doua litere, etc.
== Exemplu 1 ==
; Intrare
caiet
; Iesire
Datele de intrare corespund restrictiilor impuse
aiet
ciet
caet
cait
caie
 
== Exemplu 2 ==
; Intrare
CAIET
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea cuvântului de la tastatură
cuvant = input().strip()

# Verifică dacă cuvântul respectă restricțiile
if len(cuvant) > 100:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(not caracter.islower() for caracter in cuvant):
print("Datele de intrare nu corespund restrictiilor impuse")
return

# Afișarea mesajului de confirmare
print("Datele de intrare corespund restrictiilor impuse")

# Afișarea cuvintelor obținute prin eliminarea unei singure litere din cuvântul citit
for i in range(len(cuvant)):
print(cuvant[:i] + cuvant[i+1:])

if __name__ == "__main__":
main()

</syntaxhighlight>

0096 - Palindrom Maxim

2023-12-12T20:30:30Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Să se scrie un program care citește o propoziție și determină cuvântul '''palindrom'' de lungime maximă. == Date de intrare == Programul citește de la tastatură o propoziție alcătuită din litere mici sau mari ale alfabetului englez, cifre, semne de punctuație și spații. == Date de ieșire == Programul afișează pe ecran cel mai lung cuvânt palindrom. == Restricţii şi precizări == * propoziția va conține cel mult '''255''' de caractere; * c...

== Cerinţa ==
Să se scrie un program care citește o propoziție și determină cuvântul '''palindrom'' de lungime maximă.
== Date de intrare ==
Programul citește de la tastatură o propoziție alcătuită din litere mici sau mari ale alfabetului englez, cifre, semne de punctuație și spații.
== Date de ieșire ==
Programul afișează pe ecran cel mai lung cuvânt palindrom.
== Restricţii şi precizări ==
* propoziția va conține cel mult '''255''' de caractere;
* cuvintele conțin doar litere și/sau cifre și conțin cel mult '''20''' de caractere;
* dacă în propoziție există mai multe cuvinte palindrom de lungime maximă, se va afișa primul dintre ele;
* semnele de punctuație din propoziție pot fi ''':;.,'''
* nu se face distincție între literele mari și cele mici;
* pentru toate testele date există soluție
== Exemplu 1 ==
; Intrare
121 prieteni analizeaza Un capac; aeriSIrea radar
; Iesire
Datele de intrare corespund restrictiilor impuse
aeriSIrea
 
== Exemplu 2 ==
; Intrare
121 prieteni analizeazacevafoarteinteresant Un capac; aeriSIrea radar
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
import string

def main():
# Citirea propoziției de la tastatură
propozitie = input().strip()

# Verifică dacă propoziția respectă restricțiile
if len(propozitie) > 255:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(len(cuvant) > 20 for cuvant in propozitie.split()):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Eliminarea semnelor de punctuație din propoziție
propozitie = propozitie.translate(str.maketrans('', '', string.punctuation))

# Căutarea celui mai lung cuvânt palindrom
cuvinte = propozitie.split()
cuvinte_palindrom = [cuvant for cuvant in cuvinte if cuvant.lower() == cuvant.lower()[::-1]]
cuvant_maxim = max(cuvinte_palindrom, key=len) if cuvinte_palindrom else "nu exista"

# Afișarea cuvântului obținut
print(cuvant_maxim)

if __name__ == "__main__":
main()

</syntaxhighlight>

2304 - Cuvinte 7

2023-12-12T20:24:28Z

Ghisa Catalin: Pagină nouă: == Cerinta == Scrieţi un program care citeşte de la tastatură, în această ordine, un număr natural '''n''', apoi n cuvinte, separate prin Enter, urmate de un număr natural '''k'''. Numerele citite sunt din intervalul '''[1,20]''', iar fiecare cuvânt este format din cel mult '''20''' de caractere, numai litere mici ale alfabetului englez. Cel puţin unul dintre cuvinte are '''k''' litere. Programul construiește în memorie, apoi afișează pe ecran, un șir care să...

== Cerinta ==
Scrieţi un program care citeşte de la tastatură, în această ordine, un număr natural '''n''', apoi n cuvinte, separate prin Enter, urmate de un număr natural '''k'''. Numerele citite sunt din intervalul '''[1,20]''', iar fiecare cuvânt este format din cel mult '''20''' de caractere, numai litere mici ale alfabetului englez. Cel puţin unul dintre cuvinte are '''k''' litere.

Programul construiește în memorie, apoi afișează pe ecran, un șir care să cuprindă cuvintele citite, separate prin câte un spațiu, astfel încât toate cele care au '''k''' litere să ocupe primele poziţii, iar celelalte să se regăsească în continuarea acestora, într-o ordine oarecare.
== Exemplu 1 ==
; Intrare
5
am
un
cires
de
mai
2
; Iesire
Datele de intrare corespund restrictiilor impuse
am un de cires mai
== Exemplu 2 ==
; Intrare
3
da
acestcuvantesteunulfoartelungdoarpentrucontext
2
2
; Iesire
Datele de intrare nu corespund restrictiilor impuse
<syntaxhighlight lang="python" line>
def main():
# Citirea numărului n de la tastatură
n = int(input().strip())

# Citirea cuvintelor de la tastatură
cuvinte = [input().strip() for _ in range(n)]

# Citirea numărului k de la tastatură
k = int(input().strip())

# Verifică dacă datele de intrare respectă restricțiile
if n < 1 or n > 20 or k < 1 or k > 20 or any(len(cuvant) > 20 or not cuvant.islower() for cuvant in cuvinte):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Separarea cuvintelor în funcție de lungimea lor
cuvinte_k = [cuvant for cuvant in cuvinte if len(cuvant) == k]
cuvinte_altele = [cuvant for cuvant in cuvinte if len(cuvant) != k]

# Construirea și afișarea șirului rezultat
sir = ' '.join(cuvinte_k + cuvinte_altele)
print(sir)

if __name__ == "__main__":
main()

</syntaxhighlight>

== Explicatie ==
Există și alte soluții corecte.

2813 - Note

2023-12-12T20:14:35Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se consideră un text cu cel mult '''100''' de caractere, în care cuvintele sunt formate din litere mari ale alfabetului englez și sunt separate prin câte un spațiu. Scrieți un program care citește de la tastatură un text de tipul menționat mai sus și afișează pe ecran, pe câte un rând, cuvintele care cuprind cel puțin o notă muzicală. Dacă nu există astfel de cuvinte, se afișează pe ecran mesajul '''nu exista'''. == Date de intrare == Prog...

== Cerinţa ==
Se consideră un text cu cel mult '''100''' de caractere, în care cuvintele sunt formate din litere mari ale alfabetului englez și sunt separate prin câte un spațiu.

Scrieți un program care citește de la tastatură un text de tipul menționat mai sus și afișează pe ecran, pe câte un rând, cuvintele care cuprind cel puțin o notă muzicală. Dacă nu există astfel de cuvinte, se afișează pe ecran mesajul '''nu exista'''.
== Date de intrare ==
Programul citește de la tastatură un text de tipul menționat.
== Date de ieșire ==
Programul va afișa pe ecran, pe câte un rând, cuvintele care cuprind cel puțin o notă muzicală. Dacă nu există astfel de cuvinte, se afișează pe ecran mesajul '''nu exista'''.
== Restricţii şi precizări ==
* cuvintele vor fi afișate în ordinea din text
* notele muzicale sunt '''DO, RE, MI, FA, SOL, LA, SI'''.
== Exemplu 1 ==
; Intrare
REMI DOMINO SI KHANHOO SUNT DENUMIRI DE JOCURI CE AU ASPECTE SIMILARE
; Iesire
Datele de intrare corespund restrictiilor impuse
REMI
DOMINO
SI
DENUMIRI
SIMILARE
 
== Exemplu 2 ==
; Intrare
remi domino si khanhoo sunt denumiri de jocuri ce au aspecte similare
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de caractere de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 100:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(not caracter.isupper() and not caracter.isspace() for caracter in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Afișarea cuvintelor care cuprind cel puțin o notă muzicală
note_muzicale = ['DO', 'RE', 'MI', 'FA', 'SOL', 'LA', 'SI']
cuvinte = sir.split()
cuvinte_cu_note = [cuvant for cuvant in cuvinte if any(nota in cuvant for nota in note_muzicale)]

# Verifică dacă există cuvinte care cuprind cel puțin o notă muzicală și afișează rezultatul
if cuvinte_cu_note:
for cuvant in cuvinte_cu_note:
print(cuvant)
else:
print("nu exista")

if __name__ == "__main__":
main()

</syntaxhighlight>

2803 - Elim P

2023-12-12T20:08:43Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se citește un număr '''p''' și un șir de caractere '''s''', șirul conține cel mult '''255''' de litere mici ale alfabetului englez. Să se afișeze toate șirurile rezultate din eliminarea, pe rând, a fiecărei secvențe de '''p''' caractere din '''s''' == Date de intrare == Programul citește de la tastatură numărul '''p''' pe prima linie și șirul '''s''' pe cea de-a doua linie. == Date de ieșire == Programul va afișa pe ecran pe câte o linie, to...

== Cerinţa ==
Se citește un număr '''p''' și un șir de caractere '''s''', șirul conține cel mult '''255''' de litere mici ale alfabetului englez. Să se afișeze toate șirurile rezultate din eliminarea, pe rând, a fiecărei secvențe de '''p''' caractere din '''s'''
== Date de intrare ==
Programul citește de la tastatură numărul '''p''' pe prima linie și șirul '''s''' pe cea de-a doua linie.
== Date de ieșire ==
Programul va afișa pe ecran pe câte o linie, toate șirurile rezultate din eliminarea, pe rând, a fiecărei secvență de '''p''' caractere din '''s'''.
== Restricţii şi precizări ==
* 1 &les; p &les; 255
* eliminările se fac de la stânga la dreapta
== Exemplu 1 ==
; Intrare
3
adina
; Iesire
Datele de intrare corespund restrictiilor impuse
na
aa
ad
 
== Exemplu 2 ==
; Intrare
-1
adina
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea numărului și a șirului de caractere de la tastatură
p = int(input().strip())
sir = input().strip()

# Verifică dacă datele de intrare respectă restricțiile
if p < 1 or p > 255 or len(sir) > 255:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(not caracter.islower() for caracter in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Afișarea șirurilor rezultate din eliminarea, pe rând, a fiecărei secvențe de p caractere din s
for i in range(len(sir) - p + 1):
print(sir[:i] + sir[i+p:])

if __name__ == "__main__":
main()

</syntaxhighlight>

0846 - Dubluri

2023-12-12T20:03:00Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se dă un șir de caractere ce conține doar litere mici ale alfabetului englez. Să se afișeze cel mai lung subșir care apare de cel puțin două ori în șirul dat. == Date de intrare == Programul citește de la tastatură șirul dat. == Date de ieșire == Programul va afișa pe ecran cel mai lung subșir cu cel puțin două apariții. == Restricţii şi precizări == * șirul dat are cel mult '''255''' caractere * dacă există mai multe subșiruri de lung...

== Cerinţa ==
Se dă un șir de caractere ce conține doar litere mici ale alfabetului englez. Să se afișeze cel mai lung subșir care apare de cel puțin două ori în șirul dat.
== Date de intrare ==
Programul citește de la tastatură șirul dat.
== Date de ieșire ==
Programul va afișa pe ecran cel mai lung subșir cu cel puțin două apariții.
== Restricţii şi precizări ==
* șirul dat are cel mult '''255''' caractere
* dacă există mai multe subșiruri de lungime maximă care apar de cel puțin două ori, se va afișa primul în ordine lexicografică.
* pentru toate datele de test există cel puțin un subșir din cel puțin două caractere, care se repetă
== Exemplu 1 ==
; Intrare
cbddccdaaddccaaddbccbbdbddd
; Iesire
Datele de intrare corespund restrictiilor impuse
aadd
 
== Exemplu 2 ==
; Intrare
Bunaziua
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de caractere de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 255:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(not caracter.islower() for caracter in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Căutarea celui mai lung subșir care apare de cel puțin două ori
lungime_maxima = 0
subșir_maxim = ''
for i in range(len(sir)):
for j in range(i+2, len(sir)+1):
subșir = sir[i:j]
if sir.count(subșir) >= 2 and len(subșir) > lungime_maxima:
lungime_maxima = len(subșir)
subșir_maxim = subșir
elif len(subșir) == lungime_maxima and subșir < subșir_maxim:
subșir_maxim = subșir

# Afișarea subșirului obținut
print(subșir_maxim)

if __name__ == "__main__":
main()

</syntaxhighlight>

0891 - Pasareste

2023-12-12T19:51:04Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Limba păsărească este foarte simplă; și asemănătoare cu limba română! Un text scris în română se traduce în păsărește astfel: după fiecare vocală se inserează litera '''p''' și vocala respectivă. Se dă o propoziție scrisă în limba română. Să se traducă în păsărească. == Date de intrare == Programul citește de la tastatură un șir de caractere '''s'''. == Date de ieșire == Programul va afișa pe ecran șirul '''t''', reprezen...

== Cerinţa ==
Limba păsărească este foarte simplă; și asemănătoare cu limba română! Un text scris în română se traduce în păsărește astfel: după fiecare vocală se inserează litera '''p''' și vocala respectivă.

Se dă o propoziție scrisă în limba română. Să se traducă în păsărească.
== Date de intrare ==
Programul citește de la tastatură un șir de caractere '''s'''.
== Date de ieșire ==
Programul va afișa pe ecran șirul '''t''', reprezentând traducerea în păsărească a șirului '''s'''.
== Restricţii şi precizări ==
* șirurile '''s''' și '''t''' vor avea cel mult '''255''' de caractere
* șirul '''s''' va conține litere mici ale alfabetului englez și spații
* vocalele sunt: '''aeiou'''
== Exemplu 1 ==
; Intrare
ana are mere
; Iesire
Datele de intrare corespund restrictiilor impuse
apanapa aparepe meperepe
 
== Exemplu 2 ==
; Intrare
Aceasta este o propozitie
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de caractere de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 255:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(not caracter.islower() and not caracter.isspace() for caracter in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Traducerea în păsărească
vocale = 'aeiou'
sir_pasareasca = ''.join([caracter + 'p' + caracter if caracter in vocale else caracter for caracter in sir])

# Afișarea șirului obținut
print(sir_pasareasca)

if __name__ == "__main__":
main()

</syntaxhighlight>

0609 - Dublare Vocale

2023-12-12T19:43:43Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se dă un şir format din cel mult '''100''' de caractere – litere mici ale alfabetului englez şi spaţii. Să se modifice acest şir prin dublarea fiecărei vocale. == Date de intrare == Programul citește de la tastatură şirul dat. == Date de ieșire == Programul va afișa pe ecran şirul obţinut în urma efectuării operaţiilor cerute. == Exemplu 1 == ; Intrare problema aceea frumoasa ; Iesire Datele de intrare corespund restrictiilor impuse proobl...

== Cerinţa ==
Se dă un şir format din cel mult '''100''' de caractere – litere mici ale alfabetului englez şi spaţii. Să se modifice acest şir prin dublarea fiecărei vocale.
== Date de intrare ==
Programul citește de la tastatură şirul dat.
== Date de ieșire ==
Programul va afișa pe ecran şirul obţinut în urma efectuării operaţiilor cerute.
== Exemplu 1 ==
; Intrare
problema aceea frumoasa
; Iesire
Datele de intrare corespund restrictiilor impuse
proobleemaa aaceeeeaa fruumooaasaa
 
== Exemplu 2 ==
; Intrare
catalin12345
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirului de caractere de la tastatură
sir = input().strip()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 100:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(not caracter.islower() and not caracter.isspace() for caracter in sir):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Dublarea fiecărei vocale din șir
vocale = 'aeiou'
sir_dublat = ''.join([caracter*2 if caracter in vocale else caracter for caracter in sir])

# Afișarea șirului obținut
print(sir_dublat)

if __name__ == "__main__":
main()

</syntaxhighlight>

1335 - Caractere

2023-12-12T19:38:51Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se dau '''2''' șiruri de caractere. Sa se afișeze toate caracterele primului șir ce se găsesc și în al doilea. == Date de intrare == Programul citește de la tastatură '''2''' șiruri de caractere, dispuse pe '''2''' linii.. == Date de ieșire == Programul va afișa pe ecran toate caracterele primului șir ce se găsesc și în al doilea. == Restricţii şi precizări == * fiecare șir citit va conține cel mult 250 de caractere; * caracterele vor fi afi...

== Cerinţa ==
Se dau '''2''' șiruri de caractere. Sa se afișeze toate caracterele primului șir ce se găsesc și în al doilea.
== Date de intrare ==
Programul citește de la tastatură '''2''' șiruri de caractere, dispuse pe '''2''' linii..
== Date de ieșire ==
Programul va afișa pe ecran toate caracterele primului șir ce se găsesc și în al doilea.
== Restricţii şi precizări ==
* fiecare șir citit va conține cel mult 250 de caractere;
* caracterele vor fi afișate în ordinea în care se găsesc în primul șir.
== Exemplu 1 ==
; Intrare
asD'";*]!
da';h
; Iesire
Datele de intrare corespund restrictiilor impuse
a';
 
== Exemplu 2 ==
; Intrare
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla facilisi. Vestibulum euismod neque eu metus
rhoncus, nec iaculis purus sollicitudin. Quisque condimentum, lacus id suscipit vestibulum, odio sem
egestas nunc, vel aliquet purus erat nec elit. Nullam elementum leo ac orci congue, in fringilla nisl
euismod. Sed aliquet, elit eu pellentesque accumsan, justo ex cursus lacus, id hendrerit nisl tortor ut
nunc. Maecenas congue ligula non lacus dapibus bibendum. Fusce hendrerit tincidunt lacus, vel luctus purus
auctor vel. Integer et metus eu neque commodo sodales. Vivamus vel nisi in elit luctus ullamcorper.
Phasellus id augue nec velit tincidunt cursus.
acestaesteuncuvant
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea șirurilor de caractere de la tastatură
sir1 = input().strip()
sir2 = input().strip()

# Verifică dacă șirurile respectă restricțiile
if len(sir1) > 250 or len(sir2) > 250:
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Obținerea listei de caractere din primul șir care se găsesc și în al doilea
caractere = [caracter for caracter in sir1 if caracter in sir2]

# Verifică dacă există caractere în primul șir care se găsesc și în al doilea și afișează rezultatul
if caractere:
print(''.join(caractere))
else:
print("nu exista")

if __name__ == "__main__":
main()

</syntaxhighlight>

3112 - Bac Cuvinte

2023-12-12T19:27:35Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Cerința Într-un text cu cel mult '''100''' de caractere cuvintele sunt formate numai din litere mari și mici ale alfabetului englez și sunt separate prin câte un spațiu. Scrieți un program care citește de la tastatură un text de tipul precizat, apoi un număr natural, '''n, n∈[1,100)''', şi afişează pe ecran, pe linii separate, cuvintele din text care au exact '''n''' litere. Cuvintele sunt afișate în ordinea apariției lor în text, iar dacă n...

== Cerinţa ==
Cerința
Într-un text cu cel mult '''100''' de caractere cuvintele sunt formate numai din litere mari și mici ale alfabetului englez și sunt separate prin câte un spațiu. Scrieți un program care citește de la tastatură un text de tipul precizat, apoi un număr natural, '''n, n∈[1,100)''', şi afişează pe ecran, pe linii separate, cuvintele din text care au exact '''n''' litere. Cuvintele sunt afișate în ordinea apariției lor în text, iar dacă nu există niciun astfel de cuvânt, se afișează pe ecran mesajul '''nu exista'''.
== Date de intrare ==
Programul citește de la tastatură numărul textul dat, apoi numărul '''n'''.
== Date de ieșire ==
Programul va afișa pe ecran cuvintele din text cu exact '''n''' litere, fiecare pe câte o linie.
== Restricţii şi precizări ==
* 1 &les; n &les; 100
* textul conține cel mult '''100''' de caractere; cuvintele sunt formate numai din litere mari și mici ale alfabetului englez și sunt separate prin câte un spațiu
== Exemplu 1 ==
; Intrare
Fat Frumos este cel mai viteaz
6
; Iesire
Datele de intrare corespund restrictiilor impuse
Frumos
viteaz
 
== Exemplu 2 ==
; Intrare
catalin1234
10
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea textului și a numărului de la tastatură
text = input().strip()
n = int(input().strip())

# Verifică dacă textul respectă restricțiile
if len(text) > 100:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(not cuvant.isalpha() for cuvant in text.split()):
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(len(cuvant) > 100 for cuvant in text.split()):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Obținerea listei de cuvinte cu exact n litere
cuvinte = [cuvant for cuvant in text.split() if len(cuvant) == n]

# Verifică dacă există cuvinte în text cu exact n litere și afișează rezultatul
if cuvinte:
for cuvant in cuvinte:
print(cuvant)
else:
print("nu exista")

if __name__ == "__main__":
main()

</syntaxhighlight>

2797 - Cuvinte 9

2023-12-12T19:20:56Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Cerința Un text are cel mult '''100''' de caractere și este format din cuvinte, numere naturale și spații. Cuvintele sunt formate numai din litere mici ale alfabetului englez. Cuvintele și numerele sunt separate prin câte un spaţiu. Scrieţi un program care citește de la tastatură un text de tipul menţionat mai sus și afișează pe ecran numărul din text care începe cu cea mai mare cifră. Dacă există mai multe astfel de numere, se afișează do...

== Cerinţa ==
Cerința
Un text are cel mult '''100''' de caractere și este format din cuvinte, numere naturale și spații. Cuvintele sunt formate numai din litere mici ale alfabetului englez. Cuvintele și numerele sunt separate prin câte un spaţiu.

Scrieţi un program care citește de la tastatură un text de tipul menţionat mai sus și afișează pe ecran numărul din text care începe cu cea mai mare cifră. Dacă există mai multe astfel de numere, se afișează doar unul dintre acestea, iar dacă textul nu conține niciun număr, se afișează pe ecran mesajul '''nu exista'''.
Date de intrare
== Date de intrare ==
Programul citește de la tastatură un text de tipul menționat mai sus.
== Date de ieșire ==
Programul va afișa pe ecran numărul din text care începe cu cea mai mare cifră sau mesajul '''nu exista''', dacă textul nu conține niciun număr.
== Exemplu 1 ==
; Intrare
am 190 de nuci si 70 de castane
; Iesire
Datele de intrare corespund restrictiilor impuse
70
 
== Exemplu 2 ==
; Intrare
acestaesteuncuvantfoartelung carecontine1234
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
# Citirea textului de la tastatură
text = input().strip()

# Verifică dacă textul respectă restricțiile
if len(text) > 100:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(not cuvant.isalpha() and not cuvant.isdigit() for cuvant in text.split()):
print("Datele de intrare nu corespund restrictiilor impuse")
return
if any(len(cuvant) > 10 for cuvant in text.split()):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Obținerea listei de numere
numere = [int(cuvant) for cuvant in text.split() if cuvant.isdigit()]

# Verifică dacă există numere în text și afișează rezultatul
if numere:
print(max(numere, key=lambda numar: int(str(numar)[0])))
else:
print("nu exista")

if __name__ == "__main__":
main()

</syntaxhighlight>

0975 - Cuvinte 2

2023-12-12T19:11:10Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se dă o propoziție formată din litere mici ale alfabetului englez, spații și semnele de punctuație ,.. Determinați un cuvânt palindrom din propoziție, primul în ordine alfabetică. == Date de intrare == Programul citește de la tastatură propoziția dată. == Date de ieșire == Programul va afișa pe ecran cuvântul determinat, sau mesajul IMPOSIBIL, dacă în șir nu există niciun cuvânt palindrom. == Restricţii şi precizări == * propoziția ci...

== Cerinţa ==
Se dă o propoziție formată din litere mici ale alfabetului englez, spații și semnele de punctuație ,.. Determinați un cuvânt palindrom din propoziție, primul în ordine alfabetică.
== Date de intrare ==
Programul citește de la tastatură propoziția dată.
== Date de ieșire ==
Programul va afișa pe ecran cuvântul determinat, sau mesajul IMPOSIBIL, dacă în șir nu există niciun cuvânt palindrom.
== Restricţii şi precizări ==
* propoziția citită va conține cel mult '''255''' de caractere
* cuvintele din propoziție vor avea maximum '''10''' litere
== Exemplu 1 ==
; Intrare
ele deschid un capac, aerisirea este ok
; Iesire
Datele de intrare corespund restrictiilor impuse
aerisirea
 
== Exemplu 2 ==
; Intrare
acel produs este nemultumitor
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
import string

def este_palindrom(cuvant):
return cuvant == cuvant[::-1]

def main():
# Citirea propoziției de la tastatură
propozitie = input().strip()

# Verifică dacă propoziția respectă restricțiile
if len(propozitie) > 255 or any(len(cuvant) > 10 for cuvant in propozitie.split()):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Înlăturarea semnelor de punctuație
propozitie = propozitie.translate(str.maketrans('', '', string.punctuation))

# Obținerea listei de cuvinte
cuvinte = propozitie.split()

# Filtrarea cuvintelor palindrom și sortarea lor în ordine alfabetică
cuvinte_palindrom = sorted(cuvant for cuvant in cuvinte if este_palindrom(cuvant))

# Afișarea rezultatului
if cuvinte_palindrom:
print(cuvinte_palindrom[0])
else:
print("IMPOSIBIL")

if __name__ == "__main__":
main()

</syntaxhighlight>

0973 - Cuvinte 1

2023-12-12T19:02:04Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Hercule trebuie sa strabată un labirint cu capcane reprezentat de o matrice cu '''n''' linii și '''m''' coloane. Pentru fiecare celula a labirintului, se cunoaște timpul exprimat în minute după care celula respectivă devine capcană. După ce o celula devine capcana, Hercule piere dacă intră în acea celulă. Initial Hercule se află în celula de coordonate '''(1, 1)''' și trebuie să ajungă în celula de cordonate '''(n,m)'''. Sa se afișeze numaru...

== Cerinţa ==
Hercule trebuie sa strabată un labirint cu capcane reprezentat de o matrice cu '''n''' linii și '''m''' coloane. Pentru fiecare celula a labirintului, se cunoaște timpul exprimat în minute după care celula respectivă devine capcană. După ce o celula devine capcana, Hercule piere dacă intră în acea celulă. Initial Hercule se află în celula de coordonate '''(1, 1)''' și trebuie să ajungă în celula de cordonate '''(n,m)'''.

Sa se afișeze numarul total de drumuri pe care le poate urma Hercule prin labirint, astfel încât Hercule să nu piară.
== Date de intrare ==
Fișierul de intrare '''herculein.txt''' conține pe prima linie numerele '''n m''', iar pe următoarele '''n''' linii câte m valori naturale.
== Date de ieșire ==
Fișierul de ieșire '''herculeout.txt''' va conține pe prima linie numărul total de drumuri prin care Hercule poate ajunge în celula destinație.
== Restricţii şi precizări ==
* 1 &les; m,n &les; 10
* Hercule nu poate intra de mai multe ori in aceeasi celula
* Hercule are nevoie de un minut,ca sa treacă dintr-o celula într-una vecină
* Hercule se deplasează pe direcțiile N-S și E-V.
== Exemplu ==
; herculein.txt
4 5
4 1 1 8 1
6 3 4 5 1
3 2 8 8 8
1 3 4 2 9
; herculeout.txt
Datele de intrare corespund restrictiilor impuse
2
 
== Exemplu 2 ==
; herculein.txt
4 11
4 1 1 8 1
6 3 4 5 1
3 2 8 8 8
1 3 4 2 9
; herculeout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_drumuri(matrice, n, m):
dp = [[0 for _ in range(m)] for _ in range(n)]
dp[0][0] = 1

for i in range(n):
for j in range(m):
if i > 0 and matrice[i][j] > i + j:
dp[i][j] += dp[i-1][j]
if j > 0 and matrice[i][j] > i + j:
dp[i][j] += dp[i][j-1]

return dp[n-1][m-1]

def main():
with open('herculein.txt', 'r') as fin:
n, m = map(int, fin.readline().split())
matrice = [list(map(int, linie.split())) for linie in fin]

with open('herculeout.txt', 'w') as fout:
if not (1 <= n <= 10 and 1 <= m <= 10):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return
fout.write("Datele de intrare corespund restrictiilor impuse\n")

fout.write(str(numar_drumuri(matrice, n, m)) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>
== Explicatie ==
; Cele două trasee posibile ale lui Hercule sunt:
1 0 0 0 0
2 3 4 5 0
0 0 0 6 7
0 0 0 0 8
; si
1 0 0 0 0
2 3 4 0 0
0 0 5 6 7
0 0 0 0 8

3080- VerifNumar

2023-12-12T18:49:03Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Se dă un șir de caractere. Sa se determine numărul scris cu cifrele existente în șirul dat. Să se afișeze numărul obținut și, pe linia următoare, toate caracterele din șir care nu fac parte din număr, cu excepția spațiilor. == Date de intrare == Programul citește de la tastatură un șir de caractere == Date de ieșire == Programul afișează pe ecran numărul determinat, iar pe linia următoare, separate prin câte un spațiu, toate caracterele...

== Cerinţa ==
Se dă un șir de caractere. Sa se determine numărul scris cu cifrele existente în șirul dat. Să se afișeze numărul obținut și, pe linia următoare, toate caracterele din șir care nu fac parte din număr, cu excepția spațiilor.
== Date de intrare ==
Programul citește de la tastatură un șir de caractere
== Date de ieșire ==
Programul afișează pe ecran numărul determinat, iar pe linia următoare, separate prin câte un spațiu, toate caracterele din șir care nu fac parte din număr, cu excepția spațiilor, în ordinea din șir.
== Restricţii şi precizări ==
* șirul dat va avea cel mult '''100''' de caractere;
* dacă șirul dat reprezintă un număr natural, programul va afișa numai mesajul '''CORECT''';
* dacă șirul dat nu conține nicio cifră, programul va afișa numai mesajul '''NaN''';
* dacă șirul nu conține alte cifre în afară de '''0''', numărul rezultat va fi reprezentat de ultima apariție în șir a cifrei '''0'''
== Exemplu 1 ==
; Intrare
00573a9 3ee
; Iesire
Datele de intrare corespund restrictiilor impuse
57393
0 0 a e e
 
== Exemplu 2 ==
; Intrare
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def extrage_numar_si_restul(șir):
numar = ''
restul_caractere = []

for caracter in șir:
if caracter.isdigit() and caracter != '0':
numar += caracter
elif caracter != ' ':
restul_caractere.append(caracter)

return numar, restul_caractere

def main():
# Citirea șirului de caractere de la tastatură
sir = input()

# Verifică dacă șirul respectă restricțiile
if len(sir) > 100:
print("Datele de intrare nu corespund restrictiilor impuse")
return
if sir.isdigit():
print("Datele de intrare corespund restrictiilor impuse")
print("CORECT")
return
if not any(caracter.isdigit() for caracter in sir):
print("Datele de intrare corespund restrictiilor impuse")
print("NaN")
return

print("Datele de intrare corespund restrictiilor impuse")

# Extrage numărul și restul caracterelor
numar, restul_caractere = extrage_numar_si_restul(sir)

# Verifică condițiile și afișează rezultatul
if numar:
print(numar)
else:
print("0")

if restul_caractere:
print(' '.join(restul_caractere))

if __name__ == "__main__":
main()

</syntaxhighlight>

3975 - Intervale AB

2023-12-12T18:16:44Z

Ghisa Catalin: Pagină nouă: == Cerinţa == Dându-se '''N''' intervale '''[a, b]''', calculați numărul maxim de astfel de intervale care se intersectează în cel puțin un punct. == Date de intrare == Fișierul de intrare '''intervalein.txt''' conține pe prima linie numărul '''N''', iar pe următoarele '''N''' linii '''2''' numere naturale separate prin spații, reprezentând limitele intervalelor '''[a, b]'''. == Date de ieșire == Fișierul de ieșire '''intervaleout.txt''' va conține pe prima l...

== Cerinţa ==
Dându-se '''N''' intervale '''[a, b]''', calculați numărul maxim de astfel de intervale care se intersectează în cel puțin un punct.
== Date de intrare ==
Fișierul de intrare '''intervalein.txt''' conține pe prima linie numărul '''N''', iar pe următoarele '''N''' linii '''2''' numere naturale separate prin spații, reprezentând limitele intervalelor '''[a, b]'''.
== Date de ieșire ==
Fișierul de ieșire '''intervaleout.txt''' va conține pe prima linie numărul '''mx''', reprezentând numărul maxim de intervale care se intersectează în cel puțin un punct.
== Restricţii şi precizări ==
* 1 &les; N &les; 100.000
* -2.000.000.000 &les; a &les; b &les; 2.000.000.000
== Exemplu ==
; intervalein.txt
5
1 5
3 4
-10 10
-23 -20
100 200
; intervaleout.txt
Datele de intrare corespund restrictiilor impuse.
3
 
== Exemplu 2 ==
; intervalein.txt
-1
1 5
3 4
-10 10
-23 -20
100 200
; intervaleout.txt
Datele de intrare nu corespund restrictiilor impuse.
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def max_intersecting(intervals):
# Sortăm intervalele după capătul drept
intervals.sort(key=lambda x: x[1])

# Inițializăm o listă pentru a stoca intervalele în curs de procesare
current_intervals = []

# Inițializăm numărul maxim de intervale care se intersectează
max_inter = 0

for interval in intervals:
# Adăugăm intervalul curent la lista de intervale în curs de procesare
current_intervals.append(interval)

# Eliminăm intervalele care s-au terminat
while current_intervals and current_intervals[0][1] < interval[0]:
current_intervals.pop(0)

# Actualizăm numărul maxim de intervale care se intersectează
max_inter = max(max_inter, len(current_intervals))

return max_inter

def main():
# Deschidem fișierul de intrare și citim datele
with open('intervalein.txt', 'r') as f:
n = int(f.readline().strip())
intervals = [list(map(int, f.readline().strip().split())) for _ in range(n)]

# Verificăm dacă numărul de intervale respectă restricțiile
if 1 <= n <= 100000 and all(-2000000000 <= a <= b <= 2000000000 for a, b in intervals):
# Dacă da, calculăm numărul maxim de intervale care se intersectează
result = max_intersecting(intervals)
status = "Datele de intrare corespund restrictiilor impuse."
else:
# Dacă nu, afișăm un mesaj de eroare
result = ""
status = "Datele de intrare nu corespund restrictiilor impuse."

# Scriem rezultatul în fișierul de ieșire
with open('intervaleout.txt', 'w') as f:
f.write(status + '\n' + str(result))

if __name__ == "__main__":
main()

</syntaxhighlight>

4017 - Skip

2023-12-12T17:55:00Z

Ghisa Catalin: Pagină nouă: == Cifrul Skip == Gigel a găsit pe o foaie criptări ale unor cuvinte în cifrul Skip. Criptarea funcționează astfel: Fie un cuvânt de lungime '''n'''. Cuvântul îl vom impărti în două părti, prima parte de lungime '''[n/2]''', iar a doua parte de '''[(n+1)]/2'''. Vom scrie prima literă din prima parte, prima literă din a doua parte, a '''2-a''' literă din prima parte, a '''2-a''' literă din a doua parte, a '''3-a''' literă din prima parte, a '''3-a''' literă...

== Cifrul Skip ==
Gigel a găsit pe o foaie criptări ale unor cuvinte în cifrul Skip. Criptarea funcționează astfel:

Fie un cuvânt de lungime '''n'''. Cuvântul îl vom impărti în două părti, prima parte de lungime '''[n/2]''', iar a doua parte de '''[(n+1)]/2'''. Vom scrie prima literă din prima parte, prima literă din a doua parte, a '''2-a''' literă din prima parte, a '''2-a''' literă din a doua parte, a '''3-a''' literă din prima parte, a '''3-a''' literă din a doua parte … :.
* '''AMONG''' -> '''AOMNG'''
* '''SUSPICIOUS''' -> '''SCUISOPUIS'''
* '''SECRET''' -> '''SREECT'''
* '''CIPHER''' -> ''CHIEPR'''
Criptarea unui text constă în criptarea succesivă a fiecărui cuvânt.

== Cerinta ==
Se dă un numar c care poate fi doar '''1''' sau '''2''' și un text în care cuvintele sunt separate printr-un spațiu.
Pentru '''c=1''', textul reprezintă un mesaj necriptat și se cere să-l afișați în urma criptării.
Pentru '''c=2''', textul reprezintă un mesaj criptat și se cere să-l afișați în urma decriptării.
== Date de intrare ==
Fișierul de intrare '''skipin.txt''' citește un număr '''c''' și un mesaj.
== Date de ieșire ==
Fișierul de ieșire '''skipout.txt''' va conține pe prima linie mesajul rezultat în urma operației cerute.
== Restricţii şi precizări ==
* 1 &les; lungimea mesajului &les; 1000000
== Exemplu 1 ==
; skipin.txt
1
THERE IS ONE IMPOSTOR AMONG US
; skipout.txt
Datele de intrare corespund restrictiilor impuse
TEHRE IS ONE ISMTPOOR AOMNG US
 
== Exemplu 2 ==
; skipin.txt
-1
THERE IS ONE IMPOSTOR AMONG US
; skipout.txt
Datele de intrare nu corespund restrictiilor impuse
 

== Rezolvare ==
<syntaxhighlight lang="python" line>
def skip_cipher(c, text):
words = text.split(' ')
result = []

for word in words:
n = len(word)
part1 = word[:n // 2]
part2 = word[n // 2:]

if c == 1: # Encryption
encrypted_word = ''.join([part1[i] + part2[i] for i in range(len(part1))] + list(part2[len(part1):]))
result.append(encrypted_word)
elif c == 2: # Decryption
decrypted_word = ''.join(
[word[i] for i in range(0, len(word), 2)] + [word[i] for i in range(1, len(word), 2)])
result.append(decrypted_word)

return ' '.join(result)

def main():
# Deschidem fișierul de intrare și citim datele
with open('skipin.txt', 'r') as f:
c = int(f.readline().strip())
text = f.readline().strip()

# Verificăm dacă lungimea textului respectă restricțiile și dacă c este 1 sau 2
if 1 <= len(text) <= 1000000 and c in [1, 2]:
# Dacă da, aplicăm funcția de criptare/decriptare
result = skip_cipher(c, text)
status = "Datele de intrare corespund restrictiilor impuse."
else:
# Dacă nu, nu aplicăm funcția și afișăm un mesaj de eroare
result = ""
status = "Datele de intrare nu corespund restrictiilor impuse."

# Scriem rezultatul în fișierul de ieșire
with open('skipout.txt', 'w') as f:
f.write(status + '\n' + result)

if __name__ == "__main__":
main()

</syntaxhighlight>

== Explicatie ==

0413 - Adiacenta 1

2023-12-12T17:09:28Z

Ghisa Catalin:

== Cerinţa ==
Se dă lista muchiilor unui graf neorientat. Să se afișeze matricea de adiacență a grafului.
== Date de intrare ==
Fiecare dintre liniile fișierului '''adiacenta1in.txt''' conține câte o pereche de numere '''i j''', cu semnificația că există muchie între '''i''' și '''j'''.
== Date de ieșire ==
Fişierul de ieşire '''adiacenta1out.txt''' va conţine '''n''' linii; pe fiecare dintre ele vor fi câte '''n''' valori separate prin exact un spațiu, reprezentând matricea de adiacență a grafului dat.
== Restricţii şi precizări ==
* graful dat va avea cel mult '''100''' de vârfuri
* muchiile se pot repeta în fișierul de intrare
* numărul de vârfuri ale grafului va fi egal cu cea mai mare valoare din lista muchiilor
== Exemplu ==
; adiacenta1in.txt
1 4
1 3
3 5
4 5
2 4
1 2
4 2
3 4
; adiacenta1out.txt
Datele de intrare corespund restrictiilor impuse
0 1 1 1 0
1 0 0 1 0
1 0 0 1 1
1 1 1 0 1
0 0 1 1 0
; adiacenta1in.txt
1 400
1 3
3 5
4 5
2 4
1 2
4 2
3 4
; adiacenta1out.txt
Datele de intrare nu corespund restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare(muchii):
n = max(max(muchie) for muchie in muchii)
if not 1 <= n <= 100:
return False, "Datele de intrare nu corespund restrictiilor impuse"
return True, "Datele de intrare corespund restrictiilor impuse"

def main():
with open('adiacenta1in.txt', 'r') as fin:
muchii = [list(map(int, linie.split())) for linie in fin]

valid, message = validare(muchii)
with open('adiacenta1out.txt', 'w') as fout:
fout.write(message + '\n')
if not valid:
return

n = max(max(muchie) for muchie in muchii)
adiacenta = [[0 for _ in range(n)] for _ in range(n)]
for muchie in muchii:
i, j = muchie
adiacenta[i - 1][j - 1] = 1
adiacenta[j - 1][i - 1] = 1

for linie in adiacenta:
fout.write(' '.join(map(str, linie)) + '\n')

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

0413 - Adiacenta 1

2023-12-12T17:07:22Z

Ghisa Catalin:

== Cerinţa ==
Se dă lista muchiilor unui graf neorientat. Să se afișeze matricea de adiacență a grafului.
== Date de intrare ==
Fiecare dintre liniile fișierului '''adiacenta1in.txt''' conține câte o pereche de numere '''i j''', cu semnificația că există muchie între '''i''' și '''j'''.
== Date de ieșire ==
Fişierul de ieşire '''adiacenta1out.txt''' va conţine '''n''' linii; pe fiecare dintre ele vor fi câte '''n''' valori separate prin exact un spațiu, reprezentând matricea de adiacență a grafului dat.
== Restricţii şi precizări ==
* graful dat va avea cel mult '''100''' de vârfuri
* muchiile se pot repeta în fișierul de intrare
* numărul de vârfuri ale grafului va fi egal cu cea mai mare valoare din lista muchiilor
== Exemplu ==
; adiacenta1in.txt
1 4
1 3
3 5
4 5
2 4
1 2
4 2
3 4
; adiacenta1out.txt
Datele de intrare corespund restrictiilor impuse
0 1 1 1 0
1 0 0 1 0
1 0 0 1 1
1 1 1 0 1
0 0 1 1 0
; adiacenta1in.txt
1 400
1 3
3 5
4 5
2 4
1 2
4 2
3 4
; adiacenta1out.txt
Datele de intrare nu corespund restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line>
# Citirea datelor de intrare
with open('adiacenta1.in', 'r') as f:
muchii = [list(map(int, linie.split())) for linie in f]

# Determinăm numărul de vârfuri ale grafului
n = max(max(muchie) for muchie in muchii)

# Inițializăm matricea de adiacență cu 0
adiacenta = [[0 for _ in range(n)] for _ in range(n)]

# Parcurgem fiecare muchie
for muchie in muchii:
i, j = muchie
# Adăugăm muchia în matricea de adiacență
adiacenta[i-1][j-1] = 1
adiacenta[j-1][i-1] = 1

# Afișăm matricea de adiacență
with open('adiacenta1.out', 'w') as f:
for linie in adiacenta:
f.write(' '.join(map(str, linie)) + '\n')

</syntaxhighlight>

3973 - Logaritm

2023-12-12T16:51:53Z

Ghisa Catalin:

== Cerinţa ==
Dându-se un număr real '''x''', să se scrie un program care calculează '''ln(x)'''
cu '''6''' zecimale exacte.
== Date de intrare ==
Programul citește de la tastatură numărul real '''x'''.
== Date de ieșire ==
Programul va afișa pe ecran rezultatul cu '''6''' zecimale exacte.
== Restricţii şi precizări ==
* 1 &les; x &les; 2.000.000.000.
* '''x''' va avea cel mult '''6''' zecimale.
* Nu se vor folosi funcțiile logaritmice ale limbajului C++
== Exemplu 1==
; Intrare
5.12
; Ieșire
Datele de intrare corespund restrictiilor impuse
1.633154
== Exemplu 2==
; Intrare
-1
; Ieșire
Datele de intrare nu corespund restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line>
import math

def ln(x):
# Precizia pe care o dorim
epsilon = 1e-10

# Inițializăm limitele intervalului pentru metoda bisecției
low = 0
high = x if x > 1 else 1

# Aplicăm metoda bisecției
while high - low > epsilon:
mid = (low + high) / 2
if math.exp(mid) < x:
low = mid
else:
high = mid

# Returnăm rezultatul cu 6 zecimale exacte
return round((low + high) / 2, 6)

def validare(x):
if not 1 <= x <= 2_000_000_000:
return False, "Datele de intrare nu corespund restrictiilor impuse"
return True, "Datele de intrare corespund restrictiilor impuse"

def main():
print("Introduceți numărul real x:")
x = float(input())

valid, message = validare(x)
print(message)
if not valid:
return

print("ln(x) calculat cu 6 zecimale exacte este:")
print(ln(x))

if __name__ == "__main__":
main()

</syntaxhighlight>

0572 - Arma

2023-12-12T16:30:31Z

Ghisa Catalin:

== Cerinţa ==
Capitala imperiului este protejată de un zid de formă dreptunghiulară formată din '''n*m''' cărămizi dispuse pe '''n''' linii și '''m''' coloane, linia '''1''' fiind cea mai de sus, iar linia '''n''' fiind cea mai de jos. Fiecare cărămidă este alcătuită dintr-o substanță identificată printr-un număr natural nenul.

Cuceritorul Gigel are la dispoziție o armă specială, care poate fi programată să distrugă toate cărămizile din zid care sunt formate din aceeași substanță, cunoscută, la o singură tragere. După fiecare tragere, toate cărămizile care sunt situate deasupra celor distruse cad, până ajung pe o cărămidă din zid, sau la baza acestuia.

Solicitarea lui Gigel este să determinați structura zidului după un număr dat de trageri, '''k'''.
== Date de intrare ==
Programul citește de la tastatură numerele '''n m k''', iar apoi '''n''' șiruri cu câte '''m''' numere naturale, reprezentând cărămizile de pe fiecare linie. Apoi se vor citi '''k''' numere naturale, reprezentând, în ordine, substanța din care sunt alcătuite cărămizile afectate de tragerea curentă.
== Date de ieșire ==
Programul va afișa pe ecran '''n''' șiruri cu câte '''m''' numere naturale, separate prin exact un spațiu, reprezentând configurația zidului după cele '''k''' trageri. Cărămizile distruse vor fi precizate prin numărul '''0'''.
== Restricţii şi precizări ==
* 1 &les; n, m &les; 100
* 1 &les; k &les; 100
* substanțele din care sunt create cărămizile sunt identificate prin numere naturale nenule mai mici decât '''1000'''
* dacă la o anumită tragere nu există în zid cărămizi de tipul utilizat la acea tragere, zidul rămâne nemodificat
== Exemplu 1 ==
; Intrare
4 5 3
3 5 4 5 1
2 1 1 5 3
1 1 5 5 1
5 5 1 4 3
1 5 1
; Ieșire
Datele de intrare corespund restrictiilor impuse
0 0 0 0 0
0 0 0 0 0
3 0 0 0 3
2 0 4 4 3
== Exemplu 2 ==
; Intrare
4 5 101
3 5 4 5 1
2 1 1 5 3
1 1 5 5 1
5 5 1 4 3
1 5 1
; Ieșire
Datele de intrare nu corespund restrictiilor impuse
== Rezolvare ==
<syntaxhighlight lang="python" line>
def validare(n, m, k, zid, trageri):
if not 1 <= n <= 100 or not 1 <= m <= 100 or not 1 <= k <= 100:
return False, "Datele de intrare nu corespund restrictiilor impuse"
for row in zid:
for z in row:
if not 1 <= z < 1000:
return False, "Datele de intrare nu corespund restrictiilor impuse"
for t in trageri:
if not 1 <= t < 1000:
return False, "Datele de intrare nu corespund restrictiilor impuse"
return True, "Datele de intrare corespund restrictiilor impuse"

def main():
print("Introduceți numărul de linii, numărul de coloane și numărul de trageri:")
n, m, k = map(int, input().split())
print("Introduceți configurația inițială a zidului:")
zid = [list(map(int, input().split())) for _ in range(n)]
print("Introduceți substanțele afectate de fiecare tragere:")
trageri = list(map(int, input().split()))

valid, message = validare(n, m, k, zid, trageri)
print(message)
if not valid:
return

for tragere in trageri:
for i in range(n):
for j in range(m):
if zid[i][j] == tragere:
zid[i][j] = 0
for _ in range(n):
for i in range(n - 1, 0, -1):
for j in range(m):
if zid[i][j] == 0 and zid[i - 1][j] != 0:
zid[i][j], zid[i - 1][j] = zid[i - 1][j], zid[i][j]

print("Configurația finală a zidului este:")
for linie in zid:
print(' '.join(map(str, linie)))

if __name__ == "__main__":
main()

</syntaxhighlight>

== Explicatie ==
; După prima tragere, zidul devine:
: 0 0 0 5 0
: 3 0 0 5 0
: 2 5 4 5 3
: 5 5 5 4 3
; După a doua tragere, zidul devine:
: 0 0 0 0 0
: 0 0 0 0 0
: 3 0 0 0 3
: 2 0 4 4 3
; A treia tragere nu mai modifică zidul.

0527 - Preturi1

2023-12-12T16:19:15Z

Ghisa Catalin:

== Cerinţa ==
Gigel trebuie să cumpere '''n''' produse, pentru fiecare produs cunoscându-se cantitate necesară. În oraș sunt '''m''' magazine, în fiecare magazin găsindu-se produsele dorite la anumite prețuri. Determinați suma totală minimă necesară pentru a cumpăra produsele dorite, știind că Gigel trebuie să cumpere toate produsele din același magazin.
== Date de intrare ==
Programul citește de la tastatură, în ordine:

* numărul de produse '''n'''
* '''n''' numere naturale, reprezentând cantitățile necesare din fiecare produs
* numărul de magazine '''m'''
* m șiruri de câte n numere, șirul '''i''' conținând în ordine prețurile celor '''n''' produse la magazinul '''i'''. Dacă la un magazin nu există un anumit produs, valoarea prețului va fi '''-1'''
== Date de ieșire ==
Programul va afișa pe ecran numărul '''S''', reprezentând suma minimă determinată.
== Restricţii şi precizări ==
* 1 &les; n , m &les; 100
* cantitățile necesare sunt numere naturale nenule mai mici sau egale cu '''1000'''
* prețurile produselor sunt numere naturale nenule mai mici sau egale cu '''1000''', sau '''-1''', cu semnificația de mai sus
* trebuie cumpărate toate produsele, din același magazin
== Exemplu 1 ==
; Intrare
5
4 4 5 1 2
3
5 8 6 2 6
-1 4 1 1 5
6 6 8 3 9
; Ieșire
Datele de intrare corespund restrictiilor impuse
96
== Exemplu 2 ==
; Intrare
101
4 4 5 1 2
3
5 8 6 2 6
-1 4 1 1 5
6 6 8 3 9
; Ieșire
Datele de intrare nu corespund restrictiilor impuse
== Explicatie ==
La magazinul '''1''' produsele costă '''96''', la magazinul '''3''' produsele costă '''109''', iar din magazinul '''2''' nu se poate cumpăra produsul '''1'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def min_sum(n, quantities, m, prices):
total_min = float('inf')
for i in range(m):
if all(p != -1 for p in prices[i]):
total = sum(prices[i][j] * quantities[j] for j in range(n))
total_min = min(total_min, total)
return total_min

def validare(n, m, quantities, prices):
if not 1 <= n <= 100 or not 1 <= m <= 100:
return False, "Datele de intrare nu corespund restrictiilor impuse"
for q in quantities:
if not 1 <= q <= 1000:
return False, "Datele de intrare nu corespund restrictiilor impuse"
for row in prices:
for p in row:
if not (-1 <= p <= 1000):
return False, "Datele de intrare nu corespund restrictiilor impuse"
return True, "Datele de intrare corespund restrictiilor impuse"

def main():
print("Introduceți numărul de produse:")
n = int(input())
print("Introduceți cantitățile necesare pentru fiecare produs:")
quantities = list(map(int, input().split()))
print("Introduceți numărul de magazine:")
m = int(input())
print("Introduceți prețurile pentru fiecare produs în fiecare magazin:")
prices = [list(map(int, input().split())) for _ in range(m)]

valid, message = validare(n, m, quantities, prices)
print(message)
if not valid:
return

total_min = min_sum(n, quantities, m, prices)
if total_min == float('inf'):
print("Nu este posibilă cumpărarea tuturor produselor.")
else:
print(total_min)

if __name__ == "__main__":
main()

</syntaxhighlight>

0526 - Preturi

2023-12-12T16:01:34Z

Ghisa Catalin:

== Cerinţa ==
Gigel trebuie să cumpere '''n''' produse, pentru fiecare produs cunoscându-se cantitate necesară. În oraș sunt '''m''' magazine, în fiecare magazin găsindu-se produsele dorite la anumite prețuri. Determinați suma totală minimă necesară pentru a cumpăra produsele dorite, știind că poate cumpăra orice produs din orice magazin.
== Date de intrare ==
Programul citește de la tastatură, în ordine:
* numărul de produse '''n'''
* '''n''' numere naturale, reprezentând cantitățile necesare din fiecare produs
* numărul de magazine '''m'''
* '''m''' șiruri de câte '''n''' numere, șirul '''i''' conținând în ordine prețurile celor '''n''' produse la magazinul '''i'''. Dacă la un magazin nu există un anumit produs, valoarea prețului va fi '''-1'''
== Date de ieșire ==
Programul va afișa pe ecran numărul '''S''', reprezentând suma minimă determinată.
== Restricţii şi precizări ==
* 1 &les; n , m &les; 100
* cantitățile necesare sunt numere naturale nenule mai mici sau egale cu '''1000'''
* prețurile produselor sunt numere naturale nenule mai mici sau egale cu '''1000''', sau '''-1''', cu semnificația de mai sus
== Exemplu 1 ==
; Intrare
5
4 4 5 1 2
3
5 8 6 -1 6
-1 4 8 9 5
6 6 8 3 9
; Ieșire
Datele de intrare corespund restrictiilor impuse
79
== Exemplu 2 ==
; Intrare
101
4 4 5 1 2
3
5 8 6 -1 6
-1 4 8 9 5
6 6 8 3 9
; Ieșire
Datele de intrare nu corespund restrictiilor impuse
== Explicatie ==
Din magazinul '''1''' se cumpără produsele '''1 3'''; din magazinul '''2''' se cumpără produsele '''2 5''', iar din magazinul '''3''' se cumpără produsul '''4'''.
În total se plătesc '''4 * 5 + 4 * 4 + 5 * 6 + 1 * 3 + 2 * 5 = 79'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def min_sum(n, quantities, m, prices):
total = 0
for i in range(n):
available_prices = [prices[j][i] for j in range(m) if prices[j][i] != -1]
if available_prices:
total += min(available_prices) * quantities[i]
return total

def validare(n, m, quantities, prices):
if not 1 <= n <= 100 or not 1 <= m <= 100:
return False, "Datele de intrare nu corespund restrictiilor impuse"
for q in quantities:
if not 1 <= q <= 1000:
return False, "Datele de intrare nu corespund restrictiilor impuse"
for row in prices:
for p in row:
if not (-1 <= p <= 1000):
return False, "Datele de intrare nu corespund restrictiilor impuse"
return True, "Datele de intrare corespund restrictiilor impuse"

def main():
print("Introduceți numărul de produse:")
n = int(input())
print("Introduceți cantitățile necesare pentru fiecare produs:")
quantities = list(map(int, input().split()))
print("Introduceți numărul de magazine:")
m = int(input())
print("Introduceți prețurile pentru fiecare produs în fiecare magazin:")
prices = [list(map(int, input().split())) for _ in range(m)]

valid, message = validare(n, m, quantities, prices)
print(message)
if not valid:
return

print(min_sum(n, quantities, m, prices))

if __name__ == "__main__":
main()

</syntaxhighlight>