Informatică FMI 2026

Care este valoarea maximă a expresiei dacă x este un număr natural nenul de o cifră?

C/C++: x % 20 * x % 26 / 2

Pascal: x mod 20 * x mod 26 div 2

Care este numărul de muchii care trebuie eliminate dintr-un graf neorientat conex cu 26 de noduri, toate având gradul 20, astfel încât să se obțină un arbore?

Considerăm următoarea funcție recursivă:

C/C++:

int f(int x, int y) {
  if (x == 0) return 1;
  else if (x % 10 != x / y) return 0;
  else return f(x % y / 10, y / 100);
}

Pascal:

function f(x, y: longint): longint;
begin
  if x = 0 then f := 1
  else if x mod 10 <> x div y then f := 0
  else f := f(x mod y div 10, y div 100);
end;

Care este valoarea expresiei f(20262026, 10000000) + f(2026202, 1000000) + f(716617, 100000) + f(6062606, 100000) + f(0, 10)?

Considerăm tabloul unidimensional a, cu 8 elemente numere naturale sortate strict crescător, de forma a = [11, 14, 17, 23, x, 29, 45, 49], și tabloul unidimensional b, cu 7 elemente numere naturale sortate strict crescător, de forma b = [4, 8, 19, 21, y, z, 33]. Câte seturi de valori există pentru x, y și z astfel încât după aplicarea algoritmului de interclasare pentru tablourile a și b să se obțină [4, 8, 11, 14, 17, 19, 21, 23, x, y, z, 29, 33, 45, 49], de asemenea sortat strict crescător?

Se consideră următorii patru algoritmi (A1–A4), descriși în pseudocod, în care variabilele s, d, n și p sunt de tip întreg.

Algoritmul A1:

citește n
s ← 0
d ← 2
cât timp n ≠ 1 execută
  p ← 0
  dacă n mod d = 0 atunci
    p ← 1
    n ← n div d
  dacă p = 1 atunci
    s ← s + d
  d ← d + 1
scrie s

Algoritmul A2:

citește n
s ← 0
d ← 2
cât timp n ≠ 1 execută
  p ← 0
  cât timp n mod d = 0 execută
    p ← p + 1
    n ← n div d
    s ← s + d
  d ← d + 1
scrie s

Algoritmul A3:

citește n
s ← 0
d ← 2
cât timp n ≠ 1 execută
  p ← 0
  cât timp n mod d = 0 execută
    p ← p + 1
    n ← n div d
  dacă p ≠ 0 atunci
    s ← s + d
  d ← d + 1
scrie s

Algoritmul A4:

citește n
s ← 0
d ← 2
p ← 0
cât timp n ≠ 0 execută
  cât timp n mod d = 0 execută
    p ← p + 1
    n ← n div d
  dacă p ≠ 0 atunci
    s ← s + d
  d ← d + 1
scrie s

Care dintre algoritmii dați afișează în mod corect suma tuturor divizorilor primi ai unui număr natural n ≥ 2?

Se consideră următorul algoritm în pseudocod, în care variabilele n, c și i sunt de tip întreg:

citește n
c ← 0
pentru i ← 1, n execută
  dacă n mod i = 0 atunci
    c ← c + 1
scrie c mod 2

Pentru câte numere întregi din intervalul [1, 2026] algoritmul va afișa valoarea 1?

Variabila s de tip segment memorează în câmpurile p și q coordonatele carteziene ale celor două extremități (x este abscisa, y este ordonata).

C/C++:

struct segment {
  struct { int x; int y; } p, q;
} s;

Pascal:

type segment = record
  p, q: record
    x: integer;
    y: integer;
  end;
end;
var s: segment;

Se consideră expresiile C/C++ de mai jos (în Pascal, operatorul == este înlocuit cu =):

E1) ((s.x.q-s.x.p)*(s.x.q-s.x.p)) == 1
E2) ((s.p.x-s.q.x)*(s.q.x-s.p.x)) == -1
E3) ((s.q.y-s.p.y)*(s.q.y-s.p.y)) == 1
E4) ((s.y.q-s.y.p)*(s.y.q-s.y.p)) == 1

Știind că segmentul este paralel cu axa Ox, care expresie este adevărată dacă și numai dacă segmentul are lungimea 1? Lungimea segmentului cu extremitățile $P(x_p,y_p)$ și $Q(x_q,y_q)$ este $\sqrt{(x_p-x_q)^2+(y_p-y_q)^2}$.

