jueves, 15 de diciembre de 2016

Proyecto Final Ejercicio 1

#include<stdio.h>
#include<conio.h>
#include<c:\b.h>
#define TAM 20

int main()
{
int cajas[TAM], z, x;
do
{
printf("1. Introduce la cantidad por caja\n\n");
printf("2. Total y promedio de las primeras 18 cajas\n\n");
printf("3. De las primeras 15 cajas cuales tienen menos de 50 piezas\n\n");
printf("4. De las primeras 10 cajas cuales tinene la mayor y menor cantidad de piezas\n\n");
printf("Escoge la opcción que quiera llevar a cabo\n\n");
scanf("%d", &z);
switch (z)
{
case 1: introduce(cajas);
break;
case 2: totprom(cajas);
break;
case 3: menor(cajas);
break;
case 4: mayormenor(cajas);
break;
default:

printf("Opccion incorecta\n");
}
printf("Desea repetir las opciones?\n\n");
printf("Pulse 1 para continuar\n\n");
scanf ("%d", &x);
}
while (x==1);
getch();
return 0;
}
}

Proyecto Final Ejercicio 1 Biblioteca

Biblioteca 
#define TAM 20

void introduce(int cajas[])
{
printf("\tintrouce la cantidad de piezas por caja\n\n");
for(int i=0; i<TAM; i++)
{
do
{
printf("Caja %d\n",i);
scanf("%d", &cajas[i]);
if(cajas[i]<40 || cajas[i]>60)
{
printf("caja invalida, las piezas deben ser>40 y <60\n");
}
}
while(cajas[i]<40||cajas[i]>60);
}
}
void totprom(int cajas[])
{
float prom;
int suma=0;
for(int i=0;i<18;i++)
{
suma+=cajas[i];
}
prom=suma/18;
printf("El total de la suma es =%d\n\n",suma);
printf("El promedio es =%f\n\n",prom);
}
void menor(int cajas[])
{
int c=0;
for (int i=0;i<15;i++)
{
if (cajas[i]<50)
c++;
}
printf("Las cajas que contienen menor a 50 piezas son= %d\n\n",c);
}
void mayormenor(int cajas[])
{
int may=cajas[0], men=cajas[0], may1=0, men1=0;
for (int i=0;i<10;i++)
{
if (may<cajas[i])
{
may=cajas[i];
may1=i;
}
if(men>cajas[i])
{
men=cajas[i];
men1=i;
}
}
printf("La caja con mas piezas es %d\n",may1);
printf("La caja con menor piezas es %d\n\n",men1);
}

Proyecto Final Ejercicio 2

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define COL 6
#define FIL 5
void IMC(float peso[FIL][COL],float estatura[FIL][COL],float IMC[FIL][COL])
{
int a,r,i=0;
printf("Persona\tIMC\n");
for(a=0;a<FIL;a++)
{
for(r=0;r<COL;r++)
{
i++;
IMC[a][r]=(peso[a][r]/pow(estatura[a][r],2));
printf("%d\t%f\n",i,IMC[a][r]);
}
}
}


//a)
void dato_peso(float peso[FIL][COL],int persona[FIL][COL])
{
int a,r;
for(a=0;a<FIL;a++)
{
for(r=0;r<COL;r++)
{
printf("Ingrese el peso de la persona %d\n",persona[a][r]);
scanf("%f",&peso[a][r]);
system("cls");
}
}
}


//b)
void dato_estatura(float estatura[FIL][COL],int persona[FIL][COL])
{
int a,r;
for(a=0;a<FIL;a++)
{
for(r=0;r<COL;r++)
{
printf("Ingresa la estatura de la persona %d\n",persona[a][r]);
scanf("%f",&estatura[a][r]);
system("cls");
}
}
}


//c)
void despliegue(float estatura[FIL][COL],float peso[FIL][COL],int persona[FIL][COL])
{
int a,r;
printf("\t\tTabla\nPersona\tPeso\t\tEstatura\n");
for(a=0;a<FIL;a++)
{
for(r=0;r<COL;r++)
{
printf("%d\t%f\t%f\n",persona[a][r],peso[a][r],estatura[a][r]);
}
}
}

//d)
void indi_IMC(float IMC[FIL][COL],int persona[FIL][COL])
{
int a,r;
printf("\t\tTabla 1\nPersona\t\tIMC\t\tEstado\n");
for(a=0;a<FIL;a++)
{
for(r=0;r<COL;r++)
{
printf("%d\t%f\t",persona[a][r],IMC[a][r]);
if(IMC[a][r]<18.5)
  printf("Bajo Peso\n");
if(IMC[a][r]>18.5&&IMC[a][r]<25)
  printf("Peso normal\n");
if(IMC[a][r]>25&&IMC[a][r]<30)
  printf("Sobre peso\n");
if(IMC[a][r]>30&&IMC[a][r]<40)
  printf("Obesidad\n");
if(IMC[a][r]>40)
  printf("Obesidad morbida\n");
}
}
}


//e)
void max_min(float IMC[FIL][COL],int per[FIL][COL])
{
int a,r,max1=per[0][0],min1=per[0][0];
float max=IMC[0][0],min=IMC[0][0];
for(a=0;a<FIL;a++)
{
for(r=0;r<COL;r++)
{
if(IMC[a][r]>max)
                         {
  max=IMC[a][r];
  max1=per[a][r];
                         }
if(IMC[a][r]<min)
                         {
  min=IMC[a][r];
  min1=per[a][r];
                         }
}
}printf("El IMC mas alto es de la persona %d y es=%f\nEl IMC mas bajo es de la persona %d y es=%f",max1,max,min1,min);
}


