Programas resueltos en Lenguaje C - unpa.edu.mxblopez/ProgramacionEstructurada/Diapositivas/... ·...

Universidad del Papaloapan Campus Loma Bonita

Materia:

Programación Estructurada

Profesora: M.C. Bertha López Azamar

Programas resueltos en Lenguaje C

Ejercicios resueltos de Programación Estructurada

INDICE

Ejercicios de declaración de variables y lecturas de datos sencillos........................................... 4 1) Programa que permite leer la edad, la estatura y el peso de una persona ....................... 4 2) Programa que permite leer la edad, la estatura y el peso de una persona. E implementa una

función que imprime los datos en pantalla. Realiza el paso de parámetros por valor ... 4 3) Programa que permite leer la edad, la estatura y el peso de una persona. E implementa

funciones para captura e impresión de datos en pantalla. Realiza el paso de parámetros por valor y por referencia..................................................................................................... 5

4) Programa que permite leer valores en variables de caracteres........................................ 5

Ejercicios de ciclos...................................................................................................................... 6 5) Programa que ejemplifica el uso de un for que controla dos variables........................... 6 6) Programa que determina el valor máximo y el minimo de una lista de valores ............. 6 7) Este programa calcula el area de un circulo, las veces que el usuario desee .................. 7 8) Este programa calcula el area de un circulo, las veces que el usuario desee. Implementa

funciones. Paso de parámetros por valor ....................................................................... 7 9) Este programa calcula el area de un circulo, las veces que el usuario desee. Implementa

funciones_ paso de parámetros por referencia............................................................... 8 10) Programa que verifica un menu. Empleando ciclos y switch ......................................... 9 11) Este programa calcula el area de un circulo, las veces que el usuario desee. Implementa

funciones_ paso de parámetros por referencia con retorno de valor ........................... 10

Ejercicios de Arrays: ................................................................................................................. 10 12) Programa que lee un nombre y la edad. E imprime las direcciones de las variables.... 10 13) Ejercicio que permite leer un arreglo de números enteros ............................................ 11 14) Ejercicio que permite llenar un array, y posteriormente imprimirlo, tambien, busca un

elemento por su indice y por su contenido .................................................................. 11 15) Ejercicio que permite leer una cadena de caracteres con la función gets e imprimir la cadena

capturada, su direccion de memoria y su valor ascii ................................................... 12 16) Este programa usa getc(), putc(), getch() y putch()....................................................... 13 17) Ejercicio que permite leer una cadena de caracteres con la función gets e imprimir la cadena

capturada, su direccion de memoria y su valor ascii ................................................... 13 18) Ejercicio de arreglo unidimensional, lectura de una cadena con gets() ........................ 14 19) Ejercicio sobre arrays de dos dimensiones. Empleando funciones. Inventario de frutas y

verduras de julio a diciembre....................................................................................... 14 20) Ejercicio de cadenas de caracteres empleando funciones de manipulación de cadenas:16 21) Programa que lee una cadena de caracteres y encuentra su longitud............................ 16 22) Ejercicio de cadenas de caracteres empleando funciones de conversión –atoi- ........... 17 23) Ejercicio de cadenas de caracteres empleando funciones de conversión –itoa- ........... 17 24) Ejercicio de Arrays dinamicos: ..................................................................................... 17 25) Arrays dinamicos empleando funciones: ...................................................................... 18

Registros:................................................................................................................................... 19 26) Programa que calcula el área de un circulo, implementando estructuras y paso de parámetros

de elementos de la estructura por referencia................................................................ 19 27) Programa que calcula el área de un circulo, implementando estructuras y paso de parámetros

de la estructura completa por referencia ...................................................................... 20 28) Programa que permite capturar el inventario de verduras y frutas de 6 meses. Implementa

una estructura para leer los nombres de los meses y una matriz para leer los valores.20 29) Ejercicio empleando registros (struct)........................................................................... 21

M.C. Bertha López Azamar 2


30) Ejercicio empleando arreglos de estructuras................................................................. 22 31) Pasando elementos de una estructura a una funcion, por valor..................................... 22 32) Pasando elementos de una estructura a una funcion, por referencia ............................. 23 33) Ejercicio que crea una variable estructura empleando un puntero................................ 24 34) Ejercicio que crea una variable estructura empleando un puntero y realiza el paso de

parametros por referencia de una estructura completa ................................................ 24 35) Ejercicio de estructuras, pasando una estructura completa por valor a una función..... 25 36) Programa que implementa estructuras para el manejo de los datos de los alumnos de la

UNPA, permite capturar los nombres de las materias, los datos personales de los alumnos, y las calificaciones de los parciales. ............................................................................... 25

37) Ejercicio completo de registros, funciones y paso de parámetros y punteros............... 27 38) Ejercicio sencillo que hace uso del tipo de dato definido por el usuario: union .......... 29 39) Ejercicio con funciones que hace uso del tipo de dato definido por el usuario: union 30

Ejercicios con punteros ............................................................................................................. 31 40) Ejercicio que emplea el paso de parámetros por referencia de variables normales y el paso de

parámetros puntero ...................................................................................................... 31 41) Punteros impresión de valores....................................................................................... 32



Ejercicios de declaración de variables y lecturas de datos sencillos