Folosind metoda backtracking, se generează toți vectorii de tați ai arborilor cu mulțimea nodurilor {1, 2, 3, 4} și rădăcina 1, nodurile fiind considerate în ordinea 1, 2, 3, 4 în procesul de generare. Dacă primii patru vectori generați sunt (0, 1, 1, 1), (0, 1, 1, 2), (0, 1, 1, 3), (0, 1, 2, 1), care este a noua soluție generată?

Fie v un tablou unidimensional cu n elemente numere naturale, pe pozițiile 1…n. O poziție k (1 ≤ k ≤ n) este balansată dacă suma elementelor pare dinaintea poziției k este egală cu suma elementelor impare de după poziția k; dacă nu există asemenea elemente, suma este 0. Dimensiunea și elementele sunt deja citite. Care este complexitatea timp a celui mai eficient algoritm care afișează pozițiile balansate?

Se consideră următoarea secvență în pseudocod. i, j, s și n sunt întregi; t este un tablou de numere naturale cu n linii și n coloane, numerotate de la 1; abs(x) returnează valoarea absolută. Ce valoare se afișează?

n ← 7
pentru i ← 1, n execută
  t[i, i] ← abs(n div 2 - i + 1)
  pentru j ← i + 1, n execută
    t[i, j] ← t[i, j - 1]
    t[j, i] ← t[i, j]
s ← 0
pentru i ← 1, n execută
  pentru j ← 1, n execută
    dacă i = 1 sau j = 1 sau i = n sau j = n atunci
      s ← s + t[i, j]
scrie s

Fie G un graf orientat cu 10 vârfuri etichetate parc, bariera, par, re, arca, parcare, banca, arc, ar și apar. Între două vârfuri distincte x și y există un arc de la x la y dacă eticheta lui x este subcuvânt al etichetei lui y: literele apar în aceeași ordine și pe poziții consecutive. De exemplu, arc este subcuvânt în arcuit, marcat și parc, dar nu în baraca. Se consideră afirmațiile:

1. Există cel puțin un vârf cu gradul interior nul și gradul exterior nenul.
2. Există cel puțin un vârf cu gradul exterior nul și gradul interior nenul.
3. Nu există niciun vârf izolat.
4. Există cel puțin un circuit.
5. Vârful arc are gradul interior 1 și gradul exterior 3.

Câte afirmații sunt adevărate?

Un panou electric are forma unei matrice $2\times2$. În fiecare celulă se află un bec și un comutator. Un bec poate fi stins (0) sau aprins (1). Apăsarea unui comutator schimbă starea tuturor becurilor vecine pe orizontală sau verticală, fără a schimba becul din aceeași celulă. De exemplu, apăsarea comutatorului din stânga-sus transformă $\begin{pmatrix}\displaystyle 1&\displaystyle 0\\\displaystyle 0&\displaystyle 0\end{pmatrix}$ în $\begin{pmatrix}\displaystyle 1&\displaystyle 1\\\displaystyle 1&\displaystyle 0\end{pmatrix}$. Se pot efectua oricâte apăsări, inclusiv niciuna, în orice ordine. Pentru câte configurații inițiale se poate obține configurația cu toate becurile stinse?

Variabilele i, j și k sunt întregi, iar s și t memorează șiruri de cel mult 100 de caractere. Care va fi lungimea șirului t după secvența dată?

C/C++:

strcpy(s, "decada");
strcpy(t, "");
for (i = 0; i < strlen(s); i++) {
  k = s[i] - 'a';
  for (j = 0; j < k; j++) strcat(t, s + i);
}

Pascal:

s := 'decada';
t := '';
for i := 1 to length(s) do
begin
  k := ord(s[i]) - ord('a');
  for j := 0 to k-1 do t := t + copy(s, i, 100);
end;

v este o permutare a mulțimii {1, 2, …, 10}, pe pozițiile 1…10. Se execută:

pentru i ← 1, 9 execută
  dacă v[i] > v[i + 1] atunci
    interschimbă v[i] și v[i + 1]

Fie x numărul de tablouri pentru care după secvență v este ordonat crescător. Care afirmație este adevărată?

Considerăm funcția recursivă de mai jos. x este întreg, iar randInt(a,b) întoarce un întreg aleatoriu din [a,b].

funcție foo(x)
  dacă x ≤ 1 atunci
    returnează x
  altfel
    returnează x + foo(randInt(0, x div 2))

Pentru un întreg dat $N\ge2$, care este intervalul de lungime minimă ce conține garantat toate valorile pe care le poate returna foo(N)?