//f)
void promedio(float IMC[FIL][COL])
{
int a,r;
float suma=0;
for(a=0;a<FIL;a++)
{
for(r=0;r<COL;r++)
{
suma+=IMC[a][r];
}
}printf("EL promedio del IMC es=%f",suma/(FIL*COL));
}
void persona(int persona[FIL][COL])
{
int a,r,i=0;
for(a=0;a<FIL;a++)
{
for(r=0;r<COL;r++)
{
   i++;
persona[a][r]=i;
}
}
}
void menu()
{
int per[FIL][COL],x;
float IMc[FIL][COL],peso[FIL][COL],estatura[FIL][COL];
persona(per);
for(;;)
{
system("cls");
printf("\tMenu:\n1-Ingresar peso\n2-Ingresar estatura\n3-Calcular IMC\n4-Desplegar datos\n5-Tabla de indicadores\n6-Maximo y Minimo\n7-Promedio\n8-Salir\n");
scanf("%d",&x);
system("cls");
switch(x)
{
case 1:dato_peso(peso,per);
                system("pause>null");
      break;
case 2:dato_estatura(estatura,per);
       system("pause>null");
      break;
case 3:IMC(peso,estatura,IMc);
       system("pause>null");
      break;
case 4:despliegue(estatura,peso,per);
system("pause>null");
break;
case 5:indi_IMC(IMc,per);
system("pause>null");
break;
case 6:max_min(IMc,per);
system("pause>null");
break;
case 7:promedio(IMc);
system("pause>null");
break;
case 8:exit(0);
system("pause>null");
break;
default:printf("Ese numero no existe");
break;
}
}
}
int main()
{
menu();
}

martes, 13 de diciembre de 2016

PRACTICA MATRIZ COMPLETA

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<c:\aretavo.h>
#define FIL 5
#define COL 5

int main()
{
     float MATH[FIL][COL],pm;
        int x;
        matriz(MATH);
for(;;)
        {
        system("cls");
   printf("Seleccióna una opercación.\n\n1.- imprimir\n2.-suma diagonal  \n3.-Numeros positivos \n4.-Transpuesta \n5.-Promedio\n6-.desviacion estandar\n7.-salir\n\n");
   scanf("%i",&x);
   system("cls");
        switch(x)
   {
    case 1:
                imprimir (MATH);
                 system("pause");
            break;
    case 2:
                 suma(MATH);
                 system("pause");
            break;
    case 3:
                 positivos(MATH);
                 system("pause");
            break;
    case 4:
                 transpuesta (MATH);
                 system("pause");
            break;
    case 5:
                  pm=promedio(MATH);
                  printf("El promedio =%f\n\n",pm);
                 system("pause");
            break;
    case 6:
                 medioydesviacion (MATH);
              system("pause");
               
            break;
            case 7:exit(0);break;
    default:
            printf("no es valida la opcion\n");
}
  }
   system("pause>NULL");
}


PRACTICA MATRIZ BIBLIOTECA

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define FIL 5
#define COL 5

void matriz (float MATH[FIL][COL])
{
    int f,c;
    for (f=0;f<FIL;f++)
{for (c=0;c<COL;c++)
{printf("Introduce elemento [%d][%d]\n",f,c);
scanf("%f", &MATH[f][c]);
}}}

void imprimir (float MATH[FIL][COL])
{
     for(int f=0;f<FIL;f++)
{
     for(int c=0;c<COL;c++)
{
     printf("%.0f\t",MATH[f][c]);
}
printf("\n\n");
}
}

void suma(float MATH[FIL][COL])
{
     float s=0;
     int f,c;
     for(f=0;f<FIL;f++)
{for(c=0;c<COL;c++)
{
if (f==c)
s+=MATH[f][c];
}}
printf("\tLa suma de los elementos de la diagonal es= %f\n",s);
}
void positivos(float MATH[FIL][COL])
{
    int f,c,i=0;
     for (f=0;f<FIL;f++)
     {
         for (c=0;c<COL;c++)
         {
             if (MATH [f][c]>0)
             i++;
             }
           
             }
         printf("LOS ELEMENTOS POSITIVOS SON %d\n\n",i);
         }
void transpuesta (float MATH[FIL][COL])
{
     int f,c;
     float MATHT[FIL][COL];
 
      for (f=0;f<FIL;f++)
     {
         for (c=0;c<COL;c++)
         {
             {
             MATHT[f][c]=MATH[c][f];
             }
         printf("%.0f\t",MATHT [f][c]);
         }
          printf("\n\n");
         }
         }
float promedio (float MATH[FIL][COL])
         {
           float sumas=0,dm=0;
      for (int f=0;f<FIL;f++)
      {
          for (int c=0;c<COL;c++)
          {
           sumas+=MATH[f][c];
           }
           }
            return(sumas/25);
           }
         
void medioydesviacion (float MATH[FIL][COL])
{
     float sumas=0,dm=0;
      for (int f=0;f<FIL;f++)
      {
          for (int c=0;c<COL;c++)
          {
           sumas+=pow(MATH[f][c]-promedio(MATH),2);
           dm=sqrt(sumas/24);
         
           }
           }
           printf("La desviacion estandar =%f\n\n",dm);          
         
           }
       

