Ordena los valores de un arreglo en orden ascendente

// Este programa ordena los valores de un arreglo en orden ascendente
#include <iostream>

using std::cout;
using std::endl;

#include <iomanip>

using std::setw;

int main()
{
const int tamanoArreglo = 10;
int a[ tamanoArreglo ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
int mantiene;

cout << "Elementos de datos en el orden original \n";

// despliega el arreglo original
for ( int i = 0; i < tamanoArreglo ; i++ )
cout << setw( 4 ) << a[i];

//ordenamiento burbuja
// ciclo para controlar el numero de pasadas
for ( int pasada = 0; pasada < tamanoArreglo - 1 ; pasada++ )

//ciclo para controlar el numero de comparaciones por pasada
for ( int j = 0; j < tamanoArreglo - 1 ; j++ )

//compara los elementos contiguos y los intercambia si
//el primer elemento es mayor que el segundo
if ( a[j] > a[ j + 1 ] )
{
mantiene = a[j];
a[j] = a[j+1];
a[j+1] = mantiene;
}

cout << "\nElementos de datos en orden ascendente\n";

//muestra el arreglo ordenado
for ( int k = 0; k < tamanoArreglo ; k++ )
cout << setw( 4 ) << a[k];

cout << endl;

system("PAUSE");
return 0;
}

Paso de arreglos y de elementos individuales de arreglos a funciones

// Paso de arreglos y de elementos individuales
// de arreglos a funciones.

#include <iostream>

using std::cout;
using std::endl;

#include <iomanip>

using std::setw;

void modificaArreglo(int [], int);
void modificaElemento( int );

int main()
{
const int tamanoArreglo = 5;
int a[ tamanoArreglo ] = { 0, 1, 2, 3, 4 }; //inicializa a

cout << "Efectos de pasar el arreglo completo por referencia: "
<< "\n\nLos valores del arreglo original son: \n";

// despliega el arreglo original
for( int i = 0 ; i < tamanoArreglo ; i++ )
cout << setw( 3 ) << a[i];

cout << endl;

// pasa el arreglo a hacia modificaArreglo por referencia
modificaArreglo( a, tamanoArreglo );

cout << "Los valores del arreglo modificado son: \n";

// despliega el arreglo modificado
for( int j = 0; j < tamanoArreglo ; j++ )
cout << setw( 3 ) << a[j];

// despliega el valor de a[3]

cout << "\n\n\n"
<< "Efectos de pasar un elemento del arreglo por valor:"
<< "\n\nEl valor de a[3] es " << a[3] << '\n';

// pasa el elemento a[3] del arreglo por valor
modificaElemento( a[3] );

// muestra el valor de a[3]

cout << "El valor de a[3] es " << a[3] << endl;

system("PAUSE");
return 0; // indica terminacion exitosa

}//fin de main

// en la funcion modificaArreglo, "b" apunta hacia
// el arreglo original "a" en memoria.

void modificaArreglo( int b[], int tamanoDelArreglo )
{
// multiplica cada elemento del arreglo por 2
for(int k = 0 ; k < tamanoDelArreglo ; k++ )
b[k] *= 2;
}// fin de la funcion modificaArreglo

// en la funcion modificaElemento, "e" es una copia local del
// elemento a[3] del arreglo que se pasa desde main

void modificaElemento( int e )
{
// multiplica parametros por 2
cout << "Valor en modificaElemento es "
<< ( e *= 2 ) << endl;
}// fin de la funcion modificaElemento

Programa de encuesta a estudiantes

//Programa de encuesta a estudiantes

#include <iostream>

using std::cout;

using std::endl;

#include <iomanip>

using std::setw;

int main()

{

      system("cls");

      //define el tamaño de los arreglos

      const int tamanoRespuestas = 40;   //tamaño del arreglo respuestas

      const int tamanoFrecuencia = 11;   //tamaño del arreglo frecuencia

      //coloca las respuestas de la encuesta en el arreglo respuestas

      int respuestas[ tamanoRespuestas ] = { 1, 2, 6, 4, 8, 5, 9, 7, 8,

            10, 1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7,

            5, 6, 6, 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };

      //inicializa contadores de frecuencia en 0

      int frecuencia[ tamanoFrecuencia ] = { 0 };

      //para cada respuesta, seleccione un valor de un elemento del arreglo

      //respuestas y utilicelo como subíndice del arreglo

      //frecuencia para determinar el elemento a incrementar

      for( int respuesta = 0; respuesta < tamanoRespuestas; respuesta++ )

            ++frecuencia[ respuestas[ respuesta ] ];

      //despliega los resultados

      cout << "Calificacion" << setw ( 17 ) << "Frecuencia" << endl;

      //muestra las frecuencias en formato tabular

      for( int calificacion = 1; calificacion < tamanoFrecuencia; calificacion++ )

            cout << setw( 6 ) << calificacion

                   << setw( 17 ) << frecuencia[ calificacion ] << endl;

      system("pause");

      return 0;  // indica terminacion exitosa

}//fin de main

Programa para desplegar un histograma

//Programa para desplegar un histograma

#include <iostream>

using std::cout;

using std::endl;

#include <iomanip>

using std::setw;

int main()

{

      system("cls");

      const int tamanoArreglo = 10;

      int n[ tamanoArreglo ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };

      cout << "Elemento" << setw( 13 ) << "Valor"

             << setw( 17 ) << "Histograma" << endl;

      //para cada elemento del arreglo n, muestra una barra en el histograma

      for ( int i = 0; i < tamanoArreglo; i++)

      {

            cout << setw( 7 ) << i << setw( 13 ) << n[ i ] << setw( 9 );

            for( int j = 0; j < n[ i ]; j++)//despliega una barra

                  cout << '*';

            cout << endl;//inicia la siguiente línea de salida

      }//fin de la estructura for externa

      system("pause");

      return 0; // indica terminacion exitosa

}//fin de main

Inicializa el arreglo s con los enteros pares de 2 a 20

//Inicializa el arreglo s con los enteros pares de 2 a 20

#include <iostream>

using std::cout;

using std::endl;

#include <iomanip>

using std::setw;

int main()

{

      system("cls");

      //la variable constante se puede utilizar para

      //especificar el tamaño del arreglo.

      const int tamanoArreglo = 10;

      int s[ tamanoArreglo ]; //el arreglo s tiene 10 elementos

      for( int i = 0; i < tamanoArreglo; i++ ) // establece los valores

            s[ i ] = 2 + 2 * i;

      cout << "Elemento" << setw(13) << "Valor" << endl;

      //muestra el contenido del arreglo s en formato tabular

      for( int j = 0; j < tamanoArreglo; j++ )

            cout << setw(7) << j << setw( 13 ) << s[ j ] << endl;

      system("pause");

      return 0; //indica terminacin exitosa

}//fin de main

Inicializacion de un arreglo con una declaracion

//Inicializacion de un arreglo con una declaracion

#include <iostream>

using std::cout;

using std::endl;

#include <iomanip>

using std::setw;

int main()

{

      system("cls");

      //utiliza una lista de inicializacion para

      //inicializar el arreglo n

      int n[10] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };

      cout << "Elemento" << setw(13) << "Valor" << endl;

      //salida del contenido del arreglo n en formato tabular

      for(int i = 0; i < 10; i++)

            cout << setw(7) << i << setw(13) << n[i] << endl;

      system("pause");

      return 0;  // indica terminacion exitosa

}// fin de main

