domingo, 31 de octubre de 2010

Deitel_C++_4.21 ¿Qué hace el siguiente programa?


// QUE HACE EL SIGUIENTE PROGRAMA?    
         
#include <iostream>        
using namespace::std;        
         
void Alguna_Funcion ( char b[], int Tamano )  
{         
if ( Tamano > 0 )    
{         
Alguna_Funcion ( &b[1], Tamano - 1 );   
cout << b[0] << " ";    
}         
}         
         
         
int main()        
{         
const int Tamano_Arreglo = 4;     
char A[Tamano_Arreglo] = {'H', 'O', 'L', 'A' };  
         
cout <<"\n\nLos valores en el arreglo son: " << endl;
         
Alguna_Funcion(A, Tamano_Arreglo);        
         
cout << endl;       
         
return 0;        
}         

La ejecución del programa produce:

Los valores en el arreglo son: 
A L O H 


Deitel_C++_4.20 (Reservación de una Aerolínea en C++)


// ESTE ES UN SISTEMA DE RESERVACION DE UNA AEROLINEA      
               
#include <iostream>              
using namespace::std;              
               
#include <iomanip>              
               
int Asignar(int b[], int r);           
               
int main()              
{ // ABRE MAIN            
               
int Fumar[6] = {0};            
int No_Fumar[6] = {0};            
int respuesta, n = 0, s = 1, evaluacion;       
int Contador_Fumar = 0;            
int Contador_No_Fumar = 0;            
               
while ( (Contador_Fumar + Contador_No_Fumar) < 10 )        
{ // ABRE WHILE            
               
if ( 5 == Contador_Fumar )          
{ // ABRE IF            
cout <<"\nDesea Area de No Fumar? ( 1 para si, 0 para no) " << endl;
cin >> respuesta;             
               
if ( 1 == respuesta )          
{               
evaluacion = Asignar( No_Fumar, n ); // SI EL CLIENTE DESEA NO FUMAR SE ENVIA N
if ( 0 == evaluacion )          
Contador_No_Fumar++;               
else               
Contador_Fumar++;               
               
} // CONTADOR NO_FUMAR            
               
else               
cout <<"\nEl proximo vuelo parte en tres horas. " << endl;     
               
} // CIERRA IF            
               
else               
{ // ABRE ELSE            
cout <<"\nDesea area de fumar? (1 para si, 0 para no) "<<endl;    
cin >> respuesta;             
               
if ( 1 == respuesta )          
{               
evaluacion = Asignar( Fumar, s ); // SE ENVIA S PARA INCREMENTAR CONTADOR_FUMAR   
if (0 == evaluacion)            
Contador_No_Fumar++;               
else               
Contador_Fumar++;               
}               
else               
{ // ABRE ELSE            
cout <<"\nDesea Area de No Fumar? ( 1 para si, 0 para no ) " <<endl;
cin >> respuesta;             
if ( 1 == respuesta )          
{               
evaluacion = Asignar(No_Fumar, n );           
if ( 0 == evaluacion )          
Contador_No_Fumar++;               
else               
Contador_Fumar++;               
}               
               
else               
cout <<"\nEl proximo vuelo sale en tres horas. " << endl;     
               
} // CIERRA ELSE            
} // CIERRA ELSE            
               
} // CIERRA WHILE            
               
return 0;              
               
} // CIERRA MAIN            
               

////////////////////////////////////////////////////
// ASIGNAR
//////////////////////////////////////////////////// 
               
int Asignar( int b[], int r )         
{ // ABRE ASIGNAR            
int c, No_Fumar = 0, Fumar = 1;;        
               
for ( c = 1; 5 >= c; c++ )      
{ // ABRE FOR            
               
if ( 0 == b[c] )          
{ // ABRE IF            
cout << "\nAsiento " << c << endl;        
b[c] = 1;             
               
if ( 0 == r )          
return No_Fumar;              
               
else               
return Fumar;              
} // CIERRA IF            
} // CIERRA FOR            
               
} // CIERRA ASIGNAR            

Deitel_C++_4.18 (Programa Incógnita en C++)


// QUE HACE ESTE PROGRAMA?        
            
#include <iostream>           
using namespace::std;           
            
int Que_Es_Esto(int[], int); // FUNCION INCOGNITA       
            
int main()           
            
{            
const int Tamano_Arreglo = 10;        
int A[Tamano_Arreglo] = {1,2,3,4,5,6,7,8,9,10};         
int resultado = Que_Es_Esto(A, Tamano_Arreglo);        
            
cout <<"\nEl resultado es: " << resultado << endl;    
            
return 0;           
}            
            
            
int Que_Es_Esto(int b[], int size)        
{            
if ( size == 1 )       
return b[0];           

else            
return b[ size - 1 ] + Que_Es_Esto( b, size - 1 );
}            


El resultado al ejecutar este programa es la siguiente línea:


El resultado es: 55

Deitel_C++_4.17 (Lanzamiento de Dados en C++)

Lanzamiento de Dados en C++
Escriba un programa que simule el tiro de dos dados. El programa debe utilizar rand para tirar el primer dado y debe utilizar rand de nuevo para tirar el segundo dado. Entonces, se debe calcular la suma de los dos valores. Su programa debe lanzar los dedos 36000 veces. Utilice un arreglo con un sólo subíndice para registrar el número de veces que aparece cada suma posible. Despliegue los resultados en formato tabular. Además, determine si los totales son razonables (es decir, existen 6 maneras de tirar un 7, de manera que aproximadamente un sexto de todos los tiros debe ser 7).