Matriz Basico Modo 3

#include<stdio.h>
#include<conio.h>
#define FIL 3
#define COL 3
int main()
{
int A[FIL][COL];
int f,c;
for (f=0;f<FIL;f++)
{
for (c=0;c<COL;c++)
{
printf("introduce elemento [%d][%d]\n",f,c);
scanf("%d",&A[f][c]);
}
for (f=0;f<FIL;f++)
{
for (c=0;c<COL;c++)
{
printf("%d\t",A[f][c]);
    }
printf("\n");
}
}

getch();

}

Matriz Basico Modo 2

#include<stdio.h>
#include<conio.h>
#define FIL 3
#define COL 3
int main()
{
int A[FIL][COL]={1,0,0,0,1,0,0,0,1};
printf("%d\t  %d\t  %d\n",A[0][0],A[0][1],A[0][2]);
printf("%d\t  %d\t  %d\n",A[1][0],A[1][1],A[1][2]);
printf("%d\t  %d\t  %d\n",A[2][0],A[2][1],A[2][2]);
getch();
}

Matriz Basico Modo 1

#include<stdio.h>
#include<conio.h>
int main()
{
int M[2][2];
M[0][0]=1;
M[0][1]=0;
M[1][0]=0;
M[1][1]=1;
printf("%d\t %d\n", M[0][0],M[0][1]);
printf("%d\t %d\n", M[1][0],M[1][1]);
getch();
}

ARREGLOS PRACTICA

#include<stdio.h>
#include<conio.h>
//inciso a
void introducir(int NUMEROS[10])
{
     printf("Introduciendo datos al arreglo\n");
     for (int i=0;i<10;i++)//contador i controla la posicion del arreglo
     {
         printf("Elemento en la posicion [%d]\n",i);
         scanf("%d",&NUMEROS[i]);
         }
     }
//inciso b
void imprimir (int NUMEROS[10])
{
     printf("Desplegando datos del arreglo\n");
     for (int i=0;i<10;i++)
     {
         printf("Elemento en la posicion [%d] =%d\n",i,NUMEROS[i]);
     }
 }
       //c
         int suma (int NUMEROS[10])
         {
                  int totsuma=0;//acumulador
                  for (int i=0;i<10;i++)
                  {
                      totsuma=totsuma+NUMEROS[i];
                  }
                  return totsuma;
                  }
         //d
         float promedio(int NUMEROS[10])
         {
               float p;
               p=float(suma(NUMEROS))/10;
               return (p);
             
         }
          //e
           void max_min(int NUMEROS[10])
           {
                int posmax=0, posmin=0;
                int max=NUMEROS[0],min=NUMEROS[0];//Referencia el primer elemnto al angulo
                for(int i=1;i<10;i++)
                {
                        if(max<NUMEROS[i])
                        {
                           max=NUMEROS[i];
                           posmax=i;
                        }
                        else if(min>NUMEROS[i])
                        {
                             min=NUMEROS[i];
                             posmin=i;
                        }
                }
         printf("El valor maximo del arreglo =%d ubicado en la posicion %d\n",max,posmax);
         printf("El valor minimo del arreglo =%d ubicado en la posicion %d\n",min,posmin);
                }                      
         //F
         void busqueda(int NUMEROS[10])
         {
              int N,cont=0;
              printf("Introduce el valor busqueda\n");
              scanf("%d",&N);
              for (int i=0;i<10;i++)
              {
                  if(N==NUMEROS[i])
                 
                  cont++;
                  }
               
              printf("El valor se repite =%d",cont);
         }    
       
         //g
         void ordenamientoascendente (int NUMEROS[10])
{
     int aux,f,g,h;
   
     for(f=0;f<9;++f)
     {
         for (g=0;g<9;++g)
         {
             if (NUMEROS[g]<NUMEROS[g+1])
             {
                aux=NUMEROS[g];
                NUMEROS[g]=NUMEROS[g+1];
                NUMEROS[g+1]=aux;
             }
         }
     }
     for(h=0;h<10;++h)
     {
        printf("El orden ascendente es=%i.\n",NUMEROS[h]);
     }
}        
void ordenamientodescendente (int NUMEROS[10])
{
     int aux1,f1,g1,h1;
   
     for(f1=0;f1<9;++f1)
     {
         for (g1=0;g1<9;++g1)
         {
             if (NUMEROS[g1]>NUMEROS[g1+1])
             {
                aux1=NUMEROS[g1];
                NUMEROS[g1]=NUMEROS[g1+1];
                NUMEROS[g1+1]=aux1;
             }
         }
     }
     for(h1=0;h1<10;++h1)
     {
        printf("El orden ascendente es=%i.\n",NUMEROS[h1]);
     }
}                
       
         int main ()
{
         int NUMEROS [10];//declaro arreglo
         introducir (NUMEROS);//llamada a la funcion
         imprimir(NUMEROS);//llamda a la funcion
         printf("La suma de los elementos =%d\n",suma(NUMEROS));
         printf("El promedio total es=%f\n",promedio(NUMEROS));
         max_min(NUMEROS);
         busqueda(NUMEROS);
         ordenamientoascendente(NUMEROS);
         ordenamientodescendente(NUMEROS);
       
         getch ();
         }
       

Metodo burbuja

