Tarea #1 [solución]

Números de Armstrong

      Digite el siguiente programa, y envíe por correo electrónico a los asistentes del curso los archivos resultantes (bool.h y lab01.cpp). Además, en su mensaje incluya tambié el resultado de ejecutar el programa.

Envío de tareas por correo electrónico

Andrés Arias y Tomás Rodríguez

// bool.h (C) 2000 adolfo@di-mare.com

/*  resultado
    Define el tipo "bool" para hacer compatibles los programas C++
    con compiladores estándar.
    - De esta manera, se puede usar el tipo "bool" en compiladores
      antiguos, como el Borland C++ v3.1
*/

#ifndef _bool_h
#define _bool_h
    #ifdef __BORLANDC__               // Definida para Borland C++
        #if (__BORLANDC__ <= 0x0410)  // Definida para v3.1
            typedef int bool;
            const int false = 0;
            const int true  = ! false;
        #endif
    #endif
#endif // _bool_h

// EOF: bool.h

// lab01.cpp   (C) 2000 carlos@loria.com


#include <iostream>  // cout

int armstrong() {
/*------------------------------------------------------------*\
| 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> // cout

int armstrong_vector() { // 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 = 1+9999;

    // vectores de dígitos y cubos
    int digito [(N<10?1:(N<100?2:(N<1000?3:(N<10000?4:5))))];
    const  int Nvec = sizeof(digito) / sizeof(digito[0]);
    int cubo [Nvec];

    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
            digito[i] = temp % 10;  // Ultimo digito
            cubo[i]   = digito[i] * digito[i] * digito[i];    // cubo
            suma      += cubo[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 << digito[j] << "^3";
                if (0 != j) {     // Si no es el último
                    cout << " + ";
                }
            }

            cout << " = ";
            for (j=i-1; j>=0; --j) {
                cout << cubo[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> // cout
#include <bool.h>   // false+true

bool is_armstrong (int n);

int armstrong_funcion() { // 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()


bool 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() {
    int ret;  // código de retorno del programa principal

    ret = armstrong();
    if (ret != 0) {
        cout << "ERROR: " << ret << "armstrong()";
    }

    ret = armstrong_funcion();
    if (ret != 0) {
        cout << "ERROR: " << ret << "armstrong_funcion()";
    }

    ret = armstrong_vector();
    if (ret != 0) {
        cout << "ERROR: " << ret << "armstrong_vector()";
    }

    return 0;
} // main()

// EOF: lab01.cpp

Soluciones

Adolfo Di Mare <adolfo@di-mare.com>.
Copyright © 2000
Derechos de autor reservados © 2000