Inicializacion de un arreglo

//Inicializacion de un arreglo

#include <iostream>

using std::cout;

using std::endl;

#include <iomanip>

using std::setw;

int main()

{

      system("cls");

      int n[10];  // n es un arreglo de 10 enteros

      //Inicializa los elementos del arreglo n en 0

      for( int i = 0; i < 10; i++)

            n[i] = 0;   //establece el elemento de la ubicacion i en 0

      cout << "Elemento" << setw(13) << "Valor" << endl;

      //despliega el contenido de un arreglo n en forma tabular

      for(int j = 0; j < 10; j++)

            cout << setw(7) << j << setw(13) << n[j] << endl;

     

      system("pause");

      return 0;  //indica terminacion exitosa

}//fin de main

Uso de una plantilla de funcion

//Uso de una plantilla de funcion

#include <iostream>

using std::cout;

using std::cin;

using std::endl;

//definicion de la plantilla de funcion maximo

template < class T >    // o template < nombretipo T >

T maximo( T valor1, T valor2, T valor3 )

{

      T max = valor1;

     

      if ( valor2 > max )

            max = valor2;

           

      if (valor3 > max )

            max = valor3;

      return max;

           

}//fin de la plantilla de funcion maximo

int main()

{

      system("cls");

     

      //demostracion de maximo con valores enteros

      int entero1, entero2, entero3;

     

      cout << "Introduzca tres valores enteros: ";

      cin >> entero1 >> entero2 >> entero3;

     

      //invoca a la version int de maximo

      cout << "El mayor valor entero es: "

           << maximo(entero1, entero2, entero3) << endl;

             

      //demostracion de maximo con valores double

      double doble1, doble2, doble3;

     

      cout << "\nIntroduzca tres valores double: ";

      cin  >> doble1 >> doble2 >> doble3;

     

      //invoca a la version double de maximo

      cout << "El mayor valor double es: "

           << maximo( doble1, doble2, doble3) << endl;

             

      //demostracion de maximo con valores char

      char car1, car2, car3;

     

      cout << "\n\nIntroduzca tres caracteres: ";

      cin  >> car1 >> car2 >> car3;

     

      //invoca a la version char de maximo

      cout << "El valor caracter mayor es: "

           << maximo( car1, car2, car3) << endl;

             

             

      system("pause");

      return 0; // indica terminacion exitosa

}//fin de main

