No. 25 de 56 de articulos. Practicas C

Articulos encontrados...

Prácticas y Ejercicios con Solución

Prácticas resueltas y Ejercicios con solución de programación en c,nuevos ejercicios de programación en lenguaje C. El enunciado de las prácticas y ejercicios que se plantea es el siguiente: El ejercicio propuesto por uno de nuestro seguidores al blog www.aprendoencasa.com que nos propone realizar una práctica o ejercicio en la que se soliciten números de la lotería de 3 dígitos y a continuación se visualicen los principios de números que mas han salido, los finales de números que mas han salido, así como unidades, centenas y decenas, el ejercicio se ha intentado resolver utilizando vectores y un método de ordenación denominado hundimiento o burbuja.

Para realizar las practicas o consultar los ejercicios de programación resueltos has de pulsar sobre el enlace a continuación denominado “LEER EL ARTICULO COMPLETO”. Recuerda también darnos ánimos haciendo un clic en el botón google+1 de la columna izquierda o el que esta situado en la parte superior del articulo, así como recomendar la visita a nuestra página a tus amigos.

Ejercicios y practicas de programación en c resueltos o con solución

El ejercicio planteado es el siguiente:

Ejercicios y Practicas resueltas en lenguaje de programación en C

El ejercicio propuesto o practica solicitada es la siguiente, resolver un ejercicio que solicite una serie de números de lotería por pantalla hasta teclear el valor 0, se ha de comprobar que los números introducidos tengan 3 dígitos, y posteriormente se han de visualizar los inicios de números que mas han salido, así como los finales, unidades centenas y decenas de dichos números de lotería, mostrando los resultados la practica resuelta por pantalla.. La solución de los ejercicios que se plantean es la siguiente:

 // El siguiente programa solicitado  por un usuario del blog

    // www.aprendoencasa.com al cual agradecemos mucho su visita tiene

    // el siguiente enunciado: realizar una práctica en la que se soliciten

    // números de lotería por pantalla, los cuales han de tener tres dígitos

    // cada uno, para finalizar se ha de teclear el numero 0, y una vez

    // solicitados todos los números se han de visualizar por pantalla

    // los pares iniciales de números que mas han salido, los pares finales

    // de números que más han salido, así como las unidades, decenas y centenas.

    // Agradecemos el planteamiento de los ejercicios con solución propuesto

    // y esperamos que os animéis a plantear nuevas soluciones en

    // aprendoencasa.com 

    // Se ha de tener en cuenta que el programa no tiene en cuenta

    // números con tres dígitos como 001, 002, 045. ya que se considera

    // que los ceros a la izquierda no tienen efecto. Si se quisiera

    // reflejar también estos números este programa que utiliza calculo

    // matemático no serviría y habría que adaptarlo para que solicitase

    // los números en formato de cadena en vez de numérico. También se 

    // podría utilizar memoria dinámica para una mejor optimización.

    // Vuelvo a repetir que en muchas ocasiones la optimización del código

    // puede ser mucho mejor e incluso emplear menos ordenes para realizar

    // acciones concretas, pero como también utilizo muchas veces los

    // ejercicios que realizo para que mis alumnos practiquen, insisto

    // demasiado en utilizar o repetir ciertas ordenes para reforzar sus

    // conocimientos de las mismas.

#include <stdio.h>

#include <stdlib.h>

void Funcion_Ordenar(int [],int);

int main(int argc, char *argv[])

