Subprograme (funcții)

Cifra de comparație este cifra unităților lui n, adică n%10; ea se calculează o singură dată. Apoi parcurgem intervalul $[x,y]$ și, pentru fiecare număr, îi verificăm toate cifrele cu ciclul standard c%10 / c/10.

int ascendent(int n, int x, int y)
{
    int u = n%10, s = 0, i, c, ok;
    for (i = x; i <= y; i++)
    {
        c = i;
        ok = 1;
        if (c == 0)
            ok = (u == 0);
        while (c > 0)
        {
            if (c%10 < u)
                ok = 0;
            c = c/10;
        }
        if (ok)
            s = s+i;
    }
    return s;
}

Două detalii care se pierd ușor:

1. numărul 0 nu intră în bucla while (c > 0), deci ar fi declarat ascendent din oficiu; el are o singură cifră, 0, deci este ascendent numai dacă cifra unităților lui n este tot 0; 2. dacă nu există niciun ascendent, suma rămâne 0, deci chiar valoarea cerută de enunț - nu este nevoie de un caz separat.

Verificare pe exemplu: pentru n=827 cifra unităților este 7, iar în $[9,800]$ numerele cu toate cifrele $\ge 7$ sunt cele din enunț, cu suma 7893.

Pentru fiecare număr n din interval calculăm suma divizorilor proprii impari și suma celor pari; divizorii proprii sunt cei din intervalul [2, n/2] care divid n (excludem 1 și n).

int majImp(int a, int b)
{
    int n, d, sImpar, sPar;
    for (n = a; n <= b; n++)
    {
        sImpar = 0;
        sPar = 0;
        for (d = 2; d <= n / 2; d++)
            if (n % d == 0)
            {
                if (d % 2 == 0)
                    sPar = sPar + d;
                else
                    sImpar = sImpar + d;
            }
        if (sImpar > sPar)
            return n;
    }
    return 0;
}

Parcurgem intervalul crescător, deci primul număr găsit este cel mai mic; dacă bucla se încheie fără să găsim un număr major impar, returnăm 0. Verificare pe exemplu: pentru n=18, divizorii proprii sunt 2, 3, 6, 9, cu 3+9=12 > 2+6=8, deci se returnează 18.

Calculăm suma divizorilor cu un subprogram auxiliar, apoi comparăm raportul lui n cu maximul rapoartelor pentru $k < n$, folosind împărțire reală:

int sumaDiv(int x) {
    int s = 0;
    for (int d = 1; d <= x; d++)
        if (x % d == 0)
            s = s + d;
    return s;
}

int abundent(int n) {
    double rmax = 0, r;
    for (int k = 1; k < n; k++) {
        r = 1.0 * sumaDiv(k) / k;
        if (r > rmax)
            rmax = r;
    }
    if (1.0 * sumaDiv(n) / n > rmax)
        return 1;
    return 0;
}

Înmulțirea cu 1.0 forțează împărțirea reală (altfel raportul s-ar trunchia la întreg). Pentru $n=6$: $S(6)/6 = 12/6 = 2$, iar maximul pentru $k<6$ este $S(4)/4 = 7/4 = 1.75$, deci se returnează 1. Suma divizorilor se poate calcula și mai eficient, parcurgând doar divizorii $d$ cu $d \cdot d \le x$ și adunând perechea $x/d$.