Uso de la sobrecarga de funciones

//Uso de la sobrecarga de funciones

#include <iostream>

using std::cout;

using std::endl;

//funcion cuadrado para valores int

int cuadrado( int x )

{

     cout << "Llama a cuadrado con un argumento int: " << x << endl;

     return x * x;

}//fin de la version int de la funcion cuadrado

//funcion cuadrado para valores double

double cuadrado( double y )

{

     cout << "Llama a cuadrado con un argumento double: " << y << endl;

     return y * y;

}//fin de la version double de la funcion cuadrado

int main()

{

     system("cls");

    

     int resultadoInt = cuadrado( 7 );              //llama a la version int

     double resultadoDouble = cuadrado( 7.5 ); //llama a la version double

    

     cout << "\nEl cuadrado del int 7 es " << resultadoInt

          << "\nEl cuadrado del double 7.5 es " << resultadoDouble

          << endl;

    

     system("pause");

     return 0; //indica terminacion exitosa

}//fin de main

//Programa NotEqualCount

//Este programa cuenta las ocurrencias

//de "!=" en un archivo de datos

#include <iostream>

#include <fstream>      //para archivo I/O

using namespace std;

int main()

{

      system("cls");

      int count;              //numero de operadores !=

      char prevChar;          //ultimo caracter leido

      char currChar;          //caracter leido en esta iteracion de ciclo

      ifstream inFile;  //archivo de datos

      inFile.open("myfile.dat");         //intentar abrir el archivo de entrada

      if ( !inFile )                           // ¿se abrio?

      {

            cout << "*** No puedo abrir el archivo de entrada ***" //No--imprimir mensaje

                   << endl;

            return 1;                    //Terminar programa

      }

      count = 0;                         //inicializar el contador

      inFile.get(prevChar);        //inicializar el valor previo

      inFile.get(currChar);        //inicializar el valor actual

      while (inFile)                     //mientras la entrada previa tiene exito...

      {

            if (currChar == '=' &&  //probar el suceso

                  prevChar == '!')

                  count++;                //incrementar el contador

            prevChar = currChar;    //remplazar el valor previo

                                               //con el valor actual

            inFile.get(currChar);   //obtener el siguiente valor

      }

      cout << count << " != se encontraron operadores. " << endl;

      system("pause");

      return 0;

}//fin de main

Generar numeros aleatorios

//Escala y cambio de enteros producidos por 1 + rand() % 6.

//Generar numeros aleatorios

#include <iostream>

#include <iomanip>

#include <cstdlib>      //contiene el prototipo de la funcion rand

using std::cout;

using std::endl;

using std::setw;

int main()

{

      system("cls");

     

      //ciclo de 20 repeticiones

      for (int contador = 1; contador <= 20; contador++)

      {

            //obtiene un numero aleatorio entre 1 y 6 y lo despliega

            cout << setw(10) << (1 + rand() % 6);

           

            //si el contador es divisible entre 5, comienza nueva linea de salida

            if(contador % 5 == 0)

                  cout << endl;

           

           

      }//fin de la estructura for

      system("pause");

      return 0;  //indica terminacion exitosa

}//fin de main

Funcion recursiva fibonacci

//Funcion recursiva fibonacci.

#include <iostream>

using std::cout;

using std::cin;

using std::endl;

unsigned long fibonacci( unsigned long ); //prototipo de la funcion

int main()

{

     system("cls");

    

     unsigned long resultado, numero;

    

     //obtiene entero del usuario

     cout << "Introduzca un entero:  ";

     cin >> numero;

    

     //calcula el valor fibonacci del numero introducido por el usuario

     resultado = fibonacci( numero );

    

     //despliega el resultado

     cout << "Fibonacci(" << numero << ") = " << resultado << endl;

        

     system("pause");

     return 0;

}//fin de main

//definicion recursiva de la funcion fibonacci

unsigned long fibonacci( unsigned long n )

{

     //caso base

     if( n == 0 || n == 1)

         return n;

     //paso recursivo

     else

         return fibonacci( n - 1 ) + fibonacci ( n - 2 );

}// fin de la funcion fibonacci