Segundo Parcial

------------------------------------------------------------------------------------------------------------------

*************************************************************************************

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

*************************************************************************************

------------------------------------------------------------------------------------------------------------------

Proyecto :::::: Introduccion de datos de N alumnos y ordenamiento por medio de opciones...

#include"iostream.h"
#include"conio.h"
#include"stdio.h"
#include"string.h"
char nombre[20][30],apellidoa[20][30],apellidob[20][30];
int menu()
{
int opcion,salir=1,opc;
while(salir==1)
{
clrscr();
salir=0;
printf("::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::");
gotoxy(1,2);printf(":");gotoxy(1,3);printf(":");gotoxy(1,4);printf(":");gotoxy(1,5);printf(":");
gotoxy(1,6);printf(":");gotoxy(1,7);printf(":");gotoxy(1,8);printf(":");gotoxy(1,9);printf(":");
gotoxy(1,10);printf(":");gotoxy(1,11);printf(":");gotoxy(1,12);printf(":");gotoxy(1,13);printf(":");
gotoxy(1,14);printf(":");gotoxy(1,15);printf(":");gotoxy(1,16);printf(":");gotoxy(1,17);printf(":");
gotoxy(1,14);printf(":");gotoxy(1,15);printf(":");gotoxy(1,16);printf(":");gotoxy(1,17);printf(":");
gotoxy(1,18);printf(":");gotoxy(1,19);printf(":");gotoxy(1,20);printf(":");gotoxy(1,21);printf(":");
gotoxy(1,22);printf(":");gotoxy(1,23);printf(":");gotoxy(1,24);printf(":");
gotoxy(1,25);printf(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::");
gotoxy(30,2);printf("******-|-Menu-|-******");
gotoxy(3,5);printf("1.- Ordenar por apellidos");
gotoxy(3,6);printf("2.- Ordenar por nombre");
gotoxy(3,7);printf("3.- Ordenar por promedio mas alto al mas bajo");
gotoxy(3,8);printf("4.- Ordenar por promedio mas bajo al mas alto");
gotoxy(3,9);printf("5.- Salir");
gotoxy(8,12);printf("Que opcion deseas?");
opcion=getche();
clrscr();
switch(opcion)
{
case '1': opc=1; break;
case '2': opc=2; break;
case '3': opc=3; break;
case '4': opc=4; break;
case '5': opc=0; break;
default:
{
salir=1;
printf("Opcion Invalida");
getch();
}
}
}
return(opc);
}
int ordennomap(int num,int lista[],int opc)
{
    int i,aux=0;
    int c,temp2, j;
    char nombreaux[30],apellidoaaux[30],apellidobaux[30];
if (opc==1)
{
for(i = (num-1); i >= 0; i--)
{
    temp2=num-1;
    for(j = 1; j <= temp2; j++)
    {
        if(strcmp(apellidoa[j-1],apellidoa[j]) > 0)
            {
                aux=lista[j-1];
                lista[j-1]=lista[j];
                lista[j]=aux;
                strcpy(apellidoaaux, apellidoa[j-1]);
                strcpy(apellidoa[j-1], apellidoa[j]);
                strcpy(apellidoa[j], apellidoaaux);
                strcpy(apellidobaux, apellidob[j-1]);
                strcpy(apellidob[j-1], apellidob[j]);
                strcpy(apellidob[j], apellidobaux);
                strcpy(nombreaux, nombre[j-1]);
                strcpy(nombre[j-1], nombre[j]);
                strcpy(nombre[j], nombreaux);
            }
    }
}
             printf("Ordenado por apellidos alfabeticamente:\n\n");
     for(c=0;c<num;c++)
     {
     cout<<"El alumno "<<nombre[c]<<" "<<apellidoa[c]<<" "<<apellidob[c]<<" con un promedio de "<<lista[c]<<endl;
     }
}
else
{
for(i = (num-1); i >= 0; i--)
{
    temp2=num-1;
    for(j = 1; j <= temp2; j++)
    {
        if(strcmp(nombre[j-1],nombre[j]) > 0)
            {
                aux=lista[j-1];
                lista[j-1]=lista[j];
                lista[j]=aux;
                strcpy(apellidoaaux, apellidoa[j-1]);
                strcpy(apellidoa[j-1], apellidoa[j]);
                strcpy(apellidoa[j], apellidoaaux);
                strcpy(apellidobaux, apellidob[j-1]);
                strcpy(apellidob[j-1], apellidob[j]);
                strcpy(apellidob[j], apellidobaux);
                strcpy(nombreaux, nombre[j-1]);
                strcpy(nombre[j-1], nombre[j]);
                strcpy(nombre[j], nombreaux);
            }
    }
}
             printf("Ordenado por nombres alfabeticamente:\n\n");
     for(c=0;c<num;c++)
     {
     cout<<"El alumno "<<nombre[c]<<" "<<apellidoa[c]<<" "<<apellidob[c]<<" con un promedio de "<<lista[c]<<endl;
     }
}
}


void ordenar(int lista[],int num,int opc)
{
  int c=0,c1=0,c2=0,aux=0;
  char nombreaux[30],apellidoaaux[30],apellidobaux[30];
  for(c1=0;c1<=num;c1++)
  {
     for(c2=0;c2<num;c2++)
     {
          if(lista[c2]>lista[c2+1])
          {
             aux=lista[c2];
             lista[c2]=lista[c2+1];
             lista[c2+1]=aux;
             strcpy(nombreaux,nombre[c2]);
             strcpy(nombre[c2],nombre[c2+1]);
             strcpy(nombre[c2+1],nombreaux);
             strcpy(apellidoaaux,apellidoa[c2]);
             strcpy(apellidoa[c2],apellidoa[c2+1]);
             strcpy(apellidoa[c2+1],apellidoaaux);
             strcpy(apellidobaux,apellidob[c2]);
             strcpy(apellidob[c2],apellidob[c2+1]);
             strcpy(apellidob[c2+1],apellidobaux);
          }
        }
     }
     if (opc==4)
     {
     printf("Ordenado del promedio mas bajo al mas alto:\n\n");
     for(c=0;c<num;c++)
     {
     cout<<"El alumno "<<nombre[c]<<" "<<apellidoa[c]<<" "<<apellidob[c]<<" con un promedio de "<<lista[c]<<endl;
     }
     }
     else
     {
     printf("Ordenado del promedio mas alto al mas bajo:\n\n");
     for(c=num-1;c>=0;c--)
     {
     cout<<"El alumno "<<nombre[c]<<" "<<apellidoa[c]<<" "<<apellidob[c]<<" con un promedio de "<<lista[c]<<endl;
     }
}   }






int main()
{
int num=3,resp=1;
clrscr();
printf("::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::");
gotoxy(1,2);printf(":");gotoxy(1,3);printf(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::");
gotoxy(1,4);printf(":");gotoxy(1,5);printf(":");gotoxy(1,6);printf(":");gotoxy(1,7);printf(":");
gotoxy(1,8);printf(":");gotoxy(1,9);printf(":");gotoxy(1,10);printf(":");gotoxy(1,11);printf(":");
gotoxy(1,12);printf(":");gotoxy(1,13);printf(":");gotoxy(1,14);printf(":");gotoxy(1,15);printf(":");
gotoxy(1,16);printf(":");gotoxy(1,17);printf(":");gotoxy(1,14);printf(":");gotoxy(1,15);printf(":");
gotoxy(1,16);printf(":");gotoxy(1,17);printf(":");gotoxy(1,18);printf(":");gotoxy(1,19);printf(":");
gotoxy(1,20);printf(":");gotoxy(1,21);printf(":");gotoxy(1,22);printf(":");gotoxy(1,23);printf(":");
gotoxy(1,24);printf(":");
gotoxy(36,24);printf("Realizado por Francisco Aldana Hernandez ISC");
gotoxy(1,25);printf(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::");
gotoxy(5,2);printf("Sistema de registro de calificaciones con vista deseada por el usuario");
gotoxy(20,10);printf("Cuantos alumnos deseas introducir?\n");
gotoxy(36,11);scanf("%d",&num);
int contador=0,auxiliar=0,c=0,c1=0,lista[20],calificacion[20][3];
int opc=0;
clrscr();
  for(c=0;c<num;c++)
  {
  printf("Introduce el nombre: -->");
  scanf("%s",&nombre[c]);
  printf("Introduce el primer apellido: -->");
  scanf("%s",&apellidoa[c]);
  printf("Introduce el segundo apellido: -->");
  scanf("%s",&apellidob[c]);
  auxiliar=0;
  for(c1=0;c1<3;c1++)
  {
     cout<<"Introduce la calificacion "<<c1+1<<": ";cin>>calificacion[c][c1];
     auxiliar+=calificacion[c][c1];
  }
  lista[contador]=auxiliar/3;
  contador=contador+1;
  clrscr();
  }
  clrscr();
while(resp==1)
{
opc=menu();
clrscr();

if(opc==0)
{
printf("No se selecciono ninguna opcion!!!!!!");
}
if(opc==1)
{
ordennomap(num,lista,opc);
}
if(opc==2)
{
ordennomap(num,lista,opc);
}
if(opc==3)
{
ordenar(lista,num,opc);
}
if(opc==4)
{
ordenar(lista,num,opc);
}
getch();
printf("\n------------------------------------------------------------------\nDeseas continuar\n 1.- Si\n 2.- No\n");
scanf("%d",&resp);
}
}

Programa para sumar numeros diagonales de una matriz de 4*4

//Francisco Aldana Hernandez
#include"iostream.h"
#include"conio.h"
#include"stdio.h"
int operar(int lista[4][4])
{
int c=0,c1,c2=3,suma=0,suma2=0,conta1=2,conta2=5;
for(c1=0;c1<4;c1++)
{
    suma+=lista[c1][c1];
    suma2+=lista[c2][c1];
    c2-=1;
}
clrscr();
printf("\n----------------------------\nLa matriz es la siguiente\n");
for(c=0;c<=3;c++)
 {
     for(c2=0;c2<4;c2++)
     {
gotoxy(conta1,conta2);cout<<lista[c][c2]<<"  ";
     conta2+=1;
     }
conta2=5;
conta1+=4;
cout<<endl;
}
printf("\n---------------------------------------------------------\nSuma de la diagonal de izquierda a derecha:\n");
c2=3;
for(c=0;c<4;c++)
{
printf("--%d--",lista[c][c]);
}
printf("= ---->%d\n",suma);
printf("\n---------------------------------------------------------\nSuma de la diagonal de derecha a izquierda:\n");
c2=3;
for(c=0;c<4;c++)
{
printf("--%d--",lista[c2][c]);
c2-=1;
}
printf("= ---->%d\n",suma2);
getch();
}
void main()
{
int c,c2,suma=0,suma2=0,lista[4][4];
clrscr();
for(c2=0;c2<4;c2++)
{
  for(c=0;c<=3;c++)
  {
     cout<<"Introduce un numero en la posicion---> "<<c2<<" , "<<c<<": "; cin>>lista[c2][c];
  }
}
operar(lista); clrscr();
}

Programa para ordenar N numeros de un arreglo de N -- Varios Metodos ---- Aporte

#include <stdio.h>
int Cantidad, opcion, i, Vector[100], j, k, Aux, intb, l, Mayor, Posmayor, Volver, Central;
/*SUBRUTINA DE QUICK SORT*/
void partir(int primero,int ultimo)
{i=primero;
 j=ultimo;
 Central= Vector[(primero+ultimo)/2];
 while (i<=j)
 {while (Vector[i]<Central)
  {i=i+1;}
  while (Vector[j]>Central)
  {j=j-1;}
  if (i<=j)
  {printf("\n\nCambiando...  Vector[%d]=%d  por  Vector[%d]=%d\n",j,Vector[j],i,Vector[i]);
   Aux=Vector[i];
   Vector[i]=Vector[j];
   Vector[j]=Aux;
   for(k=1;k<=Cantidad;k++)
   {printf("\t%d",Vector[k]);}
   i=i+1;
   j=j-1;
  }              
 }
 if(primero<j)
 {partir(primero,j);}
 if(i<ultimo)
 {partir(i,ultimo);}
}


/*METODO QUICK SORT*/
void Quick_Sort()
{printf("\n\n\tCuantos numeros seran introducidos:  ");
 scanf("%d",&Cantidad);
 printf("\n");
 for(i=1;i<=Cantidad;i++)
 {printf("\tVector[%d]=",i);
  scanf("%d",&Vector[i]);
 }
 partir(1,Cantidad);  
 printf("\n\n\t\tVECTOR ORDENADO\n");
 for(i=1;i<=Cantidad;i++)              
 {printf("\t%d",Vector[i]);}
}

                
/*METODO DE SHELL*/
void Shell()
{printf("\n\n\tCuantos numeros seran introducidos:  ");
 scanf("%d",&Cantidad);
 printf("\n");
 for(i=1;i<=Cantidad;i++)
 {printf("\tVector[%d]=",i);
  scanf("%d",&Vector[i]);
 }
 intb = Cantidad / 2;
 while(intb>0)
 {for(i=intb+1;i<=Cantidad;i++)
  {j = i - intb;
   while(j>0)
   {k = j + intb;
    if(Vector[j]<Vector[k])
    {j=0;}
    else
    {printf("\n\n\tCambiando...  Vector[%d]=%d  por  Vector[%d]=%d\n",j,Vector[j],k,Vector[k]);
     Aux = Vector[j];
     Vector[j] = Vector[k];
     Vector[k] = Aux;
     for(l=1;l<=Cantidad;l++)
     {printf("\t%d",Vector[l]);}
    }
    j = j - intb;
   }
  }
  intb = intb / 2;
 }
 printf("\n\n\t\tVECTOR ORDENADO\n");
 for(i=1;i<=Cantidad;i++)              
 {printf("\t%d",Vector[i]);}
}


/*METODO DE SELECCION*/
void Seleccion()
{printf("\n\n\tCuantos numeros seran introducidos:  ");
 scanf("%d",&Cantidad);
 printf("\n");
 for(i=1;i<=Cantidad;i++)
 {printf("\tVector[%d]=",i);
  scanf("%d",&Vector[i]);
 }
 for(i=1;i<=Cantidad-1;i++)
 {Mayor=Vector[i];
  Posmayor=i;
  for(j=i+1;j<=Cantidad;j++)
  {if(Vector[j]<Mayor)     
   {Mayor=Vector[j];
    Posmayor=j;
   }
  }
  printf("\n\n\tCambiando...  Vector[%d]=%d  por  Vector[%d]=%d\n",i,Vector[i],Posmayor,Vector[Posmayor]);
  Aux=Vector[i];
  Vector[i]=Vector[Posmayor];
  Vector[Posmayor]=Aux;
  for(l=1;l<=Cantidad;l++)
  {printf("\t%d",Vector[l]);}
 }  
 printf("\n\n\t\tVECTOR ORDENADO\n");
 for(i=1;i<=Cantidad;i++)              
 {printf("\t%d",Vector[i]);}
}


/*METODO DE BURBUJA*/
void Burbuja()
{printf("\n\n\tCuantos numeros seran introducidos:  ");
 scanf("%d",&Cantidad);
 printf("\n");
 for(i=1;i<=Cantidad;i++)
 {printf("\tVector[%d]=",i);
  scanf("%d",&Vector[i]);
 }
 for(i=1;i<=Cantidad-1;i++)
 {for(j=1;j<=Cantidad-1;j++)
  {if(Vector[j+1]<Vector[j])
   {printf("\n\n\tCambiando...  Vector[%d]=%d  por  Vector[%d]=%d\n",j+1,Vector[j+1],j,Vector[j]);
    Aux=Vector[j+1];
    Vector[j+1]=Vector[j];
    Vector[j]=Aux;
    for(k=1;k<=Cantidad;k++)
    {printf("\t%d",Vector[k]);}
   }
  }
 }
 printf("\n\n\t\tVECTOR ORDENADO\n");
 for(i=1;i<=Cantidad;i++)
 {printf("\t%d",Vector[i]);}
}


/*PROGRAMA PRINCIPAL*/
void main()
{do
 {printf("\n\n\n\n\n\n\t\t\t\t\tMETODOS DE ORDENAMIENTO");
  printf("\n\n\t\t\t\t1. BURBUJA");
  printf("\n\t\t\t\t2. SELECCION");
  printf("\n\t\t\t\t3. SHELL");
  printf("\n\t\t\t\t4. QUICK SORT");
  printf("\n\t\t\t\t5. SALIDA");
  printf("\n\n\t\t\t\tESCOJA UNA DE LAS OPCIONES [1-5]:  ");
  scanf("%d", &opcion);
  switch(opcion)
  {case 1:{Burbuja();
           Volver=1;
           break;
          }
   case 2:{Seleccion();
           Volver=1;
           break;
          }
   case 3:{Shell();
           Volver=1;
           break;
          }
   case 4:{Quick_Sort();
           Volver=1;
           break;
          }
   case 5:{Volver=0;
           break;
          }
  }
 }while(Volver);
}

Programa para ordenar ascendentemente una Matriz de 3*3

#include"iostream.h"
#include"conio.h"
#include"stdio.h"
int ordenar(int lista[3][3])
{
  int c1,c2,c3,c4,aux,aux2;
for(c4=0;c4<=2;c4++)
{
for(c3=0;c3<=2;c3++)
{
for(c1=0;c1<=2;c1++)
  {
     for(c2=0;c2<=2;c2++)
     {
          if(lista[c3][c2]>lista[c3][c2+1])
          {
             aux=lista[c3][c2];
             lista[c3][c2]=lista[c3][c2+1];
             lista[c3][c2+1]=aux;
          }
        }
     }
      if(lista[c3][c4]>lista[c3][c4+1])
          {
         aux2=lista[c3][c4];
             lista[c3][c4]=lista[c3][c4+1];
             lista[c3][c4+1]=aux2;
          }
}
}



  return 0;
}
int main()
{
int c,c2,lista[3][3];
clrscr();
for(c2=0;c2<3;c2++)
{
  for(c=0;c<=2;c++)
  {
     cout<<"Introduce un numero en la posicion---> "<<c2<<" , "<<c<<": "; cin>>lista[c2][c];
  }
}
ordenar(lista); clrscr();
printf("Lista en forma ascendente:\n");
printf("\n----------------------------\n");
for(c=0;c<=2;c++)
 {
     for(c2=1;c2<=3;c2++)
     {
     cout<<lista[c][c2]<<" ";   
}
cout<<endl;
}
getch();
}

Programa para ordenar 5 promedios con su respectivo Alumno -- Metodo de Selección

#include"iostream.h"
#include"conio.h"
#include"stdio.h"
#include"string.h"
  char nombre[5][30];
void ordenar(int lista[])
{
char nombreaux[30];
int c=0,i, j, min, aux;
for(i=0;i<5;i++)
{
min=i;
j=i+1;
for(j=0;j<5;j++)
{
if(lista[j]<lista[i])
{
min=j;
aux=lista[i];
strcpy(nombreaux,nombre[i]);
lista[i]=lista[min];
strcpy(nombre[i],nombre[min]);
lista[min]=aux;
strcpy(nombre[min],nombreaux);
}
}
}
     printf("Lista en forma ascendente:\n");
     for(c=0;c<5;c++)
     {
     cout<<"El alumno "<<nombre[c]<<" con un promedio de "<<lista[c]<<endl;
     }
     printf("\n\nLista en forma descendente:\n");
     for(c=4;c>=0;c--)
     {
     cout<<"El alumno "<<nombre[c]<<" con un promedio de "<<lista[c]<<endl;
     }
}
int main()
{
  int contador=0,auxiliar=0,c=0,c1=0,lista[5],calificacion[5][3];
clrscr();
  for(c=0;c<5;c++)
  {
  printf("Introduce el nombre: -->");
  scanf("%s",&nombre[c]);
  auxiliar=0;
  for(c1=0;c1<3;c1++)
  {
     cout<<"Introduce la calificacion "<<c1+1<<": ";cin>>calificacion[c][c1];
     auxiliar+=calificacion[c][c1];
  }
  lista[contador]=auxiliar/3;
  contador=contador+1;
  clrscr();
  }
  clrscr();
ordenar(lista);
getch();
}

Programa para ordenar 10 numeros de un arreglo -- Metodo de Selección

#include"iostream.h"
#include"conio.h"
#include"stdio.h"

void ordenar(int lista[]) {
  
  int i, a, inicio,tamanio_arreglo=10;

   for (i=1; i < tamanio_arreglo; i++) {
   inicio = lista[i];
   a = i-1;
          while (a >= 0 && lista[a] > inicio) {
             lista[a + 1] = lista[a];
             a--;
          }
   lista[a+1] = inicio;
   }
}

int main()
{
  int c,lista[10];
    clrscr();
  for(c=0;c<=9;c++)
  {
     cout<<"Introduce un numero en la posicion---> "<<c+1<<": "; cin>>lista[c];
  }
ordenar(lista); clrscr();
printf("Lista en forma ascendente:\n");
     for(c=0;c<=9;c++)
     {
     cout<<lista[c]<<" ";
     }
     printf("\n\nLista en forma descendente:\n");
     for(c=9;c>=0;c--)
     {
     cout<<lista[c]<<" ";
     }
getch();

}

Programa para ordenar 5 promedios con su respectivo Alumno -- Metodo de Inserción

#include"iostream.h"
#include"conio.h"
#include"stdio.h"
#include"string.h"
  char nombre[5][30];
void ordenar(int lista[])
{
  int c=0;
  char nombreaux[30];
  int i, a,inicio;

   for (i=1; i < 5; i++) {
   inicio = lista[i];
   strcpy(nombreaux,nombre[i]);
   a = i-1;
          while (a >= 0 && lista[a] > inicio) {
             lista[a + 1] = lista[a];
         strcpy(nombre[a + 1],nombre[a]);
             a--;
          }
   lista[a+1] = inicio;
   strcpy(nombre[a+1],nombreaux);
   }
     printf("Lista en forma ascendente:\n");
     for(c=0;c<5;c++)
     {
     cout<<"El alumno "<<nombre[c]<<" con un promedio de "<<lista[c]<<endl;
     }
     printf("\n\nLista en forma descendente:\n");
     for(c=4;c>=0;c--)
     {
     cout<<"El alumno "<<nombre[c]<<" con un promedio de "<<lista[c]<<endl;
     }
}
int main()
{
  int contador=0,auxiliar=0,c=0,c1=0,lista[5],calificacion[5][3];
clrscr();
  for(c=0;c<5;c++)
  {
  printf("Introduce el nombre: -->");
  scanf("%s",&nombre[c]);
  auxiliar=0;
  for(c1=0;c1<3;c1++)
  {
     cout<<"Introduce la calificacion "<<c1+1<<": ";cin>>calificacion[c][c1];
     auxiliar+=calificacion[c][c1];
  }
  lista[contador]=auxiliar/3;
  contador=contador+1;
  clrscr();
  }
  clrscr();
ordenar(lista);
getch();
}

Programa para ordenar 10 numeros de un arreglo -- Metodo de Inserción

#include"iostream.h"
#include"conio.h"
#include"stdio.h"

void ordenar(int lista[]) {
  
  int i, a, inicio,tamanio_arreglo=10;

   for (i=1; i < tamanio_arreglo; i++) {
   inicio = lista[i];
   a = i-1;
          while (a >= 0 && lista[a] > inicio) {
             lista[a + 1] = lista[a];
             a--;
          }
   lista[a+1] = inicio;
   }
}

int main()
{
  int c,lista[10];
    clrscr();
  for(c=0;c<=9;c++)
  {
     cout<<"Introduce un numero en la posicion---> "<<c+1<<": "; cin>>lista[c];
  }
ordenar(lista); clrscr();
printf("Lista en forma ascendente:\n");
     for(c=0;c<=9;c++)
     {
     cout<<lista[c]<<" ";
     }
     printf("\n\nLista en forma descendente:\n");
     for(c=9;c>=0;c--)
     {
     cout<<lista[c]<<" ";
     }
getch();

}

Programa para ordenar 5 promedios con su respectivo Alumno -- Metodo de Burbuja

#include"iostream.h"
#include"conio.h"
#include"stdio.h"
#include"string.h"
char nombre[5][30];
void ordenar(int lista[])
{
  int c=0,c1=0,c2=0,aux=0;
  char nombreaux[30];
  for(c1=0;c1<=5;c1++)
  {
     for(c2=0;c2<5;c2++)
     {
          if(lista[c2]>lista[c2+1])
          {
             aux=lista[c2];
             lista[c2]=lista[c2+1];
             lista[c2+1]=aux;
             strcpy(nombreaux,nombre[c2]);
             strcpy(nombre[c2],nombre[c2+1]);
             strcpy(nombre[c2+1],nombreaux);
           
          }
        }
     }
     printf("Lista en forma ascendente:\n");
     for(c=0;c<5;c++)
     {
     cout<<"El alumno "<<nombre[c]<<" con un promedio de "<<lista[c]<<endl;
     }
     printf("\n\nLista en forma descendente:\n");
     for(c=4;c>=0;c--)
     {
     cout<<"El alumno "<<nombre[c]<<" con un promedio de "<<lista[c]<<endl;
     }
}
int main()
{
  int contador=0,auxiliar=0,c=0,c1=0,lista[5],calificacion[5][3];
clrscr();
  for(c=0;c<5;c++)
  {
  printf("Introduce el nombre: -->");
  scanf("%s",&nombre[c]);
  auxiliar=0;
  for(c1=0;c1<3;c1++)
  {
     cout<<"Introduce la calificacion "<<c1+1<<": ";cin>>calificacion[c][c1];
     auxiliar+=calificacion[c][c1];
  }
  lista[contador]=auxiliar/3;
  contador=contador+1;
  clrscr();
  }
  clrscr();
ordenar(lista);
getch();
}

Programa para ordenar 10 numeros de un arreglo -- Metodo de Burbuja

#include"iostream.h"
#include"conio.h"
#include"stdio.h"
int ordenar(int lista[])
{
  int c1,c2,aux;
  for(c1=0;c1<=9;c1++)
  {
     for(c2=0;c2<9;c2++)
     {
          if(lista[c2]>lista[c2+1])
          {
             aux=lista[c2];
             lista[c2]=lista[c2+1];
             lista[c2+1]=aux;
          }
        }
     }
  return 0;
}
int main()
{
  int c,lista[10];
  for(c=0;c<=9;c++)
  {
     cout<<"Introduce un numero en la posicion---> "<<c+1<<": "; cin>>lista[c];
  }
ordenar(lista); clrscr();
printf("Lista en forma ascendente:\n");
     for(c=0;c<=9;c++)
     {
     cout<<lista[c]<<" ";
     }
     printf("\n\nLista en forma descendente:\n");
     for(c=9;c>=0;c--)
     {
     cout<<lista[c]<<" ";
     }

}

----------------------................1er Parcial................----------------------

**********************************************************************************
--------------------------------------------------------------------------------------------------------------
**********************************************************************************
--------------------------------------------------------------------------------------------------------------
***********************************************************************************

--------------------------------------------------------------------------------------------------------------

Proyecto--- Primer parcial--- Invertir palabra, # de vocales y palindromos

#include <iostream.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
//********************Funcion de inversa y busquede de vocales y consonantes*********************
void inversacompara(int cont,char *a,int len,char *contadorvoc,char *contadorcon,int cont2)
{
static int max = len;
if(len)
{
int i = len-1;
char palabra = a[i];
for(;i < max-1;i++)
a[i] = a[i+1];
a[i] = palabra;
if((a[i]=='a')||(a[i]=='e')||(a[i]=='i')||(a[i]=='o')||(a[i]=='u')||(a[i]=='A')||(a[i]=='E')||(a[i]=='I')||(a[i]=='O')||(a[i]=='U'))
{
cont+=1;
contadorvoc=itoa(cont,contadorvoc,10);
}
else
{
if(a[i]==' ')
{
}
else
{
cont2+=1;
contadorcon=itoa(cont2,contadorcon,10);
}
}
inversacompara(cont,a,len-1,contadorvoc,contadorcon,cont2);
}
}
//********************Funcion Principal****************************************
int main()
{
char a[80],contadorvoc[3],contadorcon[3],auxiliar[80];
int cont=0,c;
cout << "Introduce la palabra --> " ;
scanf("%s",&a);
clrscr();
strcpy(auxiliar,a);
inversacompara(cont,a,strlen(a),contadorvoc,contadorcon,cont);
cout << endl << "********************************************************************************\nLa palabra introducida es: --> " << auxiliar << endl;
cout<<"\nLa palabra inversa es --> "<<a<<endl;
cout << endl << "La palabra contiene : --> " << contadorvoc <<" vocales y "<<contadorcon<<" consonantes"<<endl;
int valor=strcmp(auxiliar,a);
if(valor==0)
{
printf("\nLa palabra es palindroma");
}
else
{
printf("\nLa palabra no es palindroma");
}
printf("\n\n********************************************************************************\n                                          Creado por Francisco Aldana Hernandez");
getch();
return 0;
}

Recorrido de Árboles...

- Recorridos en profundidad:

* Recorrido en preorden: consiste en visitar el nodo actual (visitar puede ser simplemente mostrar la clave del nodo por pantalla), y después visitar el subárbol izquierdo y una vez visitado, visitar el subárbol derecho. Es un proceso recursivo por naturaleza.

Si se hace el recorrido en preorden del árbol de la figura 1 las visitas serían en el orden siguiente: a,b,d,c,e,f.

void preorden(tarbol *a)

{

  if (a != NULL) {

    visitar(a);

    preorden(a->izq);

    preorden(a->der);

  }

}

* Recorrido en inorden u orden central: se visita el subárbol izquierdo, el nodo actual, y después se visita el subárbol derecho. En el ejemplo de la figura 1 las visitas serían en este orden: b,d,a,e,c,f.

void inorden(tarbol *a)

{

  if (a != NULL) {

    inorden(a->izq);

    visitar(a);

    inorden(a->der);

  }

}

* Recorrido en postorden: se visitan primero el subárbol izquierdo, después el subárbol derecho, y por último el nodo actual. En el ejemplo de la figura 1 el recorrido quedaría así: d,b,e,f,c,a.

Motores de busqueda.....

¿Cómo funciona un motor de búsqueda?

Básicamente, los motores de búsqueda (search engines, SE) son bases de datos gigantescas que contienen información sobre el contenido de los sitios web que integran la web.

¿Cómo funciona el motor de búsqueda de google?

El motor de búsqueda más popular, Google, contiene más de 3.000.000.000 sitios web. Cuando introduces una frase o palabra, el motor buscará en su base de datos y devolverá resultados en un orden que estará determinado por su propio algoritmo.

Así pues, ¿cómo consiguen al principio toda esa información?

Los motores de búsqueda emplean el uso de arañas para recopilar la información de los sitios web. Las arañas rastrean los sitios web recopilando datos y siguen los enlaces que hay en las páginas. Las arañas rastrean Internet casi continuamente, recolectando las páginas nuevas y actualizadas de la Web para mantener sus resultados al día.

Programa # 7 -- Promedio mayor de 5 alumnos

#include"conio.h"
#include"stdio.h"
#include"iostream.h"
void buscar(char nom[27][5],int cal[5][3],float prom[5])
{
int cont=0,res=0;
float promf;
promf=prom[0];
while (cont<5)
{
if(promf>prom[cont])
{
promf=promf;
}
else
{
res=cont;
promf=prom[cont];
}
cont=cont+1;
}
printf("////////////////////////////////////////////////////////////////////////////////\nEl alumno %s con las siguientes calificaciones:\n*******************************************************************************\nCalificacion 1   ||   Calificacion 2   ||   Calificacion 3\n     %d                     %d                     %d \n\nCon un Promedio de: %.4f\n////////////////////////////////////////////////////////////////////////////////\n\n                    Creado por Francisco Aldana Hernandez ",nom[res],cal[res][0],cal[res][1],cal[res][2],promf);
}


void main()
{
int c=0,c2=0,calificacion[5][3];
char nombre[27][5];
float promedio[5];
while(c<5)
{
printf("             Sistema de Calificaciones con funciones\n----------------------------------------------------------------------------------------------------------------------------------------------------------------\n");
printf("Introduce el nombre\n");
scanf("%s",&nombre[c]);
while(c2<3)
{
printf("Introduce la calificacion\n");
scanf("%d",&calificacion[c][c2]);
promedio[c]+=calificacion[c][c2];
c2+=1;
}
promedio[c]=(promedio[c])/3;
clrscr();
c2-=3;
c+=1;
}
clrscr();
printf("               UPT System of ratings\n----------------------------------------------------------------------------------------------------------------------------------------------------------------\nEl alumno mas destacado es el siguiente:\n\n");
buscar(nombre,calificacion,promedio);
getch();
clrscr();
}

Programa # 6 -- Calificaciones mayores a 8

#include"conio.h"
#include"stdio.h"
void buscar(char nom[27][5],int cal[5])
{
int cont=0;
while (cont<5)
{
if(cal[cont]>=8)
{
printf("El alumno %s tiene la calificacion de %d\n",nom[cont],cal[cont]);
}
cont=cont+1;
}
}
void main()
{
int c=0,calificacion[5];
char nombre[27][5];
while(c<5)
{
printf("Introduce el nombre\n");
scanf("%s",&nombre[c]);
printf("Introduce la calificacion\n");
scanf("%d",&calificacion[c]);
clrscr();
c=c+1;
}
clrscr();
printf("Los siguientes alumnos tienen calificacion mayor o igual a 8\n\n");
buscar(nombre,calificacion);
getch();
clrscr();
}

Programa # 5 -- Torres de Hanoi

#include <stdio.h>
#include <conio.h>

void hanoi(int n,int com, int aux, int fin);

void main(void){

        clrscr();
    char com='A';
    char aux='B';
    char fin='C';
    int n;

    printf("\nIntroduce el numero de discos: ");
    scanf("%d",&n);
    fflush(stdin);

    printf("\n\nLos movimientos a realizar son: \n");
    hanoi(n,com,aux,fin);
}

void hanoi(int n,int com, int aux, int fin){

    if(n==1){
        printf("%c->%c",com,fin);
    }
    else{
        hanoi(n-1,com,fin,aux);
        printf("\n%c->%c\n",com,fin);
        hanoi(n-1,aux,com,fin);
    }
}

Programa # 4 -- Inversa de una cadena de caracteres

#include "stdio.h"
#include "conio.h"

void inversa(char s[])
{
if(s[0] == '\0')
return;
else
{
inversa(&s[1]);
putchar(s[0]);
}
}
void main()
{
char palabra[40];
clrscr();
printf("Escribe una palabra para invertir:\n");
gets(palabra);
clrscr();
printf("\nLa palabra inversa es: ");
inversa(palabra);
getch();
}

Programa # 3 -- Serie Fibonacci

#include<iostream.h>
#include<conio.h>
#include<stdio.h>
int funcion (int n)
{
clrscr();
    if (n==0) return 1;
    if (n==1) return 1;
    else
    return (funcion(n-1))+funcion(n-2);

}

int main()
{
    int x,fun,con=1;
    clrscr();
    cout<<"Ingrese un numero para calcular la serie fibonacci "<<endl;
    cin>>x;
    fun = funcion (x);
    clrscr();
    cout<<"La serie fibonacci de "<<x<<" es "<<fun<<" obtenidos de la suma de: "<<endl;
    getch();
    while(con<=x+1)
    {
    printf("%d",funcion(x-con));
    con=con+1;
    getch();
    }
    clrscr();
    return 0;
}

Programa # 2 -- Factorial de un número

#include<iostream.h>
#include<conio.h>
double factorial (int n)
{
clrscr();
    if (n<0) return 0;
    if (n==0) return 1;
    else if (n==1) return 1;
    else return n*factorial (n-1);
}

int main()
{
    double
     x,fac;
    cout<<"Ingrese un numero para calcular el factorial "<<endl;
    cin>>x;
    fac = factorial (x);
    cout<<"El factorial de: "<<x<<" = "<<fac<<endl;
    getch();
    return 0;
}

Programa # 1 -- Calculadora Basica

#include<conio.h>
#include<stdio.h>
#include<iostream.h>

int suma ()
{
int a,b,res1;
printf("Introduce el valor de a:\n");
scanf("%d",&a);
printf("Introduce el valor de b:\n");
scanf("%d",&b);
res1=a+b;
return(res1);
}
int resta (int res2)
{
int d,e;
printf("Introduce el valor de a:\n");
scanf("%d",&d);
printf("Introduce el valor de b:\n");
scanf("%d",&e);
res2=d-e;
return(res2);
}
int divicion (int res3)
{
int g,h;
printf("Introduce el valor de a:\n");
scanf("%d",&g);
printf("Introduce el valor de b:\n");
scanf("%d",&h);
res3=g/h;
return(res3);
}
int multiplicacion (int res4)
{
int j,k;
printf("Introduce el valor de a:\n");
scanf("%d",&j);
printf("Introduce el valor de b:\n");
scanf("%d",&k);
res4=j*k;
return(res4);
}
void main()
{
int resultado;
int respuesta;
printf("Que operacion es la que deseas realizar?\n");
printf("\n\n\n1.-Suma\n");
printf("2.-Resta\n");
printf("3.-Divicion\n");
printf("4.-Multiplicacion\n********************************************\n");
scanf("%d",&respuesta);
switch(respuesta)
{
case 1:
cout<<"El resultado es "<<suma()<<endl;
break;
case 2:
cout<<"El resultado es "<<resta(resultado)<<endl;
getch();
break;
case 3:
cout<<"El resultado es "<<divicion(resultado)<<endl;
getch();
break;
case 4:
cout<<"El resultado es "<<multiplicacion(resultado)<<endl;
getch();
break;
}
getch();
}

Tipo de datos:

Ejemplo de Recursividad --- Serie Fibonacci

#include <stdio.h>
#include <conio.h>
/* definicion de la funcion recursiva fibonacci */
long fibonacci( long n )
{
    /* caso base */
    if ( n == 0 || n == 1 ) {
        return n;   }
    else { /* paso recursivo */
        return fibonacci( n - 1 ) + fibonacci( n - 2 );
    }
}
int main()
{
    long resultado; /* valor fibonacci */
    long numero;    /* numero a introducir por el usuario */
    printf("                Serie Fibonacci\n********************************************************************************\n\nIntroduzca un entero: " );
    scanf( "%ld", &numero);
    clrscr();
    resultado = fibonacci( numero );
    printf( "********************************************************************************\nEl Numero Fibonacci de ( %ld ) es --> = %ld\n", numero, resultado );
    getch();
        return 0;
        clrscr();
        /*La recursividad consume muchos recursos de
        memoria y tiempo de ejecución, y se debe aplicar
         a funciones que realmente le saquen partido.*/
}

Recursividad

Se utiliza para realizar una llamada a una función desde la misma función. Como ejemplo útil se puede presentar el cálculo de números factoriales. La recursividad y la iteración (ejecución en bucle) están muy relacionadas, cualquier acción que pueda realizarse con la recursividad puede realizarse con iteración y viceversa. Normalmente, un cálculo determinado se prestará a una técnica u otra, sólo necesita elegir el enfoque más natural o con el que se sienta más cómodo. Claramente, esta técnica puede constituir un modo de meterse en problemas. Es fácil crear una función recursiva que no llegue a devolver nunca un resultado definitivo y no pueda llegar a un punto de finalización. Este tipo de recursividad hace que el sistema ejecute lo que se conoce como bucle "infinito".

Para entender mejor lo que en realidad es el concepto de recursión veamos un poco lo referente a la secuencia de Fibonacci.

Ventajas:

1.- Proporciona simplicidad en la comprencion de los problemas.

2.- Es un metodo natural de resolver problemas.

3.- Permite un gran potencial de cálculo.

4.- La corrección de los algoritmos se comprueba facilmente.

Desventajas:

1.- Aumenta el consumo de recursos de la máquina (sobre todo de la pila) .

2.- Es más lenta que las interativas equivalentes (siempre que exista la solución iterativa equivalente).