numere

Algoritmul, pas cu pas

Programul citește mai întâi $C$ și $X$, apoi tratează separat fiecare cerință.

Cerința 1 — maximul din două cifre.

1. Iau cifra unităților $u = X \bmod 10$ și cifra zecilor $z = (X / 10) \bmod 10$.
2. Pot forma două numere de două cifre: $u \cdot 10 + z$ și $z \cdot 10 + u$. Răspunsul e maximul lor.

Cerința 2 — prima apariție.

1. Citesc $N$ și parcurg șirul. La prima valoare egală cu $X$ rețin poziția și mă opresc logic (sau ignor restul).
2. Dacă nu apare deloc, răspunsul e $0$.

Cerința 3 — penultima și ultima apariție.

1. Parcurg șirul ținând două variabile: ultima (ultima poziție pe care am văzut $X$) și penultima (valoarea lui ultima dinaintea actualizării).
2. Când găsesc $X$ pe poziția $i$: penultima = ultima, apoi ultima = i.
3. La final, dacă $X$ apare o singură dată, penultima rămâne $0$; dacă nu apare deloc, ambele sunt $0$.

Cerința 4 — inversarea cifrelor impare.

1. Transform $X$ în șir de cifre.
2. Adun într-o listă cifrele impare, în ordinea apariției.
3. Parcurg cifrele de la stânga la dreapta: cifrele pare rămân neschimbate, iar pe pozițiile cifrelor impare pun cifrele impare în ordine inversă (ultima impară pe prima poziție impară etc.).

Cifrele pare nu se mișcă deloc — se rearanjează doar cifrele impare între ele. Pe $3215$, cifrele impare $3, 1, 5$ devin $5, 1, 3$, iar $2$ stă pe loc: rezultatul e $5213$.

Complexitatea e $O(N)$ pentru cerințele cu șir și $O(\text{număr de cifre})$ pentru celelalte — instantaneu pentru limitele date.

Soluția în C++

#include <fstream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

ifstream fin("numere.in");
ofstream fout("numere.out");

int main() {
    int C;
    long long X;
    fin >> C >> X;

    if (C == 1) {
        // Cele două cifre + cele două numere de două cifre posibile
        int u = X % 10;          // unitățile
        int z = (X / 10) % 10;   // zecile
        fout << max(u * 10 + z, z * 10 + u) << "\n";

    } else if (C == 2 || C == 3) {
        int N;
        fin >> N;
        int prima = 0, ultima = 0, penultima = 0;
        for (int i = 1; i <= N; i++) {
            long long v;
            fin >> v;
            if (v == X) {
                if (prima == 0) prima = i;   // prima apariție
                penultima = ultima;          // vechea ultimă devine penultima
                ultima = i;                  // poziția curentă e noua ultimă
            }
        }
        if (C == 2) fout << prima << "\n";
        else fout << penultima << " " << ultima << "\n";

    } else { // C == 4
        string s = to_string(X);
        // Adun cifrele impare în ordinea apariției
        vector<int> impare;
        for (char ch : s)
            if ((ch - '0') % 2 == 1) impare.push_back(ch - '0');
        // Le repun pe pozițiile impare, în ordine inversă
        int k = (int)impare.size() - 1;
        for (char &ch : s)
            if ((ch - '0') % 2 == 1) ch = char('0' + impare[k--]);
        fout << s << "\n";
    }
    return 0;
}