Bitnami MediaWiki - User contributions [en]

3421 - ctck

2024-01-04T15:52:24Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă un graf orientat cu '''n''' vârfuri și '''m''' arce prin lista arcelor și un număr natural '''k'''. Afișați numărul de vârfuri ale componentei tare conexe în care se află vârful '''k'''. == Date de intrare == Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce și numărul '''k''', iar apoi lista arcelor, formată din '''m''' perechi de forma '''i j''', cu semnificația că există arc orientat de la nod...

== Cerinţa ==
Se dă un graf orientat cu '''n''' vârfuri și '''m''' arce prin lista arcelor și un număr natural '''k'''. Afișați numărul de vârfuri ale componentei tare conexe în care se află vârful '''k'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce și numărul '''k''', iar apoi lista arcelor, formată din '''m''' perechi de forma '''i j''', cu semnificația că există arc orientat de la nodul '''i''' la nodul '''j'''.
== Date de ieșire ==
Programul va afișa pe ecran numărul '''c''', reprezentând numărul de vârfuri ale componentei tare conexe în care se află vârful '''k'''.
== Restricţii şi precizări ==
* '''1 ≤ k ≤ n ≤ 100'''
== Exemplu 1 ==
; Intrare
8 12 3
1 3
3 5
5 7
7 1
2 6
6 8
8 2
1 4
4 6
4 8
4 2
1 8
; Iesire
Datele de intrare corespund restrictiilor impuse
4
 
== Exemplu 2 ==
; Intrare
0 0 0
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def dfs(graph, start):
# Inițializează stiva și setul de noduri vizitate
stack = [start]
visited = set()

while stack:
node = stack.pop()
if node not in visited:
visited.add(node)
stack.extend(graph.get(node, []) - visited)

return visited

def verifica_restrictii(n, arce):
# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100) or not all(1 <= i <= n and 1 <= j <= n for i, j in arce):
return False
return True

def main():
n, m, k = map(int, input().split())
arce = [tuple(map(int, input().split())) for _ in range(m)]

# Verifică dacă datele de intrare respectă restricțiile
if not verifica_restrictii(n, arce):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Construiește graful și graful transpus
graph = {}
graph_transposed = {}
for i, j in arce:
if i not in graph:
graph[i] = set()
if j not in graph_transposed:
graph_transposed[j] = set()
graph[i].add(j)
graph_transposed[j].add(i)

# Aplică DFS pe graful transpus pentru a găsi nodurile accesibile din nodul k
reachable_nodes = dfs(graph_transposed, k)

# Verifică dacă există un nod din care se poate ajunge în toate celelalte noduri
component_nodes = [node for node in range(1, n + 1) if node in dfs(graph, node) and node in reachable_nodes]

print(len(component_nodes))

if __name__ == "__main__":
main()

</syntaxhighlight>

0581 - Drumuri

2024-01-04T15:17:04Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă un graf orientat cu '''n''' noduri și un nod '''p'''. Să se afișeze toate nodurile '''q''' ale grafului, diferite de '''p''', cu proprietatea că există cel puțin un drum de la '''p''' la '''q''' și lungimea drumului minim este pară. == Date de intrare == Programul citește de la tastatură numărul '''n''' de noduri, nodul '''p''' și numărul '''m''' de arce, iar apoi lista arcelor, formată din '''m''' perechi de forma '''i j''', cu semnificaț...

== Cerinţa ==
Se dă un graf orientat cu '''n''' noduri și un nod '''p'''. Să se afișeze toate nodurile '''q''' ale grafului, diferite de '''p''', cu proprietatea că există cel puțin un drum de la '''p''' la '''q''' și lungimea drumului minim este pară.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''' de noduri, nodul '''p''' și numărul '''m''' de arce, iar apoi lista arcelor, formată din '''m''' perechi de forma '''i j''', cu semnificația că există arc orientat de la nodul '''i''' la nodul '''j'''.
== Date de ieșire ==
Programul va afișa pe ecran numărul '''C''' de noduri care respectă cerința, iar pe rândul următor cele '''C''' noduri, în ordine crescătoare, separate prin exact un spațiu.
== Restricţii şi precizări ==
* '''1 ≤ n ≤ 100'''
* prin drum minim se înțelege drum de cu lungimea minimă
== Exemplu 1 ==
; Intrare
7 2 10
1 2
2 3
2 5
3 4
3 6
4 7
5 1
5 3
5 4
6 5
; Iesire
Datele de intrare corespund restrictiilor impuse
3
1 4 6
 
== Exemplu 2 ==
; Intrare
0 0 0
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def verifica_restrictii(n, arce):
# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100) or not all(1 <= i <= n and 1 <= j <= n for i, j in arce):
return False
return True

def noduri_drum_par(n, p, arce):
# Crează un dicționar pentru a stoca vecinii fiecărui nod
vecini = {i: [] for i in range(1, n + 1)}
for i, j in arce:
vecini[i].append(j)

# Inițializează distanțele de la nodul p la toate celelalte noduri
dist = [float('inf')] * (n + 1)
dist[p] = 0

# Aplică algoritmul lui Dijkstra pentru a calcula distanțele minime
vizitat = [False] * (n + 1)
for _ in range(n):
u = min((d, i) for i, d in enumerate(dist) if not vizitat[i])[1]
vizitat[u] = True
for v in vecini[u]:
if dist[u] + 1 < dist[v]:
dist[v] = dist[u] + 1

# Determină nodurile care au un drum de lungime pară de la nodul p
noduri = [i for i in range(1, n + 1) if i != p and dist[i] % 2 == 0]

return noduri

def main():
n, p, m = map(int, input().split())
arce = [tuple(map(int, input().split())) for _ in range(m)]

# Verifică dacă datele de intrare respectă restricțiile
if not verifica_restrictii(n, arce):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Determină nodurile care au un drum de lungime pară de la nodul p
noduri = noduri_drum_par(n, p, arce)

# Afiseaza rezultatul
print(len(noduri))
print(' '.join(map(str, sorted(noduri))))

if __name__ == "__main__":
main()

</syntaxhighlight>

0582 - Turneu

2024-01-04T15:08:36Z

Codrut Borcutean: Pagină nouă: Un '''graf orientat''' se numește graf turneu dacă oricare ar fi două noduri diferite '''i, j''', între ele există un singur arc: arcul '''(i j)''' sau arcul '''(j i)'''. În orice graf turneu există un drum elementar care trece prin toate nodurile grafului. == Cerinţa == Se dă un graf turneu cu '''n''' noduri. Să se determine un drum elementar care să conțină toate nodurile grafului. == Date de intrare == Programul citește de la tastatură numărul de noduri '''...

Un '''graf orientat''' se numește graf turneu dacă oricare ar fi două noduri diferite '''i, j''', între ele există un singur arc: arcul '''(i j)''' sau arcul '''(j i)'''. În orice graf turneu există un drum elementar care trece prin toate nodurile grafului.
== Cerinţa ==
Se dă un graf turneu cu '''n''' noduri. Să se determine un drum elementar care să conțină toate nodurile grafului.
== Date de intrare ==
Programul citește de la tastatură numărul de noduri '''n''', iar apoi '''n*(n-1)/2''' perechi '''i j''', cu semnificația că există arcul '''(i j)'''.
== Date de ieșire ==
Programul va afișa pe ecran cele '''n''' noduri ale drumului determinat, separate prin exact un spațiu.
== Restricţii şi precizări ==
* '''1 ≤ n ≤ 100'''
* orice drum corect determinat este acceptat
== Exemplu 1 ==
; Intrare
4
1 4
2 1
2 4
3 1
3 2
4 3
; Iesire
Datele de intrare corespund restrictiilor impuse
1 4 3 2
 
== Exemplu 2 ==
; Intrare
0
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def verifica_restrictii(n, arce):
# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100) or not all(1 <= i <= n and 1 <= j <= n for i, j in arce):
return False
return True

def drum_elementar(n, arce):
# Crează un dicționar pentru a stoca vecinii fiecărui nod
vecini = {i: [] for i in range(1, n + 1)}
for i, j in arce:
vecini[i].append(j)

# Alege un nod de start arbitrar
nod_curent = 1

# Inițializează drumul cu nodul de start
drum = [nod_curent]

# Construiește drumul
while len(drum) < n:
for nod in sorted(vecini[nod_curent]):
if nod not in drum:
drum.append(nod)
nod_curent = nod
break

return drum

def main():
n = int(input())
arce = [tuple(map(int, input().split())) for _ in range(n * (n - 1) // 2)]

# Verifică dacă datele de intrare respectă restricțiile
if not verifica_restrictii(n, arce):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Determină un drum elementar care să conțină toate nodurile grafului
drum = drum_elementar(n, arce)

# Afiseaza rezultatul
print(' '.join(map(str, drum)))

if __name__ == "__main__":
main()

</syntaxhighlight>

0575 - Cunoscuti

2024-01-04T14:59:25Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Într-un grup sunt '''n''' persoane, numerotate de la '''1''' la '''n''' și o persoană poate cunoaște alte persoane – relație care nu este reciprocă. Să se determine persoana cea mai cunoscută. == Date de intrare == Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de relații dintre persoane, iar apoi '''m''' perechi de forma '''i j''', cu semnificația că persoana '''i''' cunoaște persoana '''j'''. == Date de ieși...

== Cerinţa ==
Într-un grup sunt '''n''' persoane, numerotate de la '''1''' la '''n''' și o persoană poate cunoaște alte persoane – relație care nu este reciprocă. Să se determine persoana cea mai cunoscută.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de relații dintre persoane, iar apoi '''m''' perechi de forma '''i j''', cu semnificația că persoana '''i''' cunoaște persoana '''j'''.
== Date de ieșire ==
Programul va afișa pe ecran numărul de ordine al celei mai cunoscute persoane. Dacă răspunsul constă din mai multe persoane, se vor afișa toate, în ordine crescătoare a numerelor de ordine, separate prin exact un spațiu.
== Restricţii şi precizări ==
* '''1 ≤ n ≤ 100'''
== Exemplu 1 ==
; Intrare
5 8
1 3
1 4
3 2
3 4
4 2
5 2
5 4
5 1
; Iesire
Datele de intrare corespund restrictiilor impuse
2 4
 
== Exemplu 2 ==
; Intrare
104 0
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def verifica_restrictii(n, arce):
# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100) or not all(1 <= i <= n and 1 <= j <= n for i, j in arce):
return False
return True

def persoana_cea_mai_cunoscuta(n, arce):
# Inițializează gradele interioare ale nodurilor
grad_interior = [0] * (n + 1)

# Calculează gradele interioare ale nodurilor
for _, j in arce:
grad_interior[j] += 1

# Determină persoanele cele mai cunoscute
max_grad = max(grad_interior)
persoane = [i for i in range(1, n + 1) if grad_interior[i] == max_grad]

return persoane

def main():
n, m = map(int, input().split())
arce = [tuple(map(int, input().split())) for _ in range(m)]

# Verifică dacă datele de intrare respectă restricțiile
if not verifica_restrictii(n, arce):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Determină persoanele cele mai cunoscute
persoane = persoana_cea_mai_cunoscuta(n, arce)

# Afiseaza rezultatul
if persoane:
print(' '.join(map(str, sorted(persoane))))
else:
print("NU EXISTA")

if __name__ == "__main__":
main()

</syntaxhighlight>

3450 - gegik

2024-01-04T14:54:33Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă un graf orientat cu '''n''' vârfuri și '''m''' arce prin lista arcelor și un număr natural '''k'''. Afișați vârfurile din graf care au suma gradelor (interior și exterior) egală cu '''k'''. == Date de intrare == Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce și un număr '''k'''. Apoi se citește lista arcelor, formată din '''m''' perechi de forma '''i j''', cu semnificația că există arc de la no...

== Cerinţa ==
Se dă un graf orientat cu '''n''' vârfuri și '''m''' arce prin lista arcelor și un număr natural '''k'''. Afișați vârfurile din graf care au suma gradelor (interior și exterior) egală cu '''k'''.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce și un număr '''k'''. Apoi se citește lista arcelor, formată din '''m''' perechi de forma '''i j''', cu semnificația că există arc de la nodul '''i''' la nodul '''j'''.
== Date de ieșire ==
Programul va afișa pe ecran în ordine crescătoare și separate printr-un spațiu vârfurile care au suma gradelor (interior și exterior) egală cu '''k'''. Dacă nu există astfel de vârfuri, atunci programul va afișa '''Nu exista'''.
== Restricţii şi precizări ==
* '''1 ≤ n ≤ 100'''
== Exemplu 1 ==
; Intrare
7 10 3
1 2
1 3
1 4
1 5
2 5
5 1
3 4
4 3
4 6
4 7
; Iesire
Datele de intrare corespund restrictiilor impuse
3 5
 
== Exemplu 2 ==
; Intrare
103 0 0
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
Vârfurile 3 și 5 au suma gradelor egală cu 3.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def verifica_restrictii(n, arce):
# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100) or not all(1 <= i <= n and 1 <= j <= n for i, j in arce):
return False
return True

def noduri_grad_suma_k(n, arce, k):
# Inițializează gradele interioare și exterioare ale nodurilor
grad_interior = [0] * (n + 1)
grad_exterior = [0] * (n + 1)

# Calculează gradele interioare și exterioare ale nodurilor
for i, j in arce:
grad_exterior[i] += 1
grad_interior[j] += 1

# Determină nodurile care au suma gradelor egală cu k
noduri = [i for i in range(1, n + 1) if grad_interior[i] + grad_exterior[i] == k]

return noduri

def main():
n, m, k = map(int, input().split())
arce = [tuple(map(int, input().split())) for _ in range(m)]

# Verifică dacă datele de intrare respectă restricțiile
if not verifica_restrictii(n, arce):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Determină nodurile care au suma gradelor egală cu k
noduri = noduri_grad_suma_k(n, arce, k)

# Afiseaza rezultatul
if noduri:
print(' '.join(map(str, sorted(noduri))))
else:
print("NU EXISTA")

if __name__ == "__main__":
main()

</syntaxhighlight>

4158 - Grade11

2024-01-04T14:49:27Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă lista arcelor unui graf orientat. Să se determine nodurile care au gradul exterior divizibil cu gradul interior sau gradul interior divizibil cu gradul exterior. Un nod care are gradul exterior sau gradul interior egal cu '''0''' nu respectă condiția cerută. == Date de intrare == Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce, iar apoi lista arcelor, formată din '''m''' perechi de forma '''i''' '''j''', c...

== Cerinţa ==
Se dă lista arcelor unui graf orientat. Să se determine nodurile care au gradul exterior divizibil cu gradul interior sau gradul interior divizibil cu gradul exterior. Un nod care are gradul exterior sau gradul interior egal cu '''0''' nu respectă condiția cerută.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce, iar apoi lista arcelor, formată din '''m''' perechi de forma '''i''' '''j''', cu semnificația că există arc orientat de la '''i''' la '''j'''.
== Date de ieșire ==
Programul va afișa pe ecran nodurile cerute, ordonate crescător, separate prin exact un spațiu. Dacă nu există noduri care să respecte proprietatea că au gradul exterior divizibil cu gradul interior sau gradul interior divizibil cu gradul exterior, atunci se va afișa '''NU EXISTA'''.
== Restricţii şi precizări ==
* '''1 ≤ n ≤ 100'''
== Exemplu 1 ==
; Intrare
6 9
1 2
1 3
1 5
3 5
4 1
3 4
5 1
6 1
6 3
; Iesire
Datele de intrare corespund restrictiilor impuse
1 3 4 5
 
== Exemplu 2 ==
; Intrare
102 0
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
Vârful '''1''' are gradul exterior egal cu '''3''' și gradul interior egal cu '''3'''. Vârful '''3''' are gradul exterior egal cu '''2''' și gradul interior egal cu '''1'''. Vârful '''4''' are gradul exterior egal cu '''1''' și gradul interior egal cu '''1'''. Vârful '''5''' are gradul exterior egal cu '''1''' și gradul interior egal cu '''2'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def verifica_restrictii(n, arce):
# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100) or not all(1 <= i <= n and 1 <= j <= n for i, j in arce):
return False
return True