1) Programa que permite leer la edad, la estatura y el peso de una persona /*Programa que permite leer la edad, la estatura y el peso de una persona*/ #include<stdio.h> #include<conio.h> void main() { int edad; float estatura, peso; printf("Programa que permite leer la edad, la estatura y el peso de una persona\n"); printf("introduzca su edad: "); scanf("%d", &edad); printf("introduzca su estatura: "); scanf("%f", &estatura); printf("Introduzca su peso: "); scanf("%f", &peso); }

2) Programa que permite leer la edad, la estatura y el peso de una persona. E implementa una función que imprime los datos en pantalla. Realiza el paso de parámetros por valor

/*Programa que permite leer la edad, la estatura y el peso de una persona*/ #include<stdio.h> #include<conio.h> void imprimir(int, float, float); void main() { int edad; float estatura, peso; printf("Programa que permite leer la edad, la estatura y el peso de una persona\n"); printf("introduzca su edad: "); scanf("%d", &edad); printf("introduzca su estatura: "); scanf("%f", &estatura); printf("Introduzca su peso: "); scanf("%f", &peso); imprimir(edad, estatura, peso); getch(); } void imprimir(int e, float es, float p) { printf("\nsu edad: %d", e); printf("\nsu estatura: %.2f", es); printf("\nsu peso: %.2f", p); }



3) Programa que permite leer la edad, la estatura y el peso de una persona. E implementa funciones para captura e impresión de datos en pantalla. Realiza el paso de parámetros por valor y por referencia

/*Programa que permite leer la edad, la estatura y el peso de una persona*/ #include<stdio.h> #include<conio.h> void captura(int *, float *, float *); void imprimir(int, float, float); void main() { int edad; float estatura, peso; printf("Programa que permite leer la edad, la estatura y el peso de una persona\n"); captura(&edad, &estatura, &peso); /*paso de parámetros por referencia*/ imprimir(edad, estatura, peso); /*paso de parámetros por valor*/ getch(); } void captura(int *e, float *es, float *p) { printf("introduzca su edad: "); scanf("%d", e); printf("introduzca su estatura: "); scanf("%f", es); printf("Introduzca su peso: "); scanf("%f", p); } void imprimir(int e, float es, float p) { printf("\nsu edad: %d", e); printf("\nsu estatura: %.2f", es); printf("\nsu peso: %.2f", p); }

4) Programa que permite leer valores en variables de caracteres. /*Este programa usa getc(), putc(), getch() y putch()*/ #include <stdio.h> #include <conio.h> void main() { float ic; printf("\nIntroduce un caracter que sera leido con getc()y presiona enter: "); ic=getc(stdin); printf("\nEl caracter introducido fue: "); putc(ic,stdout); printf("\n\nIntroduce otro caracter que sera leido con getch()"); ic=getch(); printf("\n\ny mostrado en pantalla por putch(): "); putch(ic);



//fflush(stdin); printf("\n\nPresiona una tecla para salir del programa"); getch(); } Ejercicios de ciclos

5) Programa que ejemplifica el uso de un for que controla dos variables /*Este programa ejemplifica el uso de un for que controla dos variables y permite realizar una suma. Se realiza la impresion de una tabla de valores con las variables controladas por el ciclo*/ #include <stdio.h> #include <conio.h> void main() { int a=10, b=20, c=30; int ic; int i, j, suma=0; for(i=1, j=1; i<=100, j<=100; i++, j=j+10) { suma= suma+2; printf("\n i= %d, j= %d, suma= %d", i, j, suma); }//findel for }

6) Programa que determina el valor máximo y el minimo de una lista de valores #include<stdio.h> #include<conio.h> #define TAM 5 void main() { int mayor, menor, i; int vect[TAM]; printf("Programa que determina de una lista de valores,"); printf("cual es el maximo y cual es el minimo:\n\n"); printf("introduzca su lista de valores(se pediran 20):\n"); for(i=0;i<TAM;i++) {

printf("Elemento %d : ", i); scanf("%d",&vect[i]);

} mayor=vect[0]; menor=vect[0]; for(i=1;i<TAM;i++) { if(vect[i]>mayor) { mayor=vect[i];



} if(vect[i]<menor) { menor=vect[i]; } } printf("el valor maximo es:%d\n",mayor); printf("el valor minimo es:%d\n",menor); printf("fin"); getch(); }

7) Este programa calcula el area de un circulo, las veces que el usuario desee #include<stdio.h> #include<conio.h> #define pi 3.1416 void main() { float area,radio; char respuesta='s'; printf("Este programa calcula el area de un circulo"); do { printf("\nIntroduce el radio:"); scanf("%f",&radio); area=pi*radio*radio; printf("\nEl area del circulo es:%f",area); printf("\nDesea calcular nuevamente el area?(s/n)"); scanf("%s",&respuesta); }while(respuesta=='s'); printf("Gracias por participar"); getch(); }

8) Este programa calcula el area de un circulo, las veces que el usuario desee. Implementa funciones. Paso de parámetros por valor

#include<stdio.h> #include<conio.h> #define pi 3.1416 void calcula(float, float); void main() { float a,r; printf("Este programa calcula el area de un circulo"); calcula(a, r); printf("Gracias por participar"); getch(); }



void calcula(float area, float radio) { char respuesta='s'; do { printf("\nIntroduce el radio:"); scanf("%f",&radio); area=pi*radio*radio; printf("\nEl area del circulo es:%f",area); printf("\nDesea calcular nuevamente el area?(s/n)"); scanf("%s",&respuesta); } while(respuesta=='s'); }