{

    // Vectores donde almacenar los resultados

    int Inicios[99];

    int Finales[99];

    int Unidades[10];

    int Decenas[10];

    int Centenas[10];

    // variables a utilizar por el programa

    int Numero; // Numero que se solicita

    int Contador; // variable auxiliar para bucles

    int Contador2; // variable auxiliar para bucles

    int Auxiliar; // variable auxiliar para cálculos y bucles

    int error=0; // variable para controlar errores

    int Inicio=0; // variable que almacena los dos dígitos iniciales

    int Final=0; // variable que almacena los dos dígitos finales

    // Inicializar los vectores a valores 0

    for(Contador=0;Contador<100;Contador++) {

       Inicios[Contador]=0;

       Finales[Contador]=0;

       if(Contador<10) {

         Unidades[Contador]=0;

         Decenas[Contador]=0;

         Centenas[Contador]=0;

       }

    }

    // Solicitar un numero hasta que se teclee 0 para finalizar

    do {

       // solo se aceptan números de tres valores

       do {

          // se inicializa la variable de error a cero

          error=0;

          // se visualiza el titulo de petición del numero

          printf("Numero:");

          // se solicita el numero

          scanf(" %d",&Numero);

          // se comprueba si el numero esta en el rango correcto

          // en caso de ser incorrecto se cambia el valor de la variable

          // error para que el numero se vuelva a solicitar sin tenerlo en

          // cuenta para las estadísticas

          if((Numero<100 || Numero>999) && Numero!=0) error=1;

          // la condición de repetición es hasta que se teclee un valor cero

          // en el numero

       } while(error!=0);

       // si se llega a este punto el numero es correcto y se 

       // realizan las estadísticas necesarias siempre y cuando el 

       // numero no sea cero

       if(Numero!=0) {

           // Se extrae el inicio del numero

           Inicio = Numero / 10 ;

           //printf("\nInicio %d",Inicio);

           // Se extrae el final del numero

           Final = Numero % 100 ;

           //printf(" Final %d",Final);

           // Se almacena el inicio en las estadísticas de inicio

           Inicios[Inicio]++;

           // Se almacena el final en las estadísticas de final

           Finales[Final]++;

           // Unidades, Decenas y Centenas guardar las estadísticas

           Auxiliar = Numero / 100 ;

           Centenas[Auxiliar]++;

           //printf(" Centenas %d",Auxiliar);

           Auxiliar = Numero % 100 ;

           Auxiliar = Auxiliar / 10 ;

           Decenas[Auxiliar]++;

           //printf(" Decenas %d",Auxiliar);

           Auxiliar = Numero % 10 ;

           Unidades[Auxiliar]++;          

           //printf(" Unidades %d\n",Auxiliar); 

       }

    } while(Numero!=0);

    // Visualizar Ordenaciones realizadas

    printf("\nPares Iniciales\n");

    Funcion_Ordenar(Inicios,1);

    printf("\nPares Finales\n");

    Funcion_Ordenar(Finales,1);

    printf("\nUnidades\n");

    Funcion_Ordenar(Unidades,0);

    printf("\nDecenas\n");

    Funcion_Ordenar(Decenas,0);

    printf("\nCentenas\n");

    Funcion_Ordenar(Decenas,0);

    printf("\n"); 

  system("PAUSE");	

  return 0;

}

// Función para ordenar

void Funcion_Ordenar(int Vector[],int Tipo)

{

    // Matriz para ordenar

    int Ordenar[99][2];

    int Contador; // variable auxiliar para bucles

    int Contador2; // variable auxiliar para bucles

    int Auxiliar=0;

    int error=0;

    int cuantos=0;

    // Controlar el tipo de vector recibido

    if (Tipo==1) cuantos=100; else cuantos=10;

    // Inicializar la matriz para ordenar

    for(Contador=0;Contador<100;Contador++) {

       Ordenar[Contador][0]=0; // posición que almacenara el numero

       Ordenar[Contador][1]=0; // posición que almacenara sus repeticiones

    } 

    // Ordenar los números de inicio

    // Traspasar los inicios a la matriz de ordenar

    Auxiliar=0;

    for(Contador=0;Contador<cuantos;Contador++) {

       // Si el numero ha salido se traspasa a la matriz de ordenar

       if(Vector[Contador]>0) {

          Ordenar[Auxiliar][0] = Contador;

          Ordenar[Auxiliar][1] = Vector[Contador];

          Auxiliar++;

       }

    }

    // Ordenar el vector utilizando el sistema de hundimiento o burbuja

    for(Contador2=cuantos-1;Contador2>0;Contador2--) {

      for(Contador=0;Contador<Contador2;Contador++) {

       if(Ordenar[Contador][1]<Ordenar[Contador+1][1]) {

          Auxiliar = Ordenar[Contador][0] ;

          Ordenar[Contador][0] = Ordenar[Contador+1][0];

          Ordenar[Contador+1][0] = Auxiliar;

          Auxiliar = Ordenar[Contador][1] ;

          Ordenar[Contador][1] = Ordenar[Contador+1][1];

          Ordenar[Contador+1][1] = Auxiliar;

       }

      }

    }

    // Visualizar el vector ordenado

    for(Contador=0;Contador<cuantos;Contador++) {

       if(Ordenar[Contador][1]!=0) 

          printf("\n%d - %d",Ordenar[Contador][0],Ordenar[Contador][1]);

    }    

}

El resultado del ejercicio con unos pocos valores es el siguiente:

prácticas resueltas y ejercicios con solución de programación en C

Navegacion SeriesAnterior en la serie...Siguiente en la serie...

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies