Bitnami MediaWiki - User contributions [en]

3045 - Pro 3

2024-01-05T02:52:28Z

Miawinator: Pagină nouă: Se consideră 3 progresii aritmetice de numere naturale nenule. Notăm cu <code>Pi</code>, <code>1 ≤ i ≤ 3</code>, mulțimile formate cu elementele progresiei <code>i</code>. Fie <code>P = P1</code> <code>P2</code> <code>P3</code> reuniunea mulțimilor <code>P1</code>, <code>P2</code>, <code>P3</code>. = Cerința = Să se determine cardinalul mulțimii <code>P</code>. = Date de intrare = Fișierul de intrare <code>input.txt</code> conține <code>3</code> linii. Pe l...

Se consideră 3 progresii aritmetice de numere naturale nenule. Notăm cu <code>Pi</code>, <code>1 ≤ i ≤ 3</code>, mulțimile formate cu elementele progresiei <code>i</code>. Fie <code>P = P1</code> <code>P2</code> <code>P3</code> reuniunea mulțimilor <code>P1</code>, <code>P2</code>, <code>P3</code>.

= Cerința =
Să se determine cardinalul mulțimii <code>P</code>.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține <code>3</code> linii. Pe linia <code>i</code>, <code>1 ≤ i ≤ 3</code> se vor găsi câte trei numere naturale <code>ai</code>, <code>ri</code>, <code>ni</code>, separate prin câte un spațiu, ce reprezintă în această ordine primul termen, rația și numărul de termeni ai progresiei <code>Pi</code>.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține pe prima linie cardinalul mulțimii <code>P</code>.

== Exemplu ==
input.txt:

2 2 10

3 4 8

1 3 12

output.txt:

24

Explicație:

Prima progresie are primul termen <code>2</code>, rația <code>2</code> și <code>10</code> termeni.

A doua progresie are primul termen <code>3</code>, rația <code>4</code> și <code>8</code> termeni.

A treia progresie are primul termen <code>1</code>, rația <code>3</code> și <code>12</code> termeni.

Așadar:

<code>P1</code> <code>= {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}</code>

<code>P2</code> <code>= {3, 7, 11, 15, 19, 23, 27, 31}</code>

<code>P3</code> <code>= {1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34}</code>

Reuniunea termenilor celor trei progresii este mulțimea

<code>P = {1, 2, 3, 4, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 22, 23, 25, 27, 28, 31, 34}</code> și cardinalul mulțimii <code>P</code> este <code>24</code>.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
class Progresie:
def __init__(self, first, ratio, n):
self.first = first
self.ratio = ratio
self.n = n

def read():
with open("input.txt", "r") as f:
x_values = list(map(int, f.readline().split()))
y_values = list(map(int, f.readline().split()))
z_values = list(map(int, f.readline().split()))

return Progresie(*x_values), Progresie(*y_values), Progresie(*z_values)

def cmmdc(a, b):
while b != 0:
a, b = b, a % b
return a

def cmmmc(a, b):
return a * b // cmmdc(a, b)