// ESTE PROGRAMA SIMULA 3600 LANZAMIENTOS DE UN DADO

    #include <iostream>
    using namespace::std;
    #include <ctime>                                      
   // CONTIENE EL PROTOTIPO DE LA FUNCION TIME
    #include <cstdlib>                                   
   // CONTIENE EL PROTOTIPO DE LA FUNCION RAND Y SRAND

   int main()


   {                   // ABRE MAIN
    srand( time( 0 ) ); 
    // USA LA HORA ACTUAL COMO SEMILLA PARA PRODUCIR NUMEROS ALEATORIOS 
    // DISTINTOS EN CADA LLAMADA A RAND

    cout <<"\n\nLanzamiento de 3600 jugadas: " << endl;
    int lanzamiento;
    int Frecuencia[13] = {0};                         
    // SE LANZAN DOS DADOS Y SE EVITA EL ELEMENTO 0 DEL ARREGLO

    for ( int i = 1; i <= 3600; i++ )
      {                                                 // ABRE FOR
       lanzamiento = ( 1 + rand() % 6 ) + (1 + rand() % 6 );  
       // AQUI SE SIMULA EL LANZAMIENTO DE LOS DADOS 
       Frecuencia[lanzamiento]++;  
       // SE INCREMENTA EN 1 LA FRECUENCIA DEL NUMERO QUE CAYO

      }                  // CIERRA FOR  

    for ( int n = 2; 12 >= n; n++ ) 
    // ESTE CICLO FOR IMPRIME LAS FRECUENCAS
    cout <<"\nLa frecuencia de " << n << " es: " << Frecuencia[n];
    cout << endl;
    return 0;

   }         

Deitel_C++_4.11 (Ordenamiento Burbuja Mejorado)

Programa que mejora el ordenamiento burbuja.
     //    ESTE PROGRAMA ES UNA MEJORA AL ORDENAMIENTO LINEAL.

 
     #include <iostream>

     using namespace::std;

  

     #include <iomanip>   //PARA PODER USAR setw

 
   int main()


   {

   // AQUI VAN LAS DECLARACIONES DE VARIABLES.



   const int Tamano_Arreglo = 10;

   int A[10] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37};  
   //NO SE PUEDE INICIALIZAR SI SE PONE UNA CONSTANTE COMO TAMANO DEL ARREGLO.
   int i, hold, pass, j;

   // TERMINAN LAS DEFINICIONES DE VARIABLES.

    cout << "\n\nESTE PROGRAMA ES UNA MEJORA AL ORDENAMIENTO LINEAL. " << endl;
    cout << "Aqui estan los datos del arreglo en el orden original. " << endl;

  // ESTE CICLO FOR ES PARA IMPRIMIR LOS DATOS DEL ARREGLO A[].


    for ( i = 0; i < Tamano_Arreglo; i++ )

      cout << setw(4) << A[i];

  // TERMINA EL CICLO PARA IMPRIMIR DATOS.

  // ESTOS CICLOS ANIDADOS ORDENAN EL ARREGLO.


    for ( pass = 0; pass < Tamano_Arreglo - 1; pass++ )

      for ( i = 0, j = Tamano_Arreglo -1; i < j; i++, j-- )

      if ( A[i] > A[i+1])

      {

       hold = A[i];

       A[i] = A[i +1];
       A[i + 1] = hold;

      }

  // AQUI TERMINA EL ORDENAMIENTO DEL ARREGLO

  // EN LA ULTIMA PARTE DEL PROGRAMA SE IMPRIMEN LOS DATOS ORDENADOS.

   cout << "\nLos datos en orden ascendente: " <<endl;


   for ( i = 0; i < Tamano_Arreglo; i++ )
     cout << setw(4) << A[i];

   return 0;

  }             

Deitel_C++_4.10 (Comisión por ventas)

4.10 Utilice un arreglo con un sólo subíndice para resolver el siguiente problema. Una empresa paga a su personal de ventas en base a una comisión. El personal de ventas recibe $200 por semana, más 9 por ciento de sus ventas totales semanales. Por ejemplo, un vendedor que suma $5000 en ventas semanales recibe $200 más el 9 por ciento de $5000, o un total de $650. Escriba un programa (mediante el uso de contadores de arreglos) que determine cuántos de los vendedores reciben salarios en cada uno de los siguientes rangos ( suponga que el salario de cada vendedor se trunca para obtener un monto entero):
a) de $200 a $299
b) de $300 a $399
c) de $400 a $499
d) de $500 a $599
e) de $600 a $699
f) de $700 a $799
g) de $800 a $899
h) de $900 a $999
i) de $1000 o más

Solución:
// ESTE PROGRAMA CALCULA LOS SALARIOS DE 10 TRABAJADORES QUE GANAN UN SUELDO BASE DE 200 MAS 9 % DE SUS VENTAS SEMANALES.
#include <iostream>
    using namespace::std;
    int Tamano_Arreglo = 10;

   int main()

   {  // Abre main

    float A[Tamano_Arreglo + 1];
    int B[Tamano_Arreglo + 1], C[11] = {0};
    int i, j, k;
    float ventas;

    cout << "\n\nEste programa calcula los rangos en los que estan los salarios de los " << Tamano_Arreglo <<" empleados. "<< endl;
    for ( i = 1; i <= Tamano_Arreglo; i++ )
      {
       cout << endl << endl << endl <<"Introduzca las ventas del empleado numero " << i << endl;
       cin >> ventas;
       A[i] = (static_cast<float>(9)/100)*ventas + 200.00;
       cout << "El salario del empleado " << i << " es: " <<  A[i] << endl;
       B[i] =  static_cast< int >( A[i] )/100;
      }

    for ( k = 1; k <= Tamano_Arreglo; k++ )
      {
       if ( B[k] < 10)
       C[B[k]]++;
       else
       C[Tamano_Arreglo]++;
      }
 
   for ( j = 2; j < Tamano_Arreglo; j++ )

     {
      cout << endl << "Hay " << C[j] <<" empleados que cobran entre "  << (j * 100) << " y ";
      cout << (( j + 1 ) * 100 ) - 1 << " pesos " <<endl;
     }

   cout <<endl<<"Hay " << C[(Tamano_Arreglo)] << " empleados que cobran 1000 o mas."<<endl <<endl << endl;
   return 0;
   }  // Cierra main

Deitel_C++_3.59 (el mayor de tres enteros usando plantilla)

