// lab04.cpp   carlos@loria.com

#include <iostream.h>  // cout

int armstrong(void) {
/*------------------------------------------------------------*\
| Determina cuántos números son de Armstrong, desde 1 hasta N. |
|                                                              |
| Un número es de Armstrong si la suma de los cubos de los     |
| dígitos que lo componen es igual al número.                  |
|                                                              |
| Por ejemplo el número 153 es de Armstrong, pues:             |
|                                                              |
|    3     3     3                                             |
|   1  +  5  +  3  =  1^3 + 5^3 + 3^3  = 1 + 125 + 27 = 153    |
\*------------------------------------------------------------*/

    const int N = 3000;
    int numero, digito, suma, temp;

    cout << "Números encontrados  (1.." << N << ") que son de Armstrong.";
    cout << "\n";

    for (numero=1 ; numero<=N ; numero++) {  // Para cada número en [1..n]
        suma = 0;
        temp = numero;

        while (temp != 0) { // Suma de cubo de los dígitos
            digito = temp % 10;               // Ultimo digito
            suma  += (digito*digito*digito);  // Acumulo el cubo del dígito
            temp   = temp / 10;               // quito último dígito
        }

        if (suma == numero) { // Si suma de dígitos^3 igual al número
            cout << numero << " suma de los cubos de sus dígitos ";
            cout << suma << endl;
        }
    } // para cada número del intervalo [1..n]
    return 0;

} // armstrong()



#include <iostream.h> // cout

int armstrong_vector (void) { // Versión con "vector de cubos..."
/*------------------------------------------------------------*\
| Determina cuántos números son de Armstrong, desde 1 hasta N. |
|                                                              |
| Un número es de Armstrong si la suma de los cubos de los     |
| dígitos que lo componen es igual al número.                  |
|                                                              |
| Por ejemplo el número 153 es de Armstrong, pues:             |
|                                                              |
|    3     3     3                                             |
|   1  +  5  +  3  =  1^3 + 5^3 + 3^3  = 1 + 125 + 27 = 153    |
\*------------------------------------------------------------*/

    const  int N = 3000;
    static int digitos [3];  // vector global de dígitos
    static int cubos   [3];  // vector global de cubos

    int numero, suma, temp;

    int i;       // indice auxiliar en dígitos
    int j;       // posición inversa en el vector

    cout << "Números encontrados  (1.." << N << ") que son de Armstrong.";
    cout << "\n";

    for (numero=1 ; numero<=N ; ++numero) {  // recorre [1..n]
        suma = 0;
        temp = numero;
        i    = 0;

        while (temp != 0) { // Suma de cubo de los dígitos
            digitos[i] = temp % 10;         // Ultimo digito
            cubos[i]   = digitos[i] * digitos[i] * digitos[i];    // cubo
            suma      += cubos[i];          // Acumulo el cubo del dígito
            temp      /= 10;                // quito último dígito
            ++i;
        }

        if (suma == numero) { // Si suma de dígitos^3 igual al número
            cout << numero << " suma de los cubos de sus dígitos ";
            cout << suma << endl;
            cout << "Pues : " << numero << " = ";

            for (j=i-1; j>=0; --j) {
                cout << digitos[j] << "^3";
                if (0 != j) {     // Si no es el último
                    cout << " + ";
                }
            }

            cout << " = ";
            for (j=i-1; j>=0; --j) {
                cout << cubos [j];
                if (0 != j) {  // Si no es el último
                    cout << " + ";
                }
            }
            cout << " = " << suma << "\n";
        }

    } // para cada número del intervalo [1..n]
    return 0;

} // armstrong_vector()


#include <iostream.h> // cout

int is_armstrong (int n);

int armstrong_funcion(void) { // Versión con funci¢n
/*------------------------------------------------------------*\
| Determina cuántos números son de Armstrong, desde 1 hasta N. |
|                                                              |
| Un número es de Armstrong si la suma de los cubos de los     |
| dígitos que lo componen es igual al número.                  |
|                                                              |
| Por ejemplo el número 153 es de Armstrong, pues:             |
|                                                              |
|    3     3     3                                             |
|   1  +  5  +  3  =  1^3 + 5^3 + 3^3  = 1 + 125 + 27 = 153    |
\*------------------------------------------------------------*/

    const int N = 3000;
    int numero;

    cout << "Números encontrados  (1.." << N << ") que son de Armstrong.";
    cout << "\n";

    for (numero=1 ; numero<=N ; numero++) {  // Para cada número en [1..n]

        if (is_armstrong( numero )) { // Si suma de dígitos^3 igual al número
            cout << numero << " suma de los cubos de sus dígitos ";
            cout << numero << endl;
        }
    } // para cada número del intervalo [1..n]
    return 0;

} // armstrong_funcion()

int is_armstrong (int n) {
/*------------------------------------------------------------*\
| Determina is el número "n" es o no un número de Armstrong.   |
|                                                              |
| Un número es de Armstrong si la suma de los cubos de los     |
| dígitos que lo componen es igual al número.                  |
|                                                              |
| Por ejemplo el número 153 es de Armstrong, pues:             |
|                                                              |
|    3     3     3                                             |
|   1  +  5  +  3  =  1^3 + 5^3 + 3^3  = 1 + 125 + 27 = 153    |
\*------------------------------------------------------------*/
    int suma = 0;
    int digito;
    int temp = n;

    while (temp != 0) { // Suma de cubo de los dígitos
        digito = temp % 10;               // Ultimo digito
        suma  += (digito*digito*digito);  // Acumulo el cubo del dígito
        temp   = temp / 10;               // quito último dígito
    }

    return (suma == n);  // Si suma de dígitos^3 igual al número
} // is_armstrong ()


int main (void) {
    return armstrong_funcion();
    return armstrong_vector();
    return armstrong();
}

// EOF: lab04.cpp