def calc(a, b):
Maxa = a.first + a.ratio * (a.n - 1)
Maxb = b.first + b.ratio * (b.n - 1)
Min = min(Maxa, Maxb)
for i in range(int(1e6)):
nr = a.first + i * a.ratio
if nr >= b.first and nr <= Min and (nr - b.first) % b.ratio == 0:
return Progresie(nr, cmmmc(a.ratio, b.ratio), (Min - nr) // cmmmc(a.ratio, b.ratio) + 1)
return Progresie(0, 0, 0)

def solve(x, y, z):
xy = calc(x, y)
xz = calc(x, z)
yz = calc(y, z)
xyz = calc(xy, z)
return x.n + y.n + z.n - xy.n - xz.n - yz.n + xyz.n

def output(rez):
with open("output.txt", "w") as g:
g.write(str(rez))

if __name__ == "__main__":
x, y, z = read()
rez = solve(x, y, z)
output(rez)

</syntaxhighlight>

3831 - Medians

2024-01-05T02:44:51Z

Miawinator: Pagină nouă: = Cerința = Se dă un vector cu <code>n</code> elemente. Să se determine numărul de secvențe care au medianul valorilor egal cu <code>k</code>. = Date de intrare = Fișierul de intrare <code>input.txt</code> contine pe prima linie un număr <code>N</code> reprezentând numărul de elemente din vector și un număr <code>k</code> cu semnificația din enunț. Pe a doua linie se află <code>N</code> elemente , elementele vectorului. = Date de ieșire = Fișierul de ieșire...

= Cerința =
Se dă un vector cu <code>n</code> elemente. Să se determine numărul de secvențe care au medianul valorilor egal cu <code>k</code>.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> contine pe prima linie un număr <code>N</code> reprezentând numărul de elemente din vector și un număr <code>k</code> cu semnificația din enunț. Pe a doua linie se află <code>N</code> elemente , elementele vectorului.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> contine pe prima linie răspunsul.

= Restricții și precizări =

* <code>N ≤ 100.000</code>, <code>K ≤ 1.000.000.000</code>

== Exemplul 1 ==
input.txt:

2 2

1 2

output.txt:

1

== Exemplul 2 ==
input.txt:

3 5

5 1 5

output.txt:

3

== Exemplul 3 ==
input.txt:

3 99999999999

5 1 5

Output:

Invalid input constraints.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
MOD = 666013
Nmax = 100001
Add = 100000

def verify_constraints(n, k):
if not (1 <= n <= 100000 and 1 <= k <= 1000000000):
print("Invalid input constraints.")
exit()

def Update(pos, val):
global aib
i = pos
while i < Nmax * 2:
aib[i] += val
i += i & -i

def Query(pos):
global aib
i = pos
sum_ = 0
while i > 0:
sum_ += aib[i]
i -= i & -i
return sum_

def Fx(k):
global n, V, aib

aib = [0] * (Nmax * 2)

S = [0] * (n + 1)

for i in range(1, n + 1):
if V[i] > k:
S[i] = -1
else:
S[i] = 1

for i in range(2, n + 1):
S[i] += S[i - 1]

for i in range(1, n + 1):
Update(S[i] + Add, 1)

s = 0

for i in range(1, n + 1):
s += Query(S[i] + Add - 1)

if S[i] < 0:
s += 1

Update(S[i] + Add, -1)

return s

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
n, k = map(int, fin.readline().split())
verify_constraints(n,k)
V = [0] + list(map(int, fin.readline().split()))

sk = Fx(k)
skk = Fx(k - 1)

fout.write(str(abs(sk - skk)))

</syntaxhighlight>

3758 - inno

2024-01-05T02:39:28Z

Miawinator: Pagină nouă: Se dau numerele naturale <code>n</code> și <code>k</code>, precum și un șir <code>a[1]</code>, <code>a[2]</code> ,…, <code>a[n]</code> de numere naturale nenule. Din șir de poate elimina o singură secvență (eventual vidă) <code>a[i]</code>, <code>a[i+1]</code>, …, <code>a[j]</code> astfel că în șir rămân elementele <code>a[1]</code>, <code>a[2]</code>, …, <code>a[i-1]</code>, <code>a[j+1]</code>, …, <code>a[n]</code>. De exemplu, din șirul <code>a=(1,2,...

Se dau numerele naturale <code>n</code> și <code>k</code>, precum și un șir <code>a[1]</code>, <code>a[2]</code> ,…, <code>a[n]</code> de numere naturale nenule. Din șir de poate elimina o singură secvență (eventual vidă) <code>a[i]</code>, <code>a[i+1]</code>, …, <code>a[j]</code> astfel că în șir rămân elementele <code>a[1]</code>, <code>a[2]</code>, …, <code>a[i-1]</code>, <code>a[j+1]</code>, …, <code>a[n]</code>.

De exemplu, din șirul <code>a=(1,2,3,4,5,7)</code> se poate elimina secvența <code>3,4,5</code> și rămâne <code>1,2,7</code>; sau se poate elimina secvența vidă și rămâne șirul inițial <code>1,2,3,4,5,7</code>; sau se poate elimina <code>1,2,3,4</code> și rămâne șirul <code>5,7</code>.

După eliminarea secvenței, elementele rămase formează un șir inno dacă aplicându-se operația <code>&</code> pe biți asupra lor rezultatul este un număr care are cel puțin <code>k</code> biți de <code>1</code> în baza <code>2</code>. De exemplu, dacă <code>a=(1,2,3,4,5,7)</code> și <code>k=2</code>, atunci prin eliminarea secvenței <code>1,2,3,4</code> rămân elementele <code>5,7</code>, iar <code>5 & 7 = 5</code>, care are <code>2</code> biți de <code>1</code> în baza <code>2</code>. Dar dacă se elimină secvența <code>3,4,5</code> atunci rămân elementele <code>1,2,7</code>, iar <code>1 & 2 & 7 = 0</code>, deci nu este șir inno.

= Cerința =
Să se determine în câte moduri se poate elimina o secvență astfel încât elementele rămase să formeze șir inno.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie numerele naturale <code>n</code> și <code>k</code>. Pe linia a doua se află <code>n</code> numere naturale reprezentând elementele șirului.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține pe prima linie un singur număr natural reprezentând numărul de moduri de a elimina o secvență astfel încât șirul rămas să fie inno.

= Restricții și precizări =

* <code>3 ≤ n ≤ 200.000</code>;
* <code>1 ≤ k ≤ 29</code>;

== Exemplul 1 ==
input.txt:

4 2

10 7 5 15

output.txt:

5

Explicație:

Modalitățile sunt:

- se elimină <code>10</code> și rămâne șirul <code>7 5 15</code>, iar <code>7 & 5 & 15 = 5</code>, care are <code>2</code> biți de <code>1</code>

- se elimină <code>10 7</code> și rămâne șirul <code>5 15</code>, iar <code>5 & 15 = 5</code>, care are <code>2</code> biți de <code>1</code>

- se elimină <code>10 7 5</code> și rămâne șirul <code>15</code>, iar <code>15</code> are <code>4</code> biți de <code>1</code>

- se elimină <code>7 5</code> și rămâne șirul <code>10 15</code>, iar <code>10 & 15 = 10</code> are <code>2</code> biți de <code>1</code>

- se elimină <code>7 5 15</code> și rămâne șirul <code>10</code>, iar <code>10</code> are <code>2</code> biți de <code>1</code>

== Exemplul 2 ==
input.txt:

5 4

7 7 6 1 62

output.txt:

1

Explicație:

Singura posibilitate este eliminarea secvenței <code>7 7 6 1</code>. Rămâne doar numărul <code>62</code>, care are <code>5</code> biți de <code>1</code>.

== Exemplul 3 ==
input.txt:

999999999999 4

7 7 6 1 62

Output:

Invalid input constraints.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verify_constraints(n, k):
if not (3 <= n <= 200000 and 1 <= k <= 29):
print("Invalid input constraints.")
exit()

def count_bit(v):
v = v - ((v >> 1) & 0x55555555)
v = (v & 0x33333333) + ((v >> 2) & 0x33333333)
c = ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24
return c

def bsearch(p, u, key, k):
m = 0
while p < u:
m = (p + u) // 2
if dr[m] & key < k:
p = m + 1
else:
u = m

m = (p + u) // 2
if dr[m] & key < k:
m += 1
return m

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
n, k = map(int, fin.readline().split())
verify_constraints(n,k)
a = [0] + list(map(int, fin.readline().split()))
st = [0] * (n + 1)
dr = [0] * (n + 1)
x = -1
y = 0
val = 0
sol = 0

st[1] = a[1]
dr[n] = a[n]

for i in range(2, n + 1):
st[i] = st[i - 1] & a[i]

for i in range(n - 1, 0, -1):
dr[i] = dr[i + 1] & a[i]

if count_bit(st[1]) < k:
x = 0

if count_bit(dr[n]) < k:
y = n + 1

if x < 0:
x = 1
i = 2
while i <= n:
if count_bit(st[i]) >= k:
x = i
i += 1

if not y:
y = n
i = n - 1
while i >= 1:
if count_bit(dr[i]) >= k:
y = i
i -= 1

if x == n:
fout.write(str(n * (n + 1) // 2))
elif x == 0 and y == n + 1:
fout.write("0")
elif 1 <= x < n and y == n + 1:
fout.write(str(x))
elif x == 0 and 1 < y <= n:
fout.write(str(n - y + 1))
elif x == 0 and y == 0:
fout.write("1")
else:
sol = n - y + 1
for i in range(1, x + 1):
val = bsearch(y, n, st[i], k)
sol += (n - val + 2)

fout.write(str(sol))

</syntaxhighlight>

3748 - Secvente5

2024-01-05T02:34:52Z

Miawinator: Pagină nouă: Se consideră un șir cu <code>N</code> elemente numere întregi. Definim următoarele noțiuni: * secvență în șir = elemente situate pe poziții consecutive în șir * lungimea unei secvențe = numărul de elemente care o formează * suma unei secvențe = suma elementelor care o formează * secvența nebanală = secvența de lungime cel puțin egală cu <code>2</code> * N-secvență = secvență a cărei sumă este divizibilă cu <code>N</code> (secvența poate fi și b...

Se consideră un șir cu <code>N</code> elemente numere întregi. Definim următoarele noțiuni:

* secvență în șir = elemente situate pe poziții consecutive în șir
* lungimea unei secvențe = numărul de elemente care o formează
* suma unei secvențe = suma elementelor care o formează
* secvența nebanală = secvența de lungime cel puțin egală cu <code>2</code>
* N-secvență = secvență a cărei sumă este divizibilă cu <code>N</code> (secvența poate fi și banală)
* N-secvență nebanală = secvență nebanală a cărei sumă este divizibilă cu <code>N</code>.

= Cerințe =
Scrieți un program care să citească numărul natural <code>N</code> și apoi șirul de <code>N</code> elemente. Programul determină:

# numărul de N-secvențe nebanale, din șir;
# cea mai mare lungime a unei N-secvențe din șir;
# cea mai mare sumă a unei N-secvențe din șir.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie numere naturale <code>C</code> și <code>N</code> separate printr-un singur spațiu. <code>C</code> reprezentând cerința care trebuie rezolvată (<code>1</code>, <code>2</code> sau <code>3</code>).

= Date de ieșire =
Fișierul <code>output.txt</code> va conține pe prima linie un număr natural reprezentând:

* dacă <code>C = 1</code>, numărul de <code>N-secvențe nebanale</code> din șir (răspunsul la cerința <code>1</code>);
* dacă <code>C = 2</code>, cea mai mare lungime a unei <code>N-secvențe</code> din șir (răspunsul la cerința <code>2</code>);
* dacă <code>C = 3</code>, cea mai mare sumă a unei <code>N-secvențe</code> din șir (răspunsul la cerința <code>3</code>).

= Restricții și precizări =

* <code>2 ≤ N ≤ 100.000</code>

== Exemplul 1 ==
input.txt:

1 10

-9 -3 4 -10 -1 -16 18 18 -10 50

output.txt:

8

Explicație:

Se rezolvă cerința <code>1</code>. Șirul are <code>N=10</code> elemente întregi: <code>-9, -3, 4, -10, -1, -16, 18, 18, -10, 50</code>.

Cele <code>N-secvențe nebanale</code> sunt <code>(-3, 4, -10, -1)</code>, <code>(-16, 18, 18)</code>, <code>(-10, 50)</code>, <code>(-16, 18, 18, -10)</code>, <code>(-16, 18, 18, -10, 50)</code>, <code>(-3, 4, -10, -1, -16, 18, 18)</code>, <code>(-3, 4, -10, -1, -16, 18, 18, -10)</code>, <code>(-3, 4, -10, -1, -16, 18, 18, -10, 50)</code>.

== Exemplul 2 ==
input.txt:

2 10

9 -3 4 -10 -1 -16 18 18 -10 50

output.txt:

9

Explicație:

Se rezolvă cerința <code>2</code>. Șirul are <code>N=10</code> elemente întregi: <code>-9, -3, 4, -10, -1, -16, 18, 18, -10, 50</code>.

Cea mai lungă dintre aceste secvențe este N-secvența <code>(-3, 4,-10,-1,-16,18,18,-10,50)</code>. Lungimea acestei secvențe este <code>9</code>.

== Exemplul 3 ==
input.txt:

3 10

9 -3 4 -10 -1 -16 18 18 -10 50

output.txt:

60

Explicație:

Se rezolvă cerința <code>3</code>. Șirul are <code>N=10</code> elemente întregi: <code>-9, -3, 4, -10, -1, -16, 18, 18, -10, 50</code>.

Suma maximă a unei secvente este <code>60</code> ( suma N-secvenței: <code>-16,18,18,-10,50</code>).

== Exemplul 4 ==
input.txt:

3 999999999999

-9 -3 4 -10 -1 -16 18 18 -10 50

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(2<=n<=100000):
print("Input-ul nu convine conditiilor")
exit()

with open("input.txt", "r") as f, open("output.txt", "w") as g:
C, N = map(int, f.readline().split())
verificare(N)
v = [0] * 100001
prim = [0] * 100001
ult = [0] * 100001
s = [0] * 100001
rest = [0] * 100001
nrv = 0
nrs = 0
i = 0
sc = 0
r = 0
smax = 0
lgmax = 0
lg = 0
srest = [0] * 100001
sumaseccurenta = 0

l=list(map(int, f.readline().split()))

for i in range(1, N + 1):
x = l[i-1]
if x % N == 0:
nrv += 1
smax = max(smax, x)
s[i] = s[i - 1] + x
r = s[i] % N
if r == 0:
smax = max(smax, s[i])
lgmax = max(lgmax, i)
if r < 0:
r = N + r
rest[r] += 1
if prim[r] == 0:
ult[r] = prim[r] = i
ult[r] = i
lg = i - prim[r]
if lg > 1 and lg > lgmax:
lgmax = lg
if rest[r] == 1:
srest[r] = s[i]
else:
if s[i] < srest[r]:
srest[r] = s[i]
smax = max(smax, s[i] - srest[r]) # suma N-secventei curecte este s[i]-srest[r]

nrs = rest[0]
for i in range(N):
nrs = nrs + rest[i] * (rest[i] - 1) // 2
nrs = nrs - nrv

if C == 1:
g.write(str(nrs) + "\n")
elif C == 2:
g.write(str(lgmax) + "\n")
else:
g.write(str(smax) + "\n")

</syntaxhighlight>

3708 - selectare

2024-01-05T02:29:20Z

Miawinator: Pagină nouă: Avem un șir <code>V</code> format din <code>n</code> cifre nenule precum și două numere naturale <code>L</code> și <code>K</code>. Putem efectua următoarea operație: alegem <code>L</code> elemente aflate unul lângă altul în șir apoi selectăm <code>K</code> dintre ele pe care le eliminăm. Cele <code>L - K</code> cifre se așează una lângă alta formând un număr a cărui valoare ne interesează (cifrele nu își pot schimba ordinea relativă, adică se așează...

Avem un șir <code>V</code> format din <code>n</code> cifre nenule precum și două numere naturale <code>L</code> și <code>K</code>. Putem efectua următoarea operație: alegem <code>L</code> elemente aflate unul lângă altul în șir apoi selectăm <code>K</code> dintre ele pe care le eliminăm. Cele <code>L - K</code> cifre se așează una lângă alta formând un număr a cărui valoare ne interesează (cifrele nu își pot schimba ordinea relativă, adică se așează în ordinea crescătoare a indicilor lor în șirul inițial).

= Cerința =
Trebuie să determinăm valoarea cu număr maxim de apariții pe care o obținem cu acest procedeu. Dacă sunt mai multe valori care apar de număr maxim de ori o vom alege pe cea mai mică. Două posibilități se consideră distincte dacă diferă prin indicele în șirul dat inițial al cel puțin uneia dintre cifrele de același rang în numerele asociate.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie valorile <code>n</code>, <code>L</code>, <code>K</code>, în această ordine, separate prin câte un spațiu. Pe linia a doua se află cele <code>n</code> cifre, separate prin câte un spațiu.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține pe prima linie cea mai mică valoare care are număr maxim de apariții.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* <code>1 ≤ L ≤ 6</code>
* <code>L ≤ n</code>
* <code>0 ≤ K ≤ 2</code>

== Exemplul 1 ==
innput.txt:

8 4 0

2 1 2 1 2 1 2 3

output.txt:

1212

Explicație:

Avem de selectat secvențe de câte <code>4</code> cifre și nu trebuie să eliminăm nimic. Se formează numerele: <code>2121</code>, <code>1212</code>, <code>2121</code> și <code>1212</code>, <code>2123</code>. Avem două valori ce se pot forma și care apar de câte două ori și o valoare ce

se poate forma o dată. Valoarea <code>1212</code> se poate forma de două ori și este cea mai mică dintre cele cu acest număr de apariții.

== Exemplul 2 ==
input.txt

5 4 2

1 1 1 1 1

output.txt:

11

Explicație:

Evident că valoarea obținută nu poate fi decât <code>11</code>. Ea se poate obține de <code>9</code> ori, cu cifrele de pe pozițiile: <code>(1,2)(2,3)(3,4)(4,5)(1,3)</code>, <code>(2,4)(3,5)(1,4)(2,5)</code>.

== Exemplul 3 ==
input.txt:

9999999999999 4 0

2 1 2 1 2 1 2 3

Output:

Invalid input constraints.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verify_constraints(N, L, K):
if not (1 <= N <= 1000 and 1 <= L <= 6 and L <= N and 0 <= K <= 2 and K <= L - 1):
print("Invalid input constraints.")
exit()

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
N, L, K = map(int, fin.readline().split())
verify_constraints(N, L, K)
v = list(map(int, fin.readline().split()))

f = [0] * 1000000

for s in range(L - K, L + 1):
for i in range(1, N - s + 2):
j = i + s - 1
e = s - (L - K)

if e == 0:
val = int(''.join(map(str, v[i - 1:j])))
f[val] += 1

if e == 1:
for i1 in range(i + 1, j):
val = int(''.join(map(str, v[i - 1:i1] + v[i1 + 1:j])))
f[val] += 1

if e == 2:
for i1 in range(i + 1, j - 1):
for i2 in range(i1 + 1, j):
val = int(''.join(map(str, v[i - 1:i1] + v[i1 + 1:i2] + v[i2 + 1:j])))
f[val] += 1

p = 10 ** L
sol = max(range(p), key=lambda x: f[x])
fout.write(str(sol))

</syntaxhighlight>

3647 - secvente4

2024-01-05T02:24:34Z

Miawinator: Pagină nouă: Se dau <code>n</code> și <code>t</code> două numere naturale nenule și <code>S</code> un șir binar de <code>n</code> elemente indexate de la <code>1</code>. O interschimbare în acest șir constă în alegerea a doi indici <code>i</code>, <code>j</code> (<code>1 ≤ i, j ≤ n</code>) și schimbarea între ele a valorilor <code>S[i]</code> și <code>S[j]</code>. O subsecvență de lungime <code>t</code> a șirului <code>S</code> reprezintă <code>t</code> elemente aflate...

Se dau <code>n</code> și <code>t</code> două numere naturale nenule și <code>S</code> un șir binar de <code>n</code> elemente indexate de la <code>1</code>. O interschimbare în acest șir constă în alegerea a doi indici <code>i</code>, <code>j</code> (<code>1 ≤ i, j ≤ n</code>) și schimbarea între ele a valorilor <code>S[i]</code> și <code>S[j]</code>. O subsecvență de lungime <code>t</code> a șirului <code>S</code> reprezintă <code>t</code> elemente aflate pe poziții consecutive în șirul <code>S</code>.

= Cerința =
Să se determine numărul minim de interschimbări ce trebuie realizate în șirul <code>S</code> pentru a obține două subsecvențe disjuncte de lungime <code>t</code> formate doar din elemente egale cu <code>1</code>.

= Date de intrare =
Pe prima linie a fișierului <code>input.txt</code> se află separate printr-un spațiu numere <code>n</code> și <code>t</code>. Pe a doua linie se află <code>n</code> caractere <code>0</code> și <code>1</code>.

= Date de ieșire =
Pe prima linie a fișierului de ieșire <code>output.txt</code> se va afișa numărul minim de interschimbări necesare pentru obținerea a două subsecvențe disjuncte de lungime <code>t</code> formate doar din elemente egale cu <code>1</code>. Dacă acest lucru este imposibil se va afișa <code>-1</code>.

= Restricții și precizări =

* <code>2 ≤ n ≤ 1.000.000</code>
* <code>2 * t ≤ n</code>

== Exemplul 1 ==
input.txt:

7 2

1010101

output.txt:

2

Explicație:

Elementul de pe poziția <code>1</code> se interschimbă cu elementul de pe poziția <code>6</code>, iar elementul de pe poziția <code>3</code> se interschimbă cu elementul de pe poziția <code>4</code>.

== Exemplul 2 ==
input.txt:

26 3

00010100100100010111001001

output.txt:

1

Explicație:

O secvență convenabilă se situează între pozițiile <code>4</code> și <code>6</code> și alta între pozițiile <code>18</code> și <code>20</code>. Este nevoie de o singură interschimbare pentru a pune un element de <code>1</code> pe poziția <code>5</code>.

== Exemplul 3 ==
input.txt:

9999999999999999 3

00010100100100010111001001

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n,t):
if not(2<=n<=1000000):
print("Input-ul nu convine conditiilor")
exit()
if not(2*t<=n):
print("Input-ul nu convine conditiilor")
exit()

with open("input.txt", "r") as f, open("output.txt", "w") as g:
n, k = map(str, f.readline().split())
s = f.readline()
n = int(n)
k = int(k)
verificare(n,k)

v = [int(ch) for ch in s]
st = [0] * (n + 1)
dr = [0] * (n + 1)

sum_value = sum(v)

if sum_value < 2 * k:
g.write("-1")
exit()

sum_value = 0

for i in range(1, n + 1):
sum_value += v[i - 1]
if i - k >= 1:
sum_value -= v[i - k - 1]
st[i] = max(sum_value, st[i - 1])

if i == k:
st[i] = sum_value

sum_value = 0

for i in range(n, 0, -1):
sum_value += v[i - 1]
if i + k <= n:
sum_value -= v[i + k - 1]
dr[i] = max(sum_value, dr[i + 1])

if i == n - k + 1:
dr[i] = sum_value

sol = 2e9

for i in range(k, n - k + 1):
sol = min(sol, 2 * k - st[i] - dr[i + 1])

g.write(str(sol))

</syntaxhighlight>

2939 - Permutari4

2024-01-05T02:17:41Z

Miawinator: Pagină nouă: = Cerința = O permutare de ordin <code>K</code> este formată din toate numerele <code>1</code>, <code>2</code>, …, <code>K</code> nu neapărat în această ordine. O secvență de lungime <code>L</code> este formată din <code>L</code> elemente ale șirului aflate pe poziții consecutive. Spunem că o secvență de lungime <code>L</code> este permutare de ordin <code>L</code> dacă ea conține toate numerele <code>1</code>, <code>2</code>, …, <code>L</code>, nu neapăr...

= Cerința =
O permutare de ordin <code>K</code> este formată din toate numerele <code>1</code>, <code>2</code>, …, <code>K</code> nu neapărat în această ordine.

O secvență de lungime <code>L</code> este formată din <code>L</code> elemente ale șirului aflate pe poziții consecutive. Spunem că o secvență de lungime <code>L</code> este permutare de ordin <code>L</code> dacă ea conține toate numerele <code>1</code>, <code>2</code>, …, <code>L</code>, nu neapărat în această ordine.

Se dă un șir de <code>N</code> numere naturale nenule , ce reprezintă o permutare de ordin <code>N</code>. Să se calculeze numărul secvențelor din șirul <code>a</code> care au proprietatea că sunt permutări.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie numărul natural <code>N</code>, iar pe a doua linie se află primele <code>N</code> numere naturale nenule, separate prin spațiu. Cele <code>N</code> numere date nu sunt obligatoriu în ordine strict crescătoare.

= Date de ieșire =
În fișierul de ieșire <code>output.txt</code> se va scrie un singur număr natural reprezentând numărul secvențelor de tip permutare care apar în şirul dat.

= Restricții și precizări =

* <code>1 < N ≤ 100.000</code>

== Exemplul 1 ==
input.txt:

7

4 2 5 1 3 7 6

output.txt:

3

Explicație:

În şir există <code>3</code> secvențe de tip permutare, de lungimi <code>1, 5 şi 7</code>:

<code>1</code>

<code>4 2 5 1 3</code>

<code>4 2 5 1 3 7 6</code>

Nu există secvențe permutare de lungime <code>2</code>, <code>3</code>, <code>4</code> sau <code>6</code>.

== Exemplul 2 ==
input.txt:

9999999999999

4 2 5 1 3 7 6

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(1<=n<=100000):
print("Input-ul nu convine conditiilor")
exit()

f=open("input.txt","r")
w=open("output.txt","w")

n=f.readline().split()
n=int(n[0])
verificare(n)
q={}
r=0
v=f.readline().split()
for i in range(len(v)):
q[int(v[i])]=i+1
if 1 not in q:
q[1]=0
if q[1]!=0:
r+=1
a=q[1]
b=q[1]
for i in range(1,len(v)):
if i not in q:
q[i]=0
if q[i]<a:
a=q[i]
if q[i]>b:
b=q[i]
if b-a+1==i:
r+=1
w.write(str(r))
w.close()
</syntaxhighlight>

2896 - binar1

2024-01-05T02:13:48Z

Miawinator: Pagină nouă: Pentru a converti un număr din zecimal în binar îl vom împărți la <code>2</code> în mod repetat, până ce obținem câtul zero. Apoi vom colecta resturile obținute de la ultimul către primul. Aceste resturi sunt cifrele din reprezentarea binară a numărului dat, de la stânga la dreapta. De exemplu, <code>13(10)</code> <code>= 1101(2)</code>. = Cerința = Scrieți un program care, pentru un șir dat de n numere naturale, rezolvă următoarele cerințe: 1) Determi...

Pentru a converti un număr din zecimal în binar îl vom împărți la <code>2</code> în mod repetat, până ce obținem câtul zero. Apoi vom colecta resturile obținute de la ultimul către primul. Aceste resturi sunt cifrele din reprezentarea binară a numărului dat, de la stânga la dreapta. De exemplu, <code>13(10)</code> <code>= 1101(2)</code>.

= Cerința =
Scrieți un program care, pentru un șir dat de n numere naturale, rezolvă următoarele cerințe:

1) Determină cel mai mare dintre cele <code>n</code> numere date ce are număr maxim de valori de <code>1</code> în reprezentarea binară.

2) Determină cea mai lungă secvență de numere care au număr egal de valori de <code>1</code> în reprezentarea binară. Dacă sunt mai multe astfel de secvențe de lungime maximă, se va alege cea mai din stânga. O secvență este un subșir de numere care apar pe poziții consecutive în șirul inițial.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conţine pe prima linie numărul <code>C</code> reprezentând cerința (<code>1</code> sau <code>2</code>), pe a doua linie numărul natural <code>n</code>, iar pe a treia linie <code>n</code> numere naturale separate prin câte un spațiu.

= Date de ieșire =
Dacă <code>C = 1</code>, atunci pe prima linie a fișierului de ieșire <code>output.txt</code> se va scrie numărul ce reprezintă răspunsul la cerința <code>1</code>. Dacă <code>C = 2</code>, atunci pe prima linie a fișierului de ieșire <code>output.txt</code> se vor scrie, separate printr-un spațiu, lungimea maximă a secvenței determinate și poziția primului termen din secvență (se consideră că primul număr din cele <code>n</code> numere date se găsește pe poziția <code>1</code>).

= Restricții și precizări =

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

== Exemplul 1 ==
input.txt:

1

7

16 12 3 5 14 13 11

output.txt:

14

Explicație:

<code>16(10)</code> <code>= 10000(2)</code>; <code>12(10)</code> <code>= 1100(2)</code>; <code>3(10)</code> <code>= 11(2)</code>; <code>5(10)</code> <code>= 101(2)</code>; <code>14(10)</code> <code>= 1110(2)</code>; <code>13(10)</code> <code>= 1101(2)</code>; <code>11(10)</code> <code>= 1011(2)</code>;

Cel mai mare număr de valori de <code>1</code> dintr-o reprezentare binară este <code>3</code>; cel mai mare număr ce are <code>3</code> de <code>1</code> în reprezentarea binară este <code>14</code>.

== Exemplul 2 ==
input.txt:

2

7

16 12 3 5 14 13 11

output.txt:

3 2

Explicație:

Sunt două secvențe de lungime maximă de numere care au număr egal de valori de <code>1</code> în reprezentarea binară: <code>12 3 5</code> și <code>14 13 11</code>. O vom alege pe cea mai din stânga, care are lungimea <code>3</code> și începe la poziția <code>2</code>.

== Exemplul 3 ==
input.txt:

2

99999999999999

16 12 3 5 14 13 11

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
NM = 1000001

def verificare(n):
if not(1<=n<=1000000):
print("Input-ul nu convine conditiilor")
exit()

def count_set_bits(num):
count = 0
while num:
count += num & 1
num >>= 1
return count

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
c = int(fin.readline())
n = int(fin.readline())

verificare(n)

l=list(map(int, fin.readline().split()))

a = [0] * (n + 1)

xmax = 0
nr1max = 0

for i in range(1, n + 1):
x = l[i-1]
aux = x
nr1 = 0

while aux > 0:
nr1 += 1
aux = aux & (aux - 1)

if nr1 > nr1max or (nr1 == nr1max and x > xmax):
nr1max = nr1
xmax = x

a[i] = nr1

if c == 1:
# cerinta 1
fout.write(str(xmax))
else:
# cerinta 2
lgm = 0
lgc = 1
pc = 1

for i in range(2, n + 1):
if a[i] == a[i - 1]:
lgc += 1
else:
if lgc > lgm:
lgm = lgc
pm = pc
lgc = 1
pc = i

if lgc > lgm:
lgm = lgc
pm = pc

fout.write(f"{lgm} {pm}")

</syntaxhighlight>

1233 - Paint

2024-01-05T02:05:02Z

Miawinator: Pagină nouă: Roberto are suflet de artist. El visează să ajungă într-o bună zi un pictor celebru, dar pentru moment își câştigă existența ca zugrav. Roberto a primit sarcina de a zugrăvi un zid având lungimea <code>n</code> metri şi înălţimea un metru. Pentru aceasta are la dispoziţie <code>m</code> zile. În fiecare zi <code>i</code>, el acoperă cu un singur strat de vopsea o porţiune compactă de înălțime un metru și de lungime <code>l[i]</code> metri, începân...

Roberto are suflet de artist. El visează să ajungă într-o bună zi un pictor celebru, dar pentru moment își câştigă existența ca zugrav.

Roberto a primit sarcina de a zugrăvi un zid având lungimea <code>n</code> metri şi înălţimea un metru. Pentru aceasta are la dispoziţie <code>m</code> zile. În fiecare zi <code>i</code>, el acoperă cu un singur strat de vopsea o porţiune compactă de înălțime un metru și de lungime <code>l[i]</code> metri, începând de la distanţa <code>d[i]</code> metri faţă de capătul din stânga al zidului.

Roberto ştie din experienţă că fiecare porţiune de zid trebuie acoperită cu cel puţin <code>K</code> straturi de vopsea pentru ca stratul final de vopsea să aibă consistenţa dorită. Din nefericire, firea lui de artist nu i-a permis să-şi poată planifica munca în mod optim, astfel că la capătul celor <code>m</code> zile de efort, Roberto a constatat că zidul are porţiuni pe care le-a acoperit de mai mult de <code>k</code> ori şi alte porţiuni pe care le-a acoperit de mai puţin de <code>k</code> ori.

Pentru a recupera în proprii săi ochi dar mai ales în ochii şefului de echipă, el trebuie să afle mai întâi suprafaţa totală a tuturor porţiunilor de zid care mai trebuie zugrăvite.

= Cerinţă =
Cunoscând lungimea zidului <code>n</code>, numărul de zile <code>m</code> şi porţiunile compacte pe care le zugrăveşte în fiecare zi, determinaţi suprafaţa totală a zidului care mai trebuie zugrăvită.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie trei numerele naturale <code>n k m</code> separate printr-un spațiu, unde <code>n</code> este lungimea zidului, <code>k</code> este numărul minim de straturi de vopsea pentru a se obţine consistenţa dorită, iar <code>m</code> este numărul de zile în care Roberto pictează.

Pe următoarele <code>m</code> linii se află câte două valori naturale separate prin câte un spațiu. Numerele <code>d[i]</code> şi <code>l[i]</code> de pe linia <code>i+1</code> reprezintă distanţa faţă de capătul din stânga al zidului de la care începe să zugrăvească în ziua <code>i</code>, respectiv lungimea în metri a porţiunii de zid zugrăvite în ziua <code>i</code>.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține pe prima linie un număr natural <code>S</code> care reprezintă suprafaţa totală a zidului care nu a fost acoperită cu cel puţin <code>k</code> straturi de vopsea.

= Restricții și precizări =

* <code>1 ≤ n, m ≤ 250 000</code>

== Exemplul 1 ==
input.txt:

5 2 3

0 2

1 3

2 3

output.txt:

2

Explicație:

<code>n = 5</code>, <code>k = 2</code>, <code>m = 3</code>.

În prima zi Roberto vopsește <code>2</code> m din zid între pozițiile <code>0</code> și <code>2</code>. În a doua zi Roberto vopsește <code>3</code> m din zid între pozițiile <code>1</code> și <code>4</code>. În a treia zi Roberto vopsește <code>3</code> m din zid între pozițiile <code>2</code> și <code>5</code>.

Deci, începând cu capătul din stânga al zidului, se va găsi o porțiune de zid de lungime <code>1</code>, acoperită cu un singur strat și începând de la distanța <code>4</code> față de capăt, se va găsi o altă porțiune de zid de lungime <code>1</code>, acoperită cu un singur strat.

== Exemplul 2 ==
input.txt:

9999999999999999 2 3

0 2

1 3

2 3

Output:

Invalid input. Please ensure 1 <= n, m <= 250,000.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_input(n, m):
if not (1 <= n <= 250000) or not (1 <= m <= 250000):
print("Invalid input. Please ensure 1 <= n, m <= 250,000.")
exit()

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
n, k, m = map(int, fin.readline().split())
validate_input(n, m)
a = [0] * (n + 3)

for _ in range(m):
d, L = map(int, fin.readline().split())
a[d] += 1
a[d + L] -= 1

D = 0
cnt = 0

for i in range(n + 1):
cnt += a[i]
if cnt < k:
D += 1

fout.write(str(D - 1) + '\n')

</syntaxhighlight>

1027 - Cool

2024-01-05T01:59:06Z

Miawinator: Pagină nouă: Se consideră un șir <code>A</code> format din <code>N</code> elemente naturale nenule. Numim secvență de lungime <code>K</code> a șirului <code>A</code> orice succesiune de elemente consecutive din șir de forma <code>Ai</code>, <code>Ai+1</code> ,…, <code>Ai+K-1</code>. O secvență o numim ''secvență cool'' dacă elementele care o compun sunt distincte și pot fi rearanjate astfel încât să alcătuiască o secvență continuă de numere consecutive. De exemplu,...

Se consideră un șir <code>A</code> format din <code>N</code> elemente naturale nenule. Numim secvență de lungime <code>K</code> a șirului <code>A</code> orice succesiune de elemente consecutive din șir de forma <code>Ai</code>, <code>Ai+1</code> ,…, <code>Ai+K-1</code>.

O secvență o numim ''secvență cool'' dacă elementele care o compun sunt distincte și pot fi rearanjate astfel încât să alcătuiască o secvență continuă de numere consecutive.

De exemplu, considerând șirul <code>A=(3,1,6,8,4,5,6,7,4,3,4)</code>, atunci secvența <code>(8,4,5,6,7)</code> este o secvență cool deoarece conține elemente distincte ce pot fi rearanjate astfel încât să alcătuiască șirul de numere consecutive <code>4,5,6,7,8,</code> pe când secvențele <code>(4,3,4), (6,7,4,3)</code> nu sunt considerate secvențe cool.

= Cerinţă =
Fiind dat un şir de <code>N</code> numere naturale nenule se cer următoarele:

1. Pentru o valoare dată <code>K</code> să se verifice dacă secvența <code>A1</code>, <code>A2</code> ,…, <code>AK</code> este secvență cool. Dacă secvența este cool, atunci se va afișa cea mai mare valoare ce aparține secvenței. Dacă secvența nu este cool, atunci se va afișa numărul elementelor distincte din secvența <code>A1</code>, <code>A2</code> ,…, <code>AK</code> , adică numărul elementelor care apar o singură dată.

2. Lungimea maximă a unei secvențe cool și numărul secvențelor cool de lungime maximă.

= Date de intrare =
Fişierul de intrare <code>input.txt</code> conţine pe prima linie un număr natural <code>p</code>. Pentru toate testele de intrare, numărul p poate avea doar valoarea <code>1</code> sau valoarea <code>2</code>. Pe linia a doua se găsesc, despărțite printr-un spațiu, două numere naturale <code>N K</code>. Pe următoarea linie se găsesc <code>N</code> numere întregi, separate prin câte un spațiu, ce reprezintă elementele şirului.

= Date de ieşire =
Dacă valoarea lui <code>p</code> este <code>1</code>, atunci se va rezolva numai punctul <code>1</code> din cerință. În acest caz, fişierul de ieşire <code>output.txt</code> va conţine pe prima linie un număr natural, număr ce reprezintă conform cerinței <code>1</code>, maximul secvenței <code>A1</code>, <code>A2</code> ,…, <code>AK</code>, dacă secvența este secvență cool, sau numărul elementelor distincte din secvență, dacă aceasta nu este secvență cool.

Dacă valoarea lui <code>p</code> este <code>2</code>, se va rezolva numai punctul <code>2</code> din cerință. În acest caz, fişierul de ieşire <code>output.txt</code> va avea două linii. Prima linie va conține un număr natural nenul ce reprezintă lungimea maximă a unei secvențe cool, iar următoarea linie un număr natural nenul ce reprezintă numărul de secvențe cool care au lungimea maximă.

= Restricţii și precizări =

* <code>1 ≤ N ≤ 5000</code>
* <code>2 ≤ K ≤ 1000</code>

== Exemplul 1 ==
input.txt:

1

7 4

6 4 5 7 8 3 5

output.txt:

7

Explicație:

Secvența <code>6 4 5 7</code> este cool.

Valoarea maximă din secvență este <code>7</code>

== Exemplul 2 ==
input.txt:

1

7 6

6 4 5 7 5 4 3

output.txt:

2

Explicație:

Secvența <code>6 4 5 7 5 4</code> nu este secvență cool. Numărul valorilor distincte din secvență este <code>2</code>. Valorile distincte sunt: <code>6,7</code>

== Exemplul 3 ==
input.txt:

2

11 4

7 4 5 6 8 4 5 7 4 3 2

output.txt:

5

2

Explicație:

Cele două secvențe cool de lungime maximă 5 sunt:

<code>7 4 5 6 8</code>

<code>6 8 4 5 7</code>

== Exemplul 4 ==
input.txt:

99999999999999999

11 4

7 4 5 6 8 4 5 7 4 3 2

Output:

Invalid input. Please ensure 1 <= T <= 2, 2 <= K <= 1000, and 1 <= N <= 5000.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_input(T, K, N):
if not (1 <= T <= 2) or not (2 <= K <= 1000) or not (1 <= N <= 5000):
print("Invalid input. Please ensure 1 <= T <= 2, 2 <= K <= 1000, and 1 <= N <= 5000.")
exit()

def main():
with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
cnt = [0] * 1003
a = [0] * 5001
nr = [0] * 5001
T, K, n, maxK, minK = 0, 0, 0, 0, 5001
L, Lmax, nMaxCool, amin, amax, bad = 0, 1, 1, 0, 0, 0

T = int(fin.readline())
n, K = map(int, fin.readline().split())

validate_input(T,K, n)

l=list(map(int, fin.readline().split()))

for i in range(n):
a[i] = l[i]
if i < K:
maxK = max(maxK, a[i])
minK = min(minK, a[i])
nr[a[i]] += 1

if T == 1:
cool = True
distincte = 0

for x in range(minK, maxK + 1):
if nr[x] == 0 or nr[x] > 1:
cool = False
if nr[x] == 1:
distincte += 1

if cool:
fout.write(str(maxK) + '\n')
else:
fout.write(str(distincte) + '\n')

else:
for i in range(n):
cnt[a[i]] += 1
bad = 0
amin = amax = a[i]

for j in range(i + 1, n):
cnt[a[j]] += 1
L = j - i + 1

if cnt[a[j]] > 1:
bad += 1

if amax < a[j]:
amax = a[j]
if amin > a[j]:
amin = a[j]

if bad or amax - amin != j - i:
continue

if L > Lmax:
Lmax = L
nMaxCool = 1
elif L == Lmax:
nMaxCool += 1

cnt[a[i]] -= 1
cnt = [0] * 1003

fout.write(str(Lmax) + '\n' + str(nMaxCool) + '\n')

if __name__ == "__main__":
main()

</syntaxhighlight>

2411 - secvp

2024-01-05T01:50:43Z

Miawinator: Pagină nouă: Se consideră un şir cu <code>N</code> numere naturale <code>a[1]</code>, <code>a[2]</code>, …, <code>a[N]</code>. Asupra unui element <code>a[i]</code> din şir se pot efectua operaţii de incrementare (adunare cu <code>1</code>: <code>a[i] = a[i] + 1</code>) sau decrementare (scădere cu <code>1</code>: <code>a[i] = a[i] - 1</code>). Fiecare element din şir poate fi incrementat sau decrementat de oricâte ori. = Cerința = Dat fiind șirul celor <code>N</code> numere n...

Se consideră un şir cu <code>N</code> numere naturale <code>a[1]</code>, <code>a[2]</code>, …, <code>a[N]</code>. Asupra unui element <code>a[i]</code> din şir se pot efectua operaţii de incrementare (adunare cu <code>1</code>: <code>a[i] = a[i] + 1</code>) sau decrementare (scădere cu <code>1</code>: <code>a[i] = a[i] - 1</code>). Fiecare element din şir poate fi incrementat sau decrementat de oricâte ori.

= Cerința =
Dat fiind șirul celor <code>N</code> numere naturale, să se determine:

a. numărul total minim de operaţii necesare pentru a transforma toate numerele din şir în numere prime;

b. numărul minim de operații (incrementări şi decrementări) ce trebuie să fie efectuate asupra elementelor şirului astfel încât să existe o secvență de lungime <code>K</code> formată numai din numere prime.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie numerele naturale <code>N</code> şi <code>K</code>, iar pe următoarea linie <code>N</code> numere naturale. Numerele scrise pe aceeași linie sunt separate prin spații.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> conţine pe prima linie un număr natural <code>T</code>, reprezentând numărul total minim de operaţii necesare pentru a transforma toate numerele din şir în numere prime. Pe a doua linie vor fi scrise două numere naturale separate prin spaţiu <code>minK nrsK</code>, unde <code>minK</code> reprezintă numărul minim de operaţii ce trebuie să fie efectuate asupra elementelor şirului astfel încât să existe o secvenţă de lungime <code>K</code> formată numai din numere prime, iar <code>nrsK</code> reprezintă numărul de secvenţe de lungime <code>K</code> care se pot obţine cu acelaşi număr <code>minK</code> de operaţii de incrementare/decrementare.

= Restricții și precizări =

* <code>2 ≤ K ≤ N ≤ 100.000</code>

= Exemplul 1 =
input.txt:

7 3

15 3 8 26 22 10 14

output.txt:

9

3 2

Explicație:

Pentru a transforma <code>15</code> în număr prim sunt necesare <code>2</code> incrementări.

Pentru a transforma <code>3</code> în număr prim sunt necesare <code>0</code> operaţii.

Pentru a transforma <code>8</code> în număr prim e necesară <code>1</code> decrementare.

Pentru a transforma <code>26</code> în număr prim sunt necesare <code>3</code> decrementări.

Pentru a transforma <code>22</code> în număr prim e necesară <code>1</code> incrementare.

Pentru a transforma <code>10</code> în număr prim e necesară <code>1</code> incrementare.

Pentru a transforma <code>14</code> în număr prim e necesară <code>1</code> decrementare.

Numărul total de operaţii necesare este <code>9</code>.

Numărul minim de operaţii necesare pentru a obţine o secvenţă de lungime <code>K</code> este <code>3</code>. Cele două secvenţe de lungime <code>K</code> ce necesită <code>3</code> operaţii sunt <code>a[1], a[2], a[3]</code> şi <code>a[5], a[6], a[7]</code>.

== Exemplul 2 ==
input.txt

9999999999 3

15 3 8 26 22 10 14

Output:

Invalid input. Please ensure 2 <= K <= N <= 100,000.

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

def validate_input(n, k):
if not (2 <= k <= n <= 100000):
print("Invalid input. Please ensure 2 <= K <= N <= 100,000.")
exit()

fin = open("input.txt", "r")
fout = open("output.txt", "w")

N = 1000100

e = [0] * (N + 1)
v = []
a = [0] * 100001
iteratii = [0] * 100001
sp = [0] * 100001

def ciur():
global v
e[0] = e[1] = 1

for i in range(2, N + 1):
if not e[i]:
v.append(i)

for j in range(i * 2, N + 1, i):
e[j] = 1

def read_solve1():
global n, k, a, iteratii, sp

n, k = map(int, fin.readline().split())
validate_input(n, k)
s = 0

l=list(map(int, fin.readline().split()))

for i in range(1, n + 1):
x = l[i-1]

it = bisect.bisect_left(v, x)
it2 = bisect.bisect_right(v, x)

d1 = it
d2 = it2

if e[x]:
if d1 > 0:
s += min(abs(x - v[d1 - 1]), abs(x - v[d2]))
iteratii[i] = min(abs(x - v[d1 - 1]), abs(x - v[d2]))

if iteratii[i] == abs(x - v[d1 - 1]):
iteratii[i] *= -1
else:
s += abs(x - v[d2])
iteratii[i] = abs(x - v[d2])

a[i] = x + iteratii[i]

if iteratii[i] < 0:
iteratii[i] *= -1

sp[i] = sp[i - 1] + iteratii[i]

fout.write(str(s)+"\n")

def solve2():
global n, k, sp, mini, secv

temp = 0
mini = float('inf')
secv = 0

for i in range(k, n + 1):
temp = sp[i] - sp[i - k]

if temp < mini:
mini = temp
secv = 1
elif temp == mini:
secv += 1

fout.write(str(mini)+" ")
fout.write(str(secv))

if __name__ == "__main__":
ciur()
read_solve1()
solve2()

</syntaxhighlight>

3752 - Cvintete

2024-01-05T01:43:50Z

Miawinator: Pagină nouă: Se consideră numerele naturale nenule <code>N</code> și <code>D</code> urmate de o secvență <code>S</code> de <code>N</code> numere naturale nenule ordonate crescător, indexate de la <code>1</code> la <code>N</code>. = Cerința = Să se determine numărul de cvintete de indici <code>(i1, i2, i3, i4, i5)</code> ce verifică relațiile: * <code>a • b • c = D</code> * <code>a • x2</code> <code>+ b • y2</code> <code>= c2</code> * <code>a < b < c</code> * <code>x...

Se consideră numerele naturale nenule <code>N</code> și <code>D</code> urmate de o secvență <code>S</code> de <code>N</code> numere naturale nenule ordonate crescător, indexate de la <code>1</code> la <code>N</code>.

= Cerința =
Să se determine numărul de cvintete de indici <code>(i1, i2, i3, i4, i5)</code> ce verifică relațiile:

* <code>a • b • c = D</code>
* <code>a • x2</code> <code>+ b • y2</code> <code>= c2</code>
* <code>a < b < c</code>
* <code>x ≠ y</code>

unde am notat cu <code>a = S[i1]</code>, <code>b = S[i2]</code>, <code>c = S[i3]</code>, <code>x = S[i4]</code>, <code>y = S[i5]</code>. Rezultatul se va afișa modulo <code>1.000.000.007</code>.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie două numere naturale nenule <code>N</code> și <code>D</code> cu semnificația

din enunț. Pe următoarea linie se vor afla <code>N</code> numere naturale nenule ordonate crescător.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține un singur număr natural care reprezintă rezultatul cerinței, modulo <code>1.000.000.007</code>.

== Exemplul 1 ==
input.txt:

4 6

1 2 3 3

output.txt:

2

Explicație:

Cvintetele care respectă cerința sunt: <code>(1, 2, 3, 1, 2)</code>, <code>(1, 2, 4, 1, 2)</code>.

== Exemplul 2 ==
input.txt:

10 60

1 2 3 4 4 5 6 8 10 12

output.txt:

4

Explicație:

Cvintetele care respectă cerința sunt: <code>(1, 6, 10, 8, 4)</code>, <code>(1, 6, 10, 8, 5)</code>, <code>(1, 7, 9, 2, 4)</code>, <code>(1, 7, 9, 2, 5)</code>

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

M = 1000000007
N = 25000
P = 1235789

def gcd(A, B):
r = A % B
while r != 0:
A = B
B = r
r = A % B
return B

def main():
with open("input.txt", "r") as infile, open("output.txt", "w") as outfile:
n, d = map(int, infile.readline().split())
f = [0] * (N + 1)
di = [0] * (N + 1)
pp = [0] * (N + 1)
v = [0] * (P + 1)
k = 0
m = 0

l=list(map(int, infile.readline().split()))

for i in range(n):
x = l[i]
f[x] += 1
if x > m:
m = x

for i in range(1, m + 1):
if (d % i == 0) and (f[i] > 0):
k += 1
di[k] = i
pp[i] = i * i
v[pp[i] % P] = i

sol = 0

for i in range(1, k - 1):
a = di[i]
for j in range(i + 1, k):
b = di[j]
e = a * b
if d % e == 0:
c = d // e
if c > b and c <= m and f[c] > 0:
nr = f[a] * f[b] * f[c]
w = c * c
dc = gcd(a, b)
if w % dc == 0:
l = int(math.sqrt(w / b))
for u in range(1, l + 1):
if (w - b * pp[u]) % a == 0:
z = (w - b * pp[u]) // a
h = v[z % P]
if h * h == z and h != u and h <= m:
sol += nr * f[u] * f[h]

outfile.write(str(sol % M) + "\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

3067 - optime

2024-01-05T01:38:19Z

Miawinator: Pagină nouă: Maria iubește numerele prime. Ea scrie pe o foaie de hârtie, în ordine strict crescătoare, un șir format din numerele prime care au cel puțin două cifre. Apoi, din numerele care conțin mai mult de două cifre taie cifrele din stânga, astfel încât să rămână exact două cifre. Dacă după tăierea cifrelor numărul obținut nu este cuprins între <code>10</code> și <code>99</code>, numărul este eliminat din șir. De exemplu, numărul prim <code>101</code>, care...

Maria iubește numerele prime. Ea scrie pe o foaie de hârtie, în ordine strict crescătoare, un șir format din numerele prime care au cel puțin două cifre. Apoi, din numerele care conțin mai mult de două cifre taie cifrele din stânga, astfel încât să rămână exact două cifre. Dacă după tăierea cifrelor numărul obținut nu este cuprins între <code>10</code> și <code>99</code>, numărul este eliminat din șir. De exemplu, numărul prim <code>101</code>, care are trei cifre, nu va fi scris, deoarece i se taie cifra din stânga, rezultând numărul <code>01</code>, adică <code>1</code>, care nu are exact două cifre, deci după tăiere va fi eliminat din șir.

Maria umple un tabel cu <code>2 * k</code> linii și <code>k</code> coloane, astfel încât, parcurgându-l pe linii, de sus în jos și fiecare linie de la stânga la dreapta, se obțin numerele din șir. Studiind numerele din tabel, constată că printre acestea se află și numere care nu sunt prime. De exemplu, pentru <code>k = 4</code>, tabelul arată ca în imagine.

= Cerința =
Cunoscând un număr natural <code>k</code> nenul și un număr natural <code>x</code>, ajutați-o pe Maria:

1. Să determine suma numerelor din tabel care nu sunt prime. Dacă nu există numere care nu sunt prime, suma are valoarea <code>0</code>.

2. Să aleagă <code>x</code> coloane consecutive din tabel, astfel încât acestea să conțină, în total, un număr maxim de numere prime. Dacă există mai multe posibilități, se va alege secvența de coloane consecutive care are o valoare cât mai mare a coloanei de început din secvență. Să se determine numărul primei coloane din secvența aleasă, precum și numărul total de numere prime din secvență.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie o cifră <code>c</code> care poate să fie doar <code>1</code> sau <code>2</code>. Dacă <code>c = 1</code>, pe linia a doua se găsește un număr natural nenul <code>k</code> cu semnificația din enunț. Dacă <code>c = 2</code>, pe linia a doua se află două numere naturale nenule, <code>k</code> și <code>x</code>, cu semnificația din enunț.

= Date de ieșire =
Dacă valoarea lui <code>c</code> este <code>1</code>, atunci se va rezolva numai punctul 1 din cerință. În acest caz, fișierul de ieșire <code>output.txt</code> va conţine pe prima linie un număr natural reprezentând valoarea sumei determinate.

Dacă valoarea lui <code>c</code> este <code>2</code>, se va rezolva numai punctul 2 din cerință. În acest caz, fișierul de ieșire <code>output.txt</code> va conține pe prima linie un număr natural reprezentând numărul de ordine al primei coloane conform cerinței, iar pe linia a doua numărul de numere prime, conform cerinței.

= Restricții și precizări =

* <code>1 ≤ x ≤ k ≤ 200</code>

= Exemplul 1 =
input.txt:

1

4

output.txt:

286

Explicație:

Pentru <code>k = 4</code>, în tabel se află următoarele numere neprime: <code>27</code>, <code>39</code>, <code>49</code>, <code>51</code>, <code>57</code>, <code>63</code>, suma lor fiind <code>286</code>.

== Exemplul 2 ==
input.txt:

2

4 3

output.txt:

2

19

Explicație:

Coloana <code>1</code> conține <code>7</code> numere prime, coloana <code>2</code> conține <code>6</code> numere prime, coloana <code>3</code> conține <code>6</code> numere prime, iar coloana <code>4</code> conține <code>7</code> numere prime. Putem alege fie coloanele <code>1</code>, <code>2</code>, <code>3</code>, fie coloanele <code>2</code>, <code>3</code>, <code>4</code>, ambele variante conținând câte <code>19</code> numere prime. Se alege a doua variantă, pentru că are valoarea mai mare a coloanei de început a secvenței.

== Exemplul 3 ==
intput.txt:

2

99999999999999 3

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
from math import sqrt

def verificare(n):
if not(1<=n<=200):
print("Input-ul nu convine conditiilor")
exit()

N = 2000000

fin = open("input.txt", "r")
fout = open("output.txt", "w")

task, k, x = 0, 0, 0
a = [[0]*201 for _ in range(401)]
v = [0]*201
sp = [0]*201
s = 0
e = [0] * (N + 1)
prime = []

def ciur():
global prime
temp = 0

e[0] = e[1] = 1
for i in range(2, N + 1):
if not e[i]:
for j in range(i * 2, N + 1, i):
e[j] = 1

for i in range(10, N + 1):
if i < 100 and not e[i]:
prime.append(i)
elif i > 100 and not e[i]:
temp = i % 100
if temp >= 10:
prime.append(temp)

def read():
global task, k, x
task=int(fin.readline())

if task == 1:
k = int(fin.readline())
verificare(k)
if task == 2:
k, x = map(int, fin.readline().split())
verificare(k)

def build():
global s
p = 0

for i in range(1, 2 * k + 1):
for j in range(1, k + 1):
a[i][j] = prime[p]
s += a[i][j] * (e[a[i][j]] == 1)

if a[i][j] > 10 and not e[a[i][j]]:
v[j] += 1

p += 1

def solve():
global s
if task == 1:
fout.write(str(s))
else:
nr_prime = 0
maxi = -1
first = 0

for i in range(1, k + 1):
sp[i] = sp[i - 1] + v[i]

for i in range(x, k + 1):
nr_prime = sp[i] - sp[i - x]
if nr_prime >= maxi:
maxi = nr_prime
first = i - x + 1
fout.write(str(first)+"\n")
fout.write(str(maxi))

if __name__ == "__main__":
ciur()
read()
build()
solve()

</syntaxhighlight>

3043 - cub3

2024-01-05T00:53:01Z

Miawinator: Pagină nouă: Ionel are de rezolvat o nouă problemă. El trebuie să construiască un șir de <code>N</code> numere naturale. Numerele din șir pot avea ca divizori primi doar numere prime de o cifră. După construirea șirului, Ionel a constatat că există subsecvențe în șir pentru care produsul elementelor este cubul unui număr natural. = Cerința = Ionel vrea să determine numărul subsecvențelor din șirul construit care au produsul elementelor o valoare ce este cubul unui num...

Ionel are de rezolvat o nouă problemă. El trebuie să construiască un șir de <code>N</code> numere naturale. Numerele din șir pot avea ca divizori primi doar numere prime de o cifră. După construirea șirului, Ionel a constatat că există subsecvențe în șir pentru care produsul elementelor este cubul unui număr natural.

= Cerința =
Ionel vrea să determine numărul subsecvențelor din șirul construit care au produsul elementelor o valoare ce este cubul unui număr natural.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> va conține pe prima linie numărul natural <code>N</code>, iar pe linia următoare se vor afla <code>N</code> numere naturale separate prin câte un spațiu, elementele șirului construit de Ionel.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține pe prima linie un număr natural reprezentând numărul subsecvenţelor din șirul construit care au produsul elementelor egal cu o valoare ce este cubul unui număr natural.

= Restricții și precizări =

* <code>N</code> și elemente șirului sunt numere naturale din intervalul <code>[2, 1.000.000]</code>.

== Exemplul 1 ==
input.txt:

8

15 3 5 15 7 63 21 125

output.txt:

6

Explicație:

Sunt <code>6</code> subsecvențe în șir cu produsul elementelor egal cu o valoare care este cubul unui număr natural:

<code>15 3 5 15</code>

<code>7 63 21</code>

<code>125</code>

<code>15 3 5 15 7 63 21</code>

<code>7 63 21 125</code>

<code>15 3 5 15 7 63 21 125</code>

== Exemplul 2 ==
input.txt:

99999999999

15 3 5 15 7 63 21 125

Output:

Input-ul nu convine conditiilor

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

def verificare(n):
if not(2<=n<=1000000):
print("Input-ul nu convine conditiilor")
exit()

def convert():
return crtState[3] * 3 * 3 * 3 + crtState[2] * 3 * 3 + crtState[1] * 3 + crtState[0]

fin = open("input.txt", "r")
fout = open("output.txt", "w")

n = int(fin.readline())
verificare(n)
i, j, nr, x, mul, sol = 0, 0, 0, 0, 0, 0
crtState = [0] * 4
states = [0] * 100
divs = [2, 3, 5, 7]

l=list(map(int, fin.readline().split()))

for _ in range(1, n + 1):
x = l[i-1]

for j in range(4):
nr = 0
while x % divs[j] == 0:
nr += 1
x //= divs[j]
crtState[j] += 1

crtState[j] %= 3

states[convert()] += 1

states[0] += 1

for i in range(81):
sol += states[i] * (states[i] - 1) // 2

fout.write(str(int(math.sqrt(sol))))

fin.close()
fout.close()

</syntaxhighlight>

2897 - numere26

2024-01-05T00:14:30Z

Miawinator: Pagină nouă: Se consideră un șir format din <code>n</code> numere naturale. Asupra numerelor din șir se face următoarea prelucrare: fiecare valoare este înlocuită cu cel mai mare divizor prim al său. În noul șir se formează secvențe de numere care încep și se termină cu aceeași valoare, numite secvențe neuniforme. = Cerința = Cunoscând numerele naturale <code>n</code> și <code>c</code>, și un șir de <code>n</code> numere naturale, se cere să se rezolve următoarele...

Se consideră un șir format din <code>n</code> numere naturale. Asupra numerelor din șir se face următoarea prelucrare: fiecare valoare este înlocuită cu cel mai mare divizor prim al său. În noul șir se formează secvențe de numere care încep și se termină cu aceeași valoare, numite secvențe neuniforme.

= Cerința =
Cunoscând numerele naturale <code>n</code> și <code>c</code>, și un șir de <code>n</code> numere naturale, se cere să se rezolve următoarele cerințe:

1. dacă <code>c = 1</code>, atunci se cere să se afișeze lungimea maximă a unei secvențe neuniforme.

2. dacă <code>c = 2</code>, atunci se cere să se afișeze numărul total de secvențe neuniforme din șir.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie, despărțite prin câte un spațiu, numerele naturale <code>n</code> și <code>c</code>, cu semnificația din enunț. A doua linie conține <code>n</code> numere naturale, despărțite prin câte un spațiu.

= Date de ieșire =
Dacă <code>c = 1</code>, atunci pe prima linie a fișierului <code>output.txt</code> va fi scris un singur număr ce reprezintă lungimea maximă a unei secvențe neuniforme. Dacă <code>c = 2</code>, atunci fișierul <code>output.txt</code> va conține un singur număr ce reprezintă numărul total de secvențe neuniforme.

= Restricții și precizări =

* <code>0 < n < 10.000</code>

== Exemplul 1 ==
input.txt:

6 1

14 2 49 3 35 1024

output.txt:

5

Explicație:

Cele <code>10</code> numere sunt înlocuite cu valorile: <code>7</code>, <code>2</code>, <code>3</code>, <code>5</code>, <code>3</code>, <code>3</code>, <code>5</code>, <code>2</code>, <code>5</code>, <code>2</code>. Numărul total de secvențe neuniforme din șir este <code>3 + 3 + 3 = 9</code>.

== Exemplul 2 ==
input.txt:

10 2

14 8 3 25 6 24 20 1024 100 2

output.txt:

9

Explicație:

Cele <code>10</code> numere sunt înlocuite cu valorile: <code>7</code>, <code>2</code>, <code>3</code>, <code>5</code>, <code>3</code>, <code>3</code>, <code>5</code>, <code>2</code>, <code>5</code>, <code>2</code>. Numărul total de secvențe neuniforme din șir este <code>3 + 3 + 3 = 9</code>.

== Exemplul 3 ==
input.txt:

999999999999 2

14 8 3 25 6 24 20 1024 100 2

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(1<=n<=10000):
print("Input-ul nu convine conditiilor")
exit()

def fact_max(a):
f = 2
r = 0
if a % 2 == 0:
r = 2
while a % 2 == 0:
a //= 2
for f in range(3, a + 1, 2):
if a % f == 0:
r = f
while a % f == 0:
a //= f
return r

def main():
with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
s = 0
n, c = map(int, fin.readline().split())
verificare(n)
fr1 = [0] * 10000
fr2 = [0] * 10000
mx = 0
lmax = 0

l=list(map(int, fin.readline().split()))

for i in range(1, n + 1):
a = l[i-1]
x = fact_max(a)

if x > mx:
mx = x # cel mai mare nr prim care apare in urma prelucrarii sirului initial

# cerinta 1
if fr1[x] == 0:
fr1[x] = i
else:
d = i - fr1[x] + 1
if d > lmax:
lmax = d

# cerinta 2
fr2[x] += 1

if c == 1:
fout.write(str(lmax) + "\n")
else:
# rezolvarea de la cerinta 2
# calculez suma de x*(x-1)/2, unde x=fr2[i]

if fr2[2] > 1:
s += fr2[2] * (fr2[2] - 1) // 2

# i-au mai ramas numai valori prime impare
for i in range(3, mx + 1, 2):
if fr2[i] > 1:
s += fr2[i] * (fr2[i] - 1) // 2

fout.write(str(s) + "\n")

if __name__ == "__main__":
main()

</syntaxhighlight>

2440 - puzzle

2024-01-05T00:03:29Z

Miawinator: Pagină nouă: Mihai a primit de ziua lui un joc de puzzle. Jocul are <code>N</code> piese confecţionate prin lipirea unor bucăţi de dimensiune <code>1x1</code> (ilustrate în figurile de mai jos prin <code>X</code>); aceste bucăţi le vom numi în continuare, pe scurt, <code>X</code>-uri. Pentru confecţionarea unei piese se respectă următoarele reguli: 1. <code>X</code>-urile sunt aşezate unul peste altul, formând coloane ce pot avea înălţimi diferite, apoi coloanele se alinia...

Mihai a primit de ziua lui un joc de puzzle. Jocul are <code>N</code> piese confecţionate prin lipirea unor bucăţi de dimensiune <code>1x1</code> (ilustrate în figurile de mai jos prin <code>X</code>); aceste bucăţi le vom numi în continuare, pe scurt, <code>X</code>-uri. Pentru confecţionarea unei piese se respectă următoarele reguli:

1. <code>X</code>-urile sunt aşezate unul peste altul, formând coloane ce pot avea înălţimi diferite, apoi coloanele se aliniază în partea de jos şi se lipesc între ele, una după cealaltă, de la stânga spre dreapta;

2. pe o coloană sunt cel mult nouă <code>X</code>-uri;

3. toate piesele au acelaşi număr de coloane.

Exemple:

În figurile 1, 2, 3, 4 sunt piese de puzzle care respectă regulile descrise, iar în figura 5 și în figura 6 NU sunt piese de puzzle, pentru că nu pot fi obţinute prin lipirea unor coloane de <code>X</code>-uri, una după cealaltă, de la stânga spre dreapta.

Fiind mic, Mihai nu poate rezolva puzzle-ul, dar poate face o singură operaţie: alege două piese şi le îmbină în dreptul laturilor de sus, răsturnând una dintre piese sus-jos (fără să o rotească sau să o răstoarne stânga-dreapta). Dacă în urma acestei operaţii el obţine un dreptunghi format din coloane complete de <code>X</code>-uri, toate coloanele având aceeaşi înălţime, este mulţumit. De exemplu, piesa din figura 1 și cea din figura 2 pot fi îmbinate în modul descris.

În figura 7 este piesa din figura 2 răsturnată sus-jos. În figura 8 este ilustrat dreptunghiul care se obţine din piesa din figura 1 şi piesa din figura 2 răsturnată sus-jos.

Observaţi că, dacă am roti piesa din figura 4, am putea să o îmbinăm cu piesa din figura 1, dar rotaţia nu este permisă.

Vom codifica o piesă printr-un număr natural, fiecare cifră din număr reprezentând (în ordine de la stânga la dreapta) câte <code>X</code>-uri se află pe coloana corespunzătoare din piesă.

De exemplu:

– piesa din figura 1 este codificată <code>4232</code>;

– piesa din figura 2 este codificată <code>1323</code>;

– piesa din figura 3 este codificată <code>4444</code>;

– piesa din figura 4 este codificată <code>3231</code>.

= Cerința =
Determinați care este numărul de moduri în care Mihai poate alege câte două piese dintre cele <code>N</code> pentru a face o operaţie în modul descris mai sus.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie un număr natural <code>N</code> ce reprezintă numărul de piese din joc. Pe linia a doua se găsesc <code>N</code> numere naturale, separate prin câte un singur spațiu, reprezentând codificările celor <code>N</code> piese.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține o singură linie pe care va fi scris numărul cerut.

= Restricții și precizări =

* <code>2 ≤ N ≤ 100 000</code>

== Exemplul 1 ==
input.txt:

5

222 432 234 123 111

output.txt:

3

Explicație:

Se pot îmbina <code>3</code> perechi de piese: piesa <code>1</code> cu piesa <code>5</code>, piesa <code>2</code> cu piesa <code>3</code>, piesa <code>2</code> cu piesa <code>4</code>. Piesele <code>3</code> și <code>4</code> s-ar putea îmbina corect dacă una dintre ele ar fi răsturnată stânga-dreapta sau rotită, dar acest lucru nu e permis.

== Exemplul 2 ==
input.txt:

99999999999999999

32 3 2 1 31 4 1

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(2<=n<=100000):
print("Input-ul nu convine conditiilor")
exit()

f = [0] * 100001
v = []
frecv = [0] * 12
rez = 0
n = 0
k = 0

def fa(numar):
global frecv
t = 0
mi = 9
while numar:
t += 1
frecv[t] = numar % 10
numar //= 10
if frecv[t] < mi:
mi = frecv[t]
r = 0
for i in range(t, 0, -1):
r = r * 10 + (frecv[i] - mi)
return r

def intoarce(code, k):
global frecv
t = 0
aux = code
ma = 0
for i in range(1, k + 1):
t += 1
frecv[t] = aux % 10
aux //= 10
ma = max(ma, frecv[t])
r = 0
for i in range(t, 0, -1):
r = r * 10 + (ma - frecv[i])
return r

def lungime_nr(n):
cnt = 0
while n:
cnt += 1
n //= 10
return cnt

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
n = int(fin.readline().strip())
verificare(n)
v = list(map(int, fin.readline().split()))
if n > 0:
k = lungime_nr(v[0])

for i in range(1, n + 1):
f[fa(v[i - 1])] += 1

rez = 0
for i in range(1, 100001):
rez += 1 * f[i] * f[intoarce(i, k)]

rez //= 2
rez += 1 * f[0] * (f[0] - 1) // 2
fout.write(str(rez) + "\n")

</syntaxhighlight>

2350 - grup

2024-01-04T23:58:13Z

Miawinator: Pagină nouă: Ionel este pasionat de problemele cu șiruri de numere naturale. Pornind de la un șir dat, el numește grup un subșir de numere care se formează după criterii precizate. De aceasta dată, el alege două criterii: Criteriul 1: grupează numerele după prima lor cifră. De exemplu, numerele <code>231</code> și <code>2745</code> aparțin aceluiași grup deoarece ambele încep cu aceeași cifră (<code>2</code>). Criteriul 2: pune în același grup toate numerele care au...

Ionel este pasionat de problemele cu șiruri de numere naturale. Pornind de la un șir dat, el numește grup un subșir de numere care se formează după criterii precizate. De aceasta dată, el alege două criterii:

Criteriul 1: grupează numerele după prima lor cifră. De exemplu, numerele <code>231</code> și <code>2745</code> aparțin aceluiași grup deoarece ambele încep cu aceeași cifră (<code>2</code>).

Criteriul 2: pune în același grup toate numerele care au în componența lor aceleași cifre, indiferent de numărul de apariții a fiecărei cifre. De exemplu, numerele <code>234372</code> și <code>3224727</code> vor fi plasate în același grup deoarece în componența ambelor intră cifrele <code>2</code>, <code>3</code>, <code>4</code> si <code>7</code>, și numai acestea.

= Cerința =
Scrieţi un program care, pentru un şir dat de n numere naturale, rezolvă următoarele cerințe:

# determină numărul minim dintre numerele aparținând celui mai numeros grup care se formează conform Criteriului 1. Dacă sunt mai multe grupuri cu număr maxim de elemente, se va determina numărul minim din grupul pentru care prima cifra este cea mai mică.
# determină numărul de elemente ale celui mai numeros grup care se formează conform Criteriului 2.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conţine pe prima linie două numere naturale <code>n</code> și <code>c</code>, separate printr-un spațiu. Valoarea lui <code>c</code> este <code>1</code> sau <code>2</code>, în funcție de cerința problemei. Pe a doua linie se găsesc <code>n</code> numere naturale, separate prin câte un spațiu.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conţine pe prima linie rezultatul cerut în funcție de cerința indicată în fișierul de intrare.

= Restricții și precizări =

* <code>0 < n ≤ 10000</code>
* Valorile din șirul de intrare sunt numere naturale cu maxim <code>9</code> cifre.

== Exemplul 1 ==
input.txt:

7 1

73532 344 739 34343 34 735 23757

output.txt:

34

Explicație:

<code>c = 1</code>; Se formează următoarele grupuri:

G1: <code>73532</code>, <code>739</code>, <code>735</code> (încep cu cifra <code>7</code>)

G2: <code>344</code>, <code>34343</code>, <code>34</code> (încep cu cifra <code>3</code>)

G3: <code>23753</code> (începe cu cifra <code>2</code>)

G1 si G2 au număr maxim de elemente (<code>3</code>) dar se va afișa minimul din grupul G2 (<code>34</code>).

== Exemplul 2 ==
input.txt:

7 2

73532 344 739 34343 34 433 23757

output.txt:

4

Explicație:

<code>c = 2</code>; Se formează următoarele grupuri:

G1: <code>73532</code>, <code>23757</code> (cifrele <code>2</code>, <code>3</code>, <code>7</code>, <code>5</code>)

G2: <code>739</code> (cifrele <code>3</code>, <code>7</code>, <code>9</code>)

G3: <code>344</code>, <code>34343</code>, <code>34</code>, <code>433</code> (cifrele <code>3</code>, <code>4</code>)

G3 are numărul maxim de elemente (<code>4</code>)

== Exemplul 3 ==
input.txt:

999999999999999999 2

73532 344 739 34343 34 433 23757

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(1<=n<=10000):
print("Input-ul nu convine conditiilor")
exit()

def prima_cifra(n):
while n > 9:
n //= 10
return n

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
n, optiune = map(int, fin.readline().split())
verificare(n)
NR = [0] * 11
M = [1000000000] * 11
a = [0] * 1025

l=list(map(int, fin.readline().split()))

if optiune == 1:
for i in range(1, n + 1):
x = l[i-1]
c = prima_cifra(x)
NR[c] += 1
M[c] = min(M[c], x)

x = NR[0]
c = M[0]
for i in range(1, 10):
if NR[i] > x:
x = NR[i]
c = M[i]
elif x == NR[i]:
c = min(c, M[i])

fout.write(str(c) + "\n")
else:
for i in range(1, n + 1):
x = l[i-1]
c = 0
if x == 0:
c = 1
else:
while x > 0:
c |= 1 << (x % 10)
x //= 10
a[c] += 1

x = a[0]
for i in range(1, 1025):
x = max(x, a[i])

fout.write(str(x) + "\n")

</syntaxhighlight>

2230 - paindrom3

2024-01-04T23:38:39Z

Miawinator: Pagină nouă: Gigel a învăţat la şcoală un nou cuvânt: palindrom. El ştie acum că un palindrom este o construcţie formată din litere sau/şi cifre care arată la fel citită de la început spre sfârşit sau citită de la sfârşit spre început. De exemplu numerele <code>2552</code> și <code>12321</code> au proprietatea de palindrom. Deoarece lui Gigel îi place să se joace cu cifrele, el îşi pune următoarea problemă: dat fiind un număr natural, pot fi rearanjate cifrele...

Gigel a învăţat la şcoală un nou cuvânt: palindrom. El ştie acum că un palindrom este o construcţie formată din litere sau/şi cifre care arată la fel citită de la început spre sfârşit sau citită de la sfârşit spre început. De exemplu numerele <code>2552</code> și <code>12321</code> au proprietatea de palindrom. Deoarece lui Gigel îi place să se joace cu cifrele, el îşi pune următoarea problemă: dat fiind un număr natural, pot fi rearanjate cifrele lui astfel încât să obţinem un palindrom? Dacă da, care este numărul maxim palindrom care poate fi obţinut?

= Cerința =
Fiind dat un număr natural <code>n</code> să se determine cel mai mare număr palindrom care se poate obţine cu cifrele numărului <code>n</code>.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conţine pe prima linie numărul natural <code>n</code>.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> conţine pe prima linie cel mai mare număr palindrom care se poate obţine cu cifrele numărului <code>n</code>.

= Restricții și precizări =

* <code>0 < n < 2 147 483 648</code>
* Pentru datele de test există întotdeauna soluţie

== Exemplul 1 ==
input.txt:

3121321

output.txt:

3211123

== Exemplul 2 ==
input.txt:

999999999999999999999999999999

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(1<=n<=2147483648):
print("Input-ul nu convine conditiilor")
exit()

with open("input.txt") as f:
n = int(next(f))
verificare(n)

f = [0] * 10
while n:
f[n % 10] += 1
n //= 10

k = -1
for i in range(10):
if f[i] % 2:
f[i] -= 1
k = i

with open("output.txt", "w") as fout:
for i in range(9, -1, -1):
if f[i]:
print(str(i) * (f[i] // 2), end="", file=fout)
if k >= 0:
print(k, end="", file=fout)
for i in range(10):
if f[i]:
print(str(i) * (f[i] // 2), end="", file=fout)
</syntaxhighlight>

2121 - Tan

2024-01-04T23:34:42Z

Miawinator: Pagină nouă: Petrică, tânăr licean în clasa a IX-a, a primit în dar de la părinţii săi un cont bancar pentru micile sale cheltuieli curente. El este pasionat de Internet Banking şi îşi verifică cu grijă toate tranzacţiile efectuate. Pentru creşterea securităţii tranzacţiilor online, banca îi furnizează lui Petrică un număr pe care el va trebui să îl modifice, obţinând un număr <code>TAN</code> – număr de autentificare a tranzacţiei <code>(transaction authent...

Petrică, tânăr licean în clasa a IX-a, a primit în dar de la părinţii săi un cont bancar pentru micile sale cheltuieli curente. El este pasionat de Internet Banking şi îşi verifică cu grijă toate tranzacţiile efectuate. Pentru creşterea securităţii tranzacţiilor online, banca îi furnizează lui Petrică un număr pe care el va trebui să îl modifice, obţinând un număr <code>TAN</code> – număr de autentificare a tranzacţiei <code>(transaction authentication number)</code>. Regula de obţinere a numărului <code>TAN</code> este următoarea: se formează cel mai mic număr par din toate cifrele numărului furnizat de bancă.

= Cerința =
Cunoscând numărul <code>n</code> furnizat de bancă, să se determine numărul <code>TAN</code> obţinut de Petrică.

= Date de intrare =
Fişierul <code>input.txt</code> conţine pe prima linie numărul natural <code>n</code> cu semnificaţia din enunţ.

= Date de ieșire =
Fişierul de ieşire <code>output.txt</code> va conţine o singură linie pe care va fi scris numărul <code>TAN</code> cerut.

= Restricții și precizări =
• <code>0 < n < 18*10**18</code>

• numărul <code>TAN</code> obţinut nu poate conţine zerouri nesemnificative

== Exemplul 1 ==
input.txt:

520

output.txt:

250

Explicație:

Cel mai mic număr par format cu cifrele <code>5, 2, 0</code> este <code>250</code>.

== Exemplul 2 ==
input.txt:

9999999999999999999999999999999999999999999

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(1<=n<18*(10**18)):
print("Input-ul nu convine conditiilor")
exit()

with open("input.txt", "r") as cin, open("output.txt", "w") as cout:
n = int(cin.readline())
verificare(n)
fr = [0] * 10
x = 0
par = 0
cif_min = 10
pare = 0

while n:
fr[n % 10] += 1

if cif_min > n % 10 and n % 10:
cif_min = n % 10

if par < n % 10 and n % 10 % 2 == 0:
par = n % 10

if n % 10 % 2 == 0:
pare += 1

n //= 10

x = x * 10 + cif_min
fr[cif_min] -= 1

if cif_min % 2 == 0:
pare -= 1

if not pare:
x = 0
fr[cif_min] += 1

if cif_min == par and not fr[par]:
for i in range(0, 9, 2):
if fr[i]:
par = i
break

for i in range(10):
if i == par:
while fr[i] > 1:
x = x * 10 + i
fr[i] -= 1
else:
while fr[i]:
x = x * 10 + i
fr[i] -= 1

if fr[par]:
x = x * 10 + par

cout.write(str(x))

</syntaxhighlight>

2071 - Triunghiuri2

2024-01-04T23:28:58Z

Miawinator: Pagină nouă: Se consideră <code>N</code> puncte din plan, având coordonate numere naturale, relativ la un reper cartezian <code>XOY</code>, oricare două puncte fiind distincte. = Cerința = Cunoscând <code>N</code> și coordonatele celor <code>N</code> puncte, să se determine: 1) Numărul maxim de puncte care au aceeași abscisă. 2) Numărul triunghiurilor care se pot desena respectând următoarele condiții: * au toate vârfurile în puncte dintre cele date; * au o latură par...

Se consideră <code>N</code> puncte din plan, având coordonate numere naturale, relativ la un reper cartezian <code>XOY</code>, oricare două puncte fiind distincte.

= Cerința =
Cunoscând <code>N</code> și coordonatele celor <code>N</code> puncte, să se determine:

1) Numărul maxim de puncte care au aceeași abscisă.

2) Numărul triunghiurilor care se pot desena respectând următoarele condiții:

* au toate vârfurile în puncte dintre cele date;
* au o latură paralelă cu <code>OX</code>;
* nu au laturi paralele cu <code>OY</code>;

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie numărul <code>p</code>, care indică cerința ce trebuie rezolvată (<code>p</code> are valoarea <code>1</code> sau <code>2</code>). Pe a doua linie se află numărul natural <code>N</code>, reprezentând numărul punctelor date. Pe următoarele <code>N</code> linii se găsesc câte două valori naturale <code>x y</code>, separate prin câte un spațiu, reprezentând coordonatele punctelor date.

= Date de ieșire =
Fișierul <code>output.txt</code> va avea următoarea structură:

* Dacă <code>p = 1</code> se va scrie în fișier, pe prima linie, numărul maxim de puncte care au aceeași abscisă (cerința 1).
* Dacă <code>p = 2</code> se va scrie în fișier, pe prima linie, numărul triunghiurilor care se pot desena respectând condițiile date, <code>modulo 1.000.003</code>, adică restul împărțirii numărului de triunghiuri la <code>1 000 003</code> (cerința 2).

= Restricții și precizări =

* <code>3 ≤ N ≤ 100 000</code>

== Exemplul 1 ==
input.txt:

1

5

2 1

1 4

3 4

3 2

6 4

output.txt:

2

Explicație:

Se rezolvă cerința 1). Sunt maximum două puncte care au aceeași abscisă: <code>(3, 4)</code> și <code>(3,2)</code>.

== Exemplul 2 ==
input.txt:

2

5

2 1

1 4

3 4

3 2

6 4

output.txt:

4

Explicație:

Se rezolvă cerința 2). Se pot trasa <code>4</code> triunghiuri care satisfac cerințele. Dacă notăm cele <code>5</code> puncte din fișier cu <code>A</code>, <code>B</code>, <code>C</code>, <code>D</code>, <code>E</code> (ca în imagine), atunci, cele <code>4</code> triunghiuri care satisfac cerințele sunt : <code>ABC</code>, <code>ACE</code>, <code>ABE</code> și <code>BDE</code>.

== Exemplul 3 ==
input.txt:

2

9999999999999

2 1

1 4

3 4

3 2

6 4

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(3<=n<=100000):
print("Input-ul nu convine conditiilor")
exit()

# Define constants
Nmax = 100001 # numarul maxim de puncte
Cmax = 1001 # coordonata maxima
IN = "input.txt"
OU = "output.txt"

N = 0 # numarul punctelor
NrTr = 0 # numarul triunghiurilor gasite

nx = [0] * Cmax # nx[i] - cate puncte sunt pe absisa i
ny = [0] * Cmax # ny[i] - cate puncte sunt pe ordonata i
H = [[0] * Cmax for _ in range(Cmax)] # memorez punctele ordonate H[i] - lista punctelor cu ordonata i

# citire date
with open(IN, "r") as Fin:
V = int(Fin.readline())
N = int(Fin.readline())
verificare(N)
for i in range(Cmax):
nx[i] = ny[i] = 0
for _ in range(N):
x, y = map(int, Fin.readline().split())
nx[x] += 1
ny[y] += 1
H[y][ny[y]] = x

if V == 1:
Max = max(nx[:1000])
with open(OU, "w") as Fou:
Fou.write(f"{Max}\n")
else:
NrTr = 0
for i in range(Cmax - 1):
if ny[i] > 1:
sumLin = 0
for j in range(1, ny[i] + 1):
sumLin += (nx[H[i][j]] - 1) * (ny[i] - 1)
aux1 = (ny[i] * (ny[i] - 1) // 2)
aux2 = (N - ny[i])
aux = aux1 * aux2
NrTr += aux - sumLin
NrTr %= 1000003

with open(OU, "w") as Fou:
Fou.write(f"{NrTr}\n")

</syntaxhighlight>

1655 - Platou

2024-01-04T23:19:17Z

Miawinator: Pagină nouă: = Cerința = Fiind dat un şir de numere, denumim secvenţă a acestuia o parte dintre termenii şirului luaţi de pe poziţii consecutive. Denumim platou al acestui şir o secvenţă formată din valori identice. Lungimea unui platou este egală cu numărul de elemente care îl formează. De exemplu, în şirul de numere <code>1 1 1 7 7 3 4 4 4 7 7</code> avem: * platourile <code>1 1 1</code> şi <code>4 4 4</code> ambele având lungimea <code>3</code>; * platourile <code>...

= Cerința =
Fiind dat un şir de numere, denumim secvenţă a acestuia o parte dintre termenii şirului luaţi de pe poziţii consecutive. Denumim platou al acestui şir o secvenţă formată din valori identice. Lungimea unui platou este egală cu numărul de elemente care îl formează.

De exemplu, în şirul de numere <code>1 1 1 7 7 3 4 4 4 7 7</code> avem:

* platourile <code>1 1 1</code> şi <code>4 4 4</code> ambele având lungimea <code>3</code>;
* platourile <code>7 7</code> (cel care începe în poziţia a patra) şi <code>7 7</code> (cel care începe pe poziţia a zecea), ambele având lungimea <code>2</code>;
* platoul <code>3</code> care are lungimea <code>1</code>.

În schimb nu avem platoul <code>7 7 7 7</code> deoarece cele patru elemente egale cu <code>7</code> nu sunt pe poziţii consecutive!

Se dă un şir de n numere. Fiecare dintre aceste numere aparţine intervalului <code>[0,1000000]</code>. Asupra acestui şir se pot efectua o singură dată următoarele două operaţiuni în această ordine:

# se extrage un platou la alegere;
# se inserează platoul extras la pasul anterior într-o poziţie la alegere din şirul rezultat după extragere.

De exemplu, dacă avem următorul şir inițial: <code>2 2 5 0 5 8 8 8 4 9 9 9 0 0 2 2 8</code> extragem platoul <code>2 2</code> format din elementele aflate în penultima şi antepenultima poziţie şi obţinem şirul: <code>2 2 5 0 5 8 8 8 4 9 9 9 0 0 8</code>

În şirul rezultat inserăm platoul <code>2 2</code> (pe care l-am extras în pasul anterior) în poziţia a doua şi obţinem şirul: <code>2 2 2 2 5 0 5 8 8 8 4 9 9 9 0 0 8</code>

Să se scrie un program care pentru un şir dat determină:

# Lungimea maximă a unui platou din şirul dat iniţial precum şi valoarea cea mai mare a elementelor care formează un platou de lungime maximă.
# Lungimea maximă a unui platou care poate să apară în şir în urma efectuării celor două operaţiuni precum şi valoarea cea mai mare a elementelor care ar putea forma un astfel de platou.

= Date de intrare =
Fișierul de intrare <code>input.txt</code>conține:

* pe prima linie un număr natural <code>V</code> care poate avea valoarea <code>1</code> sau valoarea <code>2</code>;
* pe a doua linie un număr natual <code>n</code>;
* pe a treia linie un şir de <code>n</code> numere naturale separate prin câte un spaţiu, reprezentând elementele şirului dat. Fiecare dintre aceste numere aparţine intervalului <code>[0,1.000.000]</code>.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code>va conține:

* dacă <code>V=1</code>, atunci pe această linie se vor scrie cele două numere care reprezintă răspunsul la prima cerinţă.
* dacă <code>V=2</code>, atunci pe această linie se vor scrie cele două numere care reprezintă răspunsul la a doua cerinţă.

= Restricții și precizări =

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

== Exemplul 1 ==
input.txt:

1

16

2 2 5 0 5 8 8 8 4 9 9 9 0 8 2 2

output.txt:

3 9

Explicație:

<code>V=1</code>, deci se rezolvă NUMAI prima cerinţă. Lungimea maximă a unui platou din şirul dat este <code>3</code>. Sunt două astfel de platouri: <code>8 8 8</code> şi <code>9 9 9</code>. Valoarea cea mai mare din care este format unul dintre aceste platouri este <code>9</code>.

== Exemplul 2 ==
input.txt:

2

16

2 2 5 0 5 8 8 8 4 9 9 9 0 8 2 2

output.txt:

4 8

Explicație:

<code>V=2</code>, deci se rezolvă NUMAI a doua cerinţă. În urma executării celor două operațiuni pot să apară platouri de lungime maximă <code>4</code> în două moduri: <code>2 2 2 2</code> respectiv <code>8 8 8 8</code>.

Valoarea cea mai mare din care este format unul dintre aceste platouri este <code>8</code>.

== Exemplul 3 ==
input.txt:

2

999999999999999

2 2 5 0 5 8 8 8 4 9 9 9 0 8 2 2

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(1<=n<=1000000):
print("Input-ul nu convine conditiilor")
exit()

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:

v = int(fin.readline())
n = int(fin.readline())
verificare(n)

l=list(map(int, fin.readline().split()))

if v == 1:
x = l[0]
lcrt = 1
lmax = 1
valmax = x

for i in range(0,n - 1):
y = l[i]
if x == y:
lcrt += 1
else:
lcrt = 1

if lcrt > lmax:
lmax = lcrt
valmax = x
elif lmax == lcrt and x > valmax:
valmax = x

x = y

fout.write(f"{lmax} {valmax}\n")
else:
x = l[0]
lcrt = 1
max1 = [0] * 1000002
max2 = [0] * 1000002

for i in range(0,n - 1):
y = l[i]
if x == y:
lcrt += 1
else:
if lcrt >= max1[x]:
max2[x] = max1[x]
max1[x] = lcrt
elif lcrt > max2[x]:
max2[x] = lcrt
lcrt = 1

x = y

if lcrt >= max1[x]:
max2[x] = max1[x]
max1[x] = lcrt
elif lcrt > max2[x]:
max2[x] = lcrt

rezmax = 0
valmax = 0
for i in range(1000001, -1, -1):
if max1[i] + max2[i] > rezmax:
rezmax = max1[i] + max2[i]
valmax = i

fout.write(f"{rezmax} {valmax}\n")

</syntaxhighlight>

0147 - expresie1

2024-01-04T23:05:53Z

Miawinator: Pagină nouă: La ora de matematică Georgică a învăţat să evalueze expresii aritmetice. Pentru a verifica acest lucru profesorul de informatică îi propune lui Georgică să evalueze expresii aritmetice de forma: <code>A o1 B o2 C</code> Unde <code>A</code>, <code>B</code>, <code>C</code> sunt operanzi, iar <code>o1</code> şi <code>o2</code> sunt operatori. Valorile permise operanzilor pot fi numai termeni din şirul <code>x1</code>, <code>x2</code>, …, <code>xn</code>, iar...

La ora de matematică Georgică a învăţat să evalueze expresii aritmetice. Pentru a verifica acest lucru profesorul de informatică îi propune lui Georgică să evalueze expresii aritmetice de forma:

<code>A o1 B o2 C</code>

Unde <code>A</code>, <code>B</code>, <code>C</code> sunt operanzi, iar <code>o1</code> şi <code>o2</code> sunt operatori.

Valorile permise operanzilor pot fi numai termeni din şirul <code>x1</code>, <code>x2</code>, …, <code>xn</code>, iar operatorii pot fi numai caracterele <code>+</code> (adunare) şi <code>*</code> (înmulţire).

Profesorul îi pune la dispoziție lui Georgică o valoare numerică <code>V</code> şi îi cere să determine valorile operanzilor <code>A</code>, <code>B</code> şi <code>C</code> pentru care expresia are valoarea <code>V</code>.

= Cerinţă =
Scrieţi un program, care pentru <code>V</code>, <code>n</code>, <code>x1</code>, <code>x2</code>, …, <code>xn</code> şi <code>o1</code>, <code>o2</code> date, determină indicii corespunzători termenilor din şirul <code>x1</code>, <code>x2</code>, …, <code>xn</code> ce corespund valorilor operanzilor <code>A</code>, <code>B</code> şi <code>C</code> pentru ca expresia dată să aibă valoarea <code>V</code>.

= Date de intrare =
Fişierul de intrare <code>input.txt</code> conţine pe prima linie numerele naturale <code>V</code>, <code>n</code>, <code>x1</code>, <code>x2</code>, …, <code>xn</code> separate între ele printr-un spaţiu şi pe linia a doua exact două caractere asociate operatorilor <code>o1</code> şi <code>o2</code>.

= Date de ieşire =
Fişierul de ieşire <code>output.txt</code> va conţine, pe prima linie separate între ele exact trei indici ai şirului <code>x1</code>, <code>x2</code>, …, <code>xn</code> corespunzători termenilor folosiţi pentru <code>A</code>, <code>B</code>, <code>C</code>. Dacă nu există soluţie se va scrie în fişier cifra <code>0</code> de trei ori separată prin câte un spaţiu: <code>0 0 0</code>.

= Restricţii şi precizări =

* <code>0 < n < 10001</code>

== Exemplul 1 ==
input.txt:

100 5 40 13 2 11 20

+*

output.txt:

5 3 1

Explicație:

<code>A = x5</code>, <code>B = x3</code>, <code>C = x1</code>

Expresia devine <code>20 + 2 * 40 = 100</code>

== Exemplul 2 ==
input.txt:

100 9999999999999 40 13 2 11 20

+*

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(1<=n<=10000):
print("Input-ul nu convine conditiilor")
exit()

def cit():
global V, n, f, o1, o2
with open("input.txt", "r") as fin:
l=list(map(int, fin.readline().split()))
V = l[0]
n = l[1]
verificare(n)
f = [0] * 1005
for i in range(1, n + 1):
k = l[i+1]
f[k] = i
l=fin.readline()
o1 = l[0]
o2 = l[1]

def evalexp(A, B):
global V, o1, o2
if o1 == '+':
if o2 == '+':
t = V - (A + B)
else:
t = (V - A) / B
else:
if o2 == '+':
t = V - A * B
else:
t = V / (A * B)
if t > 0 and t == int(t):
return int(t)
return -1

def rezolva():
global f
for iA in range(1001):
if f[iA] > 0:
for iB in range(1001):
if f[iB] > 0:
iC = evalexp(iA, iB)
if 0 <= iC < 1001 and f[iC] > 0:
with open("output.txt", "w") as fout:
fout.write(f"{f[iA]} {f[iB]} {f[iC]}")
return 1
return 0

def main():
cit()
if rezolva() == 0:
with open("output.txt", "w") as fout:
fout.write("0 0 0")

if __name__ == "__main__":
main()

</syntaxhighlight>

0610 - Spion

2024-01-04T22:49:36Z

Miawinator: Pagină nouă: Într-un loc îndepărtat amplasat strategic, se află mai mulţi soldați identificaţi prin numere naturale nenule unice. Ordinea și disciplina militară impun aşezarea soldaților în linie la apelul de dimineață. Fiecare soldat a primit la sosirea în unitate numărul său și numerele de identificare ale camarazilor care trebuie să fie în stânga și în dreapta sa la aliniere. Excepţie fac doi soldaţi santinele care primesc doar numărul propriu de identificare...

Într-un loc îndepărtat amplasat strategic, se află mai mulţi soldați identificaţi prin numere naturale nenule unice. Ordinea și disciplina militară impun aşezarea soldaților în linie la apelul de dimineață. Fiecare soldat a primit la sosirea în unitate numărul său și numerele de identificare ale camarazilor care trebuie să fie în stânga și în dreapta sa la aliniere. Excepţie fac doi soldaţi santinele care primesc doar numărul propriu de identificare şi se vor aşeza pe prima, respectiv pe ultima poziţie din linie. Uneori, unii soldaţi sunt plecați în misiuni, iar apelul de dimineaţă în unitate se face astfel: fiecare dintre cei prezenţi strigă cele trei numere primite – numărul lui, numărul camaradului din stânga lui şi al camaradului din dreapta lui, chiar dacă aceștia lipsesc.

Ei nu ştiu însă că, după un zid, stă pitită spioana Bulbuka, trimisă în recunoaștere. Ea îi ascultă şi înregistrează toate tripletele de numere care sunt strigate. După cele trei numere strigate de fiecare soldat, Bulbuka, fiind foarte inteligentă, deduce corect câte grupuri de soldaţi care și-au strigat prezența sunt până în momentul respectiv. Ea consideră că un grup este format din toţi acei soldaţi care şi-au strigat propriul număr şi care sunt aşezaţi unul lângă celălalt (dacă un soldat a strigat numărul camaradului, acesta din urmă nu este inclus în grup decât dacă a strigat şi el propriul număr).

= Cerința =
Aflați care sunt numerele de grupuri de soldați deduse de Bulbuka în fiecare moment.

= Date de intrare =
Pe prima linie a fişierului <code>input.txt</code> se află <code>N</code>, numărul de soldaţi ce îşi vor striga prezența. Pe următoarele <code>N</code> linii se află câte <code>3</code> numere <code>x[i]</code>, <code>s[i]</code> și <code>d[i]</code>, separate prin câte un spaţiu, reprezentând tripletele pe care le strigă fiecare soldat (<code>x[i]</code> numărul soldatului, <code>s[i]</code> numărul camaradului din stânga lui şi <code>d[i]</code> numărul camaradului din dreapta lui).

= Date de ieșire =
Fişierul de ieşire <code>output.txt</code> va conţine <code>N</code> linii. Pe fiecare dintre cele <code>N</code> linii se va scrie numărul de grupuri dedus de Bulbuka la momentul respectiv.

= Restricții și precizări =

* <code>1 < N < 500000</code>

== Exemplul 1 ==
input.txt:

6

9 2 3

8 5 4

5 3 8

7 1 2

2 7 9

3 9 5

output.txt:

1

2

2

3

2

1

Explicație:

Prima dată strigă soldatul <code>9</code> care e notat prezent, deci primul grup este format doar din el. Camarazii <code>2</code> și <code>3</code> ar trebui să fie în stânga și dreapta lui dar nu și-au strigat prezența încă. În consecință, nu fac parte în acest moment din grupul lui <code>9</code>.

Strigă soldatul <code>8</code>, se formează două grupuri: <code>{9}</code> și <code>{8}</code>.

Strigă <code>5</code>, el va intra în grupul lui <code>8</code>, deci vor fi tot două grupuri: <code>{9}</code> și <code>{8,5}</code>.

Strigă <code>7</code>, dar pentru că cei doi camarazi nu s-au strigat încă prezenţi, <code>7</code> va forma un grup singur. Vor fi acum trei grupuri: <code>{7}</code>, <code>{9}</code> și @{8,5} etc.

== Exemplul 2 ==
input.txt:

9999999999

9 2 3

8 5 4

5 3 8

7 1 2

2 7 9

3 9 5

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
NMAX = 1600000

def verificare(n):
if not(2<=n<500000):
print("Input-ul nu convine conditiilor")
exit()

n = 0
grupuri = 0

soldati = [0] * ((NMAX + 31) // 32)

def bindex(b):
return b // 32

def boffset(b):
return b % 32

def set_bit(b):
soldati[bindex(b)] |= 1 << boffset(b)

def get_bit(b):
return (soldati[bindex(b)] & (1 << boffset(b))) != 0

with open("input.txt", "rt") as infile, open("output.txt", "wt") as outfile:
n = int(infile.readline())
verificare(n)
for _ in range(n):
x, s, d = map(int, infile.readline().split())

prezenta = get_bit(s) + get_bit(d)
grupuri += 1 - prezenta

outfile.write(f"{grupuri}\n")

set_bit(x)

</syntaxhighlight>

1612 - Cifre10

2024-01-04T22:33:20Z

Miawinator: Pagină nouă: Elevii clasei pregătitoare se joacă la matematică cu numere. Învățătoarea are un săculeț plin cu jetoane, pe fiecare dintre ele fiind scrisă câte o cifră. Fiecare elev și-a ales din săculeț mai multe jetoane, cu care și-a format un număr. Pentru ca totul să fie mai interesant, elevii s-au grupat în perechi. Doamna învățătoare a oferit fiecărei perechi de elevi câte o cutiuță pentru ca cei doi să își pună împreună jetoanele. De exemplu, dacă u...

Elevii clasei pregătitoare se joacă la matematică cu numere. Învățătoarea are un săculeț plin cu jetoane, pe fiecare dintre ele fiind scrisă câte o cifră. Fiecare elev și-a ales din săculeț mai multe jetoane, cu care și-a format un număr. Pentru ca totul să fie mai interesant, elevii s-au grupat în perechi. Doamna învățătoare a oferit fiecărei perechi de elevi câte o cutiuță pentru ca cei doi să își pună împreună jetoanele. De exemplu, dacă unul din elevii unei echipe și-a ales jetoane cu care a format numărul <code>5137131</code> iar celălalt elev și-a ales jetoane cu care a format numărul <code>6551813</code>, atunci cutiuța echipei va conţine <code>5</code> jetoane cu cifra <code>1</code>, câte <code>3</code> jetoane cu cifra <code>3</code> şi <code>5</code> şi câte un jeton cu cifrele <code>6</code>, <code>7</code> şi <code>8</code>.

Doar Andrei stătea supărat pentru că numărul de elevi al clasei era impar iar el nu avea partener, motiv pentru care nu și-a mai ales jetoane. Din această cauză, doamna învățătoare i-a spus:

“- Alege o echipă din a cărei cutiuță poţi lua o parte din jetoane, dar ai grijă ca fiecare dintre cei doi elevi să-și mai poată forma numărul lui din jetoanele rămase, iar tu să poți forma un număr nenul cu jetoanele extrase!“.

Dar cum Andrei nu se mulţumea cu puţin, a vrut să aleagă acea echipă din a cărei cutiuță îşi poată forma un număr de valoare maximă folosind jetoanele extrase.

= Cerința =
Scrieţi un program care să citească numărul <code>N</code> de cutiuțe și numerele formate de elevii fiecărei perechi și care să determine:

1) Numărul de cutiuțe din care Andrei poate lua jetoane respectând condiția pusă de doamna învățătoare;

2) Care este cel mai mare număr nenul pe care îl poate forma Andrei respectând aceeași condiție.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie numărul natural <code>P</code> reprezentând cerința din problemă care trebuie rezolvată. Pe a doua linie numărul natural <code>N</code>, iar pe următoarele <code>N</code> linii câte două numere naturale separate printr-un spațiu reprezentând numerele formate de elevii fiecărei perechi.

= Date de ieșire =

* Dacă valoarea lui <code>P</code> este <code>1</code>, fişierul de ieşire <code>output.txt</code> va conţine pe prima linie un număr natural reprezentând rezolvarea primei cerințe, adică numărul de cutiuțe din care Andrei poate lua jetoane.
* Dacă valoarea lui <code>P</code> este <code>2</code>, fişierul de ieşire <code>output.txt</code> va conţine pe prima linie un număr natural reprezentând rezolvarea celei de a doua cerințe, adică numărul maxim pe care îl poate forma Andrei.

= Restricții și precizări =

* <code>0 < N ≤ 10000</code>

== Exemplul 1 ==
input.txt:

1

3

1010 2000

12 34

1515 552

output.txt:

1

Explicație:

Cu jetoanele extrase din prima cutiuță Andrei nu poate forma un număr diferit de <code>0</code>. Din a doua cutiuță Andrei nu poate lua jetoane astfel încât cei doi elevi să își mai poată forma numerele <code>12</code> și <code>34</code>.

Andrei poate extrage jetoane doar din a treia cutiuță(două jetoane cu cifra <code>5</code>).

== Exemplul 2 ==
input.txt:

2

5

16815 38861

12 385

5137131 6551813

15033 11583

4704 240

output.txt:

5311

Explicație:

Numărul maxim pe care Andrei îl poate forma este <code>5311</code> și se obține din cutiuța a treia.

== Exemplul 3 ==
input.txt:

2

99999999999999

16815 38861

12 385

5137131 6551813

15033 11583

4704 240

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(1<=n<=1000):
print("Input-ul nu convine conditiilor")
exit()

with open("input.txt", "r") as f, open("output.txt", "w") as g:
a = [0] * 10
b = [0] * 10
n, i, x, y, j, k, p, cod, cate, maxim, minim = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

p = int(f.readline())
n = int(f.readline())
verificare(n)

for i in range(1, n + 1):
x, y = map(int, f.readline().split())

a = [0] * 10
b = [0] * 10

while x:
a[x % 10] += 1
x = x // 10

while y:
b[y % 10] += 1
y = y // 10

cod = 0
for j in range(9, -1, -1):
if a[j] > 0 and b[j] > 0:
minim = min(a[j], b[j])
for k in range(1, minim + 1):
cod = cod * 10 + j

if cod:
cate += 1

if cod > maxim:
maxim = cod

if p == 1:
g.write(f"{cate}")
else:
g.write(f"{maxim}")

</syntaxhighlight>

1061 - Cifru1

2024-01-04T22:26:36Z

Miawinator: Pagină nouă: Costel a descoperit într-o debara servieta cu cifru a tatălui său. Cifrul este compus din <code>4</code> discuri metalice pe care sunt inscripţionate cifrele de la <code>0</code> la <code>9</code>. Fiecare disc se poate mişca individual, de sus în jos sau de jos în sus, formându-se combinaţii de cifre. De multe ori, datorită comodităţii, combinaţia ce permite deschiderea servietei este formată numai din cifre identice: <code>0000</code>, <code>1111</code> etc....

Costel a descoperit într-o debara servieta cu cifru a tatălui său. Cifrul este compus din <code>4</code> discuri metalice pe care sunt inscripţionate cifrele de la <code>0</code> la <code>9</code>. Fiecare disc se poate mişca individual, de sus în jos sau de jos în sus, formându-se combinaţii de cifre. De multe ori, datorită comodităţii, combinaţia ce permite deschiderea servietei este formată numai din cifre identice: <code>0000</code>, <code>1111</code> etc.

Costel îşi imaginează un cifru compus din <code>N</code> discuri metalice, fiecare având inscripţionate cifrele de la <code>0</code> la <code>9</code>, fiecare putând fi deplasat în cele două direcţii specificate anterior. Prin mutare Costel înţelege deplasarea unui disc în sus sau în jos, cu o singură poziţie, adică deplasarea discului până la cifra precedentă, respectiv următoare celei curente.

= Cerința =
Realizaţi un program care, cunoscând poziţia iniţială a fiecărui disc dintre cele <code>N</code> discuri ale cifrului, determină şi afişează:

a) cifra cea mai mare care apare pe discurile cifrului în forma iniţială;

b)

