Numere și cifre

#include <iostream>
#include <fstream>
using namespace std;

/* Returneaza suma cifrelor lui n. */
int sub(int n) {
    int s = 0;
    while (n > 0) {
        s = s + n % 10;
        n = n / 10;
    }
    return s;
}

Subprogramul sub(n)

• s pornește de la 0
• cât timp n este nenul
  • ultima cifră, n % 10, se adună la s
  • n / 10 elimină ultima cifră
• se returnează s

int main() {
    ifstream f("def.in");
    int x;
    int m1 = 0, m2 = 0;   // cele mai mari doua, m1 > m2

    while (f >> x)
        if (x >= 100000 && x <= 999999)    // 6 cifre
            if (sub(x / 1000) == sub(x % 1000)) {
                if (x > m1) {
                    m2 = m1;
                    m1 = x;
                }
                else if (x < m1 && x > m2)
                    m2 = x;
            }

    if (m2 == 0)
        cout << "nu exista";
    else
        cout << m1 << " " << m2;
    return 0;
}

Programul principal

• se deschide fișierul def.in pentru citire
• m1 și m2, cele mai mari două numere echilibrate găsite, pornesc de la 0
  • un număr de 6 cifre este cel puțin 100000, deci 0 arată că nu s-a găsit încă niciun număr
• cât timp se citește un număr x din fișier
  • dacă x are 6 cifre, adică este între 100000 și 999999
    • dacă sub(x / 1000) este egal cu sub(x % 1000), x este echilibrat
      • dacă x este mai mare decât m1, m2 primește valoarea lui m1, iar m1 primește x
      • altfel, dacă x este diferit de m1 și mai mare decât m2, m2 primește x
• dacă m2 a rămas 0, nu există două numere distincte: se afișează nu exista
• altfel se afișează m1 și m2, în ordine strict descrescătoare

Numerele nu se memorează într-un tablou. Pentru cele mai mari două valori sunt suficiente două variabile, actualizate la fiecare citire.

#include <iostream>
#include <fstream>
using namespace std;

/* Furnizeaza cifra minima si cifra maxima a lui n. */
void minmax(int n, int &minim, int &maxim) {
    minim = 9;
    maxim = 0;
    do {
        int c = n % 10;
        if (c < minim)
            minim = c;
        if (c > maxim)
            maxim = c;
        n = n / 10;
    } while (n > 0);
}

Subprogramul minmax(n, minim, maxim)

• minim și maxim sunt transmiși prin referință (&), deci valorile lor ajung în programul principal
• minim pornește de la 9, cea mai mare cifră, iar maxim de la 0, cea mai mică
• pentru fiecare cifră c a lui n, de la dreapta la stânga
  • dacă c este mai mică decât minim, minim primește c
  • dacă c este mai mare decât maxim, maxim primește c
  • n / 10 elimină ultima cifră
• structura do … while prelucrează cel puțin o cifră, deci pentru n = 0 se obțin minim = 0 și maxim = 0

int main() {
    ifstream f("def.in");
    int x, mi, ma, nr = 0;

    while (f >> x) {
        minmax(x, mi, ma);
        if (ma - mi == 1)     // doua cifre, consecutive
            nr++;
    }

    cout << nr;
    return 0;
}

Programul principal

• se deschide fișierul def.in pentru citire
• nr, numărul termenilor găsiți, pornește de la 0
• cât timp se citește un număr x din fișier
  • se apelează minmax(x, mi, ma)
  • dacă diferența dintre cifra maximă și cifra minimă este 1, nr crește cu 1
• se afișează nr

#include <iostream>
#include <fstream>
using namespace std;

/* Returneaza de cate ori apare cifra c in n. */
int nrAp(int n, int c) {
    int k = 0;
    do {
        if (n % 10 == c)
            k++;
        n = n / 10;
    } while (n > 0);
    return k;
}

Subprogramul nrAp(n, c)

• k, numărul de apariții, pornește de la 0
• pentru fiecare cifră a lui n, de la dreapta la stânga
  • dacă ultima cifră, n % 10, este egală cu c, k crește cu 1
  • n / 10 elimină ultima cifră
• se returnează k

Structura do … while prelucrează cel puțin o cifră, deci nrAp(0, 0) returnează 1.