Este programa utiliza una plantilla para determinar el mayor de unos argumentos.
    # include <iostream>
   using namespace std;

   template < class Si >
   Si  maximo (Si valor1, Si  valor2, Si  valor3)
   {
   Si max = valor1;
   if (valor2 > max)
   max = valor2;

   if (valor3 > max )
   max = valor3;

   return max;
   }

   ////////////////////////////////////////////////
   //MAIN
   ////////////////////////////////////////////////
   int main()
   {
    int entero1, entero2, entero3;
    
    cout<<"\n\nIntroduzca tres valores enteros y sabra cual es el mayor: " << endl;
    cin >> entero1 >> entero2 >> entero3;
    cout <<"\nEl mayor entero es: " << maximo(entero1, entero2, entero3) << endl;

    double doble1, doble2, doble3;

    cout <<"\nIntroduzca tres valores double y sabra cual es el mayor: " << endl;
    cin >> doble1 >> doble2 >> doble3;
    cout <<"\nEl mayor valor doble es: " << maximo(doble1, doble2, doble3) << endl;

    return 0;

   }

Deitel_C++_3.58 (El mínimo de tres números mediante el uso de plantilla en C++)


// QUE HACE ESTE PROGRAMA?        
            
#include <iostream>           
using namespace::std;           
            
int Que_Es_Esto(int[], int); // FUNCION INCOGNITA       
            
int main()           
            
{            
const int Tamano_Arreglo = 10;        
int A[Tamano_Arreglo] = {1,2,3,4,5,6,7,8,9,10};         
int resultado = Que_Es_Esto(A, Tamano_Arreglo);        
            
cout <<"\nEl resultado es: " << resultado << endl;    
            
return 0;           
}            
            
            
int Que_Es_Esto(int b[], int size)        
{            
if ( size == 1 )       
return b[0];           

else            
return b[ size - 1 ] + Que_Es_Esto( b, size - 1 );
}            

Deitel_C++_3.55 (Calcular el Área de un Círculo en C++)

3.55 Escriba un programa en C++ que utilice una función inline CircleArea que pida al usuario el radio del círculo, y que calcule y despliegue el área de ése círculo.


/*+++++++++++++++++++++++++++++++++++++++++++++++++++++
 * PROGRAMA QUE CALCULA EL AREA DE UN CIRCULO         *
 *                                                    *
 * LO QUE RECIBE: EL RADIO DEL CIRCULO                *
 *                                                    *
 * LO QUE REGRESA: EL AREA DEL CIRCULO                *
 *                                                    *
 * ****************************************************/

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *                                                                             *
 *                                ALGORITMO:                                   *
 *                                                                             *
 * PEDIR EL RADIO DEL CIRCULO AL USUARIO                                       *
 * RECIBIR EL RADIO DEL CIRCULO                                                *
 *                                                                             *
 * CALCULAR EL AREA DEL CIRCULO USANDO A = PI*R*R                              *
 *                                                                             *
 * DESPLEGAR EL AREA DEL CIRCULO                                               *
 * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
               
//Introduce inline.              
               
# include <iostream>             
#include <iomanip>              
               
using namespace std;             
               
///////////////////////////////////////
// FUNCION INLINE CIRCLEAREA
///////////////////////////////////////

inline float CircleArea (const float r){return 3.1416 * r * r; }    

///////////////////////////////////////
// FUNCION MAIN
///////////////////////////////////////               

int main()              
               
{   /* Abre main */               
               
float radio;              
               
cout<<"\n\nEste programa calcula el area de un circulo. " << endl;     
cout<<"Teclee el radio. "<<endl;            
cin >> radio;             
cout<<"El area del circulo con radio" << radio << " es " << CircleArea(radio) <<endl; 
               
return 0;              
}   /* Cierra main */            

Deitel_C++_3.52 (Prueba de Funciones Matemáticas de C++)

3.52 Escriba un programa que pruebe tantas de las funciones matemáticas de la librería como pueda. Ejercite cada una de estas funciones haciendo que su programa imprima tablas de valores devueltos para una variedad de valores de argumentos.

// Probando funciones de <cmath>
#include <iostream> #include <iomanip> #include <cmath> using namespace std; // Requiere de <iostream> using std::setw; // Requiere de <iomanip> int main() { long double x, y; cout <<"\n\nEste programa prueba algunas funciones de el encabezado <cmath>."<<endl; cout <<"Introduzca un numero. " <<endl; cin >> x; cout<<"\nLa funcion ceil(x ) redondea x al entero mas pequenio no menor que x. " << setw (10) << ceil(x) <<endl; cout<<"La funcion cos(x) da el coseno de x. " <<setw(10) <<cos(x) << endl; cout<<"La funcion exp(x) da el valor e elevado a la x. " <<setw(10)<< exp(x) <<endl; cout<<"La funcion fabs(x) da el valor absoluto de x. " << setw(3) << fabs(x) <<endl; cout<<"La funcion floor(x) redondea x al entero mas grande no mayor que x. " <<setw(3) << floor(x) <<endl; cout<<"La funcion log(x) da el logaritmo base 10 de x. " << setw(3)<< log(x) << endl; cout<<"La funcion sin(x) da el seno de x. " << setw(3) << sin(x) << endl; cout<<"La funcion sqrt(x) da la raiz cuadrada de x. " << setw(3) << sqrt(x) <<endl; cout<<"La funcion sin(x) da el seno de x. " << setw(3) << sin(x) << endl; cout<<"La funcion sqrt(x) da la raiz cuadrada de x. " << setw(3) << sqrt(x) <<endl; cout<<"La funcion tan(x) da la tangente de x. " << setw(3) << sqrt(x) <<endl; cout<<"Introduzca otro numero. " <<endl; cin >> y; cout<<"La funcion fmod(x,y) da el residuo de x/y como un numero de punto flotante. " << setw (5) << fmod(x,y) <<endl; cout<<"La funcion pow(x,y) da el valor de x elevado a la y. " <<setw(3) << pow(x,y) << endl; return 0; }

Deitel_C++_3.48 (Distancia entre dos puntos en C++ con el teorema de Pitágoras)