#include<stdio.h>
#include<conio.h>
int main ()
{
int aux,i,j,k;
int n=10,A[n];

for (i=0; i<n; i++)
{
printf("dame el dato %dn",i+1);
scanf("%d",&A);
}
for (i=0;i<n;i++)
{
for (j=0;j<n-i;j++)
{
if (A[j]>=A[j+1])
{
aux=A[j];
A[j]=A[j+1];
A[j+1]=aux;
}

}

}
for (k=0;k<n;k++)
{
printf(" %d",A[k]);
getch();
}


getch();
return 0;
getch();
}

Factorial

#include<stdio.h>
#include<stdlib.h>
double factorial(int n)
{
       int i;
       double facto=1;
       if(n==0)
       return 1;
       else if (n>0)
       {
            for (i=n ; i>=1 ; i--)
            {
                facto=facto*i;
            }
            return facto;
            }
            }
            int main()
            {
               
                int a,x;
                printf("introduce valor...\n");
                scanf("%i",&x);
                a=factorial(n);
                printf("resultado es %lf...\n",a);
                system("pause>null");
                 }
               
               

Practica 6

#include<stdio.h>
#include<stdlib.h>

void suma_impares(int x);
int main()
{
    int x;
    printf("introduce el No. de la serie a sumar\n");
    scanf("%d",&x);
    suma_impares(x);
   
}
void suma_impares(int x)
{
     int i=1;
     int acum=1;
     for(i=1;i<=x;i++)
     {
                      acum+=2;//acum=acum+2
                       }
     printf("El resultado de la suma de la serie es:%d \n",x,acum);
     }
   

Arreglos

17/NOVIEMBRE/2016 APUNTE

Arreglos
Conjunto de datos del mismo tipo almacenados en forma secuencial y todos bajo un mismo nombre.
Clasificación:
a)      Unidimensionales (vectores)

·         Representación grafica

Ciclos Anidades ejemplo

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

void use_ciclos_anidades()
{
    float cal,suma,prom;
    for (int e=1;e<=5;e++)//ciclo externo
    {
    suma=0; //acumulador
    for (int m=1;m<=5;m++) //ciclo interno
    {
    printf("Introduce calificacion No=%d\n",m);
    scanf("%f",&cal);
    suma=suma+cal; //sum+=cal;
    }
    prom=suma/4;
    printf("Para estudiante No%d promedio=%f\n",e,prom);
}
}  
int main()
{
    use_ciclos_anidades();
    getch();
}

Dos experiementos Anidades

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

void ciclos_anidades()
{
    float cal,suma,prom, prome;
    for (int e=1;e<=4;e++)//ciclo externo
    {
    suma=0; //acumulador
    for (int m=1;m<=6;m++) //ciclo interno
    {
    printf("\n Introduce el resultado de prueba No=%d\n",m);
    scanf("%f",&cal);
    suma=suma+cal; //sum+=cal;
    }
    prom=suma/6;
    printf("El promedio total es de=%f",prom);
    if (prom>=6)
    printf("\n Prueba aceptada\n");
    else
    printf("\n Prueba rechazada \n");
    prome=prome+prom/4;
 
}
  printf("El promedio global es=%f",prome);
}  
int main()
{
    ciclos_anidades();
    getch();
}

Ciclos anadidos

#include <stdio.h>
#include <stdlib.h>

void ejercicio3()
{
     int x,z,y;
     for (x=1;x<=5;x++)
     {
         printf ("\nx=%d\n",x);
         for (z=2;z<=6;z++)
         {
             if(x==z)
             printf ("z=%d\t funcion indefinida\n",z);
             else
             {
             y=(x*z)/(x-z);
             printf("z=%d\t y=%d\n",z,y);
             }
         }
     }
}
int main ()
{
 ejercicio3();
 system ("pause>null");
}

While

#include<stdio.h>
#include<stdlib.h>


void serie (int x)
{
int a=2,suma=0,b=0,c=0;
while(b<=x)
{
c=a+b;

suma+=c;

printf("La seria es%i\n\n",c);
printf("La suma es=%i\n\n",suma);
b+=2;
}
}
int main()
{
int y;
printf("Ingresa tu ultimo numero de la serie");
scanf("%i",&y);
serie(y);
system("pause>null");
}

Switch

#include<stdio.h>
#include<stdlib.h>

int menu ()
{
int combo;
printf("\tHola bienvenido, estos son los combos que tenemos\n\n");
printf("\tPaquete 1, Hamburguesa, pieza de pollo, refresco mediano y helado mediano\n\n");
printf("\t\tPrecio=80\n\n");
printf("\tPaquete 2, Rebanada de pizza, papas, refresco grande, coctel de frutas\n\n");
printf("\t\tPrecio=90\n\n");
printf("\tPaquete 3 (pareja), 2 rebanadas de pizza, 2 refrescos mediano, ensalada grande\n\n");
printf("\t\tPrecio=130\n\n");
printf("\tPaquete 4 (pareja), 2 hamburguesas, 2refrescos grandes, papas, 2 helados medianos\n\n");
printf("\t\tPrecio=160\n\n");
printf("\tPor favor inserta el numero del paquete de tu agrado, si ningun paquete te convencio teclea cualquier otro numero\n\n");
scanf("%i", &combo);
return combo;
}
void combo ()
{
switch (menu())
{
case 1:
printf("\tRectifico elegiste el paquete 1 que contiene, Hamburguesa, pieza de pollo, refresco mediano y helado mediano\n\n");
printf("\t\tLe cobro 80, gracias que tenga un buen dia\n\n");
break;
case 2:
printf("\tRectifico elegiste el paquete 2 que contiene, Rebanada de pizza, papas, refresco grande, coctel de frutas\n\n");
printf("\t\tLe cobro 90, gracias que tenga un buen dia\n\n");
break;
case 3:
printf("\tRectifico elegiste el paquete 3 (pareja)que contiene, 2 rebanadas de pizza, 2 refrescos mediano, ensalada grande\n\n");
printf("\t\tLe cobro 130, gracias que tenga un buen dia\n\n");
break;
case 4:
printf("\tRectifico elegiste elpaquete 4 (pareja) que contiene, 2 hamburguesas, 2refrescos grandes, papas, 2 helados medianos\n\n8");
printf("\t\tLe cobro 160, gracias que tenga un buen dia\n\n");
break;
default:
printf("Arma tu propio combo!!!");
break;
}
}
int main()
{
combo ();
system ("pause>null");
}