int main() {
    int n;
    cin >> n;
    ofstream g("def2019.out");

    /* Cel mai mare: cifrele in ordine descrescatoare. */
    int mx = 0;
    for (int c = 9; c >= 0; c--)
        for (int k = 1; k <= nrAp(n, c); k++)
            mx = mx * 10 + c;

    /* Cel mai mic: intai cea mai mica cifra nenula,
       apoi celelalte, in ordine crescatoare. */
    int p = 1;
    while (p <= 9 && nrAp(n, p) == 0)
        p++;
    int mn = 0;
    if (p <= 9) {
        mn = p;
        for (int c = 0; c <= 9; c++) {
            int k = nrAp(n, c);
            if (c == p)
                k--;              // cifra p este deja in fata
            for (int i = 1; i <= k; i++)
                mn = mn * 10 + c;
        }
    }

    if (mn < mx)
        g << mn << " " << mx;
    else
        g << "nu exista";
    return 0;
}

Programul principal

• se citește n și se deschide fișierul def2019.out pentru scriere
• cel mai mare număr, mx, pornește de la 0
  • pentru fiecare cifră c, de la 9 la 0
    • c se adaugă la dreapta lui mx de atâtea ori cât apare în n: mx = mx * 10 + c
• cel mai mic număr, mn
  • p, cea mai mică cifră nenulă a lui n, se caută de la 1 în sus
  • dacă p există
    • mn pornește de la p
    • pentru fiecare cifră c, de la 0 la 9
      • k este numărul de apariții ale lui c în n; pentru c = p, k scade cu 1, deoarece o apariție a lui p este deja prima cifră
      • c se adaugă la dreapta lui mn de k ori
  • dacă p nu există, n este 0, iar mn rămâne 0
• dacă mn este mai mic decât mx, se scriu în fișier mn și mx
• altfel, cele două numere coincid: se scrie nu exista

#include <iostream>
#include <fstream>
using namespace std;

/* Returneaza cifra maxima a lui n. */
int cMax(int n) {
    int m = 0;
    while (n > 0) {
        if (n % 10 > m)
            m = n % 10;
        n = n / 10;
    }
    return m;
}

Subprogramul cMax(n)

• m, cifra maximă, pornește de la 0
• cât timp n este nenul
  • dacă ultima cifră, n % 10, este mai mare decât m, m primește această cifră
  • n / 10 elimină ultima cifră
• se returnează m

Pentru n = 0, structura repetitivă nu face niciun pas, iar subprogramul returnează 0, care este chiar cifra lui n.

int main() {
    ifstream f("def2020.in");
    int nr[11] = {0};   // nr[b]: numere scrise in baza b
    int x;

    while (f >> x) {
        int m = cMax(x);
        for (int b = 2; b <= 10; b++)
            if (m < b)
                nr[b]++;
    }

    for (int b = 2; b <= 10; b++)
        cout << nr[b] << " ";
    return 0;
}

Programul principal

• se deschide fișierul def2020.in pentru citire
• tabloul nr are câte un contor pentru fiecare bază; nr[b] pornește de la 0
• cât timp se citește un număr x din fișier
  • m este cifra maximă a lui x, dată de cMax(x)
  • pentru fiecare bază b, de la 2 la 10
    • dacă m este mai mică decât b, x poate fi scris în baza b: nr[b] crește cu 1
• se afișează contoarele pentru bazele de la 2 la 10

Subprogramul se apelează o singură dată pentru fiecare număr citit. Valoarea lui se reține în m și se folosește pentru toate cele 9 baze.

#include <iostream>
#include <fstream>
using namespace std;

/* Furnizeaza numarul de cifre distincte si
   cifra maxima a lui n. */
void cifDistMax(int n, int &nrd, int &cma) {
    int ap[10] = {0};     // ap[c] = 1 daca c apare in n
    do {
        ap[n % 10] = 1;
        n = n / 10;
    } while (n > 0);

    nrd = 0;
    for (int c = 0; c <= 9; c++)
        if (ap[c] == 1) {
            nrd++;
            cma = c;      // ultima cifra gasita e maxima
        }
}

Subprogramul cifDistMax(n, nrd, cma)

• nrd și cma sunt transmiși prin referință (&)
• tabloul ap are câte o poziție pentru fiecare cifră, de la 0 la 9, toate pornind de la 0
• pentru fiecare cifră a lui n, de la dreapta la stânga
  • poziția cifrei în ap primește 1
  • n / 10 elimină ultima cifră
• nrd pornește de la 0
• pentru fiecare cifră c, de la 0 la 9
  • dacă c apare în n
    • nrd crește cu 1
    • cma primește c; cifrele se parcurg crescător, deci ultima cifră găsită este cea maximă

Structura do … while prelucrează cel puțin o cifră, deci pentru n = 0 se obțin nrd = 1 și cma = 0.

int main() {
    int x, y, nrd, cma;
    cin >> x >> y;
    ofstream g("def.out");

    for (int i = x; i <= y; i++) {
        cifDistMax(i, nrd, cma);
        if (nrd == 3 && cma == 2) {   // cifrele 0, 1, 2
            g << i;
            return 0;
        }
    }
    g << "nu exista";
    return 0;
}