_____________________________________________________________________________________
3.48 Escriba una función distancia que calcule la distancia entre dos puntos (x1,y1) y (x2,y2). Todos los números y los valores devueltos deben ser del tipo double.
_____________________________________________________________________________________
Para este problema es útil la siguiente figura que presenta un triángulo rectángulo. En ella se identifican los lados del triángulo (a, b y c) El lado más grande es llamada hipotenusa, y los otros son llamados catetos. El matemático griego Pitágoras demostró que la relación entre los lados de un triángulo rectángulo es la siguiente: c² = a² + b²





/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    *                                                                    *
    *     PROGRAMA QUE CALCULA LA DISTANCIA ENTRE DOS PUNTOS             *
    *                                                                    *
    *  LO QUE RECIBE: LAS COORDENADAS DE LOS DOS PUNTOS                  *
    *  LO QUE DEVUELVE: LA DISTANCIA ENTRE LOS DOS PUNTOS                *
    *                                                                    *
    * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
   
   /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    *                                                                                            *
    *                                         ALGORITMO:                                         *
    *                                                                                            *
    *  Pide las coordenadas del primer punto                                                     *
    *     Recibe las coordenadas                                                                 *
    *  Pide las coordenadas del segundo punto                                                    *
    *     Recibe las coordenadas                                                                 *
    *                                                                                            * 
    *  Calcular la distancia entre los dos puntos usando el teorema de Pitagoras                 *
    *  Presentar esa distancia en pantalla                                                       *
    *                                                                                            *
    * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
   

   # include <iostream>
   # include <cmath>
   # include <iomanip>
 
   using namespace std;
   using std::setw;
   
   //////////////////////////////////////////////////////////////////////////////
   // PROTOTIPO DE FUNCION DISTANCIA
   //////////////////////////////////////////////////////////////////////////////
   
   float distance(float, float, float, float);
 
   //////////////////////////////////////////////////////////////////////////////
   //FUNCION MAIN
   //////////////////////////////////////////////////////////////////////////////
   
   int main()
   {              /* Abre main */

   float x1, x2, y1, y2, distancia;
   
   cout <<"\n\nEste programa calcula la distancia entre dos puntos en el plano cartesiano. "<<endl;
   cout <<"\n\nIntroduzca las coordenadas del primer punto: "<<endl;
   cin >> x1 >>  x2;

   cout <<"\nIntroduzca las coordenadas del segundo punto: " <<endl;
   cin >> y1 >>  y2;

   distancia = sqrt((x1 - y1)*(x1 - y1 ) + (x2 - y2)*(x2 - y2));

   cout <<"\nLa distancia entre los puntos es: " << setw(10) <<distancia << endl;

   return 0;
   
   }            /* Cierra main */

Deitel_C++_3.47 (Educación Asistida por Computadora, Aprendiendo las Tablas de Multiplicar)


                
// Programa para multiplicar dos numeros.           
                
#include <iostream>               
#include <cstdlib>               
#include <ctime>               
#include <cmath>               
                
using namespace std;              
                
int Generador(int);               
void Incorrectas(void);               
void Correctas(void);               
                
int main()               
{                
int number1, number2, digito;             
int respuesta, correctas = 0;            
int incorrectas = 0;             
int GeneralCounter = 0;             
int centinela = 1;             
                
srand (time (NULL));              
cout <<"\n\nEste programa le ayudara a aprender a multiplicar proponiendole ejercicios."<<endl;      
                
while (1 == centinela)             
{                
cout <<"Introduzca el numero de cifras que tendran sus numeros: " << endl;    
cin >> digito;              

number1 = Generador(digito);              
number2 = Generador(digito);              
                
cout <<"\nCuanto es "<<number1 <<" x " <<number2 << " ? "<<endl;     
cin >> respuesta;              
                
incorrectas = 0;              
                
while ( number1 * number2 != respuesta )         
{                
Incorrectas();                
cin >> respuesta;              
incorrectas++;                
GeneralCounter++;                
                
if ( 10 <= incorrectas )           
{                
cout <<"\nPide ayuda a tu maestro."<<endl;           
return 0;               
}                
                
}                
                
if ( 10 <= GeneralCounter)            
if (.25 * GeneralCounter >= correctas)           
{                
cout <<"\nPide ayuda a tu maestro." << endl;         
return 0;               
}                
                
Correctas();                
correctas++;                
GeneralCounter++;                
                
cout<<"\nSi quiere seguir introduzca 1, si no cualquier otro numero." << endl << endl;   
cin >> centinela;              
                
}                
                
return 0;               
}                
                

//Esta es la funcion Generador            
int Generador(int x )             
{                
                
int numero = rand () % 10;          
int multiplicador;               
                
if ( 0 < x )           
{                
if ( 1 < x )           
{                
for ( int n = 1; n <= x; n++ )      
{                
multiplicador = 1;              
for ( int m = 1; m < n; m++ )      
multiplicador *= 10;              
numero += ( rand() % 10 ) * multiplicador;        
}                
                
return numero;               
}                
                
else                
return rand() % 10;             
}                
                
else                
{                
return 0;               
}                
                
}                
                
//Definicion de la funcion Incorrectas.            
                
void Incorrectas(void)               
{                
int n = 1 + rand () % 4;        
                
switch(n)                
{                
case 1:               
cout <<"\nNo. Por favor trata de nuevo. " <<endl;        
break;                
case 2:               
cout <<"\nIncorrecto. Trata una vez mas. \n";          
break;                
case 3:               
cout <<"No te rindas."<<endl;             
break;                
case 4:               
cout <<"\nNo. Trata de nuevo." <<endl;           
break;                
default :               
cout <<"\nESTE PROGRAMA ESTA MAL! NO DEBERIA VER ESTE MENSAJE!"<<endl<<endl;       
break;                
}                
return;                
}                
                