b1) numărul minim de mutări necesare pentru ca numărul obţinut pe cifru să fie compus numai din cifre identice, număr necesar deschiderii servietei;

b2) cifra cea mai mică ce se poate obţine în urma efectuării numărului minim de mutări determinat;

b3) numărul de combinaţii formate din cifre identice, care se poate obţine în urma efectuării numărului minim de mutări determinat.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține:

* pe prima linie numărul natural <code>N</code> reprezentând numărul discurilor;
* pe următoarele <code>N</code> linii câte o cifră, reprezentând cifra curentă de pe fiecare disc al cifrului.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține, pe linii separate, cele <code>4</code> valori solicitate.

= Restricții și precizări =

* <code>1 < N ≤ 100 000</code>
* Un disc poate să rămână nemişcat.

== Exemplul 1 ==
input.txt:

4

7

3

9

0

output.txt:

9

7

0

2

Explicație:

Avem un cifru cu <code>4</code> discuri. Iniţial, cifrul este în starea <code>7390</code> (primul disc este poziţionat pe cifra <code>7</code>, al doilea pe cifra <code>3</code> etc.)

Cea mai mare cifră de pe cifru este cifra <code>9</code>.

Numărul minim de mutări este <code>7</code> şi se poate obţine în două moduri:

# Deplasăm primul disc cu <code>2</code> poziţii în sus, al doilea disc cu <code>4</code> poziţii în jos, al treilea rămâne nemişcat, iar ultimul se deplasează cu o poziţie în jos. Combinaţia obţinută este <code>9999</code>.
# Deplasăm primul disc cu <code>3</code> poziţii în sus, al doilea disc cu <code>3</code> poziţii în jos, al treilea cu o poziţie în sus, iar ultimul rămâne nemişcat. Combinaţia obţinută este <code>0000</code>.