Programul principal

• se citesc x și y și se deschide fișierul def.out pentru scriere
• pentru fiecare număr i, de la x la y, în ordine crescătoare
  • se apelează cifDistMax(i, nrd, cma)
  • dacă i are 3 cifre distincte și cifra maximă 2
    • i este cel mai mic număr căutat, deoarece numerele se parcurg crescător
    • i se scrie în fișier, iar return 0 încheie programul
• dacă structura repetitivă s-a încheiat fără să găsească niciun număr, se scrie nu exista

#include <iostream>
#include <fstream>
using namespace std;

/* Muta ultima cifra a lui n in fata celorlalte. */
void circular(int &n) {
    int u = n % 10;        // ultima cifra
    n = n / 10;            // celelalte cifre
    int p = 1;
    int aux = n;
    while (aux > 0) {      // p = 10 la puterea nr. de cifre
        p = p * 10;
        aux = aux / 10;
    }
    n = u * p + n;
}

Subprogramul circular(n)

• n este transmis prin referință (&), deci rezultatul ajunge în variabila din apel
• u primește ultima cifră, n % 10
• n primește celelalte cifre, n / 10
• p se calculează ca 10 la puterea numărului de cifre rămase
  • p pornește de la 1
  • pentru fiecare cifră a copiei aux, p se înmulțește cu 10
• u * p + n pune cifra u în fața cifrelor rămase

int main() {
    ifstream f("def2022.in");
    int x, mn = 0, nr = 0;  // nr = 0: niciun impar gasit

    while (f >> x) {
        circular(x);
        if (x % 2 == 1) {
            if (nr == 0 || x < mn) {
                mn = x;
                nr = 1;
            }
            else if (x == mn)
                nr++;
        }
    }

    if (nr == 0)
        cout << "nu exista";
    else
        cout << mn << " " << nr;
    return 0;
}

Programul principal

• se deschide fișierul def2022.in pentru citire
• mn este cel mai mic număr impar găsit, iar nr este numărul lui de apariții
  • nr = 0 arată că nu s-a găsit încă niciun număr impar
• cât timp se citește un număr x din fișier
  • circular(x) înlocuiește x cu termenul corespunzător din șirul circular
  • dacă x este impar
    • dacă este primul număr impar sau este mai mic decât mn, mn primește x și nr devine 1
    • altfel, dacă x este egal cu mn, nr crește cu 1
• dacă nr a rămas 0, se afișează nu exista
• altfel se afișează mn și nr

#include <iostream>
#include <fstream>
using namespace std;

/* Returneaza suma cifrelor lui n. */
int suma(int n) {
    int s = 0;
    while (n > 0) {
        s = s + n % 10;
        n = n / 10;
    }
    return s;
}

Subprogramul suma(n)

• s pornește de la 0
• cât timp n este nenul
  • ultima cifră, n % 10, se adună la s
  • n / 10 elimină ultima cifră
• se returnează s

int main() {
    ifstream f("def2023.in");
    int x, mn = 10, nr = 0;

    while (f >> x) {
        int c = x;
        while (c > 9)        // pana ramane o cifra
            c = suma(c);
        if (c < mn) {
            mn = c;
            nr = 1;
        }
        else if (c == mn)
            nr++;
    }

    cout << mn << " " << nr;
    return 0;
}

Programul principal

• se deschide fișierul def2023.in pentru citire
• mn, cea mai mică cifră de control, pornește de la 10, o valoare mai mare decât orice cifră
• nr, numărul termenilor cu cifra de control mn, pornește de la 0
• cât timp se citește un număr x din fișier
  • c pornește de la x
  • cât timp c are cel puțin două cifre, c primește suma(c)
  • c este acum cifra de control a lui x
  • dacă c este mai mică decât mn, mn primește c și nr devine 1
  • altfel, dacă c este egală cu mn, nr crește cu 1
• se afișează mn și nr

#include <iostream>
using namespace std;

int main() {
    int n;
    long long a1, a2, a3;
    cin >> n;
    a1 = 1;
    a2 = 1;
    cout << a1 << " " << a2;
    for (int i = 3; i <= n; i++) {
        a3 = a1 + a2;
        cout << " " << a3;
        a1 = a2;
        a2 = a3;
    }
    return 0;
}

Programul principal

• se citește n
• a1 și a2, primii doi termeni, primesc valoarea 1 și se afișează
• pentru i de la 3 la n
  • termenul de rang i, a3, este suma a1 + a2 și se afișează
  • ultimii doi termeni devin a2 și a3
    • a1 primește valoarea lui a2
    • a2 primește valoarea lui a3