// Aqui se define la funcion Correctas.          
void Correctas(void)               
{                
int n = 1 + rand() % 4;         

switch(n)                
{                
case 1:               
cout <<"\n Muy bien!"<<endl;             
break;                
case 2:               
cout <<"\nExcelente!"<<endl;               
break;                
case 3:               
cout <<"\nBuen trabajo!."<<endl;              
break;                
case 4:               
cout <<"\nSigue haciendolo bien!."<<endl;             
break;                
default:                
cout <<"\nSU PROGRAMA ESTA MAL! NO DEBERIA VER ESTE MENSAJE!"<<endl<<endl;       
break;                
}                
                
return;                
}                


Deitel_C++_3.46 (Llamada Recursiva a main)

Este programa crea un ciclo infinito.

          
/*+++++++++++++++++++++++++++++++++++++++++++++++++
 *                                                 +
 *  ESTE PROGRAMA LLAMA RECURSIVAMENTE A MAIN      *
 *                                                 *
 *+++++++++++++++++++++++++++++++++++++++++++++++++*/    
          
#include <iostream>         
using namespace::std;        

///////////////////////////////////////////////////////////////
// FUNCION MAIN
///////////////////////////////////////////////////////////////

int main()                             
{          
static int counter = 1;      
cout <<"\n\nUn valor de counter: " << counter++ << endl; 

/*Se llama a la funcion main dentreo de main */
main();          
          
return 0;                   
}          
          

Deitel_C++_3.45 (Maximo Comun Divisor en forma recursiva)

_____________________________________________________________________________________
3.45 (Recursividad para el Máximo Común Divisor) El máximo común divisor de los enteros x y y es el entero más grande que divide tanto a x como a y. Escriba una función reursiva mcd que devuelva el máximo común divisor de x y y, la cual está definida recursivamente de la siguiente manera: se y es igual a 0, entonces, mcd(x, y) es x; de otro modo, mcd(y, x%y), donde % es el operador módulo.
_____________________________________________________________________________________
El programa es bastante simple, y la función gcd está definida exactamente como se especifica en el enunciado del problema. El programa en sí mismo es bastante fácil de leer y seguir. Cópielo, ejecútelo y modifíquelo para mejorarlo si quiere.


////////////////////////////////////////////////////////////
//                                                        //
// Este programa recibe un par de enteros positivos y     //
// calcula el maximo comun divisor mediante la recursion  //
////////////////////////////////////////////////////////////
   
#include <iostream>
using namespace std;
int gcd (int, int);

int main()

{       /*Abre main*/
unsigned int a, b, max;

cout <<"\n\nSe calcula el maximo comun divisor de dos numeros."<<endl;
cout <<"Introduzca dos numeros enteros no negativos: "<<endl;
cin >> a >> b;

if ( a >= b )
max = gcd (a,b);
else
max = gcd (b,a);
cout <<"\nEl maximo comun divisor de los numeros es: "
<<max << endl;
 
return 0;
}     /*Cierra main*/

//////////////////////////////////////////////////////////////////////
// FUNCION GCD
//////////////////////////////////////////////////////////////////////

int gcd (int x, int y)

{            /*Abre gcd*/
if (0 == y)
return x;
else
return gcd (y, x%y);
}           /*Cierra gcd*/

Una ejecución de éste programa es la siguiente

[hernandez@localhost Programas]$ ./a.out 
Se calcula el maximo comun divisor de dos numeros.
Introduzca dos numeros enteros no negativos: 

568
456

El maximo comun divisor de los numeros es: 8

Deitel_C++_3.44 (Visualización de la Recursión en C++ con Factorial de 10)

_____________________________________________________________________________________
3.44 (Visualización de la recursividad) Es interesante observar a la recursividad en "acción". Modifique la función factorial de la figura 3.14 para que despliegue su variable local y el parámetro de llamada recursiva. Por cada llamada recursiva, despliegue los resultados en una línea diferente y agregue un nivel de sangrado. Haga su mayor esfuerzo para que sus resultados sean claros, interesantes y útiles. Su objetivo aquí es diseñar e implementar un formato para los resultados que ayude a una persona a comprender mejor la recursividad. Tal vez desee agregar dichas capacidades de despliegue a los muchos otros ejemplos y ejercicios sobre recursividad que contiene el libro.
_____________________________________________________________________________________
Solución:
// Calculo de factoriales.
    #include <iostream>
     #include <iomanip>
     using namespace std;
     using std::setw;
    unsigned long factorial (unsigned long);
 
   int main()

    {
    cout <<endl<<endl<<"Se presentan los factoriales de los primeros";
    cout <<" 10 enteros."<<endl;
    for ( int i = 0; i <= 10; i++)
       cout << setw(2) << i << "! = " <<factorial(i) << endl;

    return 0;

  }

  ////////////////////////////////////////////////////
  // FACTORIAL
  ////////////////////////////////////////////////////
    unsigned long factorial (unsigned long number)

   {
    if ( number <= 1 )
    return 1;
    else

    {
    cout <<number <<" Llamada recursiva a factorial de: "
         << number - 1<< endl;
    return number * factorial(number-1);

    }
   }

la ejecución del programa produce la siguiente salida:


Se presentan los factoriales de los primeros 10 enteros.
 0! = 1
 1! = 1
2 Llamada recursiva a factorial de: 1
 2! = 2
3 Llamada recursiva a factorial de: 2
2 Llamada recursiva a factorial de: 1
 3! = 6
4 Llamada recursiva a factorial de: 3
3 Llamada recursiva a factorial de: 2
2 Llamada recursiva a factorial de: 1
 4! = 24
5 Llamada recursiva a factorial de: 4
4 Llamada recursiva a factorial de: 3
3 Llamada recursiva a factorial de: 2
2 Llamada recursiva a factorial de: 1
 5! = 120
6 Llamada recursiva a factorial de: 5
5 Llamada recursiva a factorial de: 4
4 Llamada recursiva a factorial de: 3
3 Llamada recursiva a factorial de: 2
2 Llamada recursiva a factorial de: 1
 6! = 720
7 Llamada recursiva a factorial de: 6
6 Llamada recursiva a factorial de: 5
5 Llamada recursiva a factorial de: 4
4 Llamada recursiva a factorial de: 3
3 Llamada recursiva a factorial de: 2
2 Llamada recursiva a factorial de: 1
 7! = 5040