Astfel, cifra cea mai mică ce formează combinaţia cu număr minim de mutări este <code>0</code>. Avem <code>2</code> combinaţii care se pot obţine în numărul minim de mutări determinat: <code>0000</code> şi <code>9999</code>.

== Exemplul 2 ==
input.txt:

99999999999999

7

3

9

0

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(1<=n<=100000):
print("Input-ul nu convine conditiilor")
exit()

Fin = "input.txt"
Fou = "output.txt"

with open(Fin, "r") as IN, open(Fou, "w") as OUT:
N = int(IN.readline())
verificare(N)
Apar = [0] * 10 # Apar[i] = 1 if color i appears on at least one disc
MAX = 0 # maximum digit
NrMin = 10 * N + 1 # minimum number of moves
Cif = -1 # digit obtained in the minimum number of moves
Cate = 0 # number of possibilities

# initialize
for i in range(10):
Apar[i] = 0

# read input data and determine initially appearing digits and maximum digit
for i in range(1, N + 1):
x = int(IN.readline())
Apar[x] += 1
if MAX < x:
MAX = x

# calculate the number of moves for each appearing digit
for i in range(10):
Nr = 0
for j in range(10):
if Apar[j] and j != i:
Nr += min(abs(j - i), 10 - abs(j - i)) * Apar[j]