9) Este programa calcula el area de un circulo, las veces que el usuario desee. Implementa funciones_ paso de parámetros por referencia

#include<stdio.h> #include<conio.h> #define pi 3.1416 void calcula(float, float*); void main() { float a,r; char respuesta='s'; printf("Este programa calcula el area de un circulo"); do { printf("\nIntroduce el radio:"); scanf("%f",&r); calcula(a, &r); scanf("%s",&respuesta); } while(respuesta=='s'); printf("Gracias por participar"); getch(); } void calcula(float area, float *radio) { area=pi * (*radio) * (*radio); printf("\nEl area del circulo es:%f",area); printf("\nDesea calcular nuevamente el area?(s/n)"); fflush(stdin); }



10) Programa que verifica un menu. Empleando ciclos y switch #include<stdio.h> #include<conio.h> #include<stdlib.h> void menu(); void main() { int op; char resp; do { menu(); //llamada a funcion menu scanf("%d", &op); while(op<1 || op>3) { printf("Opción erronea, vuelve a elegir una opcion del menu."); printf("(Pulse una tecla para continuar)\n"); getch(); system("cls"); menu(); //llamada a funcion menu scanf("%d", &op); }//fin del while switch(op) { case 1: printf("\nSi es niña, entonces se llamara Diana"); break; case 2: printf("\nSi es niño, entonces se llamará Heber"); break; case 3: printf("\nAdios"); resp='n'; break; } // fin del switch getch(); if(op>0 && op<3) { printf("\n ¿otra vez? (s/n)"); scanf("%s", &resp); } }while(resp=='s' || resp=='S'); } //fin main() void menu() { printf("Elije una opcion del siguiente menu\n "); printf("\n1.- Niña "); printf("\n2.- Niño "); printf("\n3.- Salir"); printf("\nElije: "); }



11) Este programa calcula el area de un circulo, las veces que el usuario desee. Implementa funciones_ paso de parámetros por referencia con retorno de valor

#include<stdio.h> #include<conio.h> #define pi 3.1416 float calcula(float*); void main() { float a,r; char respuesta='s'; printf("Este programa calcula el area de un circulo"); do { printf("\nIntroduce el radio:"); scanf("%f",&r); a=calcula(&r);

printf("\nEl area del circulo es:%f",a); printf("\nDesea calcular nuevamente el area?(s/n)"); fflush(stdin); scanf("%s",&respuesta); }while(respuesta=='s'); printf("Gracias por participar"); getch(); } float calcula(float *radio) { float area; area=pi * (*radio) * (*radio); return(area); } Ejercicios de Arrays:

12) Programa que lee un nombre y la edad. E imprime las direcciones de las variables

#include<stdio.h> #include<conio.h> void main() { unsigned int edad; char nombre[10]; printf("Introduce tu nombre: "); gets(nombre); printf("\nintroduce tu edad: "); scanf("%d",&edad); printf("\n%s introdujo una edad de: %d\n", nombre, edad);



printf("\nla direccion edad es :%d y la de nombre es %d", &edad, &nombre); getch(); }

13) Ejercicio que permite leer un arreglo de números enteros /*Programa que permite un arreglo de enteros*/ #include<stdio.h> #include<conio.h> #define tam 5 void main() { int i; int numeros[tam]; printf("introduce los numeros\n"); for(i=0;i<tam;i++) { printf("elemento %d: ",i+1); scanf("%d",&numeros[i]); } for(i=0;i<tam;i++) { printf("\nelemento %d: %d \t\n",i+1, numeros[i]); } getch(); }

14) Ejercicio que permite llenar un array, y posteriormente imprimirlo, tambien, busca un elemento por su indice y por su contenido

#include <stdio.h> #include <conio.h> #include <string.h> #define indice 100 //void func(int ,int); void main (){ int i,j,tama,A[indice]; int valor,k; printf("Introduce el tamano del array\n"); scanf("%d",&tama); printf("El arreglo sera de %d numeros\n",tama); for(i=1;i<=tama;i++) printf("Elemento %d : ", i+1); scanf("%d",&A[i]); }



for (j=1;j<=tama;j++) printf("\t%dª numero ------> %d\n",j,A[j]); printf("\n Deseas encontrar algun valor del arreglo teclea\n"); printf(" el numero del indice\t"); scanf("%d",&k); while(k < 0 || k>=tama) { printf("Indice fuera de rango del arreglo"); printf("\n Deseas encontrar algun valor del arreglo teclea\n"); printf(" el numero del indice\t"); scanf("%d",&k); } printf(" el valor es %d\n",A[k]); printf("\n Ahora deseas encontrar algun valor del arreglo teclea\n"); printf(" el valor a encontrar\t"); scanf("%d",&k); for(i=tama;i>=0;i--)

{ if (A[i]== k) { printf(" la posición de %d es %d\n",k,i); } } getch(); }

15) Ejercicio que permite leer una cadena de caracteres con la función gets e imprimir la cadena capturada, su direccion de memoria y su valor ascii

/*Programa que permite leer una cadena de caracteres e imprimir la cadena capturada su direccion de memoria y su valor ascii*/ #include<stdio.h> #include<conio.h> #define tam 5 void main() { int i; char linea[tam]; printf("Ahora introduce 5 letras"); gets(linea); for(i=tam-1;(i>=0);--i) { printf("element : %c ",linea[i]);