8 Llamada recursiva a factorial de: 7
7 Llamada recursiva a factorial de: 6
6 Llamada recursiva a factorial de: 5
5 Llamada recursiva a factorial de: 4
4 Llamada recursiva a factorial de: 3
3 Llamada recursiva a factorial de: 2
2 Llamada recursiva a factorial de: 1
 8! = 40320
9 Llamada recursiva a factorial de: 8
8 Llamada recursiva a factorial de: 7
7 Llamada recursiva a factorial de: 6
6 Llamada recursiva a factorial de: 5
5 Llamada recursiva a factorial de: 4
4 Llamada recursiva a factorial de: 3
3 Llamada recursiva a factorial de: 2
2 Llamada recursiva a factorial de: 1
 9! = 362880
10 Llamada recursiva a factorial de: 9
9 Llamada recursiva a factorial de: 8
8 Llamada recursiva a factorial de: 7
7 Llamada recursiva a factorial de: 6
6 Llamada recursiva a factorial de: 5
5 Llamada recursiva a factorial de: 4
4 Llamada recursiva a factorial de: 3
3 Llamada recursiva a factorial de: 2
2 Llamada recursiva a factorial de: 1
10! = 3628800

Deitel_C++_3.42 (Torres de Hanoi en C++, Version Recursiva)

_____________________________________________________________________________________
3.42 (Las Torres de Hanoi) Cada científico de la computación en ciernes debe batallar con ciertos problemas clásicos. Las Torres de Hanoi representan uno de los más famosos. La leyenda cuenta que en un templo del lejano oriente, unos sacerdotes intentan mover una pila de discos de una pila a otra. La pila inicial tiene 64 discos y están acomodados de abajo hacia arriba en orden de tamaño decreciente. Los sacerdotes intentan mover la pila de esta pila hacia una segunda, con las restricciones de mover sólo un disco a la vez, y que ningún disco más grande debe colocarse en encima de uno más pequeño. Una tercera pila está disponible para alojar temporalmente los discos. Se supone que el mundo terminará cuando los sacerdotes completen su tarea, por lo cual no hay ningún incentivo para facilitarles la tarea.
_____________________________________________________________________________________

Antes de intentar resolver este problema es bueno conseguirse un juego de torres de hanoi por ahi, los he visto en puestos callejeros de ajedrez, cartas, etc.; o improvisar uno, como hacen en las ferias de ciencias; tal vez la primera impresion sea que es complicado, sin embargo no tardaran en darse cuenta de que una vez que logran agarrar la idea, la solucion es bastante aburrida, solo hay que repetir una y otra vez el mismo procedimiento. Es por eso que este problema es tan susceptible de ser resuelto mediante la recursion. Se daran cuenta de que hay que solucionarlo de abajo para arriba. Tienen que mover el disco que esta en el fondo hacia la espiga de destino, para hacer esto tienen que mover una torre un poco menor (de solo N-1 discos) hacia la espiga destino. Este ultimo paso es crucial. Es muydiscos) hacia la espiga intermedia y entonces si mover el disco mas grande a su destino. Ahora lo que falta es mover la torre de N - 1 discos que esta en la importante darse cuenta de que la torre con N - 1 discos se mueve DOS VECES, la primera hacia la espiga intermedia y la segunda hacia la espiga de destino despues de haber movido el disco de abajo. Si logran comprender esto entonces ya resolvieron el problema, solo hagan lo mismo con todas las torres hasta que lleguen a tener una torre con un solo disco. En ese caso limite ya no necesitan usar una espiga intermedia, pueden pasar directamente el disco del origen al destino.


# include <iostream>

using namespace::std;

////////////////////////////////////////////////////////////////////

// FUNCION MOVER_TORRES

////////////////////////////////////////////////////////////////////

void Mover_Torres(int N, int Origen, int Intermedio, int Destino)

{ // Abre funcion Mover_Torres

if ( N > 1 )

{ // Abre if
Mover_Torres( N - 1, Origen, Destino, Intermedio);

/* Se mueve una torre de N - 1 discos desde la espiga origen
pero hacia la espiga intermedia ( para dejar la destino libre)
usando la espiga destino como intermedia cout << "\nMueve disco "
<< N << " de " << Origen << " a " << Destino <<endl;
con esta instruccion mueven el disco de la base hacia su destino
Como comento arriba, ahora hay que mover nuevamente la torre de
N - 1 discos hacia el destino original ( en donde se ha puesto el
disco mayor ) Esto implica una segunda llamada recursiva. Ahora
el origen es la espiga intermedia a la que se movio la torre y
el destino es el destino primitivo,lo que originalmente era el
origen se usa ahora como espiga intermedia */

cout <<"\nMueve el disco " <<  N  << " de " << Origen << " a " <<  Destino << endl;
Mover_Torres( N - 1, Intermedio, Origen, Destino);
} // Cierra if

// El caso limite mas sencillo se resuelve directamente

if ( 1 == N )
cout << "\nMueve el disco 1 de " << Origen << " a " << Destino << endl;

} // Cierra funcion Mover_Torres

int main()

{ // Abre funcion main
int Discos;
cout << "\nEste programa resuelve el problema clasico de las Torres de Hanoi";
cout <<" mediante la recursion." << endl;
cout << "\nPor favor introduzca el numero de discos que quiere mover ";
cout << " de la pila 1 a la pila 3" << endl;
cin >> Discos;

Mover_Torres( Discos, 1, 2, 3);

cout << endl << endl;

return 0;

} // Cierra funcion main


Como nota final se daran cuenta de que para pasar N discos de una torre a otra se requieren (2^N) - 1 movimientos. Asi que si los monjes de marras inician con una torre de 64 discos necesitaran hacer (2 ^ 64) - 1 ( = 18446744073709551616) movimientos para terminar. Suponiendo que hacen un movimiento por segundo entonces necesitarian 584942417355 años para terminar el trabajo. Pero como esto supera, y con mucho, la edad del universo, entonces no hay por que preocuparse de los avances de los monjes ni del fin del mundo.