if Nr < NrMin:
NrMin = Nr
Cif = i
Cate = 1
elif Nr == NrMin:
Cate += 1

OUT.write(f"{MAX}\n{NrMin}\n{Cif}\n{Cate}\n")

</syntaxhighlight>

1217 - LightBot

2024-01-04T22:21:26Z

Miawinator: Pagină nouă: În acest an evenimentul ”Hour of Code” a înregistrat un număr record de participanți din țara noastră. În cadrul acestui eveniment una dintre cele mai accesate aplicații a fost Lightbot, care a permis elevilor să-și testeze abilitățile de programare. Aplicația Lightbot are <code>N</code> nivele, numerotate consecutiv de la <code>1</code> la <code>N</code>, în ordinea strict crescătoare a complexității lor. Lightbot a permis fiecărui participant să înc...

În acest an evenimentul ”Hour of Code” a înregistrat un număr record de participanți din țara noastră. În cadrul acestui eveniment una dintre cele mai accesate aplicații a fost Lightbot, care a permis elevilor să-și testeze abilitățile de programare.

Aplicația Lightbot are <code>N</code> nivele, numerotate consecutiv de la <code>1</code> la <code>N</code>, în ordinea strict crescătoare a complexității lor. Lightbot a permis fiecărui participant să înceapă cu orice nivel strict mai mic decât <code>N-1</code> și să sară peste un singur nivel, fără a finaliza codul, trecând la nivelul următor celui sărit. La finalizarea cu succes a codului corespunzător nivelului curent, participantul este promovat la nivelul imediat următor. Fiecare participant a început scrierea codurilor la un nivel <code>P</code> și a sărit peste un nivel <code>L</code> (<code>P < L < P + K</code>), finalizând <code>K</code> nivele memorate ca o succesiune de numere naturale de forma <code>P, P+1,..., L-1, L+1,..., P+K</code>. Succesiunile de nivele finalizate de participanți au fost memorate în fișierul <code>input.txt</code>. Succesiunile corespunzătoare participanților nu se intercalează în fișier.

Scrieţi un program care citeşte succesiunile corespunzătoare nivelelor finalizate de participanții care au jucat Lightbot și determină:

1. numărul total de participanți;

2. numărul celui mai dificil nivel care a fost rezolvat de un număr maxim de participanți;

3. pentru fiecare participant, numărul nivelului sărit de acesta.

= Date de intrare =
Fişierul de intrare <code>input.txt</code> conţine pe prima linie una dintre valorile <code>1</code> , <code>2</code> sau <code>3</code>, reprezentând cerinţa 1 dacă se cere determinarea numărului total de participanți, cerinţa 2 dacă se cere determinarea numărului celui mai dificil nivel care a fost rezolvat de un număr maxim de participanți, respectiv cerinţa 3, dacă se cere determinarea, pentru fiecare participant, a numărului nivelului sărit de acesta.

A doua linie a fișierului conține numărul natural <code>N</code> de nivele corespunzător aplicației Lightbot, iar pe a treia linie, succesiunile de numere naturale nenule corespunzătoare nivelelor finalizate de participanți, separate două câte două prin câte un spaţiu.

= Date de ieșire =
Fişierul de ieşire <code>output.txt</code> va conţine pe prima linie un număr natural <code>M</code>, reprezentând numărul total de participanți dacă cerința a fost 1, un număr natural reprezentând numărul celui mai dificil nivel care a fost rezolvat de un număr maxim de participanți, dacă cerința a fost 2, respectiv, o secvență de <code>M</code> numere naturale separate prin câte un spațiu ce reprezintă nivele sărite de participanți în ordinea succesiunilor memorate în fișier, dacă cerința a fost 3.

= Restricții și precizări =

* <code>3 ≤ N ≤ 200000</code>.

== Exemplul 1 ==
input.txt:

1

10

1 2 4 2 4 6 7 9

output.txt:

3

Explicație:

Sunt trei participanți, care au finalizat nivelele: <code>1 2 4</code> (primul), <code>2 4</code> (al doilea) şi <code>6 7 9</code> (al treilea).

== Exemplul 2 ==
input.txt:

2

10

1 2 4 2 4 6 7 9

output.txt:

4

Explicație:

Nivele <code>2</code> și <code>4</code> au fost finalizate de câte doi participanți, cel mai greu fiind nivelul <code>4</code>.

== Exemplul 3 ==
input.txt:

3

10

1 2 4 2 4 6 7 9

output.txt:

3 3 8

Explicație:

Primul participant a sărit nivelul <code>3</code>, al doilea nivelul <code>3</code>, iar al treilea nivelul <code>8</code>.

== Exemplul 4 ==
input.txt:

99999999999999

10

1 2 4 2 4 6 7 9

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(3<=n<=200000):
print("Input-ul nu convine conditiilor")
exit()

with open("input.txt", "r") as f, open("output.txt", "w") as g:
n, fr, P, np, cer = [0] * 200010, [0] * 200010, [0] * 200010, 0, 0
a, b, l, maxim, nm, i = 0, 0, 0, 0, 0, 0

cer = int(f.readline())
n = int(f.readline())
verificare(n)
a = int(f.readline(1))
fr[a] += 1
maxim = 1
nm = a
np = 0

for line in f:
for b in map(int, line.split()):
fr[b] += 1

if fr[b] > maxim:
maxim = fr[b]
nm = b
elif fr[b] == maxim and b > nm:
nm = b

if l == 0 and b - a == 2:
l = b - 1
elif b - a != 1:
np += 1
P[np] = l
l = 0

a = b

np += 1
P[np] = l

if cer == 1:
g.write(f"{np}\n")
elif cer == 2:
g.write(f"{nm}\n")
else:
for i in range(1, np):
g.write(f"{P[i]} ")
g.write(f"{P[np]}\n")

</syntaxhighlight>

1145 - Extraprime

2024-01-04T22:13:06Z

Miawinator: Pagină nouă: Gigel, mare amator de probleme de matematică şi informatică, a observat că unele numere prime au o proprietate interesantă: orice cifră ar elimina dintr-un astfel de număr, numărul obţinut este tot număr prim. A numit astfel de numere numere extraprime. De exemplu, numărul <code>317</code> este un număr extraprim: el este număr prim şi, în plus, dacă eliminăm cifra <code>3</code>, obţinem <code>17</code>, care este prim; dacă eliminăm <code>1</code>, obţi...

Gigel, mare amator de probleme de matematică şi informatică, a observat că unele numere prime au o proprietate interesantă: orice cifră ar elimina dintr-un astfel de număr, numărul obţinut este tot număr prim. A numit astfel de numere numere extraprime. De exemplu, numărul <code>317</code> este un număr extraprim: el este număr prim şi, în plus, dacă eliminăm cifra <code>3</code>, obţinem <code>17</code>, care este prim; dacă eliminăm <code>1</code>, obţinem <code>37</code>, care este prim; dacă eliminăm <code>7</code>, obţinem <code>31</code>, care este şi el număr prim.

= Cerință =
Spunem că <code>x</code> este între <code>a</code> şi <code>b</code> dacă <code>x≥a</code> şi <code>x≤b</code>. Fiind date două valori naturale <code>a</code> şi <code>b</code>, să se determine câte numere extraprime există între <code>a</code> şi <code>b</code>, precum şi cel mai mic şi cel mai mare număr extraprim dintre <code>a</code> şi <code>b</code>.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie cele două valori naturale <code>a</code> şi <code>b</code>, separate printr-un spaţiu.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține <code>3</code> linii. Pe prima linie se va scrie un număr natural <code>nr</code> reprezentând numărul de numere extraprime dintre <code>a</code> şi <code>b</code>. Pe linia a doua a fişierului de ieşire se va scrie cel mai mic număr extraprim dintre <code>a</code> şi <code>b</code>, iar pe linia a treia a fişierului de ieşire se va scrie cel mai mare număr extraprim dintre <code>a</code> şi <code>b</code>.

= Restricții și precizări =

* <code>10 < a ≤ b < 10000000</code>;
* Numărul <code>1</code> nu este prim;
* Pentru datele de test există întotdeauna soluţie;

== Exemplul 1 ==
input.txt:

10 100

output.txt:

4

23

73

Explicație:

Se află <code>4</code> numere extraprime mai mari decât <code>10</code> şi mai mici decât <code>100</code>: <code>23</code>, <code>37</code>, <code>53</code> şi <code>73</code>.

== Exemplul 2 ==
input.txt:

99999999999999999999 1

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
from math import log10

def verificare(a, b):
if not(10<=a<=10000000):
print("Input-ul nu convine conditiilor")
exit()
if not(10<=b<=10000000):
print("Input-ul nu convine conditiilor")
exit()

N = 10000000
e = [0] * (N + 1)
fr = [0] * (N + 1)
a, b, t, maxi, mini = 0, 0, 0, -1, N

def ciur():
e[0] = e[1] = 1

for i in range(2, N + 1):
if not e[i]:
for j in range(i * 2, N + 1, i):
e[j] = 1

def eliminare(x):
pow10, get, k = 1, 0, 0

if e[x]:
return 0

while pow10 <= x:
get = x % pow10
k = x // pow10 // 10
k = k * pow10 + get

if e[k]:
return 0

pow10 *= 10

return 1

ciur()

# Reading input from a file
with open("input.txt", "r") as infile:
a, b = map(int, infile.readline().split())
verificare(a,b)

# Writing output to a file
with open("output.txt", "w") as outfile:
for i in range(a, b + 1):
r = eliminare(i)
t += r

if r == 1:
maxi = max(maxi, i)
mini = min(mini, i)

outfile.write(f"{t}\n{mini}\n{maxi}\n")

</syntaxhighlight>

4251 - numereOJI

2024-01-04T22:07:31Z

Miawinator: Pagină nouă: Gigel este un mare pasionat al cifrelor. Orice moment liber şi-l petrece jucându-se cu numere. Jucându-se astfel, într-o zi a scris pe hârtie <code>10</code> numere distincte de câte două cifre şi a observat că printre acestea există două submulţimi disjuncte de sumă egală. Desigur, Gigel a crezut că este o întâmplare şi a scris alte <code>10</code> numere distincte de câte două cifre şi spre surpriza lui, după un timp a găsit din nou două submulţimi...