printf("direccion : %d valor ascii: %d",&linea[i], linea[i]); //putc(linea[i],stdout); printf(" \n"); } puts(linea); getch(); }

16) Este programa usa getc(), putc(), getch() y putch() /*Este programa usa getc(), putc(), getch() y putch()*/ #include <stdio.h> #include <conio.h> void main() { float ic; printf("\nIntroduce un caracter que sera leido con getc()y presiona enter: "); ic=getc(stdin); printf("\nEl caracter introducido fue: "); putc(ic,stdout); printf("\n\nIntroduce otro caracter que sera leido con getch()"); ic=getch(); printf("\n\ny mostrado en pantalla por putch(): "); putch(ic); //fflush(stdin); printf("\n\nPresiona una tecla para salir del programa"); getch(); }

17) Ejercicio que permite leer una cadena de caracteres con la función gets e imprimir la cadena capturada, su direccion de memoria y su valor ascii

/*Programa que permite leer una cadena de caracteres con la funcion getc() e imprimir la cadena capturada, su direccion de memoria y su valor ascii*/ #include<stdio.h> #include<conio.h> #define tam 5 void main() { int i; int numeros[tam]; char linea[tam]; printf("Introduce 5 letras\n"); for(i=0;i<tam;i++) { printf("element %d: ",i);

// scanf("%s",&linea[i]); /*pudo leers asi tambien*/ linea[i]= getc(stdin);

fflush(stdin); }



for(i=tam-1;(i>=0);--i) { printf("element : %c ",linea[i]); printf("direccion : %d valor ascii: %d",&linea[i], linea[i]); printf(" \n"); } puts(linea); getch(); }

18) Ejercicio de arreglo unidimensional, lectura de una cadena con gets() #include<stdio.h> #include<conio.h> void main() { unsigned int edad; char nombre[10]; printf("Introduce tu nombre: "); gets(nombre); printf("\nintroduce tu edad: "); scanf("%d",&edad); printf("\n%s introdujo una edad de: %d\n", nombre, edad); printf("\nla direccion edad es :%d y la de nombre es %d", &edad, &nombre); getch(); }

19) Ejercicio sobre arrays de dos dimensiones. Empleando funciones. Inventario de frutas y verduras de julio a diciembre

/*Programa que permite capturar el inventario de verduras y frutas de los meses de: julio, agosto, septiembre, octubre, noviembre y diciembre de la verduleria "La Esperanza" Debera imprimir posteriormente los valores capturados, mostrando de que articulo se trata y de que mes*/ #include<stdio.h> #include<conio.h> #include<stdlib.h> #define TAMC 6 #define TAMF 2 void mes(int); void captura(int inv[TAMF][TAMC]); void imprime(int inv[TAMF][TAMC]); void main() { int inventario[TAMF][TAMC]; captura(inventario); system("cls");



imprime(inventario); getch(); } void mes(int j) { switch(j) { case 0: printf("\tjulio : "); break; case 1: printf("\tagosto : "); break; case 2: printf("\tseptiembre : "); break; case 3: printf("\toctubre : "); break; case 4: printf("\tnoviembre : "); break; case 5: printf("\tdiciembre : "); break; } } void captura(int inv[TAMF][TAMC]) { int i, j; printf("Captura de inventario de frutas y verdures \"La Esperanza\"\n"); for(i=0; i <TAMF; i++) { if(i==0) printf("\nVerduras: \n"); else printf("\n\nFrutas: \n"); for(j=0; j <TAMC; j++) { mes(j); scanf("%d", &inv[i][j]); }//fin 2do for }//fin primer for }//fin de la función void imprime(int inv[TAMF][TAMC]) { int i, j; printf("Inventario "); printf("\nLa Esperanza"); for(i=0; i <TAMF; i++) { if(i==0) printf("Verduras: \n"); else printf("\nFrutas: \n"); for(j=0; j <TAMC; j++) { mes(j); printf(" %d \n", inv[i][j]); }//fin 2do for }//fin primer for }//fin de la función



20) Ejercicio de cadenas de caracteres empleando funciones de manipulación de cadenas:

/*Programa que permite leer el nombre, el apellido paterno, el apellido materno y posteriormente crear una sola cadena de caracteres con las tres cadenzas de caracteres capturadas por separado*/ #include<stdio.h> #include<conio.h> #include<string.h> #define Tam 20 void Datos(char nom[], char apat[], char amat[], char dir[]); void main() { char nombre[Tam], apep[Tam], amat[Tam], dire[50]; printf("Vamos a capturar tus datos\n"); Datos(nombre, apep, amat, dire); char completo[60]; strcpy(completo, nombre); strcat(completo, " "); strcat(completo, apep); strcat(completo, " "); strcat(completo, amat); puts(completo); getch(); } void Datos(char nom[], char apat[], char amat[], char dir[]) { printf("Nombre: ");

gets(nom); printf("Apellido Paterno: ");

gets(apat); printf("Apellido Materno: ");

gets(amat); printf("Direccion: "); gets(dir); }

21) Programa que lee una cadena de caracteres y encuentra su longitud #include <stdio.h> #include <conio.h> #include <string.h> #define TAM 30 void main() { char cadena[TAM]; int i; printf("Vamos a leer una cadena de caracteres y encontrar su longitud \n"); printf(" :::>>> "); gets(cadena); i=strlen(cadena);