Deitel_C++_3.41 (Números de Fibonacci en C++)

_____________________________________________________________________________________
Ejercicio 3.41 (La Serie de Fibonacci) La serie de Fibonacci 0, 1, 1, 2, 3, 5, 8, 13, 21, .... empieza con los números 0 y 1, y tiene la propiedad de que cada término sucesivo es la suma de los dos términos anteriores. a) Escriba una función no recursiva llamada fibonacci(n) que calcule el enésimo número de Fibonacci. b) Determine el número más grande de Fibonacci que puede desplegar su sistema. c) Modifique la parte a) del programa para que utilice double en lugar de int para que calcule y devuelva números de Fibonacci, y utilice este programa modificado para repetir la parte b)
_____________________________________________________________________________________
Solución:
La serie es una clásica de las ciencias de la complejidad, pensada, en un principio, como un modelo de crecimiento de una población de conejos. Para mayor información, revise un algo acerca de la sucesión de Fibonacci en Ésta página.
//Calcula la serie de Fibonacci

   #include <iostream>
   using namespace std;
   
   
   /*Prototipo de la funcion fibonacci*/
   int fibonacci (int);
   
   ///////////////////////////////////////////////////////////////////
   // MAIN
   ///////////////////////////////////////////////////////////////////
   int main()
 
   {

    int number, respuesta;
    cout <<endl<<endl<< "Este programa calcula el numero de Fibonacci."<<endl;
    cout <<"Introduzca un numero: " <<endl;
    cin >> number;

    if (0 == number || 1 == number )
    cout <<"Fibonacci de: " << number<<" es " << number << endl;
    else
      {

      respuesta = fibonacci (number);
      cout<<"Fibonacci de " << number << " es " << respuesta << endl;

      }
    return 0;

   }

  /////////////////////////////////////////////////////////////////////
  // FUNCION FIBONACCI
  /////////////////////////////////////////////////////////////////////
  
   int fibonacci (int number)

   {
   int fib1 = 0, fib2 = 1, fibn = 0, temp;

   for ( int n = 2; n <= number; ++n )
   {
   fibn = fib2 + fib1;
   temp = fib2;
   fib2 = temp + fib1;
   fib1 = temp;
   }

   return fibn;
   }

Deitel_C++_3.38 (Adivinar un Número en C++)

_____________________________________________________________________________________
3.38 Escriba un programa que juegue a "adivina un número", de la siguiente forma: Su programa elige el número que debe adivinarse, seleccionando un entero al azar en el rango de 1 a 2000. Si la opción del jugador es incorrecta, su programa debe repetirse hasta que el jugador obtenga el número correcto. Su programa debe continuar diciendo al jugador "Demasiado alto" o "Demasiado Bajo", para ayudar al jugador a acertar en la respuesta.
_____________________________________________________________________________________


//Programa adivine un numero.

   #include <iostream>
   using namespace::std;
   #include <ctime>
   #include <cstdlib>

   int incognita;
   int juego(int);

   int main()
   {
    int respuesta = 1;
    srand (time (NULL));
    while (1 ==  respuesta)
     {
       incognita = 1 + rand() % 1000;
       respuesta = juego(incognita);
     }

    return 0;

   }

 ////////////////////////////////////////////////////
 // FUNCION JUEGO
 ////////////////////////////////////////////////////
 
   int juego(int incognita1)

  {
   int intento, respuesta;
   cout<<endl<<endl<<"Tengo un numero entre 1 y 1000." << endl;
   cout<<"Puede adivinar el numero?"<<endl;
   cout<<"Por favor introduzca su primer intento." <<endl;
   cin>> intento;

   while (incognita1 != intento)
     {
      if ( intento < incognita1 )
      {
      cout << "Muy bajo. Intente de nuevo." <<endl;
      cin >> intento;

      }

      else
      cout <<"Muy alto. Intente de nuevo." <<endl;
      cin >> intento;
     }

   cout <<"Excelente!. Adivino el numero!"<< endl;
   cout <<"Deseas jugar otra vez? (1 para continuar, otro numero para continuar)"<<endl;
   cin>>respuesta;
   return (respuesta);
  }
 

Deitel_C++_3.36 (Tablas de Multiplicar en C++)

_____________________________________________________________________________________
3.36 al uso de las computadoras en la educación se le conoce como educación asistida por computadora. Un problema que se desarrolla en estos ambientes es la fatiga del estudiante. Esto puede eliminarse variando el diálogo de la computadora para mantener la atención del estudiante. Modifique el programa del Ejercicio 3.35 para que los diversos comentarios se impriman de la siguiente manera:

Diálogos para respuestas correctas
¡Muy bien!
¡Excelente!
¡Buen trabajo!
¡Continúa con tu buen desempeño!

Diálogos para respuestas incorrectas
No. Intenta de nuevo.
Error. Intenta una vez más.
¡No te des por vencido!
No. Sigue intentando.

Utilice el generador de números aleatorios para elegir un número del 1 al 4, para seleccionar un diálogo adecuado para cada respuesta. Utilice una estructura switch para desplegar los diálogos.
_____________________________________________________________________________________
Solución:
Este programa es una variación del anterior. También se presentan preguntas de aritmética básica y se presentan diferentes respuestas. Deberá mejorarse poniendo un ciclo que pregunte al estudiante si desea responder otra pregunta o no.


//Nuevas preguntas de artimetica con varias opciones de respuesta

 #include <iostream>
 #include <cstdlib>
 #include <ctime>

 using namespace std;

 int generador (void);
 void incorrectas (void);
 void correctas (void);

 int main ()

 {
 int number1, number2, respuesta, correctos, incorrectos;
 srand (time (NULL));
 number1 = generador();
 number2 = generador();
 cout<<"\nCuanto es: " << number1 << " x " << number2 <<"?"<<endl;
 cin >> respuesta;

 while ( number1 * number2 != respuesta)
 {
 incorrectas ();
 cin >> respuesta;
 }

 correctas ();

 return 0;
 }