Gigel este un mare pasionat al cifrelor. Orice moment liber şi-l petrece jucându-se cu numere. Jucându-se astfel, într-o zi a scris pe hârtie <code>10</code> numere distincte de câte două cifre şi a observat că printre acestea există două submulţimi disjuncte de sumă egală. Desigur, Gigel a crezut că este o întâmplare şi a scris alte <code>10</code> numere distincte de câte două cifre şi spre surpriza lui, după un timp a găsit din nou două submulţimi disjuncte de sumă egală.

= Cerința =
Date <code>10</code> numere distincte de câte două cifre, determinaţi numărul de perechi de submulţimi disjuncte de sumă egală care se pot forma cu numere din cele date, precum şi una dintre aceste perechi pentru care suma numerelor din fiecare dintre cele două submulţimi este maximă.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie 10 numere naturale distincte separate prin câte un spaţiu <code>x1 x2 ... x10</code>.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține trei linii. Pe prima linie se află numărul de perechi de submulţimi de sumă egală, precum şi suma maximă obţinută, separate printr-un spaţiu. Pe linia a doua se află elementele primei submulţimi, iar pe linia a treia se află elementele celei de a doua submulţimi, separate prin câte un spaţiu:

* <code>NrSol Smax</code>, unde <code>NrSol</code> – numărul de perechi; <code>Smax</code> – suma maximă
* <code>x1 ... xk</code> – elementele primei submulţimi
* <code>y1 ... yp</code> - elementele celei de a doua submulţimi

= Restricții și precizări =

* Ordinea submulţimilor în perechi nu contează.
* Perechea de submulţimi determinată nu este obligatoriu unică.

== Exemplul 1 ==
input.txt:

60 49 86 78 23 97 69 71 32 10

output.txt:

65 276

60 49 86 71 10

78 97 69 32

Explicație:

Sunt <code>65</code> de soluţii; suma maximă este <code>276</code>, s-au folosit <code>9</code> din cele <code>10</code> numere; prima submulţime are <code>4</code> elemente, a doua are <code>5</code> elemente.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
n = 10
v = [0] * 12
a = [0] * 12
sol = [0] * 12

i, s1, s2, nrSubm, smax = 0, 0, 0, 0, 0

l=list(map(int, fin.readline().split()))

for i in range(1, n + 1):
v[i] = l[i-1]

while a[0] == 0:
# Calculating sums
s1, s2 = 0, 0
for i in range(1, n + 1):
if a[i] == 1:
s1 += v[i]
elif a[i] == 2:
s2 += v[i]

if s1 == s2:
nrSubm += 1
if s1 > smax:
smax = s1
sol = a[:]

# Generating the next sequence of 0, 1, 2
i = n
while a[i] == 2:
a[i] = 0
i -= 1
a[i] += 1

nrSubm //= 2

fout.write(f"{nrSubm} {smax}\n")

for i in range(1, n + 1):
if sol[i] == 1:
fout.write(f"{v[i]} ")

fout.write("\n")

for i in range(1, n + 1):
if sol[i] == 2:
fout.write(f"{v[i]} ")

fout.write("\n")

</syntaxhighlight>

0955 - Miny

2024-01-04T22:00:14Z

Miawinator: Pagină nouă: Fie <code>N</code> un număr natural nenul şi <code>N</code> numere naturale nenule: <code>x1</code>, <code>x2</code>,…, <code>xN</code>. Fie <code>P</code> produsul acestor N numere, <code>P=x1•x2•...•xN</code>. = Cerinţe = Scrieţi un program care să citească numerele <code>N</code>, <code>x1</code>, <code>x2</code>,…, <code>xN</code> şi apoi să determine: a) cifra zecilor produsului <code>P</code>; b) cel mai mic număr natural <code>Y</code>, pentru ca...

Fie <code>N</code> un număr natural nenul şi <code>N</code> numere naturale nenule: <code>x1</code>, <code>x2</code>,…, <code>xN</code>.

Fie <code>P</code> produsul acestor N numere, <code>P=x1•x2•...•xN</code>.

= Cerinţe =
Scrieţi un program care să citească numerele <code>N</code>, <code>x1</code>, <code>x2</code>,…, <code>xN</code> şi apoi să determine:

a) cifra zecilor produsului <code>P</code>;

b) cel mai mic număr natural <code>Y</code>, pentru care există numărul natural <code>K</code> astfel încât <code>YK=P</code>.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conţine două linii. Pe prima linie este scris numărul natural <code>N</code>. Pe următoarea linie sunt scrise cele <code>N</code> numere naturale <code>x1</code>, <code>x2</code>,…, <code>xN</code>, separate prin câte un spaţiu.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține:

* pe prima linie o cifră reprezentând cifra zecilor produsului <code>P</code>;
* pe a doua linie numărul natural M de factori primi din descompunerea în factori primi a numărului <code>Y</code>;
* pe fiecare dintre următoarele <code>M</code> linii (câte o linie pentru fiecare factor prim din descompunere) câte două valori <code>F</code> şi <code>E</code>, separate printr-un singur spaţiu, <code>F</code> reprezentând factorul prim iar <code>E</code> exponentul acestui factor din descompunerea în factori primi a lui <code>Y</code>; scrierea în fişier a acestor factori primi se va face în ordinea crescătoare a valorii lor.

= Restricții și precizări =

* <code>2 ≤ N ≤ 50000</code>

== Exemplul 1 ==
input.txt:

6

12 5 60 25 4 36

output.txt:

0

3

2 2

3 1

5 1

Explicație:

Produsul celor <code>6</code> numere este: <code>P=12∙5∙60∙25∙4∙36=12960000</code>.

Cifra zecilor lui P este <code>0</code>.

Se observă că există <code>3</code> valori posibile pentru <code>Y</code>: <code>12960000</code>, <code>3600</code> şi <code>60</code> deoarece: <code>129600001=12960000</code>, <code>36002=12960000</code>, <code>604=12960000</code>.

Cea mai mică valoare dintre aceste valori este <code>60</code>, astfel <code>Y=60=(2**2)*3*5</code>.

== Exemplul 2 ==
input.txt:

3

2 5 7

output.txt:

7

3

2 1

5 1

7 1

Explicație:

Produsul celor <code>3</code> numere este: <code>P=2∙5∙7=70</code>. Cifra zecilor lui P este <code>7</code>. Există o singură valoare posibilă pentru <code>Y</code>: <code>70</code>.

== Exemplul 3 ==
input.txt:

999999999999

2 5 7

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(2<=n<=5000):
print("Input-ul nu convine conditiilor")
exit()

def cmmdc(a, b):
while a and b:
if a > b:
a = a % b
else:
b = b % a
return a + b

n = 10000
v = [0] * (n + 1)
fr = [0] * (n + 1)
w = [0] * (n + 1)

# determinare numere prime <=10000 - Ciurul lui Eratostene
v[2] = 1
for i in range(3, n + 1, 2):
v[i] = 1

for i in range(3, n + 1, 2):
if v[i] != 0:
for j in range(2 * i, n + 1, i):
v[j] = 0

with open("input.txt", "r") as f, open("output.txt", "w") as g:
N = int(f.readline())
verificare(N)
l=list(map(int, f.readline().split()))
p = 1
for i in range(N):
x = l[i]
fr[x] += 1
p = (p * x) % 100

for i in range(2, n + 1):
if fr[i]:
if v[i]:
w[i] += fr[i]
else:
x = i
for j in range(2, n + 1):
while v[j] and (x % j == 0) and x > 1:
w[j] += fr[i]
x //= j

M = 0
d = 0
for i in range(2, n + 1):
if w[i]:
M += 1
d = cmmdc(d, w[i])

g.write(f"{p // 10}\n{M}\n")
for i in range(2, n + 1):
if w[i]:
g.write(f"{i} {w[i] // d}\n")

</syntaxhighlight>

1639 - Secvente 3

2024-01-04T21:34:55Z

Miawinator: Pagină nouă: Considerăm şirul de numere naturale nenule distincte . Notăm cu lungimea maximă a unei secvențe de elemente cu valori consecutive care se poate obţine prin ordonarea crescătoare a primelor <code>i</code> elemente din şirul dat. De exemplu, pentru șirul <code>7, 2, 3, 8, 20, 4, 10, 9</code> avem: . = Cerința = Să se determine . = Date de intrare = Fişierul <code>input.txt</code> conţine pe prima linie numărul natural <code>N</code>. Pe fiecare din următoarel...

Considerăm şirul de numere naturale nenule distincte . Notăm cu lungimea maximă a unei secvențe de elemente cu valori consecutive care se poate obţine prin ordonarea crescătoare a primelor <code>i</code> elemente din şirul dat. De exemplu, pentru șirul <code>7, 2, 3, 8, 20, 4, 10, 9</code> avem: .

= Cerința =
Să se determine .

= Date de intrare =
Fişierul <code>input.txt</code> conţine pe prima linie numărul natural <code>N</code>. Pe fiecare din următoarele <code>N</code> linii se găseşte câte un număr natural, deci pe linia <code>i+1</code> se va afla elementul , pentru <code>i=1...N</code>.

= Date de ieșire =
Fişierul <code>output.txt</code> conţine exact <code>N</code> linii. Pe linia <code>i</code> (<code>i = 1...N</code>) se va afișa valoarea .

= Restricții și precizări =

* <code>3 ≤ N ≤ 200.000</code>

== Exemplul 1 ==
input.txt:

8

7

3

2

8

20

4

10

9

output.txt:

1

1

2

2

2

3

3

4

Explicație:

L1 Șirul: <code>7</code>. Lungime maximă <code>1</code>.

L2 Șirul: <code>7, 3</code>. Lungime maximă <code>1</code>.

L3 Șirul: <code>7, 3, 2</code>. Şirul sortat este <code>2, 3, 7</code>. Lungimea maximă este <code>2</code> (dată de secvenţa <code>2, 3</code>).

L4 Șirul: <code>7, 3, 2, 8</code>. Lungime maximă <code>2</code> (dată de <code>2, 3</code>)

L5 Șirul: <code>7, 3, 2, 8, 20</code>. Lungime maximă <code>2</code> (dată de <code>2, 3</code>).

L6 Șirul: <code>7, 3, 2, 8, 20, 4</code>. Şirul sortat este <code>2, 3, 4, 7, 8, 20</code>. Lungimea maximă este <code>3</code> (dată de secvenţa <code>2, 3, 4</code>).

L7 Șirul: <code>7, 3, 2, 8, 20, 4, 10</code>. Lungime maximă <code>3</code> (dată de <code>2, 3, 4</code>).

L8 Șirul: <code>7, 3, 2, 8, 20, 4, 10, 9</code>. Şirul sortat este <code>2, 3, 4, 7, 8, 9, 10, 20</code>. Lungimea maximă este <code>4</code> (dată de secvenţa <code>7, 8, 9, 10</code>).

== Exemplul 2 ==
input.txt:

999999999

7

3

2

8

20

4

10

9

Output:

Input-ul nu convine conditiilor

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verificare(n):
if not(3<=n<=200000):
print("Input-ul nu convine conditiilor")
exit()

infile = "input.txt"
outfile = "output.txt"
nMax = 200013
vMax = 1000013

vz = [False] * vMax
v = [0] * nMax
pos = [0] * vMax
n = 0

def read():
global n
with open(infile, "r") as fin:
n = int(fin.readline().strip())
verificare(n)
for i in range(n):
v[i + 1] = int(fin.readline().strip())
assert not vz[v[i + 1]]
vz[v[i + 1]] = True

def solve():
global n
best = 0

with open(outfile, "w") as fout:
for i in range(1, n + 1):
begin, end = v[i], v[i]

if pos[v[i] - 1]:
begin = pos[v[i] - 1]
if pos[v[i] + 1]:
end = pos[v[i] + 1]

pos[begin] = end
pos[end] = begin

best = max(best, end - begin + 1)
fout.write(f"{best}\n")

if __name__ == "__main__":
read()
solve()

</syntaxhighlight>

2072 - GG

2023-12-16T14:15:15Z

Miawinator: Pagină nouă: = Enunț = Alex se află în sistemul de coordonate <code>2D</code>. Aflându-se în coordonatele <code>(x, y)</code>, el primește un număr aleator între <code>1</code> și <code>2</code> (<code>50%</code> șanse să primească <code>1</code> și <code>50%</code> șanse să primească <code>2</code>). Dacă acest număr este <code>1</code>, atunci el se va deplasa în <code>(x + 1, y)</code>, altfel în <code>(x, y + 1)</code>. = Cerința = Știind că Alex pornește <cod...

= Enunț =
Alex se află în sistemul de coordonate <code>2D</code>. Aflându-se în coordonatele <code>(x, y)</code>, el primește un număr aleator între <code>1</code> și <code>2</code> (<code>50%</code> șanse să primească <code>1</code> și <code>50%</code> șanse să primească <code>2</code>). Dacă acest număr este <code>1</code>, atunci el se va deplasa în <code>(x + 1, y)</code>, altfel în <code>(x, y + 1)</code>.

= Cerința =
Știind că Alex pornește <code>(1, 1)</code>, se întreabă care este probabilitatea ca acesta să treacă prin <code>(N, M)</code>.

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

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

= Restricții și precizări =

* <code>1 ≤ N, M ≤ 100000</code>

== Exemplul 1 ==
Input:

2 3

Output:

0.375

== Exemplul 2 ==
Input:

99999999999999 2

Output:

Restrictiile nu sunt indeplinite.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def check_restrictions(N, M):
return 1 <= N <= 100000 and 1 <= M <= 100000

def calculate_probability(N, M):
MOD = 10**9 + 7

dp = [[0.0] * (M + 1) for _ in range(N + 1)]

dp[1][1] = 1.0 # Probabilitatea inițială

for i in range(1, N + 1):
for j in range(1, M + 1):
if i < N:
dp[i + 1][j] += 0.5 * dp[i][j]
if j < M:
dp[i][j + 1] += 0.5 * dp[i][j]

return dp[N][M]

if __name__ == "__main__":
N = int(input("Introduceti valoarea pentru N: "))
M = int(input("Introduceti valoarea pentru M: "))

if not check_restrictions(N, M):
print("Restrictiile nu sunt indeplinite.")
else:
result = calculate_probability(N, M)
print(f'{result:.3f}')

</syntaxhighlight>

3770 - Bisectoare

2023-12-12T19:57:47Z

Miawinator: Pagină nouă: = Cerința = RAU-Gigel are un șir de puncte, nu neapărat distincte, aflate pe prima bisectoare. Punctele sunt caracterizate prin câte două coordonate (abscisă și ordonată), ambele numere întregi. Când le-a copiat pe caiet, din neatenție, RAU-Gigel a amestecat coordonatele celor <code>N</code> puncte și omis ordonata unuia dintre ele. Care este aceasta, puteți să îl ajutați? = Date de intrare = Fișierul de intrare <code>bisectoareIN.txt</code> conține un num...

= Cerința =
RAU-Gigel are un șir de puncte, nu neapărat distincte, aflate pe prima bisectoare. Punctele sunt caracterizate prin câte două coordonate (abscisă și ordonată), ambele numere întregi. Când le-a copiat pe caiet, din neatenție, RAU-Gigel a amestecat coordonatele celor <code>N</code> puncte și omis ordonata unuia dintre ele. Care este aceasta, puteți să îl ajutați?

= Date de intrare =
Fișierul de intrare <code>bisectoareIN.txt</code> conține un număr impar de linii (<code>2*N-1</code>), pe fiecare linie aflându-se câte un număr întreg <code>x</code> cu semnificația din enunț.

= Date de ieșire =
Fișierul de ieșire <code>bisectoareOUT.txt</code> va conține pe prima linie un număr întreg reprezentând ordonata ștearsă din neatenție.

= Restricții și precizări =

* <code>1 ≤ N ≤ 10000</code>, <code>-1.000.000.000 ≤ x ≤ 1.000.000.000</code>
* prima bisectoare are ecuația <code>y = x</code>

== Exemplul 1 ==
bisectoareIN.txt:

1 -3 5 -3 1

bisectoareOUT.txt:

5

== Exemplul 2 ==
bisectoareIN.txt:

1 -3 5 -3 1 999999999999

bisectoareOUT.txt:

Conditiile nu sunt indeplinite

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
#Verfificare elemente
def verficicare():
with open('bisectoareIN.txt', 'r') as file:
linii = [int(line.strip()) for line in file]
for i in linii:
if -1000000000 > i or i > 1000000000:
return
if 1 > len(linii) or 10000 < len(linii):
return
return linii

#Functia principala
def main():
lista = verficicare()
if lista == None:
print("Conditiile nu sunt indeplinite")
return
lenght = len(lista)
i=0
while(i<lenght-1):
j=i+1
while(j<lenght):
if lista[i] == lista[j]:
lista.remove(lista[i])
lista.remove(lista[j-1])
lenght -= 2
i+=1
continue
j+=1
i+=1
for i in lista:
if i >= 0:
with open('bisectoareOUT.txt', 'w') as file:
file.write(str(i))
break

main()

</syntaxhighlight>

2811 - Triplete

2023-12-11T07:09:19Z

Miawinator: Pagină nouă: = Cerința = Subprogramul <code>triplete</code> are trei parametri, <code>a</code>, <code>b</code> și <code>c</code>, în această ordine, prin care primește câte un număr natural din intervalul <code>[0,10000]</code> (<code>a<b</code>). Subprogramul afișează pe ecran în ordine lexicografică toate tripletele de numere naturale, <code>x</code>, <code>y</code> și <code>z</code>, soluții ale ecuației <code>x+y+z=c</code>, cu proprietatea că <code>a≤ x≤ y≤ z≤...

= Cerința =
Subprogramul <code>triplete</code> are trei parametri, <code>a</code>, <code>b</code> și <code>c</code>, în această ordine, prin care primește câte un număr natural din intervalul <code>[0,10000]</code> (<code>a<b</code>). Subprogramul afișează pe ecran în ordine lexicografică toate tripletele de numere naturale, <code>x</code>, <code>y</code> și <code>z</code>, soluții ale ecuației <code>x+y+z=c</code>, cu proprietatea că <code>a≤ x≤ y≤ z≤ b</code>.

Fiecare triplet afișat pe câte o linie și este încadrat între acolade, iar numerele <code>x</code>, <code>y</code> și <code>z</code> sunt afișate în această ordine, separate prin câte o virgulă. Dacă nu există niciun triplet cu proprietatea cerută, se afişează mesajul <code>nu exista</code>.

Scrieți definiția completă a subprogramului.

Important:

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

== Exemplul 1 ==
Input:

a=2, b=4, c=8

Output:

{2,2,4}

{2,3,3}

== Exemplul 2 ==
Input:

a=-1, b=0, c=4

Output:

Parametrii a, b, sau c nu respectă condițiile specificate.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def is_valid_interval(a, b, c):
"""
Verifică dacă a, b și c se află în intervalul [0, 10000] și respectă relația a < b < c.

:param a: Număr natural de verificat.
:param b: Număr natural de verificat.
:param c: Număr natural de verificat.
:return: True dacă toți parametrii sunt în interval și respectă relația specificată, False în caz contrar.
"""
return 0 <= a <= 10000 and 0 <= b <= 10000 and 0 <= c <= 10000 and a < b < c

def triplete(a, b, c):
"""
Afișează în ordine lexicografică toate tripletele de numere naturale (x, y, z) soluții ale ecuației x+y+z=c,
cu proprietatea că a ≤ x ≤ y ≤ z ≤ b.

:param a: Număr natural din intervalul [0, 10000].
:param b: Număr natural din intervalul [0, 10000], a < b.
:param c: Număr natural din intervalul [0, 10000].
"""
# Verificăm condițiile privind a, b, c și relația a < b < c
if is_valid_interval(a, b, c):
found_triplet = False
# Iterăm prin posibilele valori pentru x, y, z
for x in range(a, b + 1):
for y in range(x, b + 1):
z = c - x - y
# Verificăm condiția x ≤ y ≤ z
if x <= y <= z <= b:
# Afișăm tripletul pe ecran
print(f'{{{x},{y},{z}}}')
found_triplet = True

# Afisăm mesajul dacă nu există niciun triplet
if not found_triplet:
print("nu exista")
else:
print("Parametrii a, b, sau c nu respectă condițiile specificate.")

# Exemplu de utilizare:
triplete(int(input()), int(input()), int(input()))

</syntaxhighlight>

2842 - Triplete 1

2023-12-11T06:57:28Z

Miawinator: Pagină nouă: = Cerința = Se consideră subprogramul <code>triplete</code>, cu un singur parametru, <code>n</code>, prin care primeşte o valoare naturală din intervalul <code>[2,10000]</code>. Subprogramul afișează pe ecran toate tripletele de numere naturale <code>(x,y,z)</code> cu proprietatea că <code>x<y<z</code> și <code>x·y+y·z=n</code>. Fiecare triplet se afișează pe câte o linie a ecranului, iar numerele din fiecare triplet sunt separate prin câte o virgulă și încad...

= Cerința =
Se consideră subprogramul <code>triplete</code>, cu un singur parametru, <code>n</code>, prin care primeşte o valoare naturală din intervalul <code>[2,10000]</code>. Subprogramul afișează pe ecran toate tripletele de numere naturale <code>(x,y,z)</code> cu proprietatea că <code>x<y<z</code> și <code>x·y+y·z=n</code>. Fiecare triplet se afișează pe câte o linie a ecranului, iar numerele din fiecare triplet sunt separate prin câte o virgulă și încadrate între paranteze rotunde.

Scrieți definiţia completă a subprogramului.

Important:

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

== Exemplul 1 ==
Input:

n=8

Output:

(0,1,8)

(0,2,4)

(1,2,3)

== Exemplul 2 ==
Input:

n=1

Output:

Nu sunt indeplinite conditiile

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def is_valid_interval(n):
"""
Verifică dacă n se află în intervalul [2, 10000].

:param n: Valoarea naturală de verificat.
:return: True dacă n este în interval, False în caz contrar.
"""
return 2 <= n <= 10000

def triplete(n):
"""
Afișează toate tripletele de numere naturale (x, y, z) cu proprietatea că x < y < z și x * y + y * z = n.

:param n: Valoarea naturală din intervalul [2, 10000].
"""
# Verificăm dacă n se află în intervalul specificat
if is_valid_interval(n):
# Iterăm prin posibilele valori pentru x, y, z
for x in range(0, n):
for y in range(x + 1, n):
for z in range(y + 1, n+1):
# Verificăm condiția x < y < z
if x < y < z and x * y + y * z == n:
# Afișăm tripletul pe ecran
print(f'({x},{y},{z})')
else:
print("Nu sunt indeplinite conditiile")
# Exemplu de utilizare:
# Pentru n = 8, subprogramul va afișa toate tripletele care satisfac condițiile date.
triplete(int(input()))

</syntaxhighlight>

2817 - Identice 4

2023-12-11T06:45:49Z

Miawinator: Pagină nouă: = Cerința = Subprogramul <code>identice</code> are doi parametri, în această ordine, <code>a</code> și <code>b</code>, prin care primește câte un număr natural (<code>10≤a≤b≤106</code>). Subprogramul afișează pe ecran toate numerele naturale din intervalul <code>[a,b]</code> care au toate cifrele identice. Numerele afișate sunt separate prin câte un spațiu, iar dacă nu există astfel de numere, se afişează pe ecran mesajul <code>nu exista</code>. Scrieţ...

= Cerința =
Subprogramul <code>identice</code> are doi parametri, în această ordine, <code>a</code> și <code>b</code>, prin care primește câte un număr natural (<code>10≤a≤b≤106</code>). Subprogramul afișează pe ecran toate numerele naturale din intervalul <code>[a,b]</code> care au toate cifrele identice. Numerele afișate sunt separate prin câte un spațiu, iar dacă nu există astfel de numere, se afişează pe ecran mesajul <code>nu exista</code>.

Scrieţi definiţia completă a subprogramului.

Important:

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

= Exemplul 1 =
Input:

a=700

b=1500

Output:

777 888 999 1111

== Exemplul 2 ==
Input:

a=-1

b=2

Output:

nu exista

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def cifre_identice(numar):
"""
Verifică dacă toate cifrele unui număr sunt identice.
:param numar: Numărul de verificat.
:return: True dacă toate cifrele sunt identice, False în caz contrar.
"""
cifra = numar % 10 # Se obține ultima cifră
numar_temporar = numar // 10

while numar_temporar > 0:
if numar_temporar % 10 != cifra:
return False
numar_temporar //= 10

return True

def identice(a, b):
"""
Afișează numerele naturale din intervalul [a, b] care au toate cifrele identice.

:param a: Primul număr natural din interval (10≤a≤b≤1000000).
:param b: Al doilea număr natural din interval (10≤a≤b≤1000000).
"""
a = max(a, 10) # Asigurăm că a este cel puțin 10
exista_numere_identice = False

for numar in range(a, min(b + 1, 1000001)):
if cifre_identice(numar):
print(numar, end=' ')
exista_numere_identice = True

if not exista_numere_identice:
print("nu exista")

# Exemplu de apel:
a = 700
b = 1500
identice(a, b)
</syntaxhighlight>