If Else

#include<stdio.h>
#include<stdlib.h>

void calificacion()
{
float a;
printf("\tHola, Buen dia\n\n");
printf("\tPor favor introduzca su calificacion\n\n");
scanf ("%f",&a);

if(a<=5)

printf ("\tReprobado  %.2f",a);

else

printf("\tAprobado  %.2f",a);
}
int main()
{
calificacion();
system("pause>null");
}

If

#include<stdio.h>
#include<stdlib.h>

float calificaciones_espectativas_algebra()
{
float algebra,  a1, a2, a3;
printf("\n  Suponiendo su calificacion de la materia de algebra ingrese sus calidicaciones de 1, 2, 3 parcial\n\n");
scanf("%f %f %f", &a1, &a2, &a3);
algebra=(a1+a2+a3)/3;
return algebra;
}

float calificaciones_espectativas_calculo()
{

float calculo, c1, c2, c3;
printf("\n  Suponiendo su calificacion de la materia de calculo ingrese sus calidicaciones de 1, 2, 3 parcial\n\n");
    scanf("%f %f %f", &c1, &c2, &c3);
calculo=(c1+c2+c3)/3;
return calculo;
}
float calificaciones_espectativas_programacion()
{

float programacion,p1, p2, p3;
printf("\n  Suponiendo su calificacion de la materia de progra ingrese sus calidicaciones de 1, 2, 3 parcial\n\n");
scanf("%f %f %f", &p1, &p2, &p3);
programacion=(p1+p2+p3)/3;
return programacion;
}
float calificaciones_reales_algebra()
{
float algebrareal,  ar1, ar2, ar3;
printf("\n  Tenindo sus calificaciones reales de la materia de algebra \tingrese sus calidicaciones de 1, 2, 3 parcial\n\n");
scanf("%f %f %f", &ar1, &ar2, &ar3);
algebrareal=(ar1+ar2+ar3)/3;
return algebrareal;
}

float calificaciones_reales_calculo()
{

float calculoreal, cr1, cr2, cr3;
printf("\n   Tenindo sus calificaciones reales de la materia de calculo \tingrese sus calidicaciones de 1, 2, 3 parcial\n\n");
    scanf("%f %f %f", &cr1, &cr2, &cr3);
calculoreal=(cr1+cr2+cr3)/3;
return calculoreal;
}
float calificaciones_reales_programacion()
{
float programacionreal ,pr1, pr2, pr3;
printf("\n   Tenindo sus calificaciones reales de la materia de progra \tingrese sus calidicaciones de 1, 2, 3 parcial\n\n");
scanf("%f %f %f", &pr1, &pr2, &pr3);
programacionreal=(pr1+pr2+pr3)/3;
return programacionreal;
}
int main()
{
float algebra, calculo, programacion, algebrareal, calculoreal, programacionreal;
algebra=calificaciones_espectativas_algebra();
calculo=calificaciones_espectativas_calculo();
programacion=calificaciones_espectativas_programacion();
algebrareal=calificaciones_reales_algebra();
calculoreal=calificaciones_reales_calculo();
programacionreal=calificaciones_reales_programacion();
printf("\tPromedio espectativo de algebra=%.2f, calculo=%.2f,programacion=%.2f\n\n", algebra, calculo, programacion);
printf("\tPromedio real de algebra=%.2f, calculo=%.2f,programacion=%.2f\n\n", algebrareal, calculoreal, programacionreal);


if((algebra==algebrareal)&&(calculo==calculoreal) && (programacion==programacionreal))
printf("\t Eres brujo\n\n");

if ((algebra<algebrareal)&&(calculo<calculoreal)&&(programacion<programacionreal))
printf("\t Exelente, Mejor de lo que esperabas\n\n");

if ((algebra>algebrareal)&&(calculo>calculoreal)&&(programacion>programacionreal))
printf("\t No te preocupes eres bueno en la otra te ira mejor\n\n");

system("pause>null");
}

For

#include<stdio.h>
#include<stdlib.h>
#include<math.h>



int main()
{
int x,f;
for (x;x<11;x++)
  {
  f=pow(x,2)+2;
 
printf("Los resultados son %i\n\n",f);
}

}

Do while

#include<stdio.h>
#include<stdlib.h>