def noduri_grad_divizibil(n, arce):
# Inițializează gradele interioare și exterioare ale nodurilor
grad_interior = [0] * (n + 1)
grad_exterior = [0] * (n + 1)

# Calculează gradele interioare și exterioare ale nodurilor
for i, j in arce:
grad_exterior[i] += 1
grad_interior[j] += 1

# Determină nodurile care au gradul exterior divizibil cu gradul interior
# sau gradul interior divizibil cu gradul exterior
noduri = [i for i in range(1, n + 1) if grad_interior[i] != 0 and grad_exterior[i] != 0 and
(grad_exterior[i] % grad_interior[i] == 0 or grad_interior[i] % grad_exterior[i] == 0)]

return noduri

def main():
n, m = map(int, input().split())
arce = [tuple(map(int, input().split())) for _ in range(m)]

# Verifică dacă datele de intrare respectă restricțiile
if not verifica_restrictii(n, arce):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Determină nodurile care au gradul exterior divizibil cu gradul interior
# sau gradul interior divizibil cu gradul exterior
noduri = noduri_grad_divizibil(n, arce)

# Afiseaza rezultatul
if noduri:
print(' '.join(map(str, sorted(noduri))))
else:
print("NU EXISTA")

if __name__ == "__main__":
main()

</syntaxhighlight>

4153 - Grade3

2024-01-04T14:43:45Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă lista arcelor unui graf orientat. Să se determine nodurile care au gradul exterior mai mic decât gradul interior. == Date de intrare == Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce, iar apoi lista arcelor, formată din '''m''' perechi de forma '''i j''', cu semnificația că există arc orientat de la '''i''' la '''j'''. == Date de ieșire == Programul va afișa pe ecran numărul '''C''', reprezentând num...

== Cerinţa ==
Se dă lista arcelor unui graf orientat. Să se determine nodurile care au gradul exterior mai mic decât gradul interior.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce, iar apoi lista arcelor, formată din '''m''' perechi de forma '''i j''', cu semnificația că există arc orientat de la '''i''' la '''j'''.
== Date de ieșire ==
Programul va afișa pe ecran numărul '''C''', reprezentând numărul de noduri care au gradul exterior mai mic decât cel interior, iar pe linie următoare afișează aceste noduri, ordonate crescător, separate prin exact un spațiu.
== Restricţii şi precizări ==
* '''1 ≤ n ≤ 100'''
== Exemplu 1 ==
; Intrare
6 9
1 2
1 3
1 5
3 5
4 1
3 4
5 1
6 1
6 3
; Iesire
Datele de intrare corespund restrictiilor impuse
2
2 5
 
== Exemplu 2 ==
; Intrare
101 0
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def verifica_restrictii(n, arce):
# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100) or not all(1 <= i <= n and 1 <= j <= n for i, j in arce):
return False
return True

def noduri_grad_exterior_mic(n, arce):
# Inițializează gradele interioare și exterioare ale nodurilor
grad_interior = [0] * (n + 1)
grad_exterior = [0] * (n + 1)

# Calculează gradele interioare și exterioare ale nodurilor
for i, j in arce:
grad_exterior[i] += 1
grad_interior[j] += 1

# Determină nodurile care au gradul exterior mai mic decât gradul interior
noduri = [i for i in range(1, n + 1) if grad_exterior[i] < grad_interior[i]]

return noduri

def main():
n, m = map(int, input().split())
arce = [tuple(map(int, input().split())) for _ in range(m)]

# Verifică dacă datele de intrare respectă restricțiile
if not verifica_restrictii(n, arce):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Determină nodurile care au gradul exterior mai mic decât gradul interior
noduri = noduri_grad_exterior_mic(n, arce)

# Afiseaza rezultatul
print(len(noduri))
print(' '.join(map(str, sorted(noduri))))

if __name__ == "__main__":
main()

</syntaxhighlight>

0573 - Grade2

2024-01-04T14:39:02Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă lista arcelor unui graf orientat. Să se determine nodurile care au gradul exterior egal cu gradul interior. == Date de intrare == Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce, iar apoi lista arcelor, formată din '''m''' perechi de forma '''i''' '''j''', cu semnificația că există arc orientat de la '''i''' la '''j'''. == Date de ieșire == Programul va afișa pe ecran numărul '''C''', reprezentând num...

== Cerinţa ==
Se dă lista arcelor unui graf orientat. Să se determine nodurile care au gradul exterior egal cu gradul interior.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce, iar apoi lista arcelor, formată din '''m''' perechi de forma '''i''' '''j''', cu semnificația că există arc orientat de la '''i''' la '''j'''.
== Date de ieșire ==
Programul va afișa pe ecran numărul '''C''', reprezentând numărul de noduri care au gradul interior egal cu cel exterior, iar pe linie următoare afișează aceste noduri, ordonate crescător, separate prin exact un spațiu.
== Restricţii şi precizări ==
* '''1 ≤ n ≤ 100'''
== Exemplu 1 ==
; Intrare
6 9
1 2
1 3
1 5
3 5
4 1
3 4
5 1
6 1
6 3
; Iesire
Datele de intrare corespund restrictiilor impuse
3
1 3 4
 
== Exemplu 2 ==
; Intrare
101 0
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def verifica_restrictii(n, arce):
# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100) or not all(1 <= i <= n and 1 <= j <= n for i, j in arce):
return False
return True

def noduri_grad_egale(n, arce):
# Inițializează gradele interioare și exterioare ale nodurilor
grad_interior = [0] * (n + 1)
grad_exterior = [0] * (n + 1)

# Calculează gradele interioare și exterioare ale nodurilor
for i, j in arce:
grad_exterior[i] += 1
grad_interior[j] += 1

# Determină nodurile care au gradul interior egal cu gradul exterior
noduri = [i for i in range(1, n + 1) if grad_interior[i] == grad_exterior[i]]

return noduri

def main():
n, m = map(int, input().split())
arce = [tuple(map(int, input().split())) for _ in range(m)]

# Verifică dacă datele de intrare respectă restricțiile
if not verifica_restrictii(n, arce):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Determină nodurile care au gradul interior egal cu gradul exterior
noduri = noduri_grad_egale(n, arce)

# Afiseaza rezultatul
print(len(noduri))
print(' '.join(map(str, sorted(noduri))))

if __name__ == "__main__":
main()

</syntaxhighlight>

0586 - GradIntNul

2024-01-04T14:29:46Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă lista arcelor unui graf orientat. Să se determine nodurile care au gradul interior nul. == Date de intrare == Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce, iar apoi lista arcelor, formată din '''m''' perechi de forma '''i''' '''j''', cu semnificația că există arc orientat de la '''i''' la '''j'''. == Date de ieșire == Programul va afișa pe ecran nodurile cu gradul interior nul, ordonate crescător și...

== Cerinţa ==
Se dă lista arcelor unui graf orientat. Să se determine nodurile care au gradul interior nul.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''' de noduri și numărul '''m''' de arce, iar apoi lista arcelor, formată din '''m''' perechi de forma '''i''' '''j''', cu semnificația că există arc orientat de la '''i''' la '''j'''.
== Date de ieșire ==
Programul va afișa pe ecran nodurile cu gradul interior nul, ordonate crescător și separate prin exact un spațiu. Dacă nu există nici un nod cu gradul interior nul, se va afișa mesajul '''NU EXISTA'''.
== Restricţii şi precizări ==
* '''1 ≤ n ≤ 100'''
== Exemplu 1 ==
; Intrare
6 8
1 3
1 5
3 5
4 1
3 4
5 1
6 1
6 3
; Iesire
Datele de intrare corespund restrictiilor impuse
2 6
 
== Exemplu 2 ==
; Intrare
5 1
1 6
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def verifica_restrictii(n, arce):
# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100) or not all(1 <= i <= n and 1 <= j <= n for i, j in arce):
return False
return True

def noduri_grad_interior_nul(n, arce):
# Inițializează gradele interioare ale nodurilor
grad_interior = [0] * (n + 1)

# Calculează gradele interioare ale nodurilor
for _, j in arce:
grad_interior[j] += 1

# Determină nodurile care au gradul interior nul
noduri = [i for i in range(1, n + 1) if grad_interior[i] == 0]

return noduri

def main():
n, m = map(int, input().split())
arce = [tuple(map(int, input().split())) for _ in range(m)]

# Verifică dacă datele de intrare respectă restricțiile
if not verifica_restrictii(n, arce):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Determină nodurile care au gradul interior nul
noduri = noduri_grad_interior_nul(n, arce)

# Afiseaza rezultatul
if noduri:
print(' '.join(map(str, sorted(noduri))))
else:
print("NU EXISTA")

if __name__ == "__main__":
main()

</syntaxhighlight>

2632 - Interclasari

2024-01-04T11:13:15Z

Codrut Borcutean: Pagină nouă: Se dau '''n''' șiruri de numere întregi ordonate crescător, de dimensiuni '''d[1]''', '''d[2]''', …, '''d[n]'''. Dacă se interclasează șirurile de dimensiuni '''d[i]''' și '''d[j]''' atunci se efectuează '''d[i]+d[j]''' operații și se obține un șir de dimensiuni '''d[i]+d[j]'''. Trebuie interclasate toate cele '''n''' șiruri. Pentru aceasta sunt necesari exact '''n - 1''' pași. La fiecare pas se iau două șiruri, se interclasează și cele două șiruri se î...

Se dau '''n''' șiruri de numere întregi ordonate crescător, de dimensiuni '''d[1]''', '''d[2]''', …, '''d[n]'''. Dacă se interclasează șirurile de dimensiuni '''d[i]''' și '''d[j]''' atunci se efectuează '''d[i]+d[j]''' operații și se obține un șir de dimensiuni '''d[i]+d[j]'''. Trebuie interclasate toate cele '''n''' șiruri. Pentru aceasta sunt necesari exact '''n - 1''' pași. La fiecare pas se iau două șiruri, se interclasează și cele două șiruri se înlocuiesc cu noul șir. Scopul este să se obțină un singur șir ordonat efectuând un număr minim de operații. De exemplu, dacă '''n=4''' și șirurile au dimensiunile '''1''', '''5''', '''2''' și '''5''', atunci se poate interclasa mai întâi '''1''' și '''5''', se fac '''6''' operații și rămân '''3''' șiruri de lungimi '''6''', '''2''', '''5'''. Se interclasează apoi '''2''' cu '''5''' cu un cost '''7''' și rămân două șiruri: '''6''' și '''7'''. Se interclasează aceasta două cu un cost de '''13''' și a rămas un singur șir. În total s-au efectuat '''6 + 7 + 13 = 26''' operații, dar acesta nu este numărul minim posibil.
== Cerinţa ==
Să se determine numărul minim de operații necesare pentru a interclasa cele '''n''' șiruri.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi dimensiunile celor '''n''' șiruri.
== Date de ieșire ==
Programul va afișa pe ecran numărul minim de operații.
== Restricţii şi precizări ==
* '''1 &les; n &les; 100.000'''
* cele '''n''' numere citite vor fi nenule și mai mici decât '''1.000'''
== Exemplu 1 ==
; Intrare
4
1 5 2 5
; Iesire
Datele de intrare corespund restrictiilor impuse
24
 
== Exemplu 2 ==
; Intrare
5
1001 1002 1003 1004 1005
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
import heapq

def numar_minim_operatii(siruri):
# Calculează numărul minim de operații necesare pentru a interclasa cele n șiruri.

heapq.heapify(siruri)
operatii = 0

while len(siruri) > 1:
a = heapq.heappop(siruri)
b = heapq.heappop(siruri)
operatii += a + b
heapq.heappush(siruri, a + b)

return operatii

def main():
n = int(input().strip())
siruri = list(map(int, input().split()))

# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100000 and all(1 <= x < 1000 for x in siruri)):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

operatii = numar_minim_operatii(siruri)
print(f"{operatii}")

if __name__ == "__main__":
main()

</syntaxhighlight>

3264 - Sum Min XI

2024-01-04T10:58:33Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă o matrice pătratică cu '''n''' lini şi '''n''' coloane şi elemente numere întregi. Determinaţi cea mai mică sumă a '''n''' elemente din matrice, obținută adunând câte un element de pe fiecare coloană a matricei. == Date de intrare == Fişierul de intrare '''summin_xiin.txt''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere întregi, separate prin spaţii, reprezentând elementele matricei. ==...

== Cerinţa ==
Se dă o matrice pătratică cu '''n''' lini şi '''n''' coloane şi elemente numere întregi. Determinaţi cea mai mică sumă a '''n''' elemente din matrice, obținută adunând câte un element de pe fiecare coloană a matricei.
== Date de intrare ==
Fişierul de intrare '''summin_xiin.txt''' conţine pe prima linie numărul '''n''', iar pe următoarele '''n''' linii câte '''n''' numere întregi, separate prin spaţii, reprezentând elementele matricei.
== Date de ieșire ==
Fişierul de ieşire '''summin_xiout.txt''' va conţine pe prima linie numărul '''S''', reprezentând suma minimă determinată.
== Restricţii şi precizări ==
* '''1 &les; n&les; 100'''
* elementele matricei vor avea cel mult '''4''' cifre
== Exemplu 1 ==
; summin_xiin.txt
4
12 16 5 4
11 14 6 7
8 2 3 17
10 9 13 15
; summin_xiout.txt
Datele de intrare corespund restrictiilor impuse
17
 