2659 - Split Text

2023-12-11T06:26:39Z

Miawinator:

== Cerința ==
Să se scrie funcția cu următorul antet:
SplitText(propozitie)
Funcția primește ca parametri:

* un șir de caractere <code>propozitie</code> de lungime maximă <code>200</code>.

Șirul <code>propozitie</code> memorează un text format din cuvinte și separatori. Cuvintele sunt formate din litere, iar restul caracterelor din text sunt separatori. Funcția va returna propoziția introdusă de la tastatură despărțită in cuvinte sau va afișa un mesaj corespunzător în cazul în care nu sunt respectate restricțiile impuse.

!!!Atenție: Problema este modificată față de cea de pe PbInfo ca să corespundă limbajului de programare Python.

= Restricții și precizări =

* Lungimea maximă a șirului <code>propozitie</code> este <code>200</code>
* Șirul va conține cel puțin un cuvânt
* Numărul maxim de cuvinte din text este <code>100</code>
* Cuvintele textului au lungimea maximă <code>29</code>

== Exemplul 1 ==
Input:

O suta de ani ... de Romania!

Output consola:

['O', 'suta', 'de', 'ani', 'de', 'Romania']

Va furniza rezultatul: <code>cuv[0]="O"</code>, <code>cuv[1]="suta"</code>, <code>cuv[2]="de"</code>, <code>cuv[3]="ani"</code>, <code>cuv[4]="de"</code>, <code>cuv[5]="Romania"</code>.

== Exemplul 2 ==
Input:

O suta de ani ... de Romaniaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!

Output consola:

Propoziția nu respectă toate condițiile.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_conditii(propozitie):
# Verificăm dacă lungimea șirului este mai mică sau egală cu 200
if len(propozitie) > 200:
return False
# Despartim șirul în cuvinte
cuvinte = propozitie.split()
# Verificăm dacă există cel puțin un cuvânt în șir
if not cuvinte:
return False
# Verificăm numărul maxim de cuvinte în șir
if len(cuvinte) > 100:
return False
# Verificăm lungimea maximă a cuvintelor
if any(len(cuvant) > 29 for cuvant in cuvinte):
return False
# Dacă toate condițiile sunt îndeplinite, returnăm True
return True
def SplitText(propozitie):
# Verificăm condițiile
if verifica_conditii(propozitie):
# Filtram caracterele care nu sunt alfanumerice
propozitie_filtrata = ''.join(caracter if caracter.isalnum() or caracter.isspace() else ' ' for caracter in propozitie)
# Folosim metoda split() pentru a desparti propoziția filtrată în cuvinte
cuvinte = propozitie_filtrata.split()
# Afisăm rezultatul
print("Cuvintele din propoziție sunt:", cuvinte)
else:
print("Propoziția nu respectă toate condițiile.")
SplitText(input("Introduceti propozitia: "))
</syntaxhighlight>

4254 - Matrice 12

2023-12-11T06:25:26Z

Miawinator:

== Cerința ==
Scrieți un program care citește de la tastatură două numere naturale din intervalul <code>[2,50]</code>, <code>n</code> și <code>m</code>, și elementele unei matrici cu <code>n</code> linii și <code>m</code> coloane, numere naturale distincte din intervalul <code>[0,10000]</code>.

Programul interschimbă elementele de pe coloana pe care se află valoarea minimă cu elementele de pe coloana pe care se află valoarea maximă din matrice, apoi afișează pe ecran matricea modificată, câte o linie a matricii pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spațiu.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valorile lui <code>n</code> și <code>m</code> și apoi elementele matricei
* <code>afisare</code>, care afișează pe ecran elementele matricei conform cerinței
* <code>col_min</code>, care determină indicele coloanei pe care se află elementul minim din matrice
* <code>col_max</code>, care determină indicele coloanei pe care se află elementul maxim din matrice
* <code>interschimbare</code>, care interschimbă în matricea dată elementele de pe două coloane date

= Date de intrare =
Programul citește de la tastatură numerele <code>n m</code>, iar apoi cele <code>n • m</code> elemente ale matricii.

= Date de ieșire =
Programul va afișa pe ecran elementele matricii rezultate.

= Restricții și precizări =

* <code>2 ≤ n,m ≤ 50</code>
* indexarea liniilor și a coloanelor se face începând de la 1
* elementele tabloului aparțin intervalului <code>[0,10000]</code>
* dacă atât elementul minim cât și cel maxim se află pe aceeași coloană, atunci matricea se va afișa nemodificată.

== Exemplul 1 ==
Input:

4 3

7 5 19

3 8 4

23 6 1

10 2 9

Output:

19 5 7

4 8 3

1 6 23

9 2 10

Explicație:

Elementul minim (1) se află pe coloana 3, iar elementul maxim (23) se află pe prima coloană. Prin urmare, se interschimbă coloana 1 cu coloana 3.

== Exemplul 2 ==
Input:

51 3

Output:

Numărul de linii și coloane trebuie să fie în intervalul [2, 50].

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n, m, matrice):
if not (2 <= n <= 50) or not (2 <= m <= 50):
print("Numărul de linii și coloane trebuie să fie în intervalul [2, 50].")
return False

for i in range(n):
for j in range(m):
if not (0 <= matrice[i][j] <= 10000):
print("Elementele matricei trebuie să fie în intervalul [0, 10000].")
return False

return True

def citire():
n = int(input("Introduceti numarul de linii (2 <= n <= 50): "))
m = int(input("Introduceti numarul de coloane (2 <= m <= 50): "))

matrice = []
for i in range(n):
linie = []
for j in range(m):
element = int(input(f"Introduceti elementul de pe pozitia [{i+1}, {j+1}]: "))
linie.append(element)
matrice.append(linie)

return n, m, matrice

def afisare(matrice):
for linie in matrice:
for elem in linie:
print(elem, end=" ")
print()

def col_min(matrice):
min_val = float('inf')
col_index = 0
for j in range(len(matrice[0])):
coloana = [matrice[i][j] for i in range(len(matrice))]
if min(coloana) < min_val:
min_val = min(coloana)
col_index = j
return col_index

def col_max(matrice):
max_val = float('-inf')
col_index = 0
for j in range(len(matrice[0])):
coloana = [matrice[i][j] for i in range(len(matrice))]
if max(coloana) > max_val:
max_val = max(coloana)
col_index = j
return col_index

def interschimbare(matrice, col1, col2):
for i in range(len(matrice)):
matrice[i][col1], matrice[i][col2] = matrice[i][col2], matrice[i][col1]

# Citirea datelor de intrare
n, m, matrice = citire()
if not verifica_restrictii(n, m, matrice):
exit()

# Determinarea coloanelor pentru interschimbare
col_min_index = col_min(matrice)
col_max_index = col_max(matrice)

# Verificare dacă trebuie să se facă interschimbare
if col_min_index != col_max_index:
# Efectuarea interschimbarii
interschimbare(matrice, col_min_index, col_max_index)

# Afisarea rezultatului
afisare(matrice)

</syntaxhighlight>

4252 - Matrice 11

2023-12-11T06:24:54Z

Miawinator:

= Cerința =
Scrieți un program care citește de la tastatură două numere naturale din intervalul <code>[2,50]</code>, <code>n</code> și <code>m</code>, și elementele unei matrici cu <code>n</code> linii și <code>m</code> coloane, numere naturale distincte din intervalul <code>[0,10000]</code>.

Programul interschimbă elementele de pe linia pe care se află valoarea minimă cu elementele de pe linia pe care se află valoarea maximă din matrice, apoi afișează pe ecran matricea modificată, câte o linie a matricii pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spațiu.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valorile lui <code>n</code> și <code>m</code> și apoi elementele matricei
* <code>afisare</code>, care afișează pe ecran elementele matricei conform cerinței
* <code>lin_min</code>, care determină indicele liniei pe care se află elementul minim din matrice
* <code>lin_max</code>, care determină indicele liniei pe care se află elementul maxim din matrice
* <code>interschimbare</code>, care interschimbă în matricea dată elementele de pe două linii date

În programele C/C++ nu se vor folosi variabile globale.

= Date de intrare =
Programul citește de la tastatură numerele <code>n m</code>, iar apoi cele <code>n • m</code> elemente ale matricii.

= Date de ieșire =
Programul va afișa pe ecran elementele matricii rezultate.

= Restricții și precizări =

* <code>2 ≤ n,m ≤ 50</code>
* indexarea liniilor și a coloanelor se face începând de la 1
* elementele tabloului aparțin intervalului <code>[0,10000]</code>
* dacă atât elementul minim cât și cel maxim se află pe aceeași linie, atunci matricea se va afișa nemodificată.

== Exemplul 1 ==
Input:

4 3

7 5 39

3 8 4

23 6 1

10 2 9

Output:

23 6 1

3 8 4

7 5 39

10 2 9

Explicație:

Elementul minim (1) se află pe linia 3, iar elementul maxim (39) se află pe prima linie. Prin urmare, se interschimbă linia 1 cu linia 3.

== Exemplul 2 ==
2 2

100001 232

32 0

Output:

Input-ul nu respectă restricțiile.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n, m, matrice):
if not (2 <= n <= 50) or not (2 <= m <= 50):
return False

if len(matrice) != n:
return False

for linie in matrice:
if len(linie) != m:
return False

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

return True

def citire():
n = int(input("Introduceți numărul de linii (n): "))
m = int(input("Introduceți numărul de coloane (m): "))

matrice = []
for i in range(n):
linie = list(map(int, input(f"Introduceți elementele pentru linia {i + 1}: ").split()))
matrice.append(linie)

return n, m, matrice

def afisare(matrice):
for linie in matrice:
print(*linie)

def lin_min(matrice):
min_val = float('inf')
index_linie = 0

for i, linie in enumerate(matrice):
if min(linie) < min_val:
min_val = min(linie)
index_linie = i + 1

return index_linie

def lin_max(matrice):
max_val = 0
index_linie = 0

for i, linie in enumerate(matrice):
if max(linie) > max_val:
max_val = max(linie)
index_linie = i + 1

return index_linie

def interschimbare(matrice, linie1, linie2):
matrice[linie1 - 1], matrice[linie2 - 1] = matrice[linie2 - 1], matrice[linie1 - 1]

def main():
n, m, matrice = citire()

if not verifica_restrictii(n, m, matrice):
print("Input-ul nu respectă restricțiile.")
return

linie_min = lin_min(matrice)
linie_max = lin_max(matrice)

if linie_min != linie_max:
interschimbare(matrice, linie_min, linie_max)

print("Matricea modificată:")
afisare(matrice)

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

4250 - Inlocuire 10

2023-12-11T06:23:53Z

Miawinator:

= Cerința =
Se dă un tablou cu <code>n</code> elemente, numere naturale mai mari decât <code>1</code>. Să se înlocuiască fiecare element din tablou cu produsul dintre suma divizorilor săi și numărul său de divizori și apoi să afișeze elementele din tabloului de la dreapta la stânga.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valoarea lui <code>n</code> și cele <code>n</code> elemente ale tabloului
* <code>afisare</code>, care afișează pe ecran elementele tabloului printr-o parcurgere de la dreapta la stânga, separate prin exact un spațiu
* <code>suma_div</code>, care determină suma divizorilor unui unui număr dat
* <code>nr_div</code>, care determină numărul divizorilor unui unui număr dat

În programele C/C++ nu se vor folosi variabile globale.

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

= Date de ieșire =
Se vor afișa pe ecran elementele tabloului după modificarea cerută, separate prin exact un spațiu.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* elementele tabloului vor fi mai mici decât <code>10.000</code>

== Exemplul 1 ==
Input:

7

7 18 18 5 14 20 4

Output:

[21, 252, 96, 12, 234, 234, 16]

Explicație:

Modificările efectuate sunt:

7 se înlocuiește cu 16 deoarece are suma divizorilor egala cu 8 și are 2 divizori (8*2=16).

18 se înlocuiește cu 234 deoarece are suma divizorilor egala cu 39 și are 6 divizori (39*6=234).

…

4 se înlocuiește 21 deoarece are suma divizorilor egala cu 7 și are 3 divizori (7*3=21).

La final, elementele sunt afișate de la dreapta la stânga.

== Exemplul 2 ==
Input:

0

7 18 18 5 14 20 4

Output:

Restricții neîndeplinite pentru n. Introduceți un număr între 1 și 1000.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_input_restrictions(n, tablou):
if not 1 <= n <= 1000:
print("Restricții neîndeplinite pentru n. Introduceți un număr între 1 și 1000.")
return False
if any(x <= 1 or x >= 10000 for x in tablou):
print("Elementele tabloului trebuie să fie mai mari decât 1 și mai mici decât 1.000.000.000.")
return False
return True

def citire():
n = int(input("Introduceți numărul n="))
print("Introduceți elemente vector")
vector = list(map(int, input().split()))
return n,vector

def afisare(vector):
print(vector[::-1])

def suma_div(x):
suma=x+1
div = 2
while div <= x/2:
if x%div == 0:
suma+=div
div+=1
return suma

def nr_div(x):
nr=2
div = 2
while div <= x/2:
if x%div == 0:
nr+=1
div+=1
return nr

def inloc(vector):
for i in range(len(vector)):
aux=suma_div(vector[i])*nr_div(vector[i])
vector[i]=aux
return vector

def main():
n, tablou = citire()
if not validate_input_restrictions(n, tablou):
return
tablou=inloc(tablou)
afisare(tablou)

if __name__ == "__main__":
main()

</syntaxhighlight>

4249 - Inlocuire Cmmdc Oglindit

2023-12-11T06:20:28Z

Miawinator:

= Cerința =
Se dă un tablou cu <code>n</code> elemente, numere naturale mai mari decât <code>1</code>. Să se înlocuiască fiecare element din tablou cu cel mai care divizor comun al său cu oglinditul său și apoi să afișeze elementele din tabloului de la dreapta la stânga.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valoarea lui <code>n</code> și cele <code>n</code> elemente ale tabloului
* <code>afisare</code>, care afișează pe ecran elementele tabloului printr-o parcurgere de la dreapta la stânga, separate prin exact un spațiu
* <code>oglindit</code>, care determină oglinditul unui număr dat
* <code>cmmdc</code>, care calculează cel mai care divizor comun a două numere date

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

= Date de ieșire =
Se vor afișa pe ecran elementele tabloului după modificarea cerută, separate prin exact un spațiu.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* elementele tabloului vor fi mai mici decât <code>1.000.000.000</code>

== Exemplul 1 ==
Input:

7

7 18 18 5 14 20 4

Output:

[4, 2, 1, 5, 9, 9, 7]

Explicație:

Modificările efectuate sunt:

7 se înlocuiește cu 7 deoarece cmmdc(7,7) este 7.

18 se înlocuiește cu 9 deoarece cmmdc(18,81) este 9.

18 se înlocuiește cu 9 deoarece cmmdc(18,81) este 9.

14 se înlocuiește cu 1 deoarece cmmdc(14,41) este 1.

20 se înlocuiește cu 2 deoarece cmmdc(20,2) este 2.

4 se înlocuiește cu 4 deoarece cmmdc(4,4) este 4.

La final, elementele sunt afișate de la dreapta la stânga.

== Exemplul 2 ==
Input:

0

7 18 18 5 14 20 4

Output:

Restricții neîndeplinite pentru n. Introduceți un număr între 1 și 1000.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_input_restrictions(n, tablou):
if not 1 <= n <= 1000:
print("Restricții neîndeplinite pentru n. Introduceți un număr între 1 și 1000.")
return False
if any(x <= 1 or x >= 1000000000 for x in tablou):
print("Elementele tabloului trebuie să fie mai mari decât 1 și mai mici decât 1.000.000.000.")
return False
return True

def citire():
n = int(input("Introduceți numărul n="))
print("Introduceți elemente vector")
vector = list(map(int, input().split()))
return n,vector

def afisare(vector):
print(vector[::-1])

def oglindit(x):
aux=0
while x!=0:
aux = aux*10 + x % 10
x//=10
return aux

def cmmdc(x):
a=oglindit(x)
while x != a:
if x>a:
x-=a
else:
a-=x
return x

def inloc(vector):
for i in range(len(vector)):
aux=cmmdc(vector[i])
vector[i]=aux
return vector

def main():
n, tablou = citire()
if not validate_input_restrictions(n, tablou):
return
tablou=inloc(tablou)
afisare(tablou)

if __name__ == "__main__":
main()

</syntaxhighlight>

4256 - Oglindire Secvente

2023-12-11T06:19:47Z

Miawinator:

= Cerința =
Se dă un vector cu <code>n</code> elemente, numere naturale, și un număr <code>k</code>, divizor al lui <code>n</code>. Se împarte vectorul in secvențe disjuncte de lungime <code>k</code>. Să se oglindească elementele (primul element din secvență se interschimbă cu ultimul, al doilea cu penultimul, etc.) din fiecare dintre cele <code>n/k</code> secvențe și să se afișeze pe ecran vectorul rezultat în urma acestor modificări.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valoarea lui <code>n</code>, a lui <code>k</code> și cele <code>n</code> elemente ale tabloului
* <code>afisare</code>, care afișează pe ecran elementele tabloului, separate prin exact un spațiu
* <code>oglindire</code>, care oglindește elementele unei secvențe dinr-un vector precizate prin cele două extremități <code>st</code> și <code>dr</code>.

În programele C/C++ nu se vor folosi variabile globale.

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

= Date de ieșire =
Se vor afișa pe ecran elementele tabloului după modificarea cerută, separate prin exact un spațiu.

= Restricții și precizări =

* <code>1 ≤ k < n ≤ 1000</code>, <code>k</code> este divizor al lui <code>n</code>
* cele <code>n</code> numere citite vor fi mai mici decât <code>1000</code>

== Exemplul 1 ==
Input:

15 5

3 6 4 7 6 6 6 4 6 7 6 6 4 4 5

Output:

6 7 4 6 3 7 6 4 6 6 5 4 4 6 6

Explicație:

Vectorul se împarte în <code>3</code> secvențe de lungime <code>5</code>: <code>(3 6 4 7 6)</code>, <code>(6 6 4 6 7)</code>și <code>(6 6 4 4 5)</code>. Elementele din fiecare dintre ele se oglindesc și se obține secvențele <code>(6 7 4 6 3)</code>, <code>(7 6 4 6 6)</code> și <code>(5 4 4 6 6)</code>.

== Exemplul 2 ==
Input:

15 76

3 6 4 7 6 6 6 4 6 7 6 6 4 4 5

Output:

Restricții neîndeplinite.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_input(n, k, vector):
if not (1 < k < n <= 1000) or any(x >= 1000 for x in vector):
print("Restricții neîndeplinite.")
return False
if n % k != 0:
print("k trebuie să fie divizor al lui n.")
return False
return True

def citire():
n = int(input("Introduceți n: "))
k = int(input("Introduceți k: "))

# Read the entire line, split it into a list of strings, and convert each string to an integer
vector = list(map(int, input().split()))

return n, k, vector

def afisare(vector):
print(" ".join(map(str, vector)))

def oglindire(st, dr, vector):
while st < dr:
vector[st], vector[dr] = vector[dr], vector[st]
st += 1
dr -= 1

def main():
n, k, vector = citire()

# Verificare validitate input
if not validate_input(n, k, vector):
return

# Afisare vector initial
print("Vectorul initial:")
afisare(vector)

# Oglindire si afisare vector modificat
for i in range(0, n, k):
st = i
dr = min(i + k - 1, n - 1)
oglindire(st, dr, vector)

print("Vectorul dupa oglindire:")
afisare(vector)

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

4255 - Rotire Secvente

2023-12-11T06:18:15Z

Miawinator:

= Cerința =
Se dă un vector cu <code>n</code> elemente, numere naturale, și un număr <code>k</code>, divizor al lui <code>n</code>. Se împarte vectorul în <code>k</code> secvențe disjuncte, numerotate de la <code>1</code> la <code>k</code>. Să se permute circular cu o poziție spre stânga elementele din fiecare dintre cele <code>k</code> secvențe și să se afișeze pe ecran vectorul rezultat în urma acestor modificări.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valoarea lui <code>n</code>, a lui <code>k</code> și cele <code>n</code> elemente ale tabloului
* <code>afisare</code>, care afișează pe ecran elementele tabloului, separate prin exact un spațiu
* <code>permutare</code>, care permută circular cu o poziție spre stânga elementele unei secvențe din tablou precizata prin cele două extremități <code>st</code> și <code>dr</code>.

În programele C/C++ nu se vor folosi variabile globale.

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

= Date de ieșire =
Se vor afișa pe ecran elementele tabloului după modificarea cerută, separate prin exact un spațiu.

= Restricții și precizări =

* <code>1 ≤ k < n ≤ 1000</code>, <code>k</code> este divizor al lui <code>n</code>
* cele <code>n</code> numere citite vor fi mai mici decât <code>1000</code>

== Exemplul 1 ==
Input:

15 5

3 6 4 7 6 6 6 4 6 7 6 6 4 4 5

Output:

6 4 3 6 6 7 4 6 6 6 6 7 4 5 4

Explicație:

Vectorul se împarte în <code>5</code> secvențe: <code>(3 6 4)</code>, <code>(7 6 6)</code>, <code>(6 4 6)</code>, <code>(7 6 6)</code> și <code>(4 4 5)</code>. Elementele din fiecare dintre ele se permută circular cu o poziție spre stânga și se obține secvențele <code>(6 4 3)</code>, <code>(6 6 7)</code>, <code>(4 6 6)</code>, <code>(6 6 7)</code> și <code>(4 5 4)</code>.

== Exemplul 2 ==
Input:

15 76

3 6 4 7 6 6 6 4 6 7 6 6 4 4 5

Output:

Restricții neîndeplinite.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_input(n, k, vector):
if not (1 < k < n <= 1000) or any(x >= 1000 for x in vector):
print("Restricții neîndeplinite.")
return False
if n % k != 0:
print("k trebuie să fie divizor al lui n.")
return False
return True

def citire():
n = int(input("Introduceți n: "))
k = int(input("Introduceți k: "))
vector = list(map(int, input().split()))
return n, k, vector

def afisare(vector):
print(" ".join(map(str, vector)))

def permutare(st, dr, vector):
lungime = dr - st + 1
temp = vector[st:dr + 1]
for i in range(st, dr + 1):
vector[i] = temp[(i - st - 1) % lungime]

def main():
n, k, vector = citire()

# Verificare validitate input
if not validate_input(n, k, vector):
return

# Afisare vector initial
print("Vectorul initial:")
afisare(vector)