printf("La cadena : \"%s\", tiene %d caracteres de longitud", cadena, i); getch(); }

22) Ejercicio de cadenas de caracteres empleando funciones de conversión –atoi- #include<stdio.h> #include<conio.h> #include<stdlib.h> /*el objetivo de la funcion atoi es convertir un valor numerico capturado como cadena, en un valor numerico que se permita almacenar en una variable de tipo numerica entera*/ void main() { char *cadena= "12345.67"; int r; puts("El programa permite capturar una cadena de caracteres que contenga "); puts("numeros enteros y convertir la cadena capturada a un valor numerico "); puts("para almacenarse en una variable de tipo entero"); puts("Introduce una cadena de caracteres :"); gets(cadena); r=atoi(cadena); printf("cadena %s = %d",cadena, r); getch(); }

23) Ejercicio de cadenas de caracteres empleando funciones de conversión –itoa- #include <stdlib.h> #include <stdio.h> #include <conio.h> /*El objetivo de este programa es convertir un valor numerico a un valor de cadena de caracteres, para poder manipularse posteriormente segun sea necesario como una cadena*/ void main(void) { int numero = 12345; char cadena[25]; itoa(numero, cadena, 10); printf("Entero = %d Cadena = %s\n", numero, cadena); getch(); }

24) Ejercicio de Arrays dinamicos: #include<stdio.h> #include<conio.h> #include<stdlib.h> void main() {



int i, n_elementos, *a; printf("Introduce el número de elementos para crear el arreglo : "); scanf("%d", &n_elementos); /*Asignacion del espacio de memoria para el puntero */ a=(int *)malloc(n_elementos * sizeof(int)); for(i=0; i < n_elementos; i++) { printf("%d.- ",i+1); scanf("%d", (a+i)); /*en el scanf se coloca (a+i) en lugar de &a[i] que pudo tambien ocuparse*/ } system("cls"); for(i=0; i < n_elementos; i++) { printf("%d.- %d ",i+1, *(a+i)); /*aqui debe colocarse * antes */ } getch(); }

25) Arrays dinamicos empleando funciones: #include<stdio.h> #include<conio.h> #include<stdlib.h> void llena(int *, int); void imprime(int *, int); void main() { int i, n_elementos, *a; printf("Introduce el número de elementos para crear el arreglo : "); scanf("%d", &n_elementos); /*Asignacion del espacio de memoria para el puntero */ a=(int *)malloc(n_elementos * sizeof(int)); llena(a, n_elementos); system("cls"); imprime(a, n_elementos); getch(); } void llena(int *arr, int num) { int i; for(i=0; i < num; i++) { printf("%d.- ",i+1); scanf("%d", (arr+i)); /*en el scanf se coloca (a+i) pero pudo emplearse &a[i] también */



} } void imprime(int *arr, int num) { int i; for(i=0; i < num; i++) { printf("%d.- %d ",i+1, *(arr+i)); /*aqui debe colocarse * antes */ } }

Registros: 26) Programa que calcula el área de un circulo, implementando estructuras y paso

de parámetros de elementos de la estructura por referencia #include<stdio.h> #include<conio.h> #define pi 3.1416 struct d_circulo { float a,r; }; float calcula(float *); void main() { struct d_circulo circulo; char respuesta='s'; printf("Este programa calcula el area de un circulo"); do { printf("\nIntroduce el radio:"); scanf("%f",&circulo.r); circulo.a = calcula(&circulo.r); printf("\nEl area del circulo es:%f",circulo.a); printf("\nDesea calcular nuevamente el area?(s/n)"); fflush(stdin); scanf("%s",&respuesta); } while(respuesta=='s'); printf("Gracias por participar"); getch(); } float calcula(float *radio) { float area; area=pi * (*radio) * (*radio);



return(area); }

27) Programa que calcula el área de un circulo, implementando estructuras y paso de parámetros de la estructura completa por referencia

#include<stdio.h> #include<conio.h> #define pi 3.1416 struct d_circulo { float a,r; }; void calcula(struct d_circulo *); void main() { struct d_circulo circulo; char respuesta='s'; printf("Este programa calcula el area de un circulo"); do { printf("\nIntroduce el radio:"); scanf("%f",&circulo.r); calcula(&circulo); scanf("%s",&respuesta); }while(respuesta=='s'); printf("Gracias por participar"); getch(); } void calcula(struct d_circulo *c) { c->a = pi * (c->r) * (c->r); printf("\nEl area del circulo es:%f", c->a); printf("\nDesea calcular nuevamente el area?(s/n)"); fflush(stdin); }

28) Programa que permite capturar el inventario de verduras y frutas de 6 meses. Implementa una estructura para leer los nombres de los meses y una matriz para leer los valores.

#include<stdio.h> #include<conio.h> #include<stdlib.h> struct mes { char nom[12];



int num_mes; }; void main () { int i,j; struct mes meses[6]; int inv [6][2]; for(i=0;i<6;i++) { printf("introduce mes No. %d : ", i+1); gets(meses[i].nom); meses[i].num_mes=i+1; } for (i=0;i<2;i++) { if (i==0) printf("\nverderas:\n"); else printf("\nfrutas \n"); for (j=0; j<6; j++) { printf("%s : ",meses[j].nom); scanf("%d",&inv[j][i]); } } system("cls"); for (i=0;i<2;i++) { if (i==0) printf("\nverderas:\n"); else printf("\nfrutas \n"); for (j=0; j<6; j++) { printf("%s : %d ",meses[j].nom, inv[j][i]); } } getch(); }