== Exemplu 2 ==
; summin_xiin.txt
4000
12 16 5 4
11 14 6 7
8 2 3 17
10 9 13 15
; summin_xiout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
'''17=8+2+3+4'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def suma_minima(matrice):
# Calculează suma minimă a elementelor din matrice, adunând câte un element de pe fiecare coloană.

suma = 0
for coloana in zip(*matrice):
suma += min(coloana)
return suma

def main():
with open('summin_xiin.txt', 'r') as fin, open('summin_xiout.txt', 'w') as fout:
n = int(fin.readline().strip())
matrice = [list(map(int, linie.split())) for linie in fin.readlines()]

# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100 and all(0 <= x < 10000 for linie in matrice for x in linie)):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

suma = suma_minima(matrice)
fout.write(f"{suma}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

0556 - Flici

2024-01-04T10:51:35Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Un '''flic''' este o creatură pufoasă de dimensiunea unui hamster, având trei ochi și o blană colorată. De la naștere, fiecărui flic îi place în mod deosebit un anumit număr. Hobby-ul lor este să intre în cutii, iar în lumea flicilor, pe fiecare cutie este inscripționat un număr. Flicii sunt pretențioși și nu vor alege orice cutie. În mod ideal, ar alege cutia pentru care numărul inscripționat este cel mai apropiat de numărul lor favorit...

== Cerinţa ==
Un '''flic''' este o creatură pufoasă de dimensiunea unui hamster, având trei ochi și o blană colorată. De la naștere, fiecărui flic îi place în mod deosebit un anumit număr.

Hobby-ul lor este să intre în cutii, iar în lumea flicilor, pe fiecare cutie este inscripționat un număr. Flicii sunt pretențioși și nu vor alege orice cutie. În mod ideal, ar alege cutia pentru care numărul inscripționat este cel mai apropiat de numărul lor favorit, dar pentru că flicii sunt altruiști, vor alege cutiile astfel încât ceilalți flici să nu se supere prea tare.

Astăzi s-a format un grup de '''n''' flici, fiecare cu un număr favorit, care au la dispoziție '''n''' cutii, fiecare având inscripționat un număr. Sarcina ta este să stabilești pentru fiecare flic în ce cutie va intra, astfel încât suma modulelor diferențelor dintre numărul favorit a flicului și cel inscripționat pe cutia în care intră acesta să fie minimă.
== Date de intrare ==
Fișierul de intrare '''fliciin.txt''' conține pe prima linie numărul '''n'''; a doua linie conține '''n''' numere naturale separate prin spații, reprezentând numerele favorite ale flicilor, iar a treia linie conține '''n''' numere naturale separate prin spații, reprezentând numerele inscripționate pe cutii.
== Date de ieșire ==
Fișierul de ieșire '''fliciout.txt''' va conține pe prima linie numărul '''S''', reprezentând suma minimă obținută.
== Restricţii şi precizări ==
* '''1 &les; n &les; 100.000'''
* numerele favorite și cele inscripționate sunt numere naturale mai mici sau egale cu '''10.000'''
* pentru 40% din punctaj, '''n < 10'''
* pentru 80% din punctaj, '''n &les; 1.000'''
== Exemplu 1 ==
; fliciin.txt
3
1 1 3
1 2 2
; fliciout.txt
Datele de intrare corespund restrictiilor impuse
2
 
== Exemplu 2 ==
; fliciin.txt
3
1 1 3000000
1 2 2
; fliciout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
Flicul '''1''' va intra în cutia '''1''', flicul '''2''' în a doua, flicul '''3''' în a treia, rezultând suma
'''|1-1| + |1-2| + |3-2| = 2.'''
== Rezolvare ==
<syntaxhighlight lang="python" line>
def suma_minima(n, flici, cutii):
# Calculează suma minimă a diferențelor dintre numărul favorit al flicului și cel inscripționat pe cutie.

flici.sort()
cutii.sort()
suma = 0

for i in range(n):
suma += abs(flici[i] - cutii[i])

return suma

def main():
with open('fliciin.txt', 'r') as fin, open('fliciout.txt', 'w') as fout:
n = int(fin.readline().strip())
flici = list(map(int, fin.readline().split()))
cutii = list(map(int, fin.readline().split()))

# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100000 and all(1 <= x <= 10000 for x in flici + cutii)):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

suma = suma_minima(n, flici, cutii)
fout.write(f"{suma}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

1262 - Sub Secv

2024-01-04T10:39:51Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dau '''n''' numere naturale. Să se găsească o subsecvență astfel încât suma elementelor din această subsecvență să fie divizibilă cu '''n'''. == Date de intrare == Fișierul de intrare '''subsecvin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații. == Date de ieșire == Fișierul de ieșire '''subsecvout.txt''' va conține pe prima linie indicele stânga al subsecvenței, respectiv...