///////////////////////////////////////////////////////////////////////////////////
// FUNCION GENERADOR
///////////////////////////////////////////////////////////////////////////////////

 int generador (void)
 {
 return 1 + rand() % 9;
 }

 //////////////////////////////////////////////////////////////////////////////////
 // FUNCION INCORRECTAS
 //////////////////////////////////////////////////////////////////////////////////

 void incorrectas (void)
 {

 int n = 1 + rand() % 4;
 
 switch (n)
 { 
 case 1:
 cout <<"No. Por favor trata de nuevo"<<endl;
 break;
 case 2:
 cout <<"Incorrecto. Trata una vez mas."<<endl;
 break;
 case 3:
 cout <<"No te rindas." << endl;
 break;
 case 4:
 cout <<"No. Trata de Nuevo." <<endl;
 break;
 default:
 cout <<"Su programa esta mal! Este mensaje no deberia verse!" << endl;
 break;
 }

 return;
 }

///////////////////////////////////////////////////////////////////////////
// FUNCION CORRECTAS
///////////////////////////////////////////////////////////////////////////

 void correctas (void)
 {
 int n = 1 + rand() % 4;

 switch (n)
 {
 case 1:
 cout<<"Muy bien!."<<endl;
 break;
 case 2:
 cout <<"Excelente!."<<endl;
 break;
 case 3:
 cout <<"Buen trabajo!." <<endl;
 break;
 case 4:
 cout <<"Sigue haciendolo bien!"<<endl;
 break;
 default:
 cout <<"Este programa esta mal!. No deberia ver este mensaje!"<<endl;
 break;
 }
 return;

 }

Deitel_C++_3.35 (Operaciones simples de Aritmética)

_____________________________________________________________________________________
3.35 Las computadoras son cada vez más importantes en la educación. Escriba un programa que ayude a un estudiante de primaria a que aprenda a multiplicar. Utilice rand para producir dos enteros positivos de un sólo dígito. Después debe desplegar una pregunta como la siguiente:
¿Cuánto es 6 por 7?
Entonces el estudiante escribe la respuesta. Su programa verifica la respuesta del estudiante. Si ésta es correcta, despliega "Muy bien", y después hace otra pregunta. Si la respuesta es incorrecta, despliega "No. Intenta de nuevo", y deja que el estudiante intente de nuevo la misma pregunta repetidamente, hasta que al final da la respuesta correcta.
_____________________________________________________________________________________
Este programa ayuda a alumnos de primaria a aprender a realizar operaciones simples de aritmética. El propio programa también es muy simple. Se genera un par de números aleatorios y se solicita la respuesta al alumno hasta que ésta es correcta. Una versión completa de este programa es Educación asistida por computadora
//Preguntas de aritmetica. 

  #include <iostream>
  #include <ctime>
  #include <cstdlib>
  using namespace std;

////////////////////////////////////////////////
// FUNCION GENERADOR
////////////////////////////////////////////////
  
  int generador (void)

  {
   return 1 + rand() % 9;
  }

//////////////////////////////////////////////
// MAIN
//////////////////////////////////////////////

  int main ()
  {
   int number1, number2, respuesta;
   number1 = generador();
   number2 = generador();

   cout <<"\nCuanto es " << number1 << " x "<<number2 << "?" <<endl;
   cin>> respuesta;

  while (number1 * number2 != respuesta)
     {
      cout <<"No. Por favor trata de nuevo."<<endl;
      cin >> respuesta;
     }

  cout << "Muy bien!"<<endl; 
  return 0;
  }

Deitel_C++_3.34 (Lanzamiento de una Moneda Cien Veces en C++ )

_____________________________________________________________________________________
3.34 Escriba un programa que simule el lanzamiento de una moneda. Por cada lanzamiento el programa debe desplegar Cara o Cruz. Deje que el programa lance la moneda 100 veces y cuente el número de veces en que aparece cada uno de los lados de la moneda. Despliegue los resultados. El programa debe llamar a la función flip que no tome argumentos y que devuelva 0 para cruz y 1 para cara. [Nota: Si el programa en realidad simula el lanzamiento de una moneda, entonces cada lado de la moneda debe aparecer aproximadamente la mitad de las veces.]
_____________________________________________________________________________________
Solución
Este programa simula el lanzamiento de una moneda cien veces. Desde luego, el resultado será aproximadamente 50 % de caras y 50 % de cruces. Este problema me recuerda una plática con un físico: Un profesor de estadística pide a sus alumnos que de tarea lancen una moneda 100 veces y anoten los resultados. Al día siguiente todos entregan la tarea y el profesor la revisa. Sorprendentemente el hombre acertaba a decir si el alumno de verdad había realizado los experimentos o sólo había inventado los datos. ¿Cómo lo sabía? Cuando se lanzan las monedas, la probabilidad de obtener una racha de 5 caras o 5 cruces seguidas es muy alta. Prácticamente debe haber por lo menos una racha de 5. Cuando alguien inventa los datos, no se le ocurre poner tal racha. Revise las corridas para ver cómo funciona su generador de números aleatorios.

//Simulacion del lanzamiento de una moneda.
#include <iostream> #include <cstdlib> #include <ctime> using namespace std; int flip (void); //////////////////////////////////////////// // FUNCION MAIN //////////////////////////////////////////// int main() { int value, cruz = 0, cara = 0; srand (time (NULL)); cout <<endl<<endl<<"Simulacion del lanzamiento de una moneda." << endl; for (int n =1; n<=100; ++n) { value = flip(); if (0 == value) { cout <<"Cruz\n"; ++cruz; } else { cout <<"Cara"<<endl; cara++; } } cout << endl<<"Numero de caras: " << cara << endl; cout << "Numero de cruces: "<<cruz<<endl; return 0; } //////////////////////////////////////////////////////////// // FUNCION FLIP /////////////////////////////////////////////////////////// int flip (void) { return rand() % 2; }
Related Posts Plugin for WordPress, Blogger...

¿Qué lenguaje de programación usas?