# Permutare si afisare vector modificat
for _ in range(k):
for i in range(1, k + 1):
st = (i - 1) * (n // k)
dr = i * (n // k) - 1
permutare(st, dr, vector)

print("Vectorul dupa permutari:")
afisare(vector)

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

2659 - Split Text

2023-12-04T16:45:48Z

Miawinator: Pagină nouă: == Cerința == Să se scrie funcția cu următorul antet: SplitText(propozitie) Funcția primește ca parametri: * un șir de caractere <code>propozitie</code> de lungime maximă <code>200</code>. Șirul <code>propozitie</code> memorează un text format din cuvinte și separatori. Cuvintele sunt formate din litere, iar restul caracterelor din text sunt separatori. Funcția va returna propoziția introdusă de la tastatură despărțită in cuvinte sau va afișa un mesaj co...

== Cerința ==
Să se scrie funcția cu următorul antet:
SplitText(propozitie)
Funcția primește ca parametri:

* un șir de caractere <code>propozitie</code> de lungime maximă <code>200</code>.

Șirul <code>propozitie</code> memorează un text format din cuvinte și separatori. Cuvintele sunt formate din litere, iar restul caracterelor din text sunt separatori. Funcția va returna propoziția introdusă de la tastatură despărțită in cuvinte sau va afișa un mesaj corespunzător în cazul în care nu sunt respectate restricțiile impuse.

!!!Atenție: Problema este modificată față de cea de pe PbInfo ca să corespundă limbajului de programare Python.

= Restricții și precizări =

* Lungimea maximă a șirului <code>propozitie</code> este <code>200</code>
* Șirul va conține cel puțin un cuvânt
* Numărul maxim de cuvinte din text este <code>100</code>
* Cuvintele textului au lungimea maximă <code>29</code>

== Exemplul 1 ==
Input:

O suta de ani ... de Romania!

Output consola:

['O', 'suta', 'de', 'ani', 'de', 'Romania']

== Exemplul 2 ==
Input:

O suta de ani ... de Romaniaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!

Output consola:

Propoziția nu respectă toate condițiile.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_conditii(propozitie):
# Verificăm dacă lungimea șirului este mai mică sau egală cu 200
if len(propozitie) > 200:
return False
# Despartim șirul în cuvinte
cuvinte = propozitie.split()
# Verificăm dacă există cel puțin un cuvânt în șir
if not cuvinte:
return False
# Verificăm numărul maxim de cuvinte în șir
if len(cuvinte) > 100:
return False
# Verificăm lungimea maximă a cuvintelor
if any(len(cuvant) > 29 for cuvant in cuvinte):
return False
# Dacă toate condițiile sunt îndeplinite, returnăm True
return True
def SplitText(propozitie):
# Verificăm condițiile
if verifica_conditii(propozitie):
# Filtram caracterele care nu sunt alfanumerice
propozitie_filtrata = ''.join(caracter if caracter.isalnum() or caracter.isspace() else ' ' for caracter in propozitie)
# Folosim metoda split() pentru a desparti propoziția filtrată în cuvinte
cuvinte = propozitie_filtrata.split()
# Afisăm rezultatul
print("Cuvintele din propoziție sunt:", cuvinte)
else:
print("Propoziția nu respectă toate condițiile.")
SplitText(input("Introduceti propozitia: "))
</syntaxhighlight>

0991 - Matrice 5

2023-12-04T16:13:49Z

Miawinator: Pagină nouă: = Cerința = Se dă o matrice pătratică cu <code>n</code> linii și <code>n</code> coloane, numerotate de la <code>1</code> la <code>n</code> și elemente numere naturale. Să se determine suma elementelor aflate strict deasupra diagonalei secundare a matricei. Se va defini și folosi subprogramul <code>sub</code>, cu <code>3</code> parametri: * <code>n</code> – dimensiunea matricei * <code>x</code> – matricea * <code>k</code> – un număr natural, <code>1 < k ≤ 2*...

= Cerința =
Se dă o matrice pătratică cu <code>n</code> linii și <code>n</code> coloane, numerotate de la <code>1</code> la <code>n</code> și elemente numere naturale. Să se determine suma elementelor aflate strict deasupra diagonalei secundare a matricei.

Se va defini și folosi subprogramul <code>sub</code>, cu <code>3</code> parametri:

* <code>n</code> – dimensiunea matricei
* <code>x</code> – matricea
* <code>k</code> – un număr natural, <code>1 < k ≤ 2*n</code>

care va returna suma tuturor elementelor <code>aij</code> din matrice pentru care <code>i + j = k</code>.

!!!Variabila k nu va fi folosită deloc. Programul va afișa doar suma elementelor de pe diagonala secundară.

= Date de intrare =
Fișierul de intrare <code>matriceIN.txt</code> conține pe prima linie numărul <code>n</code>, iar următoarele <code>n</code> linii câte <code>n</code> numere naturale, reprezentând elementele matricei.

= Date de ieșire =
Fișierul de ieșire <code>matriceOUT.txt</code> va conține pe prima linie suma determinată. În cazul în care restricțiile nu sunt îndeplinite, se va afișa un mesaj corespunzător.

= Restricții și precizări =

* <code>1 ≤ n ≤ 100</code>
* elementele matricei sunt numere naturale mai mici decât <code>1000</code>
* liniile matricei sunt numerotate de la <code>1</code> la <code>n</code>.

== Exemplul 1 ==
Input:

4

1 6 3 1

6 1 3 1

1 3 1 6

3 1 6 1

Output:

18

== Exemplul 2 ==
Input:

121

1 6 3 1

6 1 3 1

1 3 1 6

3 1 6 1

Output consola:

n trebuie să fie între 1 și 100 inclusiv.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def sub(n, x, k=0):
if not check_constraints(n,matrix):
return
suma = 0
for i in range(0, n-1):
for j in range(0, n-1-i):
suma += x[i][j]
return suma
def check_constraints(n, matrix):
if not(1 <= n <= 100):
print("n trebuie să fie între 1 și 100 inclusiv.")
for row in matrix:
for elem in row:
if elem >= 1000:
print("Elementele matricei trebuie să fie mai mici decât 1000.")
# Citirea datelor de intrare
with open("matriceIN.txt", "r") as fin:
n = int(fin.readline())
matrix = [list(map(int, fin.readline().split())) for _ in range(n)]
# Calculul si afisarea sumei elementelor deasupra diagonalei secundare in fisierul de iesire
with open("matriceOUT.txt", "w") as fout:
fout.write(str(sub(n,matrix)))

</syntaxhighlight>

0987 - Matrice 4

2023-12-04T12:34:29Z

Miawinator: Pagină nouă: = Cerința = Se dă o matrice pătratică cu <code>n</code> linii și <code>n</code> coloane și elemente numere naturale. Să se afișeze indicii liniilor pentru care suma elementelor este număr par. Se va defini și folosi subprogramul <code>suma</code>, cu <code>3</code> parametri: * <code>x</code> – matricea * <code>n</code> – dimensiunea matricei * <code>p</code> – un număr natural, <code>1 ≤ p ≤ n</code> care va returna suma elementelor de pe linia <code>...

= Cerința =
Se dă o matrice pătratică cu <code>n</code> linii și <code>n</code> coloane și elemente numere naturale. Să se afișeze indicii liniilor pentru care suma elementelor este număr par.

Se va defini și folosi subprogramul <code>suma</code>, cu <code>3</code> parametri:

* <code>x</code> – matricea
* <code>n</code> – dimensiunea matricei
* <code>p</code> – un număr natural, <code>1 ≤ p ≤ n</code>

care va returna suma elementelor de pe linia <code>p</code> a matricei <code>x</code>.

= Date de intrare =
Fișierul de intrare <code>matriceIN.txt</code> conține pe prima linie numărul <code>n</code>, iar următoarele <code>n</code> linii câte <code>n</code> numere naturale, reprezentând elementele matricei.

= Date de ieșire =
Fișierul de ieșire <code>matriceOUT.txt</code> va conține pe prima linie indicii determinați, separați prin exact un spațiu, în ordine crescătoare.

= Restricții și precizări =

* <code>1 ≤ n ≤ 100</code>
* elementele matricei sunt numere naturale mai mici decât <code>1 000 000</code>
* liniile matricei sunt numerotate de la <code>1</code> la <code>n</code>.

== Exemplul 1 ==
Input:

4

1 2 3 4

1 1 1 2

2 2 41 8

3 3 10 2

Output:

1 4

== Exemplul 2 ==
Input:

51

1 2 3

1 2 3

1 2 3

Output consola:

Dimensiunea n nu respecta restrictiile.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def suma(x, n, p):
# Implementarea subprogramului suma
return sum(x[p-1])

def verificare_dimensiune_n(n):
# Verifică restricțiile pentru dimensiunea n
return 1 <= n <= 100

def verificare_elemente_matrice(matrice):
# Verifică restricțiile pentru elementele matricei
for linie in matrice:
for elem in linie:
if not (0 <= elem < 1000000):
return False
return True

def main():
# Citirea datelor de intrare din fisierul matrice4.in
with open("matriceIN.txt", "r") as file_in:
n = int(file_in.readline().strip())
matrice = [list(map(int, file_in.readline().split())) for _ in range(n)]

# Verificarea restricțiilor pentru dimensiunea n
if not verificare_dimensiune_n(n):
print("Dimensiunea n nu respecta restrictiile.")
return

# Verificarea restricțiilor pentru elementele matricei
if not verificare_elemente_matrice(matrice):
print("Elementele matricei nu respecta restrictiile.")
return

# Determinarea indiciilor liniilor cu suma elementelor număr par
linii_par = [i+1 for i in range(n) if suma(matrice, n, i+1) % 2 == 0]

# Scrierea rezultatului în fisierul matrice4.out
with open("matriceOUT.txt", "w") as file_out:
file_out.write(" ".join(map(str, linii_par)))

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

4254 - Matrice 12

2023-12-04T12:25:41Z

Miawinator: Pagină nouă: == Cerința == Scrieți un program care citește de la tastatură două numere naturale din intervalul <code>[2,50]</code>, <code>n</code> și <code>m</code>, și elementele unei matrici cu <code>n</code> linii și <code>m</code> coloane, numere naturale distincte din intervalul <code>[0,10000]</code>. Programul interschimbă elementele de pe coloana pe care se află valoarea minimă cu elementele de pe coloana pe care se află valoarea maximă din matrice, apoi afișează p...

== Cerința ==
Scrieți un program care citește de la tastatură două numere naturale din intervalul <code>[2,50]</code>, <code>n</code> și <code>m</code>, și elementele unei matrici cu <code>n</code> linii și <code>m</code> coloane, numere naturale distincte din intervalul <code>[0,10000]</code>.

Programul interschimbă elementele de pe coloana pe care se află valoarea minimă cu elementele de pe coloana pe care se află valoarea maximă din matrice, apoi afișează pe ecran matricea modificată, câte o linie a matricii pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spațiu.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valorile lui <code>n</code> și <code>m</code> și apoi elementele matricei
* <code>afisare</code>, care afișează pe ecran elementele matricei conform cerinței
* <code>col_min</code>, care determină indicele coloanei pe care se află elementul minim din matrice
* <code>col_max</code>, care determină indicele coloanei pe care se află elementul maxim din matrice
* <code>interschimbare</code>, care interschimbă în matricea dată elementele de pe două coloane date

= Date de intrare =
Programul citește de la tastatură numerele <code>n m</code>, iar apoi cele <code>n • m</code> elemente ale matricii.

= Date de ieșire =
Programul va afișa pe ecran elementele matricii rezultate.

= Restricții și precizări =

* <code>2 ≤ n,m ≤ 50</code>
* indexarea liniilor și a coloanelor se face începând de la 1
* elementele tabloului aparțin intervalului <code>[0,10000]</code>
* dacă atât elementul minim cât și cel maxim se află pe aceeași coloană, atunci matricea se va afișa nemodificată.

== Exemplul 1 ==
Input:

4 3

7 5 19

3 8 4

23 6 1

10 2 9

Output:

19 5 7

4 8 3

1 6 23

9 2 10

== Exemplul 2 ==
Input:

51 3

Output:

Numărul de linii și coloane trebuie să fie în intervalul [2, 50].

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n, m, matrice):
if not (2 <= n <= 50) or not (2 <= m <= 50):
print("Numărul de linii și coloane trebuie să fie în intervalul [2, 50].")
return False

for i in range(n):
for j in range(m):
if not (0 <= matrice[i][j] <= 10000):
print("Elementele matricei trebuie să fie în intervalul [0, 10000].")
return False

return True

def citire():
n = int(input("Introduceti numarul de linii (2 <= n <= 50): "))
m = int(input("Introduceti numarul de coloane (2 <= m <= 50): "))

matrice = []
for i in range(n):
linie = []
for j in range(m):
element = int(input(f"Introduceti elementul de pe pozitia [{i+1}, {j+1}]: "))
linie.append(element)
matrice.append(linie)

return n, m, matrice

def afisare(matrice):
for linie in matrice:
for elem in linie:
print(elem, end=" ")
print()

def col_min(matrice):
min_val = float('inf')
col_index = 0
for j in range(len(matrice[0])):
coloana = [matrice[i][j] for i in range(len(matrice))]
if min(coloana) < min_val:
min_val = min(coloana)
col_index = j
return col_index

def col_max(matrice):
max_val = float('-inf')
col_index = 0
for j in range(len(matrice[0])):
coloana = [matrice[i][j] for i in range(len(matrice))]
if max(coloana) > max_val:
max_val = max(coloana)
col_index = j
return col_index

def interschimbare(matrice, col1, col2):
for i in range(len(matrice)):
matrice[i][col1], matrice[i][col2] = matrice[i][col2], matrice[i][col1]

# Citirea datelor de intrare
n, m, matrice = citire()
if not verifica_restrictii(n, m, matrice):
exit()

# Determinarea coloanelor pentru interschimbare
col_min_index = col_min(matrice)
col_max_index = col_max(matrice)

# Verificare dacă trebuie să se facă interschimbare
if col_min_index != col_max_index:
# Efectuarea interschimbarii
interschimbare(matrice, col_min_index, col_max_index)

# Afisarea rezultatului
afisare(matrice)

</syntaxhighlight>

4252 - Matrice 11

2023-12-03T15:04:40Z

Miawinator: Pagină nouă: = Cerința = Scrieți un program care citește de la tastatură două numere naturale din intervalul <code>[2,50]</code>, <code>n</code> și <code>m</code>, și elementele unei matrici cu <code>n</code> linii și <code>m</code> coloane, numere naturale distincte din intervalul <code>[0,10000]</code>. Programul interschimbă elementele de pe linia pe care se află valoarea minimă cu elementele de pe linia pe care se află valoarea maximă din matrice, apoi afișează pe ecra...

= Cerința =
Scrieți un program care citește de la tastatură două numere naturale din intervalul <code>[2,50]</code>, <code>n</code> și <code>m</code>, și elementele unei matrici cu <code>n</code> linii și <code>m</code> coloane, numere naturale distincte din intervalul <code>[0,10000]</code>.

Programul interschimbă elementele de pe linia pe care se află valoarea minimă cu elementele de pe linia pe care se află valoarea maximă din matrice, apoi afișează pe ecran matricea modificată, câte o linie a matricii pe câte o linie a ecranului, elementele fiecărei linii fiind separate prin câte un spațiu.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valorile lui <code>n</code> și <code>m</code> și apoi elementele matricei
* <code>afisare</code>, care afișează pe ecran elementele matricei conform cerinței
* <code>lin_min</code>, care determină indicele liniei pe care se află elementul minim din matrice
* <code>lin_max</code>, care determină indicele liniei pe care se află elementul maxim din matrice
* <code>interschimbare</code>, care interschimbă în matricea dată elementele de pe două linii date

În programele C/C++ nu se vor folosi variabile globale.

= Date de intrare =
Programul citește de la tastatură numerele <code>n m</code>, iar apoi cele <code>n • m</code> elemente ale matricii.

= Date de ieșire =
Programul va afișa pe ecran elementele matricii rezultate.

= Restricții și precizări =

* <code>2 ≤ n,m ≤ 50</code>
* indexarea liniilor și a coloanelor se face începând de la 1
* elementele tabloului aparțin intervalului <code>[0,10000]</code>
* dacă atât elementul minim cât și cel maxim se află pe aceeași linie, atunci matricea se va afișa nemodificată.

== Exemplul 1 ==
Input:

4 3

7 5 39

3 8 4

23 6 1

10 2 9

Output:

23 6 1

3 8 4

7 5 39

10 2 9

== Exemplul 2 ==
2 2

100001 232

32 0

Output:

Input-ul nu respectă restricțiile.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n, m, matrice):
if not (2 <= n <= 50) or not (2 <= m <= 50):
return False

if len(matrice) != n:
return False

for linie in matrice:
if len(linie) != m:
return False

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

return True

def citire():
n = int(input("Introduceți numărul de linii (n): "))
m = int(input("Introduceți numărul de coloane (m): "))

matrice = []
for i in range(n):
linie = list(map(int, input(f"Introduceți elementele pentru linia {i + 1}: ").split()))
matrice.append(linie)

return n, m, matrice

def afisare(matrice):
for linie in matrice:
print(*linie)

def lin_min(matrice):
min_val = float('inf')
index_linie = 0

for i, linie in enumerate(matrice):
if min(linie) < min_val:
min_val = min(linie)
index_linie = i + 1

return index_linie

def lin_max(matrice):
max_val = 0
index_linie = 0

for i, linie in enumerate(matrice):
if max(linie) > max_val:
max_val = max(linie)
index_linie = i + 1

return index_linie

def interschimbare(matrice, linie1, linie2):
matrice[linie1 - 1], matrice[linie2 - 1] = matrice[linie2 - 1], matrice[linie1 - 1]

def main():
n, m, matrice = citire()

if not verifica_restrictii(n, m, matrice):
print("Input-ul nu respectă restricțiile.")
return

linie_min = lin_min(matrice)
linie_max = lin_max(matrice)

if linie_min != linie_max:
interschimbare(matrice, linie_min, linie_max)

print("Matricea modificată:")
afisare(matrice)

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

4250 - Inlocuire 10

2023-12-03T14:54:59Z

Miawinator: Pagină nouă: = Cerința = Se dă un tablou cu <code>n</code> elemente, numere naturale mai mari decât <code>1</code>. Să se înlocuiască fiecare element din tablou cu produsul dintre suma divizorilor săi și numărul său de divizori și apoi să afișeze elementele din tabloului de la dreapta la stânga. Se vor defini și apela următoarele subprograme: * <code>citire</code>, care citește de la tastatură valoarea lui <code>n</code> și cele <code>n</code> elemente ale tabloului *...

= Cerința =
Se dă un tablou cu <code>n</code> elemente, numere naturale mai mari decât <code>1</code>. Să se înlocuiască fiecare element din tablou cu produsul dintre suma divizorilor săi și numărul său de divizori și apoi să afișeze elementele din tabloului de la dreapta la stânga.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valoarea lui <code>n</code> și cele <code>n</code> elemente ale tabloului
* <code>afisare</code>, care afișează pe ecran elementele tabloului printr-o parcurgere de la dreapta la stânga, separate prin exact un spațiu
* <code>suma_div</code>, care determină suma divizorilor unui unui număr dat
* <code>nr_div</code>, care determină numărul divizorilor unui unui număr dat

În programele C/C++ nu se vor folosi variabile globale.

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

= Date de ieșire =
Se vor afișa pe ecran elementele tabloului după modificarea cerută, separate prin exact un spațiu.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* elementele tabloului vor fi mai mici decât <code>10.000</code>

== Exemplul 1 ==
Input:

7

7 18 18 5 14 20 4

Output:

21 252 96 12 234 234 16

== Exemplul 2 ==
Input:

0

7 18 18 5 14 20 4

Output:

Restricții neîndeplinite pentru n. Introduceți un număr între 1 și 1000.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_input_restrictions(n, tablou):
if not 1 <= n <= 1000:
print("Restricții neîndeplinite pentru n. Introduceți un număr între 1 și 1000.")
return False
if any(x <= 1 or x >= 10000 for x in tablou):
print("Elementele tabloului trebuie să fie mai mari decât 1 și mai mici decât 1.000.000.000.")
return False
return True

def citire():
n = int(input("Introduceți numărul n="))
print("Introduceți elemente vector")
vector = list(map(int, input().split()))
return n,vector

def afisare(vector):
print(vector[::-1])

def suma_div(x):
suma=x+1
div = 2
while div <= x/2:
if x%div == 0:
suma+=div
div+=1
return suma

def nr_div(x):
nr=2
div = 2
while div <= x/2:
if x%div == 0:
nr+=1
div+=1
return nr

def inloc(vector):
for i in range(len(vector)):
aux=suma_div(vector[i])*nr_div(vector[i])
vector[i]=aux
return vector

def main():
n, tablou = citire()
if not validate_input_restrictions(n, tablou):
return
tablou=inloc(tablou)
afisare(tablou)

if __name__ == "__main__":
main()

</syntaxhighlight>

4249 - Inlocuire Cmmdc Oglindit

2023-12-03T14:43:55Z

Miawinator: Pagină nouă: = Cerința = Se dă un tablou cu <code>n</code> elemente, numere naturale mai mari decât <code>1</code>. Să se înlocuiască fiecare element din tablou cu cel mai care divizor comun al său cu oglinditul său și apoi să afișeze elementele din tabloului de la dreapta la stânga. Se vor defini și apela următoarele subprograme: * <code>citire</code>, care citește de la tastatură valoarea lui <code>n</code> și cele <code>n</code> elemente ale tabloului * <code>afisare...

= Cerința =
Se dă un tablou cu <code>n</code> elemente, numere naturale mai mari decât <code>1</code>. Să se înlocuiască fiecare element din tablou cu cel mai care divizor comun al său cu oglinditul său și apoi să afișeze elementele din tabloului de la dreapta la stânga.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valoarea lui <code>n</code> și cele <code>n</code> elemente ale tabloului
* <code>afisare</code>, care afișează pe ecran elementele tabloului printr-o parcurgere de la dreapta la stânga, separate prin exact un spațiu
* <code>oglindit</code>, care determină oglinditul unui număr dat
* <code>cmmdc</code>, care calculează cel mai care divizor comun a două numere date

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

= Date de ieșire =
Se vor afișa pe ecran elementele tabloului după modificarea cerută, separate prin exact un spațiu.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* elementele tabloului vor fi mai mici decât <code>1.000.000.000</code>

== Exemplul 1 ==
Input:

7

7 18 18 5 14 20 4

Output:

4 2 1 5 9 9 7

== Exemplul 2 ==
Input:

0

7 18 18 5 14 20 4

Output:

Restricții neîndeplinite pentru n. Introduceți un număr între 1 și 1000.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_input_restrictions(n, tablou):
if not 1 <= n <= 1000:
print("Restricții neîndeplinite pentru n. Introduceți un număr între 1 și 1000.")
return False
if any(x <= 1 or x >= 1000000000 for x in tablou):
print("Elementele tabloului trebuie să fie mai mari decât 1 și mai mici decât 1.000.000.000.")
return False
return True

def citire():
n = int(input("Introduceți numărul n="))
print("Introduceți elemente vector")
vector = list(map(int, input().split()))
return n,vector

def afisare(vector):
print(vector[::-1])

def oglindit(x):
aux=0
while x!=0:
aux = aux*10 + x % 10
x//=10
return aux

def cmmdc(x):
a=oglindit(x)
while x != a:
if x>a:
x-=a
else:
a-=x
return x

def inloc(vector):
for i in range(len(vector)):
aux=cmmdc(vector[i])
vector[i]=aux
return vector

def main():
n, tablou = citire()
if not validate_input_restrictions(n, tablou):
return
tablou=inloc(tablou)
afisare(tablou)

if __name__ == "__main__":
main()

</syntaxhighlight>

1828 - Inlocuire 4

2023-12-03T14:24:02Z

Miawinator: Pagină nouă: = Cerința = Pentru un număr natural <code>x</code> mai mare decât <code>1</code> numim redusul lui <code>x</code> cel mai mic număr natural care are exact aceiași divizori primi ca și <code>x</code>. Se dă un tablou cu <code>n</code> elemente, numere naturale mai mari decât <code>1</code>. Să se înlocuiască fiecare element din tablou cu redusul său și apoi să afișeze elementele din tabloului ordonate descrescător. Se vor defini și apela următoarele subprog...

= Cerința =
Pentru un număr natural <code>x</code> mai mare decât <code>1</code> numim redusul lui <code>x</code> cel mai mic număr natural care are exact aceiași divizori primi ca și <code>x</code>.

Se dă un tablou cu <code>n</code> elemente, numere naturale mai mari decât <code>1</code>. Să se înlocuiască fiecare element din tablou cu redusul său și apoi să afișeze elementele din tabloului ordonate descrescător.

Se vor defini și apela următoarele subprograme:

* <code>citire</code>, care citește de la tastatură valoarea lui <code>n</code> și cele <code>n</code> elemente ale tabloului
* <code>afisare</code>, care afișează pe ecran elementele tabloului, separate prin exact un spațiu
* <code>redus</code>, care determină pentru un număr dat redusul său
* <code>sortare</code>, care sortează descrescător un tablou
* <code>inloc</code>, care realizează înlocuirile cerute.

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

= Date de ieșire =
Se vor afișa pe ecran elementele tabloului după transformările cerute, separate prin exact un spațiu.

= Restricții și precizări =

* <code>1 ≤ n ≤ 1000</code>
* elementele tabloului vor fi mai mici decât <code>1.000.000.000</code>

== Exemplul 1 ==
Input:

7

7 18 18 5 14 20 4

Output:

14 10 7 6 6 5 2

== Exemplul 2 ==
Input:

0

7 18 18 5 14 20 4

Output:

Restricții neîndeplinite pentru n. Introduceți un număr între 1 și 1000.

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def validate_input_restrictions(n, tablou):
if not 1 <= n <= 1000:
print("Restricții neîndeplinite pentru n. Introduceți un număr între 1 și 1000.")
return False
if any(x <= 1 or x >= 1000000000 for x in tablou):
print("Elementele tabloului trebuie să fie mai mari decât 1 și mai mici decât 1.000.000.000.")
return False
return True

def citire():
n = int(input("Introduceți numărul n="))
print("Introduceți elemente vector")
vector = list(map(int, input().split()))
return n,vector

def afisare(vector):
for i in vector:
print(i, end=" ")
print()

def sortare_descrescatoare(tablou):
return sorted(tablou, reverse=True)

def factorizare_in_divizori_primi(x):
divizori_primi = []
divizor = 2
while divizor <= x:
if x % divizor == 0:
divizori_primi.append(divizor)
while x % divizor == 0:
x //= divizor
divizor += 1
if x > 1:
divizori_primi.append(x)
return divizori_primi

def redus(x):
a=1
tab=factorizare_in_divizori_primi(x)
for i in tab:
a*=i
return a

def inloc(vector):
for i in range(len(vector)):
aux=redus(vector[i])
vector[i]=aux
return vector

def main():
n, tablou = citire()
if not validate_input_restrictions(n, tablou):
return
tablou=inloc(tablou)
tablou=sortare_descrescatoare(tablou)
afisare(tablou)

if __name__ == "__main__":
main()

</syntaxhighlight>