29) Ejercicio empleando registros (struct) /*El programa permite capturar valores en un registro de datos, empleando estructuras*/ #include <stdio.h> #include <conio.h> struct fecha {



unsigned int dd; unsigned int mm; unsigned int aa; }; void main() { struct fecha hoy; /*hoy es una variable de tipo estructura*/ printf("Introducir fecha (dd-mm-aa): "); scanf("%u-%u-%u", &hoy.dd, &hoy.mm, &hoy.aa); printf("\n\nDia %u del mes %u del año %u \n ", hoy.dd, hoy.mm, hoy.aa); getch(); }

30) Ejercicio empleando arreglos de estructuras /*El programa permite capturar un arreglo de estructuras*/ #include <stdio.h> #include <conio.h> #define TAM 5 struct fecha { unsigned int dd; unsigned int mm; unsigned int aa; }; void main() { int i; struct fecha hoy[TAM]; /*hoy es una variable de tipo estructura*/ for(i=0; i<TAM; i++) { printf("Introducir fecha (dd-mm-aa): "); scanf("%u-%u-%u", &hoy[i].dd, &hoy[i].mm, &hoy[i].aa); } for(i=0; i<TAM; i++) { printf("\n\nDia %u del mes %u del año %u \n ", hoy[i].dd, hoy[i].mm, hoy[i].aa); } getch(); }

31) Pasando elementos de una estructura a una funcion, por valor /*Pasando elementos de una estructura a una funcion, por valor*/ /*Pasando elementos de una estructura a una funcion, por valor*/ #include <stdio.h> #include <conio.h> #include <stdlib.h> struct fecha



{ unsigned int dd; unsigned int mm; unsigned int aa; }; void escribir(unsigned int); void main() { struct fecha hoy; /*hoy es una variable de tipo estructura*/ printf("Introducir fecha (dd-mm-aa): "); scanf("%u-%u-%u", &hoy.dd, &hoy.mm, &hoy.aa); escribir(hoy.dd); /*pasando los elementos por valor*/ printf("del mes %u del anio %u \n ", hoy.mm, hoy.aa); getch(); } void escribir(unsigned int dia) { printf("\n\nDia %u ", dia); }

32) Pasando elementos de una estructura a una funcion, por referencia /*Pasando elementos de una estructura a una funcion, por referencia*/ #include <stdio.h> #include <conio.h> #include <stdlib.h> struct fecha { unsigned int dd; unsigned int mm; unsigned int aa; }; void leer(unsigned int *); void main() { struct fecha hoy; /*hoy es una variable de tipo estructura*/ printf("Introducir fecha : "); leer(&hoy.dd); printf("Ahora introduce (mm-aa) :"); scanf("%u-%u", &hoy.mm, &hoy.aa); printf("\n\nDia %u del mes %u del año %u \n ", hoy.dd, hoy.mm, hoy.aa); getch(); } void leer(unsigned int *dia) { printf("Introduce el dia:"); scanf("%u", dia); }



33) Ejercicio que crea una variable estructura empleando un puntero *el programa crea una estructura empleando un puntero para ello*/ #include <stdio.h> #include <conio.h> #include <stdlib.h> struct fecha { unsigned int dd; unsigned int mm; unsigned int aa; }; void main() { struct fecha *hoy; /*hoy es un puntero a una estructura*/ /*asignación de memoria para la estructura*/ hoy = (struct fecha *)malloc(sizeof(struct fecha)); printf("Introducir fecha (dd-mm-aa): "); scanf("%u-%u-%u", &hoy->dd, &hoy->mm, &hoy->aa); printf("Día %u del mes %u del año %u \n ", hoy->dd, hoy->mm, hoy->aa); getch(); }

34) Ejercicio que crea una variable estructura empleando un puntero y realiza el paso de parametros por referencia de una estructura completa

#include <stdio.h> /*El programa realiza el paso de parametros por referencia de una estructura, empleando punteros*/ #include <conio.h> #include <stdlib.h> struct fecha { unsigned int dd; unsigned int mm; unsigned int aa; }; void escribir(struct fecha *f); void main() { struct fecha *hoy; /*hoy es un puntero a una estructura*/ /*asignación de memoria para la estructura*/ hoy = (struct fecha *)malloc(sizeof(struct fecha)); printf("Introducir fecha (dd-mm-aa): "); scanf("%u-%u-%u", &hoy->dd, &hoy->mm, &hoy->aa); escribir(hoy); getch(); } void escribir(struct fecha *f)



{ printf("Día %u del mes %u del año %u \n ", f->dd, f->mm, f->aa); }

35) Ejercicio de estructuras, pasando una estructura completa por valor a una función