== Cerinţa ==
Se dau '''n''' numere naturale. Să se găsească o subsecvență astfel încât suma elementelor din această subsecvență să fie divizibilă cu '''n'''.
== Date de intrare ==
Fișierul de intrare '''subsecvin.txt''' conține pe prima linie numărul '''n''', iar pe a doua linie '''n''' numere naturale separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''subsecvout.txt''' va conține pe prima linie indicele stânga al subsecvenței, respectiv indicele dreapta al subsecvenței.
== Restricţii şi precizări ==
* '''1 &les; n &les; 10000'''
* numerele de pe a doua linie a fișierului de intrare vor fi mai mici decât '''2.000.000.000'''
* în caz că există mai multe soluții se va afișa cea cu indicele stânga minim, iar dacă există mai multe soluții cu indicele stânga minim se va afișa cea cu indicele dreapta minim
== Exemplu 1 ==
; subsecvin.txt
7
65 26877 13488 43 256888 53 428
; subsecvout.txt
Datele de intrare corespund restrictiilor impuse
3 4
 
== Exemplu 2 ==
; subsecvin.txt
700000000
65 26877 13488 43 256888 53 428
; subsecvout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
Suma numerelor aflate în intervalul '''[3, 4]''' este '''13531''', care este divizibil cu '''7'''.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def subsecventa_divizibila(n, numere):
# Calculează subsecvența cu suma elementelor divizibilă cu n.

prefix = [0] * (n + 1)
poz = [-1] * (n + 1)
poz[0] = 0

for i in range(1, n + 1):
prefix[i] = (prefix[i - 1] + numere[i - 1]) % n
if poz[prefix[i]] != -1:
return poz[prefix[i]] + 1, i
poz[prefix[i]] = i

return None

def main():
with open('subsecvin.txt', 'r') as fin, open('subsecvout.txt', 'w') as fout:
n = int(fin.readline().strip())
numere = list(map(int, fin.readline().split()))

# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 10000 and all(1 <= x < 2000000000 for x in numere)):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

subsecventa = subsecventa_divizibila(n, numere)
if subsecventa is not None:
fout.write(f"{subsecventa[0]} {subsecventa[1]}\n")
else:
fout.write("-1\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

3624 - Bal 1

2024-01-04T10:28:59Z

Codrut Borcutean: Pagină nouă: Tocmai a ajuns la balul din sat un grup de '''n''' fete numerotate de la '''1''' la '''n'''. Acolo sunt așteptate de '''m''' băieți frumoși, numerotați de la '''1''' la '''m'''. Fiecare băiat '''i''' ('''i=1..m''') are un coeficient de frumusețe '''b[i]'''. Fetele nu acceptă orice băiat la dans. Fata '''i''' va accepta să danseze cu un băiat doar dacă băiatul are un coeficient de frumusețe mai mare sau egal cu '''f[i]'''. == Cerinţa == Cunoscând coeficienții...

Tocmai a ajuns la balul din sat un grup de '''n''' fete numerotate de la '''1''' la '''n'''. Acolo sunt așteptate de '''m''' băieți frumoși, numerotați de la '''1''' la '''m'''. Fiecare băiat '''i''' ('''i=1..m''') are un coeficient de frumusețe '''b[i]'''. Fetele nu acceptă orice băiat la dans. Fata '''i''' va accepta să danseze cu un băiat doar dacă băiatul are un coeficient de frumusețe mai mare sau egal cu '''f[i]'''.
== Cerinţa ==
Cunoscând coeficienții de frumusețe ai băieților, '''b[1]''', '''b[2]''', …, '''b[m]''' precum și coeficienții preferințelor fetelor, '''f[1]''', '''f[2]''', …, '''f[n]''', să se determine numărul maxim de perechi de dansatori care se poate forma.
== Date de intrare ==
Fișierul de intrare '''balin.txt''' conține pe prima linie numerele '''n''' și '''m'''. Pe a doua linie sunt n numere naturale separate prin spații '''f[1]''', '''f[2]''', …, '''f[n]''' reprezentând coeficienții fetelor, iar pe a treia linie sunt numerele '''b[1]''', '''b[2]''', …, '''b[m]''' reprezentând coeficienții băieților.
== Date de ieșire ==
Fișierul de ieșire '''balout.txt''' va conține un singur număr natural '''P''', reprezentând numărul perechilor '''(f[i], b[j])''' care se poate forma astfel încât '''f[i] &les; b[j]'''.
== Restricţii şi precizări ==
* '''1 &les; n, m &les; 100.000'''
* coeficienții băieților și fetelor sunt numere naturale nenule mai mici sau egale cu '''1.000.000.000'''
== Exemplu 1 ==
; balin.txt
3 3
4 1 5
2 6 3
; balout.txt
Datele de intrare corespund restrictiilor impuse
2
 
== Exemplu 2 ==
; balin.txt
3 3
4 11000000000 5
2 6 3
; balout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
Sunt trei fete și trei băieți. Se pot forma doar două perechi: '''(1,2)''' și '''(4,6)'''
== Rezolvare ==
<syntaxhighlight lang="python" line>
def numar_maxim_perechi(n, m, fete, baieti):
# Calculează numărul maxim de perechi de dansatori care se poate forma.

fete.sort()
baieti.sort()
i = j = perechi = 0

while i < n and j < m:
if fete[i] <= baieti[j]:
perechi += 1
i += 1
j += 1

return perechi

def main():
with open('balin.txt', 'r') as fin, open('balout.txt', 'w') as fout:
n, m = map(int, fin.readline().split())
fete = list(map(int, fin.readline().split()))
baieti = list(map(int, fin.readline().split()))

# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100000 and 1 <= m <= 100000 and all(1 <= x <= 1000000000 for x in fete + baieti)):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

perechi = numar_maxim_perechi(n, m, fete, baieti)
fout.write(f"{perechi}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

2684 - Hard ssc

2024-01-04T10:13:02Z

Codrut Borcutean: Pagină nouă: Se dă un șir de '''n''' numere naturale. Șirul poate fi partiționat în mai multe moduri într-un număr de subșiruri strict crescătoare. De exemplu, șirul '''4 6 2 5 8 1 3 7''' poate fi partiționat astfel: '''4 6 8''' (primul subșir), '''2 5 7''' (al doilea) și '''1 3''' (al treilea). O altă modalitate este formând patru subșiruri: '''4 5 7''', '''6 8''', '''2 3''' și '''1'''. == Cerinţa == Să se determine numărul minim de subșiruri strict crescătoare în...

Se dă un șir de '''n''' numere naturale. Șirul poate fi partiționat în mai multe moduri într-un număr de subșiruri strict crescătoare. De exemplu, șirul '''4 6 2 5 8 1 3 7''' poate fi partiționat astfel: '''4 6 8''' (primul subșir), '''2 5 7''' (al doilea) și '''1 3''' (al treilea). O altă modalitate este formând patru subșiruri: '''4 5 7''', '''6 8''', '''2 3''' și '''1'''.
== Cerinţa ==
Să se determine numărul minim de subșiruri strict crescătoare în care se poate partiționa șirul.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi șirul de '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Programul va afișa pe ecran numărul minim de subșiruri strict crescătoare în care se poate partiționa șirul.
== Restricţii şi precizări ==
* '''1 &les; n &les; 100.000'''
* cele '''n''' numere citite vor fi mai mici decât '''100.000'''
* Un subșir se obține dintr-un șir prin eliminarea a zero, unul, sau mai multe elemente.
== Exemplu 1 ==
; Intrare
8
4 6 2 5 8 1 3 7
; Iesire
Datele de intrare corespund restrictiilor impuse
3
 
== Exemplu 2 ==
; Intrare
100002
12 12
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
from bisect import bisect_left

def numar_minim_subsecvente(n, sir):
# Calculează numărul minim de subșiruri strict crescătoare în care se poate partiționa șirul.

subsecvente = [0] * n
lungime = 1

# Primul element al sirului este întotdeauna o subsecvență în sine
subsecvente[0] = sir[0]

for i in range(1, n):
# Dacă elementul curent este mai mare decât ultimul element al subsecvenței curente,
# îl adăugăm la sfârșitul subsecvenței și creștem lungimea acesteia
if sir[i] > subsecvente[lungime - 1]:
subsecvente[lungime] = sir[i]
lungime += 1
else:
# Dacă elementul curent este mai mic sau egal cu ultimul element al subsecvenței curente,
# înlocuim cel mai mare element care este mai mic sau egal cu elementul curent
j = bisect_left(subsecvente, sir[i], 0, lungime)
subsecvente[j] = sir[i]

return lungime

def main():
n = int(input().strip())
sir = list(map(int, input().split()))

# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 100000 and all(0 <= x < 100000 for x in sir)):
print("Datele de intrare nu corespund restrictiilor impuse\n")
return

print("Datele de intrare corespund restrictiilor impuse\n")

numar = numar_minim_subsecvente(n, sir)
print(f"{numar}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

2683 - Easy ssc

2024-01-04T10:07:09Z

Se dă un șir de '''n''' numere naturale. Șirul poate fi partiționat în mai multe moduri într-un număr de subșiruri strict crescătoare. De exemplu, șirul '''4 6 2 5 8 1 3 7''' poate fi partiționat astfel: '''4 6 8''' (primul subșir), '''2 5 7''' (al doilea) și '''1 3''' (al treilea). O altă modalitate este formând patru subșiruri: '''4 5 7''', '''6 8''', '''2 3''' și '''1'''.
== Cerinţa ==
Să se determine numărul minim de subșiruri strict crescătoare în care se poate partiționa șirul.
== Date de intrare ==
Programul citește de la tastatură numărul '''n''', iar apoi șirul de '''n''' numere naturale, separate prin spații.
== Date de ieșire ==
Programul va afișa pe ecran numărul minim de subșiruri strict crescătoare în care se poate partiționa șirul.
== Restricţii şi precizări ==
* '''1 &les; n &les; 1000'''
* cele '''n''' numere citite vor fi mai mici decât '''50.000'''
* Un subșir se obține dintr-un șir prin eliminarea a zero, unul, sau mai multe elemente.
== Exemplu 1 ==
; Intrare
8
4 6 2 5 8 1 3 7
; Iesire
Datele de intrare corespund restrictiilor impuse
3
 
== Exemplu 2 ==
; Intrare
10001
4 6 2 5 8 1 3 7
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
from bisect import bisect_left

def numar_minim_subsecvente(n, sir):
# Calculează numărul minim de subșiruri strict crescătoare în care se poate partiționa șirul.

subsecvente = [0] * n
lungime = 1

# Primul element al sirului este întotdeauna o subsecvență în sine
subsecvente[0] = sir[0]

for i in range(1, n):
# Dacă elementul curent este mai mare decât ultimul element al subsecvenței curente,
# îl adăugăm la sfârșitul subsecvenței și creștem lungimea acesteia
if sir[i] > subsecvente[lungime - 1]:
subsecvente[lungime] = sir[i]
lungime += 1
else:
# Dacă elementul curent este mai mic sau egal cu ultimul element al subsecvenței curente,
# înlocuim cel mai mare element care este mai mic sau egal cu elementul curent
j = bisect_left(subsecvente, sir[i], 0, lungime)
subsecvente[j] = sir[i]

return lungime

def main():
n = int(input().strip())
sir = list(map(int, input().split()))

# Verifică dacă datele de intrare respectă restricțiile
if not (1 <= n <= 1000 and all(0 <= x < 50000 for x in sir)):
print("Datele de intrare nu corespund restrictiilor impuse\n")
return

print("Datele de intrare corespund restrictiilor impuse\n")

numar = numar_minim_subsecvente(n, sir)
print(f"{numar}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

0932 - Aria Poligon Simplu

2024-01-04T09:50:39Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dau coordonatele în plan pentru '''n''' puncte. Să se afișeze valoarea ariei poligonului pe care acestea îl formează. == Date de intrare == Fișierul de intrare '''ariapoligonsimpluin.txt''' conține pe prima linie numărul de vârfuri ale poligonului, notat cu '''n'''. Pe următoarele '''n''' linii se găsesc câte două numere separate printr-un spațiu, reprezentând abscisa respectiv ordonata câte unui vârf. Acestea sunt date într-un sens de parc...

== Cerinţa ==
Se dau coordonatele în plan pentru '''n''' puncte. Să se afișeze valoarea ariei poligonului pe care acestea îl formează.
== Date de intrare ==
Fișierul de intrare '''ariapoligonsimpluin.txt''' conține pe prima linie numărul de vârfuri ale poligonului, notat cu '''n'''. Pe următoarele '''n''' linii se găsesc câte două numere separate printr-un spațiu, reprezentând abscisa respectiv ordonata câte unui vârf. Acestea sunt date într-un sens de parcurgere a laturilor poligonului.
== Date de ieșire ==
Fișierul de ieșire '''ariapoligonsimpluout.txt''' va conține pe prima linie un număr real, cu exact o zecimală, reprezentând valoarea cerută.
== Restricţii şi precizări ==
* Numerele din fișierul de intrare sunt întregi cuprinse între '''-1001''' și '''1001'''.
* Poligonul nu este neapărat convex dar nu se autointersectează.
== Exemplu 1 ==
; ariapoligonsimpluin.txt
4
0 0
1 0
1 1
0 1
; ariapoligonsimpluout.txt
Datele de intrare corespund restrictiilor impuse
1.0
 
== Exemplu 2 ==
; ariapoligonsimpluin.txt
4
0 0
1 0
1 5000
0 1
; ariapoligonsimpluout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def calculeaza_arie(puncte):
# Calculează aria unui poligon dat prin coordonatele punctelor sale.

n = len(puncte)
arie = 0.0
for i in range(n):
j = (i + 1) % n
arie += puncte[i][0] * puncte[j][1]
arie -= puncte[j][0] * puncte[i][1]
arie = abs(arie) / 2.0
return arie

def main():
with open('ariapoligonsimpluin.txt', 'r') as fin, open('ariapoligonsimpluout.txt', 'w') as fout:
n = int(fin.readline().strip())
puncte = []
for _ in range(n):
x, y = map(int, fin.readline().split())
puncte.append((x, y))

# Verifică dacă datele de intrare respectă restricțiile
if not all(-1001 <= x <= 1001 and -1001 <= y <= 1001 for x, y in puncte):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

arie = calculeaza_arie(puncte)
fout.write(f"{arie:.1f}\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

1413 - ConstructPalindrom

2024-01-04T09:11:52Z

Codrut Borcutean: Pagină nouă: Mai sunt câteva săptămâni și vine Crăciunul. Ajuns într-un magazin de jucării, Robert îl roagă pe tatăl său să-i cumpere cea mai frumoasă mașină cu telecomandă. Tatăl său îi spune că nu a fost cuminte în timpul anului și nu merită această jucărie, însă după dispute intense acesta hotaraste să-i mai acorde o sansă, doar dacă va rezolva următoarea problema: Având un string '''S''', putem să obținem un palindrom din acest șir ștergând un s...

Mai sunt câteva săptămâni și vine Crăciunul. Ajuns într-un magazin de jucării, Robert îl roagă pe tatăl său să-i cumpere cea mai frumoasă mașină cu telecomandă. Tatăl său îi spune că nu a fost cuminte în timpul anului și nu merită această jucărie, însă după dispute intense acesta hotaraste să-i mai acorde o sansă, doar dacă va rezolva următoarea problema:

Având un string '''S''', putem să obținem un palindrom din acest șir ștergând un singur caracter?

Robert nu se prea descurca la algoritmică așa că vă roagă foarte mult să-i rezolvați problema pentru a se putea juca cu mașina cu telecomandă. În schimbul acestei mașini el vă va recompensa cu 100 puncte.
== Cerinţa ==
Find dat un string '''S''', se poate obține un palindrom din șirul inițial ștergând doar un singur caracter ?
== Date de intrare ==
Fişierul de intrare '''constructpalindromin.txt''' conţine pe prima linie o valoare '''T''' reprezentând numărul de teste. Pe următoarele T linii vom avea cate un string reprezentând întrebarea adresata lui Robert de către tatăl sau.
== Date de ieșire ==
Fişierul de ieşire '''constructpalindromout.txt''' va conține '''T''' linii cu răspunsul '''YES''' daca se poate obține un palindrom ștergând un singur caracter și '''NO''' dacă nu se poate obține.
== Restricţii şi precizări ==
* '''1 &les; T &les; 100'''
* Dimensiunea stringului '''&les; 100000'''
* Pentru 10% din punctaj dimensiunea stringului '''&les; 1000'''
* String-ul conține caractere de la '''a''' la '''z'''.
* Dimensiunea string-ului după ștergerea unui caracter va fi mai mică decât a fost înainte.
== Exemplu 1 ==
; constructpalindromin.txt
4
aaa
abc
abdbca
abba
; constructpalindromout.txt
Datele de intrare corespund restrictiilor impuse
YES
NO
YES
YES
 
== Exemplu 2 ==
; constructpalindromin.txt
40000000
aaa
abc
abdbca
abba
; constructpalindromout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
Pentru primul exemplu ('''aaa'''): Putem șterge orice '''a''', string-ul rezultat este '''aa''', care este palindrom.

Pentru al doilea exemplu ('''abc'''): Nu este posibil să eliminăm exact un caracter și să obtinem un palindrom.

Pentru al treilea exemplu ('''abdbca'''): ștergem caracterul '''c''', string-ul rezultat este '''abdba''' care este palindrom.

Pentru exemplul al patrulea ('''abba'''): Ștergem '''b''', obținem '''aba''' care este palindrom.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def is_palindrome(s):
# Funcția verifică dacă un șir este palindrom.

return s == s[::-1]

def can_form_palindrome(s):
# Funcția verifică dacă se poate forma un palindrom ștergând un singur caracter din șirul s.

for i in range(len(s)):
t = s[:i] + s[i + 1:]
if is_palindrome(t):
return True
return False

def main():
with open('constructpalindromin.txt', 'r') as fin, open('constructpalindromout.txt', 'w') as fout:
t = int(fin.readline().strip())

# Verificăm dacă numărul de teste respectă restricțiile
if not (1 <= t <= 100):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

for _ in range(t):
s = fin.readline().strip()

# Verificăm dacă șirul respectă restricțiile
if len(s) > 100000:
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

# Verificăm dacă se poate forma un palindrom și scriem rezultatul în fișierul de ieșire
fout.write('YES\n' if can_form_palindrome(s) else 'NO\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

0888 - ChangeCase

2024-01-03T19:51:18Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Cele mai multe editoare de text moderne oferă utilizatorilor o serie de opțiuni pentru modificarea textului grupate sub numele '''Change Case'''. Aceste opțiuni sunt: 1. '''lowercase''' – toate literele din text sunt transformate în litere mici. Celelalte caractere rămân neschimbate; 2. '''UPPERCASE''' – toate literele din text sunt transformate în litere mari. Celelalte caractere rămân neschimbate; 3. '''TitleCase''' – primul caracter a fiec...

== Cerinţa ==
Cele mai multe editoare de text moderne oferă utilizatorilor o serie de opțiuni pentru modificarea textului grupate sub numele '''Change Case'''. Aceste opțiuni sunt:

1. '''lowercase''' – toate literele din text sunt transformate în litere mici. Celelalte caractere rămân neschimbate;
2. '''UPPERCASE''' – toate literele din text sunt transformate în litere mari. Celelalte caractere rămân neschimbate;
3. '''TitleCase''' – primul caracter a fiecărui cuvânt se transformă în literă mare, dacă este literă; celelalte litere se transformă în litere mici;
4. '''iNVERTcASE''' – primul caracter a fiecărui cuvânt se transformă în literă mică, dacă este literă; celelalte litere se transformă în litere mari;
5. '''Sentencecase''' – prima literă a fiecărei propoziții este transformată în literă mare, celelalte în litere mici.
Se dă un sir de caractere format din litere mari și mici ale alfabetului englez, cifre, spații și semnele de punctuație '''.,;''', în care cuvintele sunt alcătuite din litere sau cifre, iar propozițiile sunt separate prin punct ('''.'''), precum și o transformare dintre cele date care trebuie aplicată.

Aplicați asupra șirului dat transformarea precizată și afișați șirul.
== Date de intrare ==
Fișierul de intrare '''changecasein.txt''' conține pe prima linie unul dintre cuvintele '''lowercase UPPERCASE TitleCase iNVERTcASE Sentencecase''', iar pe a doua linie șirul dat.
== Date de ieșire ==
Fișierul de ieșire '''changecaseout.txt''' va conține pe prima linie șirul transformat în concordanță cu operația precizată.
== Restricţii şi precizări ==
* șirul dat va avea cel mult '''255''' de caractere.
== Exemplu 1 ==
; changecasein.txt
UPPERCASE
Ana are mere. Multe
; changecaseout.txt
Datele de intrare corespund restrictiilor impuse
51 223 19 37 111
 
== Exemplu 2 ==
; changecasein.txt
Ana are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mereAna are mere
; changecaseout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def change_case(case, s):
# Funcția aplică transformarea specificată asupra șirului s.

if case == 'lowercase':
return s.lower()
elif case == 'UPPERCASE':
return s.upper()
elif case == 'TitleCase':
return s.title()
elif case == 'iNVERTcASE':
return s.swapcase()
elif case == 'Sentencecase':
return '. '.join(sentence.capitalize() for sentence in s.split('. '))

def main():
with open('changecasein.txt', 'r') as fin, open('changecaseout.txt', 'w') as fout:
case = fin.readline().strip()
s = fin.readline().strip()

# Verificăm dacă șirul respectă restricțiile
if len(s) > 255:
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Aplicăm transformarea și scriem șirul rezultat în fișierul de ieșire
fout.write(change_case(case, s) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

2344 - Dvorak

2024-01-03T19:40:39Z

Codrut Borcutean: Pagină nouă: == Enunt == '''R.''' a descoperit de curând tastatura '''DVORAK''' și s-a decis că poate scrie mult mai rapid și mai corect cod folosind această tastatură decât folosind tastatura '''QWERTY'''. Plictisindu-se, '''R'''. a creat, pentru a onora tastatura lui preferată, '''transformarea''' '''dvorak''', care se realizează prin înlocuirea fiecărei litere dintr-un șir de caractere cu corespondența acesteia dintr-o permutare dată a alfabetului englez. De exemplu, cuv...

== Enunt ==
'''R.''' a descoperit de curând tastatura '''DVORAK''' și s-a decis că poate scrie mult mai rapid și mai corect cod folosind această tastatură decât folosind tastatura '''QWERTY'''. Plictisindu-se, '''R'''. a creat, pentru a onora tastatura lui preferată, '''transformarea''' '''dvorak''', care se realizează prin înlocuirea fiecărei litere dintr-un șir de caractere cu corespondența acesteia dintr-o permutare dată a alfabetului englez. De exemplu, cuvântul '''informatica''' poate să devină, printr-o transformare dvorak, '''cburpmaycja'''.

'''H.''', profitor din fire, a decis să intre pe calculatorul lui '''R.''' și să îi fure sursele valoroase de la problemele “rupere” pe care le-a rezolvat.

Dar '''R.''' şi-a securizat calculatorul cu o parolă (constând într-o succesiune de litere mici ale alfabetului englez). Din când în când, '''R.''' își modifică o parte din parolă efectuând următoarea operație: alege două poziții în parolă '''Si''' (capăt stânga) si '''Di''' (capăt dreapta) apoi aplică transformarea dvorak asupra secvenței formată din caracterele situate în parolă pe poziții din intervalul '''[Si''', '''Di]'''. Această operație este de tipul '''1''' și este codificată prin: '''1 Si Di'''.

Acum '''H.''' are nevoie de ajutorul vostru ca să afle parola şi să furați împreună toate sursele ca sa fiți primii la statistici pe Varena). Din când în când, el vă va da câte un sir de caractere nevid ('''SIR''') și vă va întreba dacă acest șir se regăsește ca subsecvență în parola lui '''R.''' Această operație este de tipul '''2''' și este codificată prin: '''2 SIR'''
== Cerinţa ==
Cunoscându-se permutarea dată, parola lui '''R.''' precum și o succesiune de '''Q''' operații de tipul '''1''' sau '''2''', găsiți răspunsurile la întrebările toate lui '''H.'''
== Date de intrare ==
Pe prima linie a fișierului '''dvorakin.txt''' se va afla numărul natural Q reprezentând numărul de operații din succesiunea dată.
Pe cea de-a doua linie se va afla '''permutarea dată''' pentru '''transformarea dvorak'''.
Pe cea de-a treia linie se va afla un sir de caractere litere mici, reprezentând '''parola inițială''' a lui '''R.'''
Pe fiecare dintre următoarele '''Q''' linii se află câte o operație de tip '''1''' sau '''2''', codificate ca în enunț.
== Date de ieșire ==
Pe fiecare linie a fișierului '''dvorakout.txt''' se va afla răspunsul pentru fiecare dintre intrebările lui '''H.''', în ordinea în care apar în fișierul de intrare: răspundeti cu '''Da''' dacă șirul se regăsește ca subsecvență în parola și '''Nu''' altfel.
== Restricţii şi precizări ==
* '''1 &les; Q &les; 500'''
* Fiecare al '''i'''-lea element al permutării date reprezintă litera în care se transformă cel de-al '''i'''-lea caracter din alfabetul englez într-o transformare dvorak
* Se garantează că fiecare literă din permutarea dată apare o singură dată, iar permutarea are fix '''26''' de caractere
* Parola este un șir de cel mult '''500''' de litere mici ale alfabetului englez.
* Pozițiile caracterelor din parolă sunt numerotate incepând de la '''1'''
* '''1 &les; Si &les; Di &les;''' lungimea parolei
* Intervalele '''[Si''', '''Di]''' corespunzătoare operației '''1''' se pot suprapune
* Șirul '''SIR''' pentru operația '''2''' are cel mult '''500''' de caractere
== Exemplu 1 ==
; dvorakin.txt
6
ifynmlbkpduogahqzsjxcervwt
olimpiadadeinformatica
1 1 6
2 info
2 olimpiada
1 8 15
1 9 14
2 olimpiadadeinformaticaecool5
; dvorakout.txt
Datele de intrare corespund restrictiilor impuse
Da
Nu
Nu
 
== Exemplu 2 ==
; dvorakin.txt
6
ASDASD
; dvorakout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
După prima operație, parola se transformă în '''hopgqpadadeinformatica'''

La a doua operație se răspunde cu '''Da'''.

La a treia operație se răspunde cu '''Nu'''.

După a patra operație, parola se transformă în '''hopgqpaninmpalhrmatica'''.

După a cincea operație, parola se transformă în '''hopgqpanpagqiohrmatica'''.

La a șasea operație se răspunde cu '''Nu'''.

== Rezolvare ==
<syntaxhighlight lang="python" line>
def transform(s, perm, la, r):
# Funcția aplică transformarea dvorak pe un substring al șirului s.

return s[:la] + ''.join(perm[ord(c) - ord('a')] for c in s[la:r]) + s[r:]

def main():
with open('dvorakin.txt', 'r') as fin, open('dvorakout.txt', 'w') as fout:
q = int(fin.readline().strip())
perm = fin.readline().strip()
s = fin.readline().strip()

# Verificăm dacă datele de intrare respectă restricțiile
if not (1 <= q <= 500) or len(s) > 500 or len(set(perm)) != 26:
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

for _ in range(q):
op = fin.readline().strip().split()
if op[0] == '1':
# Aplicăm transformarea dvorak
s = transform(s, perm, int(op[1]) - 1, int(op[2]))
else:
# Verificăm dacă șirul se regăsește ca subsecvență în parola
fout.write('Da\n' if op[1] in s else 'Nu\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

2321 - HappyNY2018

2024-01-03T19:08:01Z

Codrut Borcutean: Pagină nouă: == Alba ca Zapada == şi cei '''n''' pitici locuiau încă în căsuţa lor din pădure. Piticilor le făcuse cadou Moş Crăciun câte un număr şi fiecare pitic s-a hotărât să scrie numărul primit ca sumă de '''m''' numere naturale. == Cerinţa == Dându-se cele '''n''' numere naturale primite de pitici, să se afle, pentru fiecare pitic, cele '''m''' numere a căror sumă este egală cu numărul primit de pitic, astfel încât cel mai mic dintre numerele din sumă s...

== Alba ca Zapada ==
şi cei '''n''' pitici locuiau încă în căsuţa lor din pădure. Piticilor le făcuse cadou Moş Crăciun câte un număr şi fiecare pitic s-a hotărât să scrie numărul primit ca sumă de '''m''' numere naturale.

== Cerinţa ==
Dându-se cele '''n''' numere naturale primite de pitici, să se afle, pentru fiecare pitic, cele '''m''' numere a căror sumă este egală cu numărul primit de pitic, astfel încât cel mai mic dintre numerele din sumă să fie maxim posibil, iar diferenţa dintre cel mai mare număr din sumă şi cel mai mic să fie minimă.
== Date de intrare ==
Programul citește de la tastatură numerele '''n''' şi '''m''', iar apoi de pe a doua linie '''n''' numere naturale, separate prin spații, reprezentând numerele primite de pitici.
== Date de ieșire ==
Programul va afișa pe ecran, pe primele '''n''' linii, câte '''m''' numere, reprezentând numerele cerute pentru fiecare pitic, în ordine crescătoare.
== Restricţii şi precizări ==
* '''1 &les; n &les; 2017'''
* '''2 &les; m &les; 2018'''
* cele '''n''' numere citite vor fi mai mici decât '''1.000.000'''
== Exemplu 1 ==
; Intrare
1 2
5
; Iesire
Datele de intrare corespund restrictiilor impuse
2 3
 
== Exemplu 2 ==
; Intrare
3000 3000
3000
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
Avem un pitic care a primit numărul '''5''' şi trebuie să-l scrie ca sumă de două numere naturale : '''2+3=5'''. Cel mai mic dintre cele două numere este maxim ('''2''').
== Rezolvare ==
<syntaxhighlight lang="python" line>
def find_numbers(n, m):
# Funcția găsește m numere a căror sumă este egală cu n,
# astfel încât cel mai mic număr să fie maxim posibil și diferența dintre
# cel mai mare număr și cel mai mic să fie minimă.

# Calculăm cât de mari pot fi numerele
q, r = divmod(n, m)
# Primele r numere vor fi cu 1 mai mari decât restul
return [q + 1] * r + [q] * (m - r)

def main():
n, m = map(int, input().strip().split())
numbers = list(map(int, input().strip().split()))

# Verificăm dacă numerele respectă restricțiile
if not (1 <= n <= 2017) or not (2 <= m <= 2018) or any(number >= 1000000 for number in numbers):
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Pentru fiecare număr, găsim m numere a căror sumă este egală cu numărul
for number in numbers:
print(' '.join(map(str, sorted(find_numbers(number, m)))))

if __name__ == "__main__":
main()

</syntaxhighlight>

2890 - Base Convertor

2024-01-03T16:25:34Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă numărul '''n''' în baza '''b''', să se afișeze numărul '''n''' în convertit în baza '''c'''. == Date de intrare == Fișierul de intrare '''base_converterin.txt''' conține pe prima linie numerele '''n''', '''b''', '''c''', separate prin spații. == Date de ieșire == Fișierul de ieșire '''base_converterout.txt''' va conține pe prima linie numărul '''n''' în baza '''c'''. == Restricţii şi precizări == * la afișarea numerelor în baze mai m...

== Cerinţa ==
Se dă numărul '''n''' în baza '''b''', să se afișeze numărul '''n''' în convertit în baza '''c'''.
== Date de intrare ==
Fișierul de intrare '''base_converterin.txt''' conține pe prima linie numerele '''n''', '''b''', '''c''', separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''base_converterout.txt''' va conține pe prima linie numărul '''n''' în baza '''c'''.
== Restricţii şi precizări ==
* la afișarea numerelor în baze mai mare decât '''10''', cifrele mai mari decât '''9''' sunt înlocuite cu litere mari din alfabetul englez ('''10''' cu '''A''', '''11''' cu '''B''', etc.);
* '''1≤nrcif(n(b))≤1585'''
* '''2≤b≤36'''
* '''2≤c≤36'''
== Exemplu 1 ==
; base_converterin.txt
26 17 11
; base_converterout.txt
Datele de intrare corespund restrictiilor impuse
37
 
== Exemplu 2 ==
; base_converterin.txt
26 40 11
; base_converterout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def base_converter(n, b, c):
# Funcția convertește numărul n din baza b în baza c.

# Convertim numărul n din baza b în baza 10
n_in_base_10 = int(n, b)

# Convertim numărul n din baza 10 în baza c
n_in_base_c = ''
while n_in_base_10 > 0:
n_in_base_10, remainder = divmod(n_in_base_10, c)
if 0 <= remainder <= 9:
n_in_base_c = str(remainder) + n_in_base_c
else:
n_in_base_c = chr(ord('A') + remainder - 10) + n_in_base_c

return n_in_base_c

def main():
with open('base_converterin.txt', 'r') as fin, open('base_converterout.txt', 'w') as fout:
n, b, c = fin.readline().strip().split()
b = int(b)
c = int(c)

# Verificăm dacă datele de intrare respectă restricțiile
if len(n) > 1585 or not (2 <= b <= 36) or not (2 <= c <= 36):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Convertim numărul n din baza b în baza c și scriem rezultatul în fișierul de ieșire
fout.write(base_converter(n, b, c) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

0853 - Cadouri

2024-01-03T16:17:21Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Elevii clasei a X-a s-au implicat în strângerea de cadouri pentru Crăciun. Fiecare elev a adus mai multe cadouri, și a trimis prin email șefului clasei o urare, însoțită de lista cadourilor. Fiecare email are forma: '''urare lista_cadouri''' '''urare''' este un text care nu conţine cifre. Lista cadourilor constă într-o enumerare a cadourilor: '''numar_cadouri denumire_cadou''' ('''numar_cadouri''' este un număr natural, iar '''denumire_cadou''' este...

== Cerinţa ==
Elevii clasei a X-a s-au implicat în strângerea de cadouri pentru Crăciun. Fiecare elev a adus mai multe cadouri, și a trimis prin email șefului clasei o urare, însoțită de lista cadourilor. Fiecare email are forma:
'''urare lista_cadouri'''
'''urare''' este un text care nu conţine cifre. Lista cadourilor constă într-o enumerare a cadourilor:
'''numar_cadouri denumire_cadou'''
('''numar_cadouri''' este un număr natural, iar '''denumire_cadou''' este un cuvânt scris cu litere mici ale alfabetului englez; '''numar_cadouri''' şi '''denumire_cadou''' sunt separate prin cel puţin un spaţiu), cadourile din listă fiind separate prin spaţii şi/sau diverse semne de punctuaţie

Şeful clasei trebuie să centralizeze listele primite. Ajutaţi-l să construiască o listă a care să conţină denumirea fiecărui cadou şi numărul total de cadouri de acel tip (cantitatea). Lista va fi ordonată descrescător după cantitate.

== Date de intrare ==
Fișierul de intrare '''cadouriin.txt''' conține pe prima linie numărul '''n''' de elevi din clasa a X-a; fiecare dintre următoarele '''n''' linii, conţine câte un email.
== Date de ieșire ==
Fișierul de ieșire '''cadouriout.txt''' va conține pe prima linie numărul de cadouri diferite '''C'''; următoarele '''C''' linii vor conţine câte un cadou şi cantitatea totală, separate prin exact un spaţiu. Lista cadouri va fi ordonată descrescător după cantitate. Dacă există mai multe cadouri cu aceeaşi cantitate, se va afişa mai întâi cadoul cu denumirea mai mică din punct de vedere lexicografic.
== Restricţii şi precizări ==
* '''1 &les; n &les; 100'''
* fiecare linie a fişierului de intrare conţine cel mult '''255''' caractere
* sunt cel mult '''500''' de cadouri diferite cu denumirea de cel mult '''20''' de litere ale afabetului englez
* cantitatea din fiecare cadou este cel mult '''100.000'''
== Exemplu 1 ==
; cadouriin.txt
3
La multi ani! 4 papusi, 15 ciocolate , 20 sosete.
Sarbatori fericite :) ! 3 ciocolate , 10 biscuiti, 5 papusi
Salut. 2 ciocolate , 1 papusi. 1 ciocolate!
; cadouriout.txt
Datele de intrare corespund restrictiilor impuse
4
ciocolate 21
sosete 20
biscuiti 10
papusi 10
 
== Exemplu 2 ==
; cadouriin.txt
1000
La multi ani! 40 ab, 15 ciocolate , 20 sosete.
Sarbatori fericite :) ! 3 ciocolateciocolateciocolate , 10 biscuiti, 5 papusi
Salut. 2 ciocolate , 1 papusi. 1 ciocolate!
; cadouriout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
import re
from collections import Counter

def process_emails(emails):
# Funcția procesează emailurile și returnează un dicționar
# cu denumirea fiecărui cadou și numărul total de cadouri de acel tip.

gifts = Counter()
for email in emails:
# Extragem lista de cadouri din email
gift_list = re.findall(r'(\d+) (\w+)', email)
for count, gift in gift_list:
gifts[gift] += int(count)
return gifts

def main():
with open('cadouriin.txt', 'r') as fin, open('cadouriout.txt', 'w') as fout:
n = int(fin.readline().strip())
emails = [fin.readline().strip() for _ in range(n)]

# Verificăm dacă emailurile respectă restricțiile
if len(emails) > 100 or any(len(email) > 255 for email in emails):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Procesăm emailurile și obținem numărul total de cadouri de fiecare tip
gifts = process_emails(emails)

# Sortăm cadourile în ordine descrescătoare a numărului de cadouri și lexicografică
sorted_gifts = sorted(gifts.items(), key=lambda x: (-x[1], x[0]))