void numeros()
{

int a,i=0,x;
char salida;


Decision en Cascada

#include<stdio.h>
#include<conio.h>
 int main()
 {
     float x,y;
     char z,l;
     printf("Cual es el precio del preducto que quieres comprar?\n");
     scanf("%f",&x);
     printf("Cuanto dinero traes de presupuesto?\n");
     scanf("%f",&y);
     if(x<y)
     {
     printf("Tienes dinero sufuciente, pero, enrealidad necesitas esto? R=(s/n)\n");
     scanf("%s",&z);
     if(z=='s')
     {
               printf("Seria una buena opcion comprarlo\n");
     }
     else if(z=='n')

Ciclo For

7.- Ciclo For

Los ciclos for son lo que se conoce como estructuras de control de flujo cíclicas o simplemente estructuras cíclicas, estos ciclos, como su nombre lo sugiere, nos permiten ejecutar una o varias líneas de código de forma iterativa, conociendo un valor especifico inicial y otro valor final, además nos permiten determinar el tamaño del paso entre cada "giro" o iteración del ciclo.

En resumen, un ciclo for es una estructura de control iterativa, que nos permite ejecutar de manera repetitiva un bloque de instrucciones, conociendo previamente un valor de inicio, un tamaño de paso y un valor final para el ciclo.

Sentencia while.

6.- Sentencia while.
Un ciclo es cualquier construcción de programa que repite una sentencia o secuencia de sentencias un número de veces.
•   La sentencia o grupo de sentencias que se repite en un bloque se denomina cuerpo del ciclo y cada repetición del cuerpo del ciclo se llama iteración del ciclo.
•    Un ciclo while tiene una condición del ciclo, una expresión lógica que controla la secuencia de repetición.
•  La posición de esta condición del ciclo es delante del cuerpo del ciclo y significa que un ciclo while es un ciclo de preverificación de modo que cuando se ejecuta el mismo, se evalúa la condición antes de que se ejecute el cuerpo del ciclo.

Do while.

5.- Do while.
Estructura Do-While o Hacer-Repetir
Es una estructura repetitiva en donde el número de repeticiones es desconocido y se hará mientras se cumpla cierta condición, dependiendo de ella puede que se realice más de una o ninguna vez.
Se diferencia con el ciclo while ya que en este la condición se realiza al finalizar el ciclo, mientras que en el do-while se ejecutan las instrucciones y luego se evalúa la condición.
Sintáxis
do
{
Bloque de instrucciones;
}

while(condición de finalización);

Switch

4.- Switch
*CASE
*BREAK
*DEFEAULT
Aunque la sentencia if es muy importante, en ocasiones    puede ser muy tediosa, sobre todo en los casos en el que         programa presenta varias elecciones.

En situaciones donde el valor de una expresión determina  que sentencias serán ejecutadas será mejor utilizar una      sentencia switch en lugar de una if.


El condicional switch permite elegir entre varias opciones posibles. En realidad, este condicional puede ser expresado también usando condicionales if, por lo que podríamos decir que no es estrictamente necesario. Sin embargo, en algunos casos resulta más claro usar el condicional switch y resulta útil.

Decisiones en cascada o anidadas.

3.- Decisiones en cascada o anidadas.
Una estructura de selección múltiple puede constar de una serie de alternativas simples o dobles, unas interiores a otras. Como esto puede volverse bastante complejo para que el algoritmo resulte claro de leer, se recomienda usar indentación (sangrías), de modo que exista una correspondencia entre las palabras reservadas si y fin_si.
En este ejemplo, leemos tres números para determinar cuál de ellos es el mayor usando estructuras de selección anidadas:

ESTRUCTURAS DE DECISIÓN DOBLE

2.-ESTRUCTURAS DE DECISIÓN DOBLE
Las estructuras selectivas se utilizan para tomar decisiones lógicas; de ahí que se suelan denominar también estructuras de decisión o alternativas.
En las estructuras selectivas se evalúa una condición y en función del resultado de la misma se realiza una opción u otra. Las condiciones se especifican usando expresiones lógicas.

Estructura simple

1.- Estructura simple

Diariamente utilizamos condiciones para llegar a un resultado deseado. “Si no lavas la ropa, no irás al concierto de Roger Waters”, “Si no pasas el semestre, llorarás en los ETS”… Las oraciones anteriormente mencionadas tienen una parte condicional y una consecuencia o sentencia. En el lenguaje de programación se utilizan expresiones similares.
Sentencia If
La sentencia if permite a un programa tomar una decisión para ejecutar una acción u otra, basándose en el resultado verdadero o falso de una expresión. La sintaxis para utilizar esta sentencia es la siguiente:

Tarea 18/10/2016

18/OCTUBRE/2016 TAREA

Contadores
Un contador es una variable que inicialmente vale 0 (suponiendo que la cuenta empieza desde 1) y que después se incrementa en una unidad cada vez que ocurre el suceso que se desea contar.
Estructura:
int cont = 0
inicio del bucle
i = i +1
fin del bucle

Acumulador
Es una variable que suma sobre sí misma un conjunto de valores para de esta manera tener la suma de todos ellos en una sola variable. La diferencia entre un contador y un acumulador es que mientras el primero va aumentando de uno en uno, el acumulador va aumentando en una cantidad variable.
Estructura:
int acum = 0
inicio del bucle
acum = acum + valor

fin del bucle

Mutiplicacion y division

#include<stdio.h>
#include<conio.h>
#include<math.h>
float funA(float x,float y,float z);
void FunB(void);
int main()
{
    FunB();
    getch();
}
 void FunB(void)
 {
      float x,y,z;
      printf("Introduce el valor de x\n");
      scanf("%f",&x);
      printf("Introduce el valor de y\n");
      scanf("%f",&y);
      printf("Introduce el valor de z\n");
      scanf("%f",&z);
      printf("El valor de la funcion A=%.2f con valores de x=%.2f, y=%.2f, z=%.2f",funA(x,y,z),x,y,z);
 }  
 float funA(float x,float y,float z)
 {
       float op=(x*y)/z;
       return op;
 }
     

Funciones que no reciben y no retornan VALOR DE UN PUNTO

/*Funciones que no reciben y no retornan*/
#include<stdio.h>
#include<conio.h>
void funB(void);
int main()
{
funB();
getch();

}
void funB(void)
{
float x,y,z,funB;
printf("Introduce el valor de x...\n");
scanf("%f",&x);
printf("Introduce el valor de y...\n");
scanf("%f",&y);
printf("Introduce el valor de z...\n");
scanf("%f",&z);
funB=(x*y)/z;
printf("El valor de la funcion B=%.2f, con valores de x=%f, y=%f, z=%f",funB,x,y,z);

}

Funcion que no recibe ni retorna CONVERSIONES

/*Funcion que no recibe ni retorna*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
void conversiones (void);
void conv_cm_a_in(float cm);
void conv_cm_a_m(float cm);
void conv_cm_a_ft(float cm);
void conv_cm_a_yarda(float cm);
void conv_cm_a_milla(float cm);
int main()
{
    conversiones();
    getch();
}
void conversiones(void)
{
     float cm;
     printf("Introduce los cm a convertir...\n");
     scanf("%f",&cm);
     conv_cm_a_in(cm);
     conv_cm_a_m(cm);
     conv_cm_a_ft(cm);
     conv_cm_a_yarda(cm);
     conv_cm_a_milla(cm);
   
}
void conv_cm_a_in(float cm)
{
     float in;
   
     in=(cm*0.393701);
     printf("conversion de cm a in=%.2f pulgadas \n",in);
}
void conv_cm_a_m(float cm)
{
     float m;
   
     m=(cm/100);
     printf("conversion de cm a m=%.2f metros \n",m);
}
void conv_cm_a_ft(float cm)
{
     float ft;
   
     ft=(cm*0.0328084);
     printf("conversion de cm a ft=%.2f pies \n",ft);
}
void conv_cm_a_yarda(float cm)
{
     float yarda;
 
     yarda=(cm*0.0109361);
     printf("conversion de cm a yardas=%.2f \n",yarda);
}
void conv_cm_a_milla(float cm)
{
     float milla;
   
     milla=(cm*(6.21371*pow(10,-6)));
     printf("conversion de cm a millas=%f \n",milla);
}

Funcion que recibe y retorna retorna POBLACION

/*Funcion que recibe y retorna*/
#include<stdio.h>
#include<math.h>
#include<conio.h>

float poblacion(float x);

int main()
{
    float x,result;
    printf("Introducir el año a estimar la poblacion...\n");
    scanf("%f",&x);
    result=poblacion(x);
    printf("En el año=%f, la poblacion estimada sera de=%f miles de millones\n",x,result);
    getch();
    }
    float poblacion(float x)
    {
          float result;
          result=((6.0)*exp(0.02*(x-2000)));
          return result;
}
       
 

Funciones que reciben y no retornan

/*Funciones que reciben y no retornan*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
void FGen1(float a, float b, float c);
void FGen2(float a, float b, float c);
int main()
{
    float a, b, c, x1, x2;
    printf("Introduce los valores (a,b,c)...\n");
    scanf("%f,%f,%f",&a,&b,&c);
    FGen1(a,b,c);
    FGen2(a,b,c);
    getch();
}
void FGen1(float a, float b, float c)
{
      float x1;
      x1=(-b+sqrt(pow(b,2)-(4*a*c)))/(2*a);
      printf("FGen1=%f\n",x1);
}
void FGen2(float a, float b, float c)
{
      float x2;
      x2=(-b-sqrt(pow(b,2)-(4*a*c)))/(2*a);
      printf("FGen2=%f\n",x2);
     
}

Funciones que reciben y no retornan FORMULA GENERAL

/*Funciones que reciben y no retornan*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
void FGen1(float a, float b, float c);
void FGen2(float a, float b, float c);
int main()
{
    float a, b, c, x1, x2;
    printf("Introduce los valores (a,b,c)...\n");
    scanf("%f,%f,%f",&a,&b,&c);
    FGen1(a,b,c);
    FGen2(a,b,c);
    getch();
}
void FGen1(float a, float b, float c)
{
      float x1;
      x1=(-b+sqrt(pow(b,2)-(4*a*c)))/(2*a);
      printf("FGen1=%f\n",x1);
}
void FGen2(float a, float b, float c)
{
      float x2;
      x2=(-b-sqrt(pow(b,2)-(4*a*c)))/(2*a);
      printf("FGen2=%f\n",x2);
     
}

Funciones que no reciben y no retornan DISTANCIA

/*funciones que no reciben y no retornan*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
void distancia(void);
int main()
{
distancia();
getch();
}
void distancia(void)
{
float x1,y1,x2,y2,d1;
printf("Introduce los valores de(P)...\n");
scanf("%f,%f",&x1,&y1);
printf("Introduce los valores de(Q)...\n");
scanf("%f,%f",&x2,&y2);
d1=sqrt(pow(x2-x1,2)+pow(y2-y1,2));
printf("distancia=%f\n",d1);
}

Funciones que no reciben y retornan DISTANCIA

/*Funciones que no reciben y retornan*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
float distancia(void);
int main()
{
float d1;
d1=distancia();
printf("distancia=%f \n",d1);
getch();
}
float distancia(void)
{
float x1,y1,x2,y2,d1;
printf("Introduce valores de(P)...\n");
scanf("%f,%f",&x1,&y1);
printf("Introduce valores de(Q)...\n");
scanf("%f,%f",&x2,&y2);

d1=sqrt(pow(x2-x1,2)+pow(y2-y1,2));
return d1;
}

Funciones que no reciben y no retornan FORMULA GENERAL

/*funciones que no reciben y no retornan*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
void FGen1(void);
int main()
{
FGen1();
getch();

}
void FGen1(void)
{
float a, b, c, x1,x2;
printf("Introduce los valores (a,b,c)...\n");
scanf("%f,%f,%f",&a, &b, &c);
x1=(-b+sqrt(pow(b,2)-(4*a*c)))/(2*a);
printf("FGen1=%f \n", x1);
x2=(-b-sqrt(pow(b,2)-(4*a*c)))/(2*a);
printf("FGen2=%f \n", x2);
}

Funciones que no reciben y no retornan

/*funciones que no reciben y no retornan*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
void FGen1(void);
int main()
{
FGen1();
getch();

}
void FGen1(void)
{
float a, b, c, x1,x2;
printf("Introduce los valores (a,b,c)...\n");
scanf("%f,%f,%f",&a, &b, &c);
x1=(-b+sqrt(pow(b,2)-(4*a*c)))/(2*a);
printf("FGen1=%f \n", x1);
x2=(-b-sqrt(pow(b,2)-(4*a*c)))/(2*a);
printf("FGen2=%f \n", x2);
}

Funciones que no reciben y retornan

/*Funciones que no reciben y retornan*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
float FGen1(void);
float FGen2(void);
int main()
{
    float x1,y2;
   
    x1=FGen1();
    y2=FGen2();
    printf("FGen1=%f \n",x1);
    printf("FGen2=%f \n",y2);
     getch();
}
float FGen1(void)
{
      float a,b,c,x1;
      printf("Introduce valores (a,b,c)...\n");
      scanf("%f,%f,%f",&a, &b, &c);
      x1=(-b+sqrt(pow(b,2)-(4*a*c)))/(2*a);
      return x1;
     
}
float FGen2(void)
{
      float a,b,c,x2;
      x2=(-b-sqrt(pow(b,2)-(4*a*c)))/(2*a);
      return x2;
}

Funciones que reciben y no retornan DISTANCIA

/*Funciones que reciben y no retornan*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
void distancia(float x1, float y1, float x2, float y2);
int main()
{
    float x1, y1, x2, y2,result;
    printf("Introduce los valores de (P)...\n");
    scanf("%f,%f",&x1,&y1);
     printf("Introduce los valores de (Q)...\n");
    scanf("%f,%f",&x2,&y2);
    distancia(x1,y1,x2,y2);
    getch();
}
void distancia(float x1, float y1, float x2, float y2)
{
      float result;
      result=sqrt(pow(x2-x1,2)+pow(y2-y1,2));
      printf("d1=%f\n",result);
}

Funciones que reciben y retornan

/*Funciones que reciben y retornan*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
float FGen1(float a, float b, float c);
float FGen2(float a, float b, float c);
int main()
{
    float a, b, c, x1, x2;
    printf("Introduce los valores (a,b,c)...\n");
    scanf("%f,%f,%f",&a,&b,&c);
    x1=FGen1(a,b,c);
    x2=FGen2(a,b,c);
    printf("FGen=%f\n",x1);
    printf("FGen=%f\n",x2);
    getch();
}
float FGen1(float a, float b, float c)
{
      float x1;
      x1=(-b+sqrt(pow(b,2)-(4*a*c)))/(2*a);
      return x1;
}
float FGen2(float a, float b, float c)
{
      float x2;
      x2=(-b-sqrt(pow(b,2)-(4*a*c)))/(2*a);
      return x2;
}

Funciones que reciben y retornan DISTANCIA

/*Funciones que reciben y retornan*/
#include<stdio.h>
#include<math.h>
#include<conio.h>
float distancia(float x1, float y1, float x2, float y2);
int main()
{
float x1,y1,x2,y2,result;
    printf("Introduce los valores de(P)...\n");
scanf("%f,%f",&x1,&y1);
printf("Introduce los valores de(Q)...\n");
scanf("%f,%f",&x2,&y2);
result=distancia(x1,y1,x2,y2);
printf("distancia=%f\n",result);
getch();
}
float distancia(float x1, float y1, float x2, float y2)
{
float result;
result=sqrt(pow((x2-x1),2)+pow((y2-y1),2));
return result;
}

Apunte 6/09/2016

6/SEPTIEMBRE/2016 APUNTE

Programación estructurada
Es un tipo de programación que hace uso de estructuras secuenciales, condicionales y repetitivas.
Nos permite resolver un problema dividiendo en n partes, cada parte es una subrutina o también llamada función.