/*El programa permite pasar una estructura completa a una funcion, mediante el paso de parametros por valor*/ #include <stdio.h> #include <conio.h> #include <stdlib.h> struct fecha { unsigned int dd; unsigned int mm; unsigned int aa; }; void escribir(struct fecha); void main() { struct fecha hoy; /*hoy es una variable de tipo estructura*/ printf("Introducir fecha (dd-mm-aa): "); scanf("%u-%u-%u", &hoy.dd, &hoy.mm, &hoy.aa); escribir(hoy); /*pasando los elementos por valor*/ getch(); } void escribir(struct fecha ahora) { printf("\n\nDia %u del mes %u del año %u \n ", ahora.dd, ahora.mm, ahora.aa); }

36) Programa que implementa estructuras para el manejo de los datos de los alumnos de la UNPA, permite capturar los nombres de las materias, los datos personales de los alumnos, y las calificaciones de los parciales.

#include <stdio.h> #include <conio.h> #define NUM_ALUM 2 struct materia { float par1, par2, par3, promedio; }; struct datos_personales { char nombre[10]; char apellidopat[10]; char apellidomat[10]; int edad;



float estatura, peso; struct materia materias[6]; }; struct mat { char nombre[15]; int hr_sem; }; void leer(char *,char *,char *,int *); void mostrar(char *,char *,char *,int ); float calf(float *, float *, float *, char *); void final(float *); void captura_lista_materias(struct mat *); void main() { int i,j; struct datos_personales alumno[NUM_ALUM]; struct mat lista_mat[6]; captura_lista_materias(lista_mat); for (j=0; j<NUM_ALUM; j++) { fflush(stdin); leer(alumno[j].nombre, alumno[j].apellidopat, alumno[j].apellidomat, &alumno[j].edad ); mostrar(alumno[j].nombre, alumno[j].apellidopat, alumno[j].apellidomat, alumno[j].edad ); for (i=0; i<6; i++) { fflush(stdin); alumno[j].materias[i].promedio = calf(&alumno[j].materias[i].par1,

&alumno[j].materias[i].par2, &alumno[j].materias[i].par3, lista_mat[i].nombre);

printf("\nSu promedio es %s: %f, ", lista_mat[i].nombre, alumno[j].materias[i].promedio); final(&alumno[j].materias[i].promedio); } } getch(); } void captura_lista_materias(struct mat *mat) { int i; printf("Nombres de las materias\n"); for(i=0; i<6; i++) { printf("%d.- ", i+1); gets(mat[i].nombre); } } void mostrar(char *nombre,char *apellidopat,char *apellidomat,int edad) {



printf("\n\n DATOS PERSONALES "); printf("\nNombre: %s", nombre); printf("\tapellido paterno: %s", apellidopat); printf("\tapellido materno: %s",apellidomat); printf("\tedad : %d",edad); } void leer(char *nombre,char *apellidopat,char *apellidomat,int *edad) { fflush(stdin); printf("\n\n DATOS PERSONALES "); printf("introduzca el nombre: "); gets(nombre); printf("introduzca el apellido paterno: "); gets(apellidopat); printf("introduzca el apellido materno: "); gets(apellidomat); printf("introduzca la edad: "); scanf("%d",edad); } float calf(float *par1, float *par2, float *par3, char *mat) { printf("\nIntroduzca las calificaciones de: %s ", mat); printf("\n\tprimer parcial: "); scanf("%f",par1); printf("\tsegundo parcial: "); scanf("%f",par2); printf("\ttercer parcial: "); scanf("%f",par3); return(((*par1)+(*par2)+(*par3))/3); } void final(float *prom) { if (*prom >= 6) printf("tienes derecho a examen final"); else printf("no tienes derecho a examen final"); }

37) Ejercicio completo de registros, funciones y paso de parámetros y punteros #include<stdio.h> #include<conio.h> #include<stdlib.h> struct direccion { int numero_ext, num_int; char calle[25], colonia[25]; char ciudad[25], estado[25]; };



struct datos { char nombre[20], apellidop[20], apellidom[20]; struct direccion particular; }; void leer_datos(struct datos *); void imprimir_datos(struct datos *); void main() { struct datos alumno; system("cls"); leer_datos(&alumno); imprimir_datos(&alumno); getch(); } void leer_datos(struct datos *al) { printf("Se capturan los datos personales del alumno"); printf("\n\n"); printf("Nombre : "); gets(al->nombre); printf("Apellido Paterno : "); gets(al->apellidop); printf("Apellido Materno : "); gets(al->apellidom); printf("\n\n Domicilio Particular: "); printf("\n\t\tNumero externo :"); scanf("%d", &al->particular.numero_ext); printf("\n\t\tNumero interno :"); scanf("%d", &al->particular.num_int); fflush(stdin); printf("\n\t\tCalle :"); gets(al->particular.calle); printf("\n\t\tColonia :"); gets(al->particular.colonia); printf("\n\t\tCiudad :"); gets(al->particular.ciudad); printf("\n\t\tEstado :"); gets(al->particular.estado); } void imprimir_datos(struct datos *al) { printf("Datos personales del alumno"); printf("\n\n"); printf("Nombre : "); puts(al->nombre); printf("Apellido Paterno : "); puts(al->apellidop); printf("Apellido Materno : "); puts(al->apellidom); printf("\n\n Domicilio Particular: "); printf("\n\t\tNumero externo :"); printf("%d", al->particular.numero_ext); printf("\n\t\tNumero interno :"); printf("%d", al->particular.num_int); printf("\n\t\tCalle :"); puts(al->particular.calle); printf("\n\t\tColonia :"); puts(al->particular.colonia); printf("\n\t\tCiudad :"); puts(al->particular.ciudad); printf("\n\t\tEstado :"); puts(al->particular.estado); }