# Scriem numărul de cadouri diferite și lista de cadouri în fișierul de ieșire
fout.write(str(len(sorted_gifts)) + '\n')
for gift, count in sorted_gifts:
fout.write(f'{gift} {count}\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

3054 - PrimeXXL

2024-01-03T16:04:35Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă un număr natural '''n'''. Să se afișeze '''DA''' dacă numărul este prim altfel se afișează '''NU'''. == Date de intrare == Fișierul de intrare '''primexxlin.txt''' conține pe prima linie numărul '''n'''. == Date de ieșire == Fișierul de ieșire '''primexxlout.txt''' va conține pe prima linie '''DA''' sau '''NU''' după caz. == Restricţii şi precizări == * '''1 ≤ nrcif(n) ≤ 1000''' == Exemplu 1 == ; primexxlin.txt 5 ; primexxlout.txt...

== Cerinţa ==
Se dă un număr natural '''n'''. Să se afișeze '''DA''' dacă numărul este prim altfel se afișează '''NU'''.
== Date de intrare ==
Fișierul de intrare '''primexxlin.txt''' conține pe prima linie numărul '''n'''.
== Date de ieșire ==
Fișierul de ieșire '''primexxlout.txt''' va conține pe prima linie '''DA''' sau '''NU''' după caz.
== Restricţii şi precizări ==
* '''1 ≤ nrcif(n) ≤ 1000'''
== Exemplu 1 ==
; primexxlin.txt
5
; primexxlout.txt
Datele de intrare corespund restrictiilor impuse
DA
 
== Exemplu 2 ==
; primexxlin.txt
10000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001
; primexxlout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def is_prime(n):
# Funcția verifică dacă un număr este prim.

if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
p = 3
while p * p <= n:
if n % p == 0:
return False
p += 2
return True

def main():
with open('primexxlin.txt', 'r') as fin, open('primexxlout.txt', 'w') as fout:
n = int(fin.readline().strip())

# Verificăm dacă numărul respectă restricțiile
if len(str(n)) > 1000:
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Verificăm dacă numărul este prim și scriem rezultatul în fișierul de ieșire
fout.write('DA\n' if is_prime(n) else 'NU\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

0851 - Email

2024-01-03T15:52:11Z

Codrut Borcutean: Pagină nouă: O adresă de email este alcătuită din '''numele de utilizator''' și '''numele de domeniu''', separate prin simbolul '''@'''. De exemplu, '''gigel@pbinfo.ro''' este o adresă de email corectă ca structură, chiar dacă inexistentă. == Cerinţa == Se dă o listă de adrese de email corecte ca structură. Să se determine câte adrese de email sunt asociate cu fiecare nume de domeniu == Date de intrare == Fișierul de intrare '''emailin.txt''' conține mai multe adrese de e...

O adresă de email este alcătuită din '''numele de utilizator''' și '''numele de domeniu''', separate prin simbolul '''@'''. De exemplu, '''gigel@pbinfo.ro''' este o adresă de email corectă ca structură, chiar dacă inexistentă.
== Cerinţa ==
Se dă o listă de adrese de email corecte ca structură. Să se determine câte adrese de email sunt asociate cu fiecare nume de domeniu
== Date de intrare ==
Fișierul de intrare '''emailin.txt''' conține mai multe adrese de email, câte una pe o linie.
== Date de ieșire ==
Fișierul de ieșire '''emailout.txt''' va conține pe prima linie numărul '''C''' de nume de domenii diferite. Următoarele '''C''' linii conțin câte un nume de domeniu, urmat de un spațiu și de numărul de adrese date asociate cu acel domeniu. Numele de domeniu se vor afișa în ordine descrescătoare a numărului de adrese asociate. Dacă există mai multe nume de domenii cu același număr de adrese asociate, se vor afișa în ordine lexicografică.
== Restricţii şi precizări ==
* fișierul de intrare va conține cel mult '''1000''' de adrese distincte, cu cel mult '''200''' de domenii distincte;
* lungimea maximă a unei adrese de email este de '''50''' de caractere;
* numele de domeniu începe după simbolul '''@''' și se termină la sfârșitul adresei;
* adresa de email nu conține spații sau alte caractere albe.
== Exemplu 1 ==
; emailin.txt
gigel@pbinfo.ro
gigel@yahoo.com
ionel.c@gmail.com
gigi@pbinfo.ro
vasile@yahoo.com
jr@gmail.com
qwerty@yahoo.com
; emailout.txt
Datele de intrare corespund restrictiilor impuse
3
yahoo.com 3
gmail.com 2
pbinfo.ro 2
 
== Exemplu 2 ==
; emailin.txt
012345678901234567890123456789012345678901234567891@pbinfo.ro
gigel@yahoo.com
ionel.c@gmail.com
gigi@pbinfo.ro
vasile@yahoo.com
jr@gmail.com
qwerty@yahoo.com
; emailout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
from collections import Counter

def count_domains(emails):
# Funcția numără câte adrese de email sunt asociate cu fiecare nume de domeniu.

# Extragem numele de domeniu din fiecare adresă de email și le numărăm
domains = [email.split('@')[1] for email in emails]
return Counter(domains)

def main():
with open('emailin.txt', 'r') as fin, open('emailout.txt', 'w') as fout:
emails = [line.strip() for line in fin]

# Verificăm dacă adresele de email respectă restricțiile
if len(emails) > 1000 or any(len(email) > 50 for email in emails):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Numărăm câte adrese de email sunt asociate cu fiecare nume de domeniu
domain_counts = count_domains(emails)

# Sortăm numele de domeniu în ordine descrescătoare a numărului de adrese asociate
sorted_domains = sorted(domain_counts.items(), key=lambda x: (-x[1], x[0]))

# Scriem numărul de nume de domenii diferite și numărul de adrese asociate cu fiecare domeniu
fout.write(str(len(sorted_domains)) + '\n')
for domain, count in sorted_domains:
fout.write(f'{domain} {count}\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

0850 - Repetitii

2024-01-03T15:41:14Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se consideră un șir de caractere format numai din litere mici ale alfabetului englez. Dacă șirul conține subșiruri consecutive care se repetă, el poate fi scris condensat. De exemplu, șirul '''mamateteter''' poate fi scris '''(ma)2(te)3r''' – subșirul care se repetă se scrie între paranteze rotunde, urmat de numărul de apariții. Dându-se un șir în forma condensată, să se determine șirul în forma inițială. == Date de intrare == Programul...

== Cerinţa ==
Se consideră un șir de caractere format numai din litere mici ale alfabetului englez. Dacă șirul conține subșiruri consecutive care se repetă, el poate fi scris condensat. De exemplu, șirul '''mamateteter''' poate fi scris '''(ma)2(te)3r''' – subșirul care se repetă se scrie între paranteze rotunde, urmat de numărul de apariții.

Dându-se un șir în forma condensată, să se determine șirul în forma inițială.
== Date de intrare ==
Programul citește de la tastatură șirul '''s''', în forma condensată.
== Date de ieșire ==
Programul va afișa pe ecran șirul '''t''', în forma inițială.
== Restricţii şi precizări ==
* lungimea șirurilor '''s''' și '''t''' nu depășește '''255''' caractere
* șirul condensat nu va conține paranteze în alte paranteze
== Exemplu 1 ==
; Intrare
(ma)2(te)3r
; Iesire
Datele de intrare corespund restrictiilor impuse
mamateteter
 
== Exemplu 2 ==
; Intrare
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
import re

def expand_string(s):
# Funcția expandează un șir de caractere condensat în forma sa inițială.

# Folosim o expresie regulată pentru a găsi toate subșirurile de forma (x)n
matches = re.findall(r'\((.*?)\)(\d+)', s)
for match in matches:
# Înlocuim fiecare subșir (x)n cu x repetat de n ori
s = s.replace(f'({match[0]}){match[1]}', match[0] * int(match[1]))
return s

def main():
# Citim șirul de la tastatură
s = input().strip()

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

print("Datele de intrare corespund restrictiilor impuse")

# Expandăm șirul și îl afișăm
print(expand_string(s))

if __name__ == "__main__":
main()

</syntaxhighlight>

0992 - NrVocale1

2024-01-03T15:33:02Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă un şir cu cel mult '''255''' de caractere. Să se determine câte vocale conţine. Se va defini şi utiliza subprogramul '''apcar''', cu doi parametri: * '''s''' – un şir cu cel mult '''255''' de caractere * '''c''' – un caracter care returnează numărul de apariţii ale caracterului '''c''' în şirul '''s'''. == Date de intrare == Programul citește de la tastatură un şir de caractere. == Date de ieșire == Programul va afișa pe ecran numă...

== Cerinţa ==
Se dă un şir cu cel mult '''255''' de caractere. Să se determine câte vocale conţine.

Se va defini şi utiliza subprogramul '''apcar''', cu doi parametri:

* '''s''' – un şir cu cel mult '''255''' de caractere
* '''c''' – un caracter
care returnează numărul de apariţii ale caracterului '''c''' în şirul '''s'''.
== Date de intrare ==
Programul citește de la tastatură un şir de caractere.
== Date de ieșire ==
Programul va afișa pe ecran numărul de vocale din şirul dat.

== Exemplu 1 ==
; Intrare
VULPEA11 vulpea22
; Iesire
Datele de intrare corespund restrictiilor impuse
6
 
== Exemplu 2 ==
; Intrare

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def apcar(s, c):
# Funcția returnează numărul de apariții ale caracterului c în șirul s.

return s.count(c)

def main():
# Citim șirul de la tastatură
s = input().strip()

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

print("Datele de intrare corespund restrictiilor impuse")

# Definim vocalele
vowels = 'aeiouAEIOU'

# Calculăm numărul de vocale din șir
num_vowels = sum(apcar(s, vowel) for vowel in vowels)

# Afișăm numărul de vocale
print(num_vowels)

if __name__ == "__main__":
main()

</syntaxhighlight>

3492 - PalPal

2024-01-03T15:19:55Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se dă un șir '''s''' care conține litere mici ale alfabetului englez, urmat de un număr natural '''k'''. Să se afișeze câte subsecvențe ale șirului '''s''' de lungime '''1''', '''2''', … '''k''' sunt palindromuri. == Date de intrare == Fișierul de intrare '''palpalin.txt''' conține pe prima linie un șir '''s''' și pe următoarea linie un număr natural '''k'''. == Date de ieșire == Fișierul de ieșire '''palpalout.txt''' va conține '''k''' lin...

== Cerinţa ==
Se dă un șir '''s''' care conține litere mici ale alfabetului englez, urmat de un număr natural '''k'''. Să se afișeze câte subsecvențe ale șirului '''s''' de lungime '''1''', '''2''', … '''k''' sunt palindromuri.
== Date de intrare ==
Fișierul de intrare '''palpalin.txt''' conține pe prima linie un șir '''s''' și pe următoarea linie un număr natural '''k'''.
== Date de ieșire ==
Fișierul de ieșire '''palpalout.txt''' va conține '''k''' linii. Pe linia '''i''' ('''1 ≤ i ≤ k''') se va găsi numărul de subsecvențe de '''i''' caractere care sunt palindromuri.
== Restricţii şi precizări ==
* '''1 &les; k &les; 1000'''
* șirul '''s''' are maxim '''20000''' de caractere
* Prin subsecvență a unui șir de caractere se înțelege o succesiune de unul sau mai multe caractere din șir aflate pe poziții consecutive.
* Un șir de caractere este palindrom dacă se citește la fel de la stânga la dreapta și de la dreapta la stânga.
== Exemplu 1 ==
; palpalin.txt'
eaaebeadaebcc
5
; palpalout.txt
Datele de intrare corespund restrictiilor impuse
13
2
2
1
2
 
== Exemplu 2 ==
; palpalin.txt'
eaaebeadaebcc
-5
; palpalout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
Subsecvențe palindrom de lungime 1: '''e''', '''a''', '''a''', '''e''', '''b''', '''e''', '''a''', '''d''', '''a''', '''e''', '''b''', '''c''', '''c'''.

Subsecvențe palindrom de lungime 2: '''aa''', '''cc'''.

Subsecvențe palindrom de lungime 3: '''ebe''', '''ada'''.

Subsecvențe palindrom de lungime 4: '''eaae'''.

Subsecvențe palindrom de lungime 5: '''aebea''', '''eadae'''.

== Rezolvare ==
<syntaxhighlight lang="python" line>
def is_palindrome(s):

#Verifică dacă un șir de caractere este palindrom.

return s == s[::-1]

def count_palindromic_subsequences(s, k):

#Numără subsecvențele palindromice de lungime 1, 2, ..., k ale unui șir.

counts = [0] * k
for length in range(1, k + 1):
for i in range(len(s) - length + 1):
if is_palindrome(s[i:i+length]):
counts[length-1] += 1
return counts

def main():
with open('palpalin.txt', 'r') as fin, open('palpalout.txt', 'w') as fout:
s = fin.readline().strip()
k = int(fin.readline().strip())

# Verifică dacă datele de intrare respectă restricțiile
if len(s) > 20000 or k < 1 or k > 1000:
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Numără subsecvențele palindromice și scrie rezultatele în fișierul de ieșire
counts = count_palindromic_subsequences(s, k)
for count in counts:
fout.write(str(count) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

2029 - AfisareN

2024-01-03T15:03:08Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Citindu-se un număr natural '''n''' şi un şir de caractere să se afişeze de '''n''' ori şirul de caractere. De fiecare dată se va trece pe rând nou. == Date de intrare == Fişierul de intrare '''afisarenin.txt''' conţine pe prima linie numărul '''n''', iar pe a două şirul de caractere. == Date de ieșire == Fişierul de ieşire '''afisarenout.txt''' va afişa pe fiecare linie de la '''1''' la '''n''' şirul de caractere. == Restricţii şi precizăr...

== Cerinţa ==
Citindu-se un număr natural '''n''' şi un şir de caractere să se afişeze de '''n''' ori şirul de caractere. De fiecare dată se va trece pe rând nou.
== Date de intrare ==
Fişierul de intrare '''afisarenin.txt''' conţine pe prima linie numărul '''n''', iar pe a două şirul de caractere.
== Date de ieșire ==
Fişierul de ieşire '''afisarenout.txt''' va afişa pe fiecare linie de la '''1''' la '''n''' şirul de caractere.
== Restricţii şi precizări ==
* '''1 ≤ n ≤ 50'''
* lungimea şirului de caractere este maxim '''1.000.000'''
* '''daca n = 0 nu se va afisa nimic'''
== Exemplu 1 ==
; afisarenin.txt
3
AfisareN
; afisarenout.txt
Datele de intrare corespund restrictiilor impuse
AfisareN
AfisareN
AfisareN
 
== Exemplu 2 ==
; afisarenin.txt
51
AfisareN
; afisarenout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def main():
with open('afisarenin.txt', 'r') as fin, open('afisarenout.txt', 'w') as fout:
n = int(fin.readline().strip())
sir = fin.readline().strip()

# Verifică dacă numărul și șirul respectă restricțiile
if not (1 <= n <= 50) or len(sir) > 1000000 or not all(c.isalpha() or c.isspace() for c in sir):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Afișează șirul de n ori
for _ in range(n):
fout.write(sir + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

3101 - XORCrypt

2024-01-03T14:54:26Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se citește un text de maxim '''256''' caractere și o cheie de număr egal de caractere cu textul citit. După aplicarea '''Encripției XOR''', caracterele rezultate se vor afișa în '''format binar''' deoarece în majoritatea cazurilor se obțin caractere neprintabile. '''Encripția XOR''' presupune aplicarea operatorului pe biți '''XOR''' între text și cheie, între fiecare caracter din text și caracterul din cheie de pe aceeași poziție cu cel din te...

== Cerinţa ==
Se citește un text de maxim '''256''' caractere și o cheie de număr egal de caractere cu textul citit. După aplicarea '''Encripției XOR''', caracterele rezultate se vor afișa în '''format binar''' deoarece în majoritatea cazurilor se obțin caractere neprintabile.

'''Encripția XOR''' presupune aplicarea operatorului pe biți '''XOR''' între text și cheie, între fiecare caracter din text și caracterul din cheie de pe aceeași poziție cu cel din text: '''text[i] XOR cheie[i]'''. Pentru decriptare, operatorul se aplică între cheie și textul criptat.
== Date de intrare ==
Fișierul de intrare '''xorcryptin.txt''' conține:
1. Pe prima linie un text format din maxim '''256''' caractere.
2.Pe a doua linie cheia, de lungime egală cu textul.

== Date de ieșire ==
Fișierul de ieșire '''xorcryptout.txt''' va conține o singură linie, având caracterele în '''format binar''' separate prin spațiu.
== Restricţii şi precizări ==
* Se va folosi alfabetul englez.
== Exemplu 1 ==
; xorcryptin.txt
xor
key
; xorcryptout.txt
Datele de intrare corespund restrictiilor impuse
00010011 00001010 00001011
 
== Exemplu 2 ==
; xorcryptin.txt
xor10
key
; xorcryptout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
'''x^k -> 00010011'''

'''o^e -> 00001010'''

'''r^y -> 00001011'''

== Rezolvare ==
<syntaxhighlight lang="python" line>
def xor_encrypt(text, key):
# Aplică encripția XOR pe text cu cheia dată
return ' '.join([format(ord(a) ^ ord(b), '08b') for a, b in zip(text, key)])

def main():
with open('xorcryptin.txt', 'r') as fin, open('xorcryptout.txt', 'w') as fout:
text = fin.readline().strip()
key = fin.readline().strip()

# Verifică dacă textul și cheia respectă restricțiile
if len(text) > 256 or len(key) != len(text) or not all(c.isalpha() or c.isspace() for c in text):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Aplică encripția XOR pe text cu cheia dată și scrie rezultatul în fișierul de ieșire
fout.write(xor_encrypt(text, key) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

1868 - Prosirx

2024-01-03T14:37:29Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se consideră un text format din cel mult '''200''' de caractere litere mici și spații. Cuvintele din text sunt separate prin unul sau mai multe spații. Scrieti un program care citește textul și care: '''a)''' determină numărul de consoane din textul citit; '''b)''' înlocuiește prima literă a fiecărui cuvânt din textul citit cu litera X (mare); '''c)''' modifică textul citit prin aranjarea în ordine lexicografică a tuturor cuvintelor din text...

== Cerinţa ==
Se consideră un text format din cel mult '''200''' de caractere litere mici și spații. Cuvintele din text sunt separate prin unul sau mai multe spații. Scrieti un program care citește textul și care:

'''a)''' determină numărul de consoane din textul citit;

'''b)''' înlocuiește prima literă a fiecărui cuvânt din textul citit cu litera X (mare);

'''c)''' modifică textul citit prin aranjarea în ordine lexicografică a tuturor cuvintelor din text și separarea lor prin câte un singur spațiu.
== Date de intrare ==
Fișierul de intrare '''prosirxin.txt''' conține pe prima linie textul.
== Date de ieșire ==
Fișierul de ieșire '''prosirxout.txt''' va conține:

- pe prima linie răspunsul la cerința '''a)'''

- pe a doua linie răspunsul la cerința '''b)'''

- pe a treia linie răspunsul la cerința '''c)'''
== Restricţii şi precizări ==
* textul este format din cel mult '''200''' de caractere, doar litere mici sau spații
== Exemplu 1 ==
; prosirxin.txt
oana este la scoala
; prosirxout.txt
Datele de intrare corespund restrictiilor impuse
7
Xana Xste Xa Xcoala
este la oana scoala
 
== Exemplu 2 ==
; prosirxin.txt
oana este la scoala999
; prosirxout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicație ==
Sunt '''7''' consoane în textul citit.

== Rezolvare ==
<syntaxhighlight lang="python" line>
def analyze_text(text):
# Analizează textul și returnează numărul de consoane,
# textul cu prima literă a fiecărui cuvânt înlocuită cu 'X'
# și textul cu cuvintele aranjate în ordine lexicografică
consoane = 'bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ'
vocale = 'aeiouAEIOU'
nr_consoane = sum(c in consoane for c in text)
cuvinte = text.split()
cuvinte_x = ['X' + cuvant[1:] if cuvant[0] in vocale else cuvant for cuvant in cuvinte]
cuvinte_sortate = sorted(cuvinte)
return nr_consoane, ' '.join(cuvinte_x), ' '.join(cuvinte_sortate)

def main():
with open('prosirxin.txt', 'r') as fin, open('prosirxout.txt', 'w') as fout:
text = fin.readline().strip()

# Verifică dacă textul respectă restricțiile
if len(text) > 200 or not all(c.isalpha() or c.isspace() for c in text):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Analizează textul și scrie rezultatele în fișierul de ieșire
nr_consoane, text_x, text_sortat = analyze_text(text)
fout.write(str(nr_consoane) + '\n')
fout.write(text_x + '\n')
fout.write(text_sortat + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

1711 - Siruri concatenate

2024-01-03T14:27:30Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Scrieţi un program care citeşte din fişierul de intrare mai multe şiruri de caractere formate din litere mici ale alfabetului englez şi determină câte dintre acestea sunt formate din două şiruri identice (cu lungimea cel puţin 1) concatenate. == Date de intrare == Fișierul de intrare '''siruri_concatenatein.txt''' conține pe prima linie un număr natural nenul '''n''', iar pe următoarele '''n''' linii câte un şir format din litere mici ale alfabe...

== Cerinţa ==
Scrieţi un program care citeşte din fişierul de intrare mai multe şiruri de caractere formate din litere mici ale alfabetului englez şi determină câte dintre acestea sunt formate din două şiruri identice (cu lungimea cel puţin 1) concatenate.
== Date de intrare ==
Fișierul de intrare '''siruri_concatenatein.txt''' conține pe prima linie un număr natural nenul '''n''', iar pe următoarele '''n''' linii câte un şir format din litere mici ale alfabetului englez.
== Date de ieșire ==
Fișierul de ieșire '''siruri_concatenateout.txt''' va conține pe prima linie numărul de şiruri din fişierul de intrare care sunt formate din două şiruri identice concatenate.
== Restricţii şi precizări ==
* '''1 &les; n &les; 1000000'''
* şirurile au cel mult '''5000''' de caractere.
== Exemplu 1 ==
; siruri_concatenatein.txt
5
sirsir
micropico
pp
vara
nanonano
; siruri_concatenateout.txt
Datele de intrare corespund restrictiilor impuse
3
 
== Exemplu 2 ==
; siruri_concatenatein.txt
-5
sirsir
micropico
pp
vara
nanonano
; siruri_concatenateout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
Cele 3 şiruri din fişier obţinute prin concatenarea a două şiruri identice sunt: '''sirsir''' ('''sir'''), '''pp''' ('''p''') şi '''nanonano''' ('''nano''').
== Rezolvare ==
<syntaxhighlight lang="python" line>
def is_concatenated(s):
# Verifică dacă șirul s este format din două șiruri identice concatenate
n = len(s)
if n % 2 != 0:
return False
return s[:n//2] == s[n//2:]

def main():
with open('siruri_concatenatein.txt', 'r') as fin, open('siruri_concatenateout.txt', 'w') as fout:
n = int(fin.readline().strip())
siruri = [fin.readline().strip() for _ in range(n)]

# Verifică dacă șirurile respectă restricțiile
if not (1 <= n <= 1000000) or any(not s.islower() or len(s) > 5000 for s in siruri):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Numără șirurile care sunt formate din două șiruri identice concatenate
nr = sum(is_concatenated(s) for s in siruri)
fout.write(str(nr) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

1631 - Cuvinte5

2024-01-03T14:12:33Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Se citește un text cu cel mult '''255''' de caractere, litere mici și mari ale alfabetului englez și spații. Cuvintele sunt separate printr-un singur spațiu. Să se determine câte cuvinte din text au exact trei litere, care sunt cuvintele care încep și se termină cu vocală și care este lungimea celui mai lung cuvânt. == Date de intrare == Programul citește de la tastatură textul. == Date de ieșire == Programul va afișa pe ecran, pe prima linie n...

== Cerinţa ==
Se citește un text cu cel mult '''255''' de caractere, litere mici și mari ale alfabetului englez și spații. Cuvintele sunt separate printr-un singur spațiu. Să se determine câte cuvinte din text au exact trei litere, care sunt cuvintele care încep și se termină cu vocală și care este lungimea celui mai lung cuvânt.
== Date de intrare ==
Programul citește de la tastatură textul.
== Date de ieșire ==
Programul va afișa pe ecran, pe prima linie numărul '''nr''', reprezentând numărul cuvintelor din text cu exact trei litere, pe următoarele linii cuvintele care încep și se termină cu vocală, iar pe ultima linie numărul '''mx''' reprezentând lungimea celui mai lung cuvânt.
== Restricţii şi precizări ==
* textul conține cel mult '''30''' cuvinte
* fiecare cuvânt conține cel mult '''10''' caractere
* se consideră vocale '''a e i o u A E I O U'''
== Exemplu 1 ==
; Intrare
Dan are un pix care este albastru si un creion care e gri
; Iesire
Datele de intrare corespund restrictiilor impuse
4
are
este
albastru
e
8
 
== Exemplu 2 ==
; Intrare
dan4
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def analyze_text(text):
# Analizează textul și returnează numărul de cuvinte cu exact trei litere,
# cuvintele care încep și se termină cu vocală și lungimea celui mai lung cuvânt
cuvinte = text.split()
cuvinte_trei_litere = [cuvant for cuvant in cuvinte if len(cuvant) == 3]
cuvinte_vocale = [cuvant for cuvant in cuvinte if cuvant[0] in 'aeiouAEIOU' and cuvant[-1] in 'aeiouAEIOU']
lungime_max = max(len(cuvant) for cuvant in cuvinte)
return cuvinte_trei_litere, cuvinte_vocale, lungime_max

def main():
text = input().strip()

# Verifică dacă textul respectă restricțiile
if len(text) > 255 or not all(c.isalpha() or c.isspace()
for c in text) or len(text.split()) > 30 \
or any(len(cuvant) > 10 for cuvant in text.split()):
print("Datele de intrare nu corespund restrictiilor impuse\n")
return

print("Datele de intrare corespund restrictiilor impuse\n")

# Analizează textul și afișează rezultatele
cuvinte_trei_litere, cuvinte_vocale, lungime_max = analyze_text(text)
print(str(len(cuvinte_trei_litere)) + '\n')
print('\n'.join(cuvinte_vocale) + '\n')
print(str(lungime_max) + '\n')

if __name__ == "__main__":
main()

== Explicatie ==
'''4''' cuvinte au exact trei litere.
Cuvintele care încep și termină cu vocală sunt '''are este albastru e.'''
Cuvântul cel mai lung are '''8''' litere.

</syntaxhighlight>

1873 - Cuvinte pare

2024-01-03T13:18:06Z

Codrut Borcutean: Pagină nouă: == Cerinţa == Un text are cel mult '''100''' de caractere, iar cuvintele sale sunt formate doar din litere mici ale alfabetului englez și sunt separate prin câte un spațiu. Scrieți un program C/C++ care citește de la tastatură un text de tipul precizat mai sus și îl transformă în memorie prin înlocuirea fiecărui cuvânt format din număr par de litere cu simbolul '''#'''. Programul afișează pe ecran textul obținut sau mesajul '''nu exista''' dacă textul cit...

== Cerinţa ==
Un text are cel mult '''100''' de caractere, iar cuvintele sale sunt formate doar din litere mici ale alfabetului englez și sunt separate prin câte un spațiu.

Scrieți un program C/C++ care citește de la tastatură un text de tipul precizat mai sus și îl transformă în memorie prin înlocuirea fiecărui cuvânt format din număr par de litere cu simbolul '''#'''.

Programul afișează pe ecran textul obținut sau mesajul '''nu exista''' dacă textul citit nu conține astfel de cuvinte.
== Date de intrare ==
Programul citește de la tastatură un text.
== Date de ieșire ==
Programul va afișa textul modificat.
== Restricţii şi precizări ==
* textul are cel mult '''100''' de caractere
* cuvintele sunt formate doar din litere mici ale alfabetului englez
== Exemplu 1 ==
; Intrare
anii de liceu sunt foarte frumosi
; Iesire
Datele de intrare corespund restrictiilor impuse
# # liceu # # frumosi
 
== Exemplu 2 ==
; Intrare
ANII DE LICEU SUNT FOARTE FRUMOSI
; Iesire
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def transforma_text(text):
# Înlocuiește fiecare cuvânt format din număr par de litere cu simbolul #
cuvinte = text.split()
for i in range(len(cuvinte)):
if len(cuvinte[i]) % 2 == 0:
cuvinte[i] = '#'
return ' '.join(cuvinte)

def main():
text = input().strip()

# Verifică dacă textul respectă restricțiile
if len(text) > 100 or not text.islower():
print("Datele de intrare nu corespund restrictiilor impuse")
return

print("Datele de intrare corespund restrictiilor impuse")

# Transformă textul și afișează rezultatul
text_transformat = transforma_text(text)
if '#' in text_transformat:
print(text_transformat)
else:
print("nu exista")

if __name__ == "__main__":
main()

</syntaxhighlight>

3190 - Vigenere

2024-01-03T13:02:13Z

Codrut Borcutean: Pagină nouă: == Vigenere == La fel ca '''cifrul Cezar''', cifrul Vigenere deplasează literele, dar acesta folosește o deplasare multiplă. Cheia este constituită din câțiva întregi '''ki''', unde '''0 ≤ ki ≤ 25.''' Aceşti întregi pot fi, de exemplu, '''k = (21, 4, 2 19, 14, 17)'''. Această cheie ar provoca deplasare primei litere cu '''21''', '''c1 = p1 + 21 (mod 26)''', a celei de-a doua cu '''4''', '''c2 = p2 + 4 (mod 26)''', ş.a.m.d. până la sfârşitul cheii și apoi d...

== Vigenere ==
La fel ca '''cifrul Cezar''', cifrul Vigenere deplasează literele, dar acesta folosește o deplasare multiplă. Cheia este constituită din câțiva întregi '''ki''', unde '''0 ≤ ki ≤ 25.'''
Aceşti întregi pot fi, de exemplu, '''k = (21, 4, 2 19, 14, 17)'''. Această cheie ar provoca deplasare primei litere cu '''21''', '''c1 = p1 + 21 (mod 26)''', a celei de-a doua cu '''4''', '''c2 = p2 + 4 (mod 26)''', ş.a.m.d. până la sfârşitul cheii și apoi de la început, din nou.

Pentru o memorare mai ușoară cheia este de regulă dată printr-un cuvânt – cheia de mai sus corespunde cuvântului '''vector''', litera ''''v''''” corespondând numărului '''21''' (numerotarea începe de la '''0'''), litera ''''e'''' cu '''4''', etc.
Un exemplu de cifru Vigenere:

Textul clar: '''thisisanexampleofthevigenerecipher'''

Cheia: '''vector'''

Textul cifrat: '''olklwjvrgqodkpghtkcixbuviitxqzklgk'''
== Cerinţa ==
Se citesc două texte '''a''' și '''b''' cu lungimea maximă de '''255''' de caractere. Să se afișeze textul după
aplicarea cifrului Vigenere la textul '''a''' cu cheia '''b'''.
== Date de intrare ==
Fișierul de intrare '''vigenerein.txt''' conține pe prima linie textul '''a''' iar pe a doua linie textul '''b'''.
== Date de ieșire ==
Fișierul de ieșire '''vigenereout.txt''' va conține pe prima linie rezultatul criptării.
== Restricţii şi precizări ==
* lungimea lui '''b &les;''' Lungimea lui '''a &les; 255''';
* cele două șiruri vor conține doar litere mici din alfabetul englez.
== Exemplu 1 ==
; vigenerein.txt
pbinfo
dio
; vigenereout.txt
Datele de intrare corespund restrictiilor impuse
sjwqnc
 
== Exemplu 2 ==
; vigenerein.txt
abc123
; vigenereout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Explicatie ==
În Cifrul Vigenere începem numărătoarea caracterelor din cheie de la 0, astfel, caracterul ''''d'''' din cheie deplasează caractrrul corespunzător din text cu 3 caractere; astfel, ''''p'''' devine ''''s''''. Acest procedeu se repetă și pentru restul șirului.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def vigenere(a, b, c):
# Aplică cifrul Vigenere pe textul a cu cheia b
alfabet = 'abcdefghijklmnopqrstuvwxyz'
if c == 1:
return ''.join([alfabet[(alfabet.index(a[i]) + alfabet.index(b[i % len(b)])) % 26] for i in range(len(a))])
else:
return ''.join([alfabet[(alfabet.index(a[i]) - alfabet.index(b[i % len(b)])) % 26] for i in range(len(a))])

def main():
with open('vigenerein.txt', 'r') as fin, open('vigenereout.txt', 'w') as fout:
a = fin.readline().strip()
b = fin.readline().strip()

# Verifică dacă textele respectă restricțiile
if len(a) > 255 or len(b) > len(a) or not a.islower() or not b.islower():
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Aplică cifrul Vigenere pe textul a cu cheia b și scrie rezultatul în fișierul de ieșire
fout.write(vigenere(a, b, 1) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

3141 - Atbash

2024-01-03T12:41:23Z

Codrut Borcutean: Pagină nouă: == Atbash == Cifrul atbash este un cifru de substituție care constă în inversarea alfabetului: prima literă din alfabet se interschimbă cu ultima, a doua cu penultima, etc. == Cerinţa == Se dă un șir '''s''' care conține doar litere mari. Să se aplice cifrul atbash pe el. == Date de intrare == Fișierul de intrare '''atbashin.txt''' conține pe prima linie șirul '''s'''. == Date de ieșire == Fișierul de ieșire '''atbashout.txt''' va conține pe prima linie...

== Atbash ==
Cifrul atbash este un cifru de substituție care constă în inversarea alfabetului: prima literă din alfabet se
interschimbă cu ultima, a doua cu penultima, etc.
== Cerinţa ==
Se dă un șir '''s''' care conține doar litere mari. Să se aplice cifrul atbash pe el.
== Date de intrare ==
Fișierul de intrare '''atbashin.txt''' conține pe prima linie șirul '''s'''.
== Date de ieșire ==
Fișierul de ieșire '''atbashout.txt''' va conține pe prima linie șirul după aplicarea cifrului atbash.
== Restricţii şi precizări ==
* '''1 &les; lungimea șirului &les; 1.000.000'''
== Exemplu 1 ==
; atbashin.txt
ANAAREMERE
; atbashout.txt
Datele de intrare corespund restrictiilor impuse
ZMZZIVNVIV
 
== Exemplu 2 ==
; atbashin.txt
anaaremere1
; atbashout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def atbash(s):
# Aplică cifrul Atbash pe șirul s
return ''.join([chr(ord('Z') - (ord(c) - ord('A'))) for c in s])

def main():
with open('atbashin.txt', 'r') as fin, open('atbashout.txt', 'w') as fout:
s = fin.readline().strip()

# Verifică dacă șirul respectă restricțiile
if len(s) > 1000000 or not s.isupper():
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Aplică cifrul Atbash pe șirul s și scrie rezultatul în fișierul de ieșire
fout.write(atbash(s) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

3140 - A1z26

2024-01-03T12:31:17Z

Codrut Borcutean: Pagină nouă: == A1Z26 == Cifrul A1Z26 este cel mai ușor cifru de substituție: fiecare literă este înlocuită cu numărul ei de ordine în alfabet. Astfel, '''A''' devine '''1''', '''B''' devine '''2''', ș.a.m.d. == Cerinţa == Se dă un număr '''p''': 1. Dacă '''p = 1''', se dă un șir de caractere '''s''' format din litere mari. Să se afișeze numărul de ordine al caracterelor separate printr-un spațiu. 2. Dacă '''p = 2''', se dă un număr '''n''' și '''n''' numere...

== A1Z26 ==
Cifrul A1Z26 este cel mai ușor cifru de substituție: fiecare literă este înlocuită cu numărul ei de ordine în
alfabet. Astfel, '''A''' devine '''1''', '''B''' devine '''2''', ș.a.m.d.
== Cerinţa ==
Se dă un număr '''p''':
1. Dacă '''p = 1''', se dă un șir de caractere '''s''' format din litere mari. Să se afișeze numărul de ordine
al caracterelor separate printr-un spațiu.
2. Dacă '''p = 2''', se dă un număr '''n''' și '''n''' numere cuprinse între '''1''' și '''26'''. Să se afișeze
șirul corespunzător numerelor.
== Date de intrare ==
Fișierul de intrare '''a1z26in.txt''' conține pe prima linie numărul '''p'''.
Dacă '''p = 1''', pe a doua linie din fișier se află șirul de caractere '''s'''.
Dacă '''p = 2''', pe a doua linie din fișier se află numarul natural '''n''' iar pe următoarea linie se află '''n''' numere.
== Date de ieșire ==
Dacă '''p = 1''', fișierul de ieșire '''a1z26out.txt''' va conține pe prima linie numerele de ordine ale caracterelor din șirul '''s''', separate prin câte un spațiu.
Daca '''p = 2''', fișierul de ieșire '''a1z26out.txt''' va conține pe prima linie șirul format din numerele de ordine date, afișate cu litere mari.
== Restricţii şi precizări ==
* '''1 &les; p &les; 2'''
* '''1 &les; lungimea șirului s &les; 1.000.000'''
* '''1 &les; n &les; 1.000.000'''
* '''1 &les; numerele de pe a doua linie &les; 26'''
== Exemplu 1 ==
; a1z26in.txt
1
ANAAREMERE
; a1z26out.txt
Datele de intrare corespund restrictiilor impuse
1 14 1 1 18 5 13 5 18 5
 
== Exemplu 2 ==
; a1z26in.txt
2
10
1 14 1 1 18 5 13 5 18 5
; a1z26out.txt
Datele de intrare corespund restrictiilor impuse
ANAAREMERE
== Exemplu 3==
; a1z26in.txt
1
anaaremere
; a1z26out.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def cifrare(s):
# Transformă fiecare literă în numărul ei de ordine în alfabet
return ' '.join([str(ord(c) - ord('A') + 1) for c in s])

def decifrare(numere):
# Transformă fiecare număr în litera sa corespunzătoare în alfabet
return ''.join([chr(numar + ord('A') - 1) for numar in numere])

def main():
with open('a1z26in.txt', 'r') as fin, open('a1z26out.txt', 'w') as fout:
p = int(fin.readline().strip())

# Verifică dacă datele de intrare respectă restricțiile
if p == 1:
s = fin.readline().strip()
if len(s) > 1000000 or not s.isupper():
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return
fout.write("Datele de intrare corespund restrictiilor impuse\n")
fout.write(cifrare(s) + '\n')
elif p == 2:
n = int(fin.readline().strip())
numere = list(map(int, fin.readline().strip().split()))
if n > 1000000 or not all(1 <= numar <= 26 for numar in numere):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return
fout.write("Datele de intrare corespund restrictiilor impuse\n")
fout.write(decifrare(numere) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

3398 - Kps

2024-01-03T10:59:39Z

Codrut Borcutean: Pagină nouă: Un cuvânt se numește '''k'''-ps dacă prefixul său de lungime '''k''' este identic cu sufixul de lungime '''k''', iar '''k''' este cea mai mare valoare strict mai mică decât lungimea cuvântului, cu această proprietate. Dacă nu există nicio astfel de valoare '''k''' nenulă, spunem despre cuvânt că este '''0'''-ps. De exemplu, '''amalgam''' este '''2'''-ps, iar '''amestec''' este '''0'''-ps. == Cerinţa == Rezolvați următoarele cerințe: 1) Se dă un cuvânt. De...

Un cuvânt se numește '''k'''-ps dacă prefixul său de lungime '''k''' este identic cu sufixul de lungime '''k''', iar '''k''' este cea mai mare valoare strict mai mică decât lungimea cuvântului, cu această proprietate. Dacă nu există nicio astfel de valoare '''k''' nenulă, spunem despre cuvânt că este '''0'''-ps. De exemplu, '''amalgam''' este '''2'''-ps, iar '''amestec''' este '''0'''-ps.

== Cerinţa ==
Rezolvați următoarele cerințe:

1) Se dă un cuvânt. Determinați '''k''' asfel încât cuvântul să fie '''k'''-ps.

2) Se dă un șir de caractere în care cuvintele sunt alcătuite din litere mici ale alfabetului englez și sunt separate prin spații. Să se afișeze în ordine cuvintele '''0'''-ps, '''1'''-ps, '''2'''-ps, '''3'''-ps, etc, până la cel mai mare '''k''' pentru care există în șir cel puțin un cuvânt '''k'''-ps. Pentru fiecare categorie, cuvintele vor fi afișate în ordine alfabetică.
== Date de intrare ==
Fișierul de intrare '''kpsin.txt''' conține pe prima linie numărul '''C''', care reprezintă cerința și poate fi '''1''' sau '''2'''.

* Dacă '''C=1''', a doua linie conține un cuvânt format litere mici ale alfabetului englez.
* daca '''C=2''', a doua linie conține șir de caractere în care cuvintele sunt alcătuite din litere mici ale alfabetului englez și sunt separate prin spații.
== Date de ieșire ==
* Dacă '''C=1''', fișierul de ieșire '''kpsout.txt''' va conține pe prima linie numărul '''K''', astel încât cuvântul dat este cuvânt '''K'''-ps. Dacă cuvântul dat nu este cuvânt '''k'''-ps, se va afișa valoarea '''0'''.
* Dacă '''C=2''', fișierul de ieșire '''kpsout.txt''' va conține mai multe linii:
* prima linie corespunde cuvintelor '''0'''-ps, a doua corespunde cuvintelor '''1'''-ps, a treia cuvintelor '''2'''-ps, etc.
* fiecare linie începe cu numărul de cuvinte din categoria curentă, urmat de un spațiu și de aceste cuvinte, in ordine alfabetică, separate prin câte un spațiu;
* dacă nu există niciun cuvânt dintr-o anumită categorie, linia corespunzătoare va conține doar valoarea '''0'''.

== Restricţii şi precizări ==
* pentru '''C=1''', cuvântul dat va avea cel mult '''1000''' de litere;
* pentru '''C=2''', șirul dat va avea cel mult '''10000''' de caractere, fiecare cuvânt având cel mult '''100''' de litere;
* pentru 50 de puncte, '''C=1'''.
== Exemplu 1 ==
; kpsin.txt
1
amalgam
; kpsout.txt
Datele de intrare corespund restrictiilor impuse
2
 
== Exemplu 2 ==
; kpsin.txt
2
asdfqwasdf zar amalgam zarzar barbar ghjtttyuttghj asaswasas kps
; kpsout.txt
Datele de intrare corespund restrictiilor impuse
2 kps zar
0
1 amalgam
3 barbar ghjtttyuttghj zarzar
2 asaswasas asdfqwasdf
== Exemplu 3 ==
; kpsin.txt
1
ASD SCCS
; kpsout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def k_ps(cuvant):
# Determină k pentru care cuvântul este k-ps
for k in range(len(cuvant) - 1, 0, -1):
if cuvant[:k] == cuvant[-k:]:
return k
return 0

def sortare_cuvinte(sir):
# Sortează cuvintele în funcție de valoarea k
cuvinte = sir.split()
k_cuvinte = {k: [] for k in range(max(map(k_ps, cuvinte)) + 1)}
for cuvant in cuvinte:
k_cuvinte[k_ps(cuvant)].append(cuvant)
for k in k_cuvinte:
k_cuvinte[k].sort()
return k_cuvinte

def main():
with open('kpsin.txt', 'r') as fin, open('kpsout.txt', 'w') as fout:
c = int(fin.readline().strip())

# Verifică dacă datele de intrare respectă restricțiile
if c == 1:
cuvant = fin.readline().strip()
if len(cuvant) > 1000 or not cuvant.islower():
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return
fout.write("Datele de intrare corespund restrictiilor impuse\n")
fout.write(str(k_ps(cuvant)) + '\n')
elif c == 2:
sir = fin.readline().strip()
if len(sir) > 10000 or not all(cuvant.islower() for cuvant in sir.split()):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return
fout.write("Datele de intrare corespund restrictiilor impuse\n")
k_cuvinte = sortare_cuvinte(sir)
for k in k_cuvinte:
fout.write(str(len(k_cuvinte[k])) + ' ' + ' '.join(k_cuvinte[k]) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

3669 - Bacon

2024-01-03T10:10:35Z

Codrut Borcutean: Pagină nouă: == Bacon == Cifrul Bacon funcţionează așa: * se citește un mesaj * fiecare litera este înlocuită cu un cod: '''A-0, B-1, C-2, ... Z-25.''' * codul fiecarei litere este scris în baza '''2''' cu exact '''5''' cifre: '''A-00000''', '''B-00001''', '''C-00010''', … '''Z-11001''' * fiecare cifră de '''0''' este înlocuită cu litera '''A''' * fiecare cifră de '''1''' este înlocuită cu litera '''B''' == Cerinţa == Pentru un număr '''c''': * dacă '''c=1''', se dă un...

== Bacon ==
Cifrul Bacon funcţionează așa:

* se citește un mesaj
* fiecare litera este înlocuită cu un cod: '''A-0, B-1, C-2, ... Z-25.'''
* codul fiecarei litere este scris în baza '''2''' cu exact '''5''' cifre: '''A-00000''', '''B-00001''', '''C-00010''', … '''Z-11001'''
* fiecare cifră de '''0''' este înlocuită cu litera '''A'''
* fiecare cifră de '''1''' este înlocuită cu litera '''B'''
== Cerinţa ==
Pentru un număr '''c''':
* dacă '''c=1''', se dă un mesaj ce trebuie codificat
* dacă '''c=2''', se dă un mesaj ce trebuie decodificat
== Date de intrare ==
Fișierul de intrare '''baconin.txt''' conține pe prima linie numărul '''c''', iar pe a doua linie un mesaj
== Date de ieșire ==
Fișierul de ieșire '''baconout.txt''' va conține pe prima linie mesajul codificat, dacă '''c=1''' sau mesajul decodificat in caz contrar
== Restricţii şi precizări ==
* '''1 &les;''' lungimea mesajului necodificat '''&les; 10000'''
* mesajul necodificat va conține numai litere mari ale alfabetului englez
== Exemplu 1 ==
; baconin.txt
1
PBINFO
; baconout.txt
Datele de intrare corespund restrictiilor impuse
ABBBBAAAABABAAAABBABAABABABBBA
 
== Exemplu 2 ==
; baconin.txt
2
ABBBBAAAABABAAAABBABAABABABBBA
; baconout.txt
Datele de intrare corespund restrictiilor impuse
PBINFO
== Exemplu 3 ==
; baconin.txt
1
pbinfo
; baconout.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def codificare(mesaj):
# Transformă fiecare literă în codul său corespunzător
return ''.join(['A' if cifra == '0' else 'B' for litera
in mesaj for cifra in format(ord(litera) - ord('A'), '05b')])

def decodificare(mesaj):
# Transformă fiecare cod în litera sa corespunzătoare
return ''.join([chr(int(mesaj[i:i+5].replace('A', '0').replace('B', '1'), 2) + ord('A'))
for i in range(0, len(mesaj), 5)])

def main():
with open('baconin.txt', 'r') as fin, open('baconout.txt', 'w') as fout:
c = int(fin.readline().strip())
mesaj = fin.readline().strip()

# Verifică dacă mesajul respectă restricțiile
if len(mesaj) > 10000 or not mesaj.isupper():
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return

fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Codifică sau decodifică mesajul în funcție de valoarea lui c
if c == 1:
fout.write(codificare(mesaj) + '\n')
elif c == 2:
fout.write(decodificare(mesaj) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

3146 - Sort 4

2024-01-03T09:28:45Z

Codrut Borcutean: Pagină nouă: == Cerinţa == '''Laurențiu''' este un copil pasionat de teoria numerelor, dar și de informatică. Astfel, în timp ce își savura limonada după o zi obositoare de scoală alături de prietenii săi, acestuia i-a venit în minte o problemă interesantă: dându-se un șir de '''n''' numere naturale, sortați-l '''descrescător''' după numărul de cifre distincte, la număr de cifre distincte egal sortați-l '''crescător''' după suma cifrelor, la suma cifrelor egală so...

== Cerinţa ==
'''Laurențiu''' este un copil pasionat de teoria numerelor, dar și de informatică. Astfel, în timp ce își savura limonada după o zi obositoare de scoală alături de prietenii săi, acestuia i-a venit în minte o problemă interesantă: dându-se un șir de '''n''' numere naturale, sortați-l '''descrescător''' după numărul de cifre distincte, la număr de cifre distincte egal sortați-l '''crescător''' după suma cifrelor, la suma cifrelor egală sortați-l '''crescător''' după produsul cifrelor, iar dacă și produsul cifrelor este egal, atunci numerele se vor sorta '''crescător''' după valorile lor.
== Date de intrare ==
Fișierul de intrare '''sort4in.txt''' conține pe prima linie numărul '''n''', iar pe a două linie '''n''' numere naturale separate prin spații.
== Date de ieșire ==
Fișierul de ieșire '''sort4out.txt''' vă conține șirul sortat.
== Restricţii şi precizări ==
* '''1 &les; n &les; 1.000.000'''
* numerele de pe a două linie a fișierului de intrare vor fi mai mici decât '''2.000.000.000'''
== Exemplu 1 ==
; sort4in.txt
5
111 19 223 51 37
; sort4out.txt
Datele de intrare corespund restrictiilor impuse
51 223 19 37 111
 
== Exemplu 2 ==
; sort4in.txt
5
111 19 223 51 20000000001
; sort4out.txt
Datele de intrare nu corespund restrictiilor impuse
 
== Rezolvare ==
<syntaxhighlight lang="python" line>
def cifre_distincte(n):
return len(set(str(n)))

def suma_cifrelor(n):
return sum(int(c) for c in str(n))

def produs_cifrelor(n):
produs = 1
for c in str(n):
produs *= int(c)
return produs

def main():
# Deschiderea fișierelor de intrare și ieșire
with open('sort4in.txt', 'r') as fin, open('sort4out.txt', 'w') as fout:
# Citirea numărului de elemente din fișierul de intrare
int(fin.readline().strip())

# Citirea numerelor și verificarea restricțiilor
numere = list(map(int, fin.readline().strip().split()))
if any(numar < 1 or numar >= 2000000000 for numar in numere):
fout.write("Datele de intrare nu corespund restrictiilor impuse\n")
return
else:
fout.write("Datele de intrare corespund restrictiilor impuse\n")

# Sortarea numerelor
numere.sort(key=lambda x: (-cifre_distincte(x), suma_cifrelor(x), produs_cifrelor(x), x))

# Scrierea numerelor sortate în fișierul de ieșire
fout.write(' '.join(map(str, numere)) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>