38) Ejercicio sencillo que hace uso del tipo de dato definido por el usuario: union #include <stdio.h> #include <conio.h> union mes { int mm_num; char mm_char[12]; }; struct fecha { unsigned int dd; union mes mm; unsigned int aa; }; void main() { unsigned op; struct fecha hoy; /*hoy es una variable de tipo estructura*/ printf("Introducir fecha \n "); printf("Dia: "); scanf("%u", &hoy.dd); printf("Como desea capturar el mes: "); printf("\n1.- en numero entero"); printf("\n2.- en letras"); printf("\nOpcion: "); scanf("%u", &op); fflush(stdin); switch(op) { case 1: printf("Mes: "); scanf("%u", &hoy.mm.mm_num); break; case 2: printf("Mes: "); gets(hoy.mm.mm_char); break; } printf("Anio: "); scanf("%u", &hoy.aa); switch(op) { case 1: printf("\n\nDia %u del mes %u del anio %u \n ", hoy.dd, hoy.mm.mm_num, hoy.aa); break; case 2: printf("\n\nDia %u del mes %s del anio %u \n ", hoy.dd, hoy.mm.mm_char, hoy.aa); break; } getch(); }



39) Ejercicio con funciones que hace uso del tipo de dato definido por el usuario: union

/*programa que emplea uniones y funciones*/ #include <stdio.h> #include <conio.h> union mes { unsigned int mm_num; char mm_char[12]; }; struct fecha { unsigned int dd; unsigned int aa; }; void imprime_mes(unsigned int); void main() { unsigned int op; struct fecha hoy; /*hoy es una variable de tipo estructura*/ union mes mm; printf("Introducir fecha \n "); printf("Dia: "); scanf("%u", &hoy.dd); printf("Como desea capturar el mes: "); printf("\n1.- en numero entero"); printf("\n2.- en letras"); printf("\nOpcion: "); scanf("%u", &op); fflush(stdin); switch(op) { case 1: printf("Mes: "); scanf("%u", &mm.mm_num); break; case 2: printf("Mes: "); gets(mm.mm_char); break; default: printf("Mes no existente solo 1 al 12"); } printf("Anio: "); scanf("%u", &hoy.aa); switch(op) { case 1: printf("\n\nDia %u ",hoy.dd); imprime_mes(mm.mm_num);



printf("del anio %u \n ", hoy.aa); reak; case 2: printf("\n\nDia %u del mes %s del anio %u \n ", hoy.dd, mm.mm_char, hoy.aa); break; } getch(); } void imprime_mes(unsigned int mes) { printf(" del mes %u ", mes); }

Ejercicios con punteros 40) Ejercicio que emplea el paso de parámetros por referencia de variables

normales y el paso de parámetros puntero /*Programa que permite leer la edad, la estatura y el peso de una persona*/ #include<stdio.h> #include<conio.h> void captura(int *, float *, float *); void imprimir(int *, float *, float *); void main() { int edad; float estatura, peso; printf("Programa que permite leer la edad, la estatura y el peso de una persona\n"); captura(&edad, &estatura, &peso); /*paso de parámetros por referencia*/ getch(); } void captura(int *e, float *es, float *p) { printf("introduzca su edad: "); scanf("%d", e); printf("introduzca su estatura: "); scanf("%f", es); printf("introduzca su peso: "); scanf("%f", p); imprimir(e, es, p); //llamada a función, empleando argumentos que son punteros } /* observación: la función imprimir manipula punteros, es decir, recibe variables que son punteros y las recoge en parámetros punteros, por lo tanto, deben referenciarse las variables de tipo puntero mediante el uso del operador “*” ya que se trata de una indirección de punteros */ void imprimir(int *e, float *es, float *p) {



printf("\nsu edad: %d", *e); printf("\nsu estatura: %.2f", *es); printf("\nsu peso: %.2f", *p); }

41) Punteros impresión de valores #include <stdio.h> #include <conio.h> void main() { int var; var=10; int *pt1=&var; int **pt2=&pt1; printf("\nvar: %d", var); /*imprime el contenido de var, o sea "10"*/ printf("\nvar: %d", &var); /*imprime la direccion de var, o sea "1000"*/ printf("\npt1: %d", pt1); /*imprime el contenido de pt1, o sea "1000" */ printf("\n*pt1:%d", *pt1); /*imprime el contenido de al que apunta pt1, o sea "10"*/ printf("\npt1: %d", &pt1); /*imprime la direccion de pt1, o sea "2500"*/ printf("\npt2 ; %d", pt2); /*imprime el contenido de pt2 , o sea 2500*/ printf("\n*pt2: %d", *pt2); /*imprime el contenido al que apunta pt2, o se "2500*/ printf("\n**pt2: %d", **pt2); /*imprime el contenido de la direccion a la que apunta *pt2, o sea 10*/ printf("\npt2: %d", &pt2); /*imprime la direccion de pt2, o sea "3500"*/ getch(); }


Programas resueltos en Lenguaje C - unpa.edu.mxblopez/ProgramacionEstructurada/Diapositivas/... ·...

Documents

Transcript of Programas resueltos en Lenguaje C - unpa.edu.mxblopez/ProgramacionEstructurada/Diapositivas/... ·...