Programas en C

Programa que convierte de metros a pies y pulgadas.
#include stdio.h
main(){
float metros,resul,pulg;
int resul2,pulg2;
clrscr();
printf("\nValor en metros: ");

scanf("%f",&metros);
resul=metros*(1/.3048);
resul2=resul;
pulg=resul-resul2;
pulg=pulg*12;
pulg2=pulg;
printf("El resultado es: %d pies %d pulgadas",resul2,pulg2);
getch();
}
Programa que realiza las cuatro operaciones aritméticas fundamentales (+,-,*,/).

#include stdio.h
#include conio.h
void main(){
int prim,seg,resul;
char oper;
clrscr();
printf("\nPrimer numero: ");

scanf("%d",&prim);
printf("\nOperacion a realizar (+,-,*,/): ");
oper=getche();
printf("\nSegundo numero: ");
scanf("%d",&seg);
if(oper=='+')
resul=prim+seg;
if(oper=='-')
resul=prim-seg;
if(oper=='*')
resul=prim*seg;
if(oper=='/')
resul=prim/seg;
printf("\nEl resultado de la operacion %d %c %d es

%d",prim,oper,seg,resul);
getch();
}
Programa que lee los tres lados de un triᮧulo y detecta el tipo.

#include stdio.h
main(){
float uno,dos,tres;
clrscr();
printf("\nValor del primer lado: ");

scanf("%f",&uno);
printf("\nValor del segundo lado: ");

scanf("%f",&dos);
printf("\nValor del tercer lado: ");

scanf("%f",&tres);
if((uno==dos) && (dos==tres) && (uno==tres))

printf("\nEl triangulo es equilatero");
else if((uno!=dos) && (dos!=tres) && (uno!=tres))

printf("\nEl triangulo es escaleno");
else
printf("\nEl triangulo es isoceles");
getch();
}
Programa que lee las edades de un grupo de alumnos y encuentra el promedio.

#include stdio.h
main(){
int alumnos,edad,counter=1;
float promedio,sumaedad=0;
clrscr();
printf("\nNumero de alumnos: ");

scanf("%d",&alumnos);
while(1){
printf("\nEdad alumno %d: ",counter);

scanf("%d",&edad);
sumaedad=sumaedad+edad;
if(counter==alumnos){
break;
}
counter++;
}
promedio=sumaedad/counter;
printf("\nLa edad promedio de %d alumno(s) es %.1f
a񯳢,counter,promedio);
getch();
}
Función que lee calificaciones (0-10) de alumnos y cuente el numero de alumnos

reprobados (calif<7) de un conjunto de notas. La función recibe como entrada el número
de notas a leer y deberá regresar el número de alumnos reprobados. Crear un programa
que llame a la función anterior y que despliegue el número de alumnos reprobados.
#include stdio.h
int numreprob(int not);
void main(void){
int notas,reprobados;
clrscr();
printf("\nNumero de notas a leer: ");
scanf("%d",& notas);
reprobados=numreprob(notas);
printf("\nExiste un total de %d alumnos reprobados",reprobados);
getch();
}
int numreprob(int not){
int c=1,calif,rep=0;
while(c<=not){
printf("\nCalificacion de la nota %d: ",c);

scanf("%d",&calif);
if(calif<7){
rep++;}
c++;
}
return(rep);
}
Función que lee las matriculas (números enteros) y las calificaciones (tipo char) de los
alumnos de un grupo y las almacene en dos arreglos unidimensionales. La función
deberá leer los datos hasta que se de una matricula cero la cual indica el fin de captura.
La función regresa el numero de alumnos por el mecanismo de return. Después debe de
imprimir el contenido de los arreglos.
#include stdio.h
void despliega(int *mats,char *califs,int numcap);

int leedato(int *mats,char *califs,int maximo);
void main(void){
int max=30,matr[29],numalumn;
char calif[29];
clrscr();
numalumn=leedato(matr,calif,max);
printf("\nEl numero de alumnos capturados es %d",numalumn);
despliega(matr,calif,numalumn);
}
int leedato(int *mats,char *califs,int maximo){
int n=0;
printf("\n *** Introduce la matricula y su calificacion. ***");

printf("\n *** Para terminar dale un cero a la matricula. ***");
while(1){
if(n>=maximo){
printf("\nEl arreglo se encuentra lleno");
getch();
break;
}
printf("\n\nMatricula del alumno %d: ",n+1);
scanf("%d",mats);
if(*mats==0){
break;
}
printf("\nCalificacion del alumno %d: ",n+1);
scanf("%d",califs);
mats++;
califs++;
n++;
}
return n;
}
void despliega(int *mats,char *califs,int numcap){
int i=1;
while(1){
if(i>numcap){
break;
}
printf("\nLa calificacion del alumno %d es %d",*mats,*califs);
i++;
mats++;
califs++;
}
getch();
}
Programa que despliega una tabla de conversión entre oC a oF y viceversa. El programa

debe tener una funcion que pregunte el tipo de conversión deseada. El usuario teclear
“c” o “C” si la conversión va a ser de oC a oF y "f" o "F" si la conversión es de oF a oC,
regresando el carácter por medio de return. Otra funcion debe preguntar el rango de
valores de la tabla y el incremento, recibiendo como parametros las direcciones de las
variables donde se almacenar esos datos. Otras dos funciones seran para desplegar
cada tipo de tabla de conversión.
#include stdio.h
#include ctype.h
void despliegaFC(int *ran1,int *ran2,int *inc);

void despliegaCF(int *ran1,int *ran2,int *inc);
void leeDatos(int *ran1,int *ran2,int *inc);
char tipoConv(void);
void main(void){
int rango1,rango2,incremento;
char tipo;
clrscr();
tipo=tipoConv();
leeDatos(&rango1,&rango2,&incremento);
if(tipo=='C'){
despliegaCF(&rango1,&rango2,&incremento);
}
else{
despliegaFC(&rango1,&rango2,&incremento);
}
}
char tipoConv(void){
char caract;
printf(" TABLA DE CONVERSION DE GRADOS CENTIGRADOS A GRADOS

FARENHEIT");
printf("\n Y DE GRADOS FARENHEIT A GRADOS
CENTIGRADOS");
printf("\n\nPara convertir de Centigrados a Farenheit oprime 'C'");
printf("\npara convertir de Farenheit a Centigrados oprime 'F'");
printf("\n\nTipo de Conversion (C o F): ");

caract=toupper(getch());
return caract;
}
void leeDatos(int *ran1,int *ran2,int *inc){
printf("\n\nValor inicial de la tabla: ");

scanf("%d",ran1);
printf("\nValor final de la tabla: ");
scanf("%d",ran2);
printf("\n\nIncremento de los valores de la tabla: ");

scanf("%d",inc);
}
void despliegaCF(int *ran1,int *ran2,int *inc){
int suma=*ran1,incremento=*inc,rango2=*ran2;
float conversion;
while(suma<=rango2){
conversion=(((suma)*9)/5)+32;
printf("\n%d ?C ----------------------------- %.1f ?
F",suma,conversion);
suma=suma+incremento;
}
getch();
}
void despliegaFC(int *ran1,int *ran2,int *inc){
int suma=*ran1,incremento=*inc,rango2=*ran2;
int conversion;
while(suma<=rango2){
conversion=((suma-32)*5)/9;
printf("\n%d ?F ----------------------------- %d ?
C",suma,conversion);
suma=suma+incremento;
}
getch();
}
Ejemplos de cadenas. Funcion que realiza la misma operación que la funcion toi, que
convierte una cadena en un entero. La funcion regresa el entero representado por la
cadena s si se pudo convertir, en caso contrario regresa 0. Si la funcion encuentra
caracteres espacio o tabulacion los salta. Si al empezar la secuencia de datos, la se
interrumpe, el programa termina.
#include stdio.h
#include ctype.h
int myatoi(char *s);
void main(void){
int n;
char cad[50];
clrscr();
printf("Introduce la cadena: ");

gets(cad);
n=myatoi(cad);
printf("\nEl entero extraido de la cadena fue %d",n);
getch();
}
int myatoi(char *s){

int signo=1,num=0;
while(1){
if(*s==' ' || *s=='\t'){
s++;
}
else break;
}
if(*s=='+'){
s++;
}
else if(*s=='-'){
signo=-1;
s++;
}
while(1){
if(*s=='\0' || !isdigit(*s)){
break;
}
num=10*num+(*s-'0');
s++;
}
return signo*num;
}
Ejemplos de cadenas. Funcion que realiza la misma operación que la funcion trlen.
Calcula la longitud de la cadena S. Regresa el n? de caracteres en S sin contar el
caracter de fin de cadena.
#include stdio.h
#include ctype.h
int mystrlen(char *s);
void main(void){
int n;
char cad[50];
clrscr();
printf("Introduce la cadena: ");

gets(cad);
n=mystrlen(cad);
printf("\nEl numero de caracteres de la cadena s fue %d",n);
getch();
}
int mystrlen(char *s){
int c=0;
while(1){
if(*s=='\0'){
break;
}
c++;
s++;
}
return c;
}
Funcion que lee una serie de n?s de la linea de comandos y ejecuta la instruccon
proporcionada después del ?o n? de la serie. Si la instruccion GUARDA, los n?s son
guardados en un arreglo de tipo entero. Si la instrucción LISTA, los numeros son
desplegados como cadenas.
#include stdio.h
#include ctype.h
#include string.h
#include stdlib.h
void main(int np, char *ps[]){

int arreglo[100],j,i;
clrscr();
if(strcmp(ps[np-1],"GUARDA")==0){
for(i=0,j=1;j<(np-1);i++,j++){
arreglo[i]=atoi(ps[j]);
printf("\n%d",arreglo[i]);
}
}
if(strcmp(ps[np-1],"LISTA")==0){
for(i=1;i<(np-1);i++){
puts(ps[i]);
}
}
Volver
Programa que recibe en la l�a de comando un n? flotante, un caracter que represente

una de las cuatro operaciones fundamentales y un segundo n?. El programa
deber ᠤ esplegar el resultado de la operaci󮠤eseada.
#include stdio.h
#include stdlib.h
#include string.h
void main(int narg,char *sarg[]){

float op1,op2,resul;
int i=1;
clrscr();
printf("PROGRAMA QUE CALCULA UNA OPERACION ARITMETICA SIMPLE ENTRE

DOS OPERANDOS");
printf("\n\nLa sintaxis es: Calcula operando operador operando");
printf("\n");
while(i<=narg){
printf("%s",sarg[i]);
i++;
}
op1=atof(sarg[1]);
op2=atof(sarg[3]);
if(strcmp(sarg[2],"+")==0)
resul=op1+op2;
else if(sarg[2][0]=='-')
resul=op1-op2;
else if(strcmp(sarg[2],"*")==0)
resul=op1*op2;
else if(sarg[2][0]=='/')
resul=op1/op2;
else{
printf("\nOperador invalido: '%s'",sarg[2]);
return;
}
printf("\n\nEl resultado es %.1f",resul);
getch();
}
Volver
Editor de textos con arreglo de cadenas.
#include string.h
#include stdio.h
#include ctype.h
void inserta(char t[][50],int *ll,int act,int max);

void modif_actual(int *act,int ll);
void reemplaza_linea(char t[][50],int ll,int *act);
void lista(char t[][50],int *ll);
void agrega_linea(char t[][50],int *ll,int max,int *act);
void main(void){
char txt[30][50],opcion;
int llenas=0,max=30,actual;
while(1){
clrscr();
printf(" EDITOR DE TEXTO");
printf("\n SELECCIONA LA PRIMERA LETRA DE LA OPCION
DESEADA");
printf("\n\nAgregar Salir Lista Reemplaza Inserta
Opcion: ");
opcion=toupper(getch());
if(opcion=='S')
break;
if(opcion=='A')
agrega_linea(txt,&llenas,max,&actual);
if(opcion=='L')
lista(txt,&llenas);
if(opcion=='R')
reemplaza_linea(txt,llenas,&actual);
if(opcion=='I')
inserta(txt,&llenas,actual,max);
}
}
/
**********************************************************************
****/
void agrega_linea(char t[][50],int *ll,int max,int *act){
if(*ll==max){
printf("\n\nMemoria insuficiente...");
return;
}
printf("\n\n>");
fflush(stdin);
gets(t[*ll]);
*ll=*ll+1;
*act=*ll;
}
/
**********************************************************************
****/
void lista(char t[][50],int *ll){
int i=0;
printf("\n\n");
while(i<*ll){
puts(t[i]);
i++;
}
getch();
}
/
**********************************************************************
****/
void modif_actual(int *act,int ll){

int v;
printf("\n\nIndica el numero de la linea a posicionar: ");

scanf("%d",&v);
if(v<=ll && v!=0){

*act=v;
}
else{
*act=-1;
}
}
/
**********************************************************************
****/
void reemplaza_linea(char t[][50],int ll,int *act){
if(ll==0){
printf("\n\nNo existe informacion a reemplazar");
getch();
return;
}
modif_actual(act,ll);
if(*act==-1){
printf("\n\nLa linea seleccionada no existe...");
getch();
}
else{
printf("\n\nIntroduce la nueva linea: ");

fflush(stdin);
gets(t[*act-1]);
}
}
/
**********************************************************************
***/
void inserta(char t[][50],int *ll,int act,int max){

int j;
if(*ll==max){
printf("\n\nMemoria insuficiente...");
getch();
return;
}
modif_actual(&act,*ll);
if(act==-1){
printf("\n\nLa linea seleccionada no existe...");
getch();
}
else{
j=*ll-1;
while(j>=act-1){
strcpy(t[j+1],t[j]);
j--;
}
printf("\n\nInserta la nueva linea: ");
fflush(stdin);
gets(t[act-1]);
(*ll)++;
}
}
Volver
Directorio telef󮩣o con manejo de archivos.
#include stdio.h
#include conio.h
#include ctype.h
#include string.h
#include stdlib.h
struct DIREC{
char nombre[35];
char tele[20];
} ;
FILE *pack(FILE *a);

void ordena(FILE *a);
void consulta2(FILE *a);
long busca_Clave2(FILE *a,char buscado[]);
void lee(FILE *a);
void imprime(FILE *a);
void main(){
char opcion;
FILE *archivo;
archivo=fopen("TELE.DAT","rb+"); /* usar opci󮠢wb+" para crear el
archivo .DAT y despu 鳠 cambiar a "rb+" */
while(1){
clrscr();
textattr(6+5*5);
clrscr();
textcolor(YELLOW);
cprintf(" DIRECTORIO TELEFONICO");
printf("\n\n");
cprintf(" N");
printf("uevo");
textcolor(YELLOW);
cprintf(" L");
printf("ista");
textcolor(YELLOW);
cprintf(" B");
printf("aja");
textcolor(YELLOW);
cprintf(" C");
printf("onsulta");
textcolor(YELLOW);
cprintf(" O");
printf("rdena");
textcolor(YELLOW);
cprintf(" S");
printf("alir");
gotoxy(1,25);
printf(" *** PRESIONE LA LETRA RESALTADA PARA ESCOGER LA
OPCION ***");
gotoxy(1,4);
opcion=toupper(getch());
if(opcion=='S')
break;
switch(opcion){
case 'N':{
lee(archivo);
break;
}
case 'L':{
imprime(archivo);
break;
}
case 'B':{
pack(archivo);
break;
}
case 'C':{
consulta2(archivo);
break;
}
case 'O':{
ordena(archivo);
break;
}
}
}
clrscr();
fclose(archivo);
normvideo();
clrscr();
}
/
*********************************************************************/
void imprime(FILE *a){

int r,y=0,c=1;
struct DIREC reactivo;
clrscr();
textcolor(YELLOW);
cprintf("NOMBRE TELEFONO");
normvideo();
rewind(a);
while(1){
r=fread(&reactivo,sizeof(struct DIREC),1,a);
if(r==0)
break;
if((c%2)!=0){
textattr(6+5*5);
/* textcolor(LIGHTGRAY);*/
printf("\n");
cprintf("%d.- %-30s %16s",c,reactivo.nombre,reactivo.tele);
normvideo();
}
else{
textattr(6+5*4);
/* textcolor(WHITE);*/
printf("\n");
cprintf("%d.- %-30s
%16s",c,reactivo.nombre,reactivo.tele);
normvideo();
}
if(y==23){
getch();
y=0;
}
y++;
c++;
}
getch();
}
/
*********************************************************************/
void lee(FILE *a){

struct DIREC reactivo;
printf("\n\n");
fflush(stdin);
printf("Nombre : ");strupr(gets(reactivo.nombre));
if(strlen(reactivo.nombre)<30){
if(busca_Clave2(a,reactivo.nombre)==0){
printf("Tel?fono : ");gets(reactivo.tele);
fseek(a,0,SEEK_END);
fwrite(&reactivo,sizeof(struct DIREC),1,a);
}
else{
printf("\n\nYa existen esos datos!!!");
getch();
}
}
else{
printf("\n\nM?ximo 25 letras por nombre...");
printf("\n\n???El programa puede da?arse si repite
este error!!!");
getch();
}
}
/
*********************************************************************/
long busca_Clave2(FILE *a,char buscado[]){

long p;
struct DIREC r;
rewind(a);
while(1){
if(fread(&r,sizeof(struct DIREC),1,a)==0)
break;
if(strcmp(r.nombre,buscado)==0){
p=ftell(a)/sizeof(struct DIREC);
return(p);
}
}
return 0;
}
/
*********************************************************************/
void consulta2(FILE *a){

char nombre[30];
long p;
struct DIREC r;
printf("\n\nDame el nombre a buscar: ");
strupr(gets(nombre));
p=busca_Clave2(a,nombre);
if(p!=0){
fseek(a,(p-1)*sizeof(struct DIREC),SEEK_SET);
fread(&r,sizeof(struct DIREC),1,a);
printf("\n\n\n");
textcolor(LIGHTGRAY);
cprintf("NOMBRE
TELEFONO");
normvideo();
printf("\n%-20s %30s",r.nombre,r.tele);
getch();
}
else{
printf("\n\nLa informaci?n solicitada no existe ...");
getch();
}
}
/
*********************************************************************/
void ordena(FILE *a){

int i=0,j=0,s,t;
struct DIREC r;
struct DIREC temp[100];
struct DIREC temporal;
while(1){
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
break;
temp[j]=r;
i++;
j++;
}
for(s=0;s0){
temporal=temp[s];
temp[s]=temp[t];
temp[t]=temporal;
}
s=0;
i=0;
while(1){
if(s>=j)
break;
r=temp[s];
fwrite(&r,sizeof(struct DIREC),1,a);
s++;
i++;
}
printf("\n\nSus archivos han sido ordenados
alfab?ticamente...");
getch();
/
*********************************************************************/
FILE *pack(FILE *a){

int i=0;
long p;
char clave[30];
struct DIREC r;
FILE *t;
t=fopen("TMP.DAT","wb");
printf("\n\nDame el nombre a dar de baja: ");

strupr(gets(clave));
p=busca_Clave2(a,clave);
if(p!=0){
while(1){
break;
if(strcmp(r.nombre,clave)!=0){
fwrite(&r,sizeof(struct DIREC),1,t);
}
i++;
}
fclose(t);
fclose(a);
remove("TELE.DAT");
rename("TMP.DAT","TELE.DAT");
t=fopen("TELE.DAT","rb+");
printf("\n\nLa informaci?n solicitada ha sido dada de baja...");
getch();
return(t);
}
else{
printf("\n\nNo existe el nombre...");
getch();
}
return 0;
}
/
*********************************************************************/
Volver
Programas en c
Empezando a programar
Pedir la base y la altura de un rectángulo, calcular su área y su

perímetro, y mostrar los resultados por pantalla.
#include <stdio.h>
void main ()
{
int base,altura,area,perimetre;
printf( "Entra la base:" );

scanf( "%d", &base );
printf( "Entra la altura:" );

scanf( "%d", &altura );
area=(base*altura)/2;
perimetre=(2*base)+(2*altura);
printf( "El area es %d.\n", area );

printf( "El perimetre es %d.\n", perimetre );
}
/*
Aunque no es hasta el tema 6 que se ven conceptos relacionados con los
tipos de datos elementales cabe notar que este programa tiene una
pequeña carencia. Por ser area de tipo int la linea
'area=(base*altura)/2; 'nos da el cociente de la divisi¢n sin
decimales. Por lo que no es del todo exacto.*/
/*Si no declaramos area como variable float el valor que retorna el

programa
no es exacto porque se hace la division entera*/
#include <stdio.h>
void main ()
{
int base,altura,perimetre;
float area;
printf( "Entra la base:" );

printf( "Entra la altura:" );

scanf( "%d", &altura );
area=(base*altura)/2.0; /*notese que el 2 ahora es 2.0*/

perimetre=(2*base)+(2*altura);
printf( "El area es %.2f.\n", area );
printf( "El perimetre es %d.\n",perimetre );
/*Al ser area de tipo float el modificador para la funcion scanf

cambia.
Ver ap‚ndice B. */
}
Pedir una cantidad de segundos y mostrar por pantalla a cuántas horas,
minutos y segundos corresponden.
#include<stdio.h>
void main()
{
int seg,h,m,s;
printf( "Entra el numero de segundos: " );
scanf("%d",&seg);
h=seg/3600;
m=(seg%3600)/60;
s=(seg%3600)%60;
printf( "\n%dhora(s) %d minuto(s) %d segundo(s)\n", h, m, s );
}
Suponiendo que previamente se ha realizado la declaración int x=7,

y; calcular el valor de la variable y tras evaluar cada una de las
siguientes sentencias de asignación:
(a) y = -2 + --x;
(b) y += 2;
(c) y = (y == x);
(d) y = y++ - x;
/*Para realizar este ejercicio intentar deducir los valores

de x e y en base al punto 3.4.2 del libro. Tras ello ejecutar
este problema y contrastar el resultado. Tener en cuenta que los
apartados dependen de la soluci¢n de los anteriores.
Ejecutar paso a paso el programa (Step over) puede ser interesante*/
#include <stdio.h>
void main()
{
int x=7,y;
/*Inicio*/
/*x= 7*/
y=-2 + --x;
/*x= 6*/
printf("\n(a) x=%d y=%d \n",x,y); /* y=4 */
y+=2;
/*x= 6*/
printf("\n(b) x=%d y=%d \n",x,y); /* y=6 */
y=(y==x);
/*x= 6*/
printf("\n(c) x=%d y=%d \n",x,y); /* y=1 */
y=y++ -x;
/*x= 6*/
printf("\n(d) x=%d y=%d \n",x,y); /* y=-4 */
}
Evaluar las siguientes expresiones:
(a) 5 / 2 + 20 % 6
(b) 4 * 6 / 2 - 15 / 2
(c) 5 * 15 / 2 / (4 - 2)
(d) 8 == 16 || 7 != 4 && 4 < 1
(e) (4 * 3 < 6 || 3 > 5 - 2) && 3 + 2 < 12

de x e y en base al punto 3.4.5 del libro. Tras ello ejecutar
/*La evaluacion de las expresiones es la siguiente:

a) 5/2+20%6=2+2=4
b) 4*6/2-15/2=12-7=5
c) 5*15/2/(4-2)=37/2=18
d) 8==16||7!=4&&4<1 (falso ||cierto && falso) es FALSO
e) (4*3<6||3>5-2)&&3+2<12 (falso||falso && cierto) es FALSO */
void main()
{
int a,b,c,d,e;
a=5/2+20%6;
b=4*6/2-15/2;
c=5*15/2/(4-2);
d=8==16||7!=4&&4<1;
e=(4*3<6||3>5-2)&&3+2<12;
printf( "Los resultados son:\na) %d\nb) %d\nc) %d\nd) %d\ne) %d\n",

a, b, c, d, e );
}
Constantes condicionales
Escribir un programa que lea tres valores enteros y muestre por

pantalla el máximo y el mínimo de ellos.
/*Realizaci¢n con el operador condicional ? punto 4.2 del libro*/
#include <stdio.h>
void main()
{
int a,b,c,max,min;
printf( "Introduzca los tres numeros:" );

scanf( "%d%d%d", &a, &b, &c );
max=(a>b)?a:b;
min=(a<b)?a:b;
max=(c>max)?c:max;
min=(c<max)?c:min;
printf( "El maximo es %d y el minimo es %d\n", max, min );

}
/*Realizado por R. Vila*/

/*Realizaci¢n con estructura if-else. Como puede verse el
c¢digo es menos compacto. Por contra puede ejecutarse el programa
con s¢lo dos operaciones de comparaci¢n mientras que con el
operador ? siempre se realizan cuatro comparaciones*/
#include <stdio.h>
void main()
{
int a,b,c,max,min;
printf( "Introduzca tres n£meros enteros\n" );

scanf( "%d%d%d", &a, &b, &c );
max=a; min=a;
if(b>max)
max=b;
else if(b<min)
min=b;
if(c>max)
max=c;
else if(c<min)
min=c;
printf( "\nEl m ximo es %d y el m¡nimo es %d.\n", max, min );
Dado el siguiente programa, realizar un seguimiento de la ejecución

en los siguientes supuestos:
(a) a = 0, b = 0, c = 5, d = 3
(b) a = 2, b = 1, c = 5, d = 3
(c) a = 2, b = 1, c = 2, d = 2
(d) a = 2, b = 1, c = 0, d = 0
#include<stdio.h>
void main()
{
int a,b,c,d;
scanf( "%d %d %d %d", &a, &b, &c, &d );

if( ((a>0) || (b>a)) && (c!=d))
{
a = c;
b = 0;
}
else
{
c += d;
c = (c==0) ? (c+b) : (c-a);
b = a + c + d;
}
printf( "\nLos valores finales son a=%d; b=%d; c=%d, d=%d:\n",
a, b, c, d );
}

de x e y en base al punto 3.4.4 y 4.1.1 del libro. Tras ello ejecutar
#include<stdio.h>
void main()
{
int a,b,c,d;
printf( "Introduce los valores iniciales de a,b,c,d:\n" );

scanf( "%d %d %d %d", &a, &b, &c, &d );
if( ((a>0) || (b>a)) && (c!=d))
{
a=c;
b=0;
}
else
{
c+=d;
c=(c==0)?(c+b):(c-a);
b=a+c+d;
}
printf( "\nLos valores finales son a=%d; b=%d; c=%d, d=%d:\n", a,
b, c, d );
}
/* a) Inicialmente a=0,b=0,c=5,d=3
Al final los valores son:a=0,b=11,c=8,d=3
b) Inicialmente a=2,b=1,c=5,d=3
c) Inicialmente a=2,b=1,c=2,d=2
d) Inicialmente a=2,b=1,c=0,d=0
Al final los valores son: a=2,b=3,c=1,d=0;
Todos estos valores obtenidos se pueden comprobar con la ejecucion

del programa
*/
Escribir un programa que lea un valor entero y determine si es

múltiplo de 2 y de 5.
#include <stdio.h>
void main ()
{
int a;
printf( "Introduzca el numero:\n" );

scanf( "%d", &a );
if (a%10==0)
printf( "\nEl numero %d es multiplo de 2 y 5\n", a );
else if(a%2==0)
printf( "\nEl numero %d es multiplo de 2 pero no de 5\n", a );
else if(a%5==0)
printf( "\nEl numero %d es multiplo de 5 pero no de 2\n", a );
else
printf( "\nEl numero %d no es multiplo ni de 2 ni de 5\n", a );
}
Escribir un programa que muestre por pantalla la ecuación de una

recta en un plano, Ax + By + C = 0, leyendo previamente las
coordenadas de dos de sus puntos (x_1, y_1) y (x_2, y_2).
Recordar que:
A=y_2-y_1 y B=y_1*(x_2-x_1)-x_1*(y_2-y_1)
#include<stdio.h>
void main()
{
int x1,x2,y1,y2,A,B,C;
printf("Introducir las coordenadas de dos puntos que esten sobre la

recta:x1,x2,y1,y2\n");
scanf("%d %d %d %d",&x1,&x2,&y1,&y2);
A=y2-y1;
B=y1*(x2-x1)-x1*(y2-y1);
C=-A*x1-B*y1;
printf( "La ecuacion de la recta es:(%d)*x+(%d)*y+(%d)=0", A, B,
C );
}
Constantes iterativas
Escribir un programa que calcule la suma de los 20 primeros números

múltiplos de 5 o de 7.
/*Este programa calcula la suma de los 20 primeros multiplos de

5 Y de 7*/
#include <stdio.h>
void main()
{
int cont,num,suma;
cont=0;
suma=0;
num=35;
while(cont!=20)
{
if(num%35==0)
{
suma+=num; /*suma=suma+num;*/
cont++;
}
num++;
}
printf( "\nLa suma es %d\n", suma );
}
/*Realizado por R.Vila*/

/*El siguiente programa calcula la suma de los 20 primeros multiplos
de 5 o (inclusiva) de 7
Realizacion con estructura for. Notese que la utilizacion de la
directiva define permite adaptar facilmente el programa al calculo
de otros multiplos*/
#define const1 5
#define const2 7
#include <stdio.h>
void main()
{
int i, suma=0,num=1;
for(i=0;i<20;)
{
if( (num%const1==0) || !(num%const2) )
{
i++; /*recuerdese que una condicion es cierta*/
suma+=num; /*si su valor es no cero y falsa si es cero*/
}
num++;
}
printf( "La suma es %d\n", suma );
}

/*Calculo de los primeros 20 multiplos de 5 o 7 con estructura
do-while y utilizacion de constantes predefinidas del preprocesador*/
#define const1 5
#define const2 7
#include <stdio.h>
void main ()
{
int num=1,suma=0,i=0;
do
{
if( (num%const1==0) || (num%const2==0) )
{
i++;
suma+=num;
}
num++;
} while(i<20);
printf( "La suma es %d\n", suma );

}
Escribir un programa que calcule la potencia de un número entero,

dado su valor y el del exponente.
/*Realizacion con estructura for*/
#include<stdio.h>
void main()
{
int v,exp,i,pot=1;
printf("Introducir el valor y el exponente:\n");
scanf("%d%d",&v,&exp);
for(i=0;i<exp;i++)
pot=pot*v;
printf( "El resultado es:%d\n", pot );
}

/*Realizacion con estructura while. Este programa accepta exponentes
positivos y negativos. Para ello necesitamos utilizar variables de
tipo
double, consultar apendice C del libro y tema 6.
El objetivo de este ejercicio es fomentar el dominio de las
estructuras
de bucle. Sin embargo cuando queramos dise¤ar programas de mayor
envergadura
no dise¤aremos un codigo especifico para una operacion tan simple como
una
potencia. Para ello C en su libreria math.h dispone de una funcion:
pow(double x,double y). Esta funcion recibe dos valores double y
retorna otro
valor double que es x^y. Consultar Apendice C y temas 6 y 10 (tipos de
datos
y funciones)*/
#define FALSE 0
#define TRUE !FALSE
#include <stdio.h>
#include <math.h>
void main()
{
int base, exp, limit, cont=0,boolea=FALSE;
double pot=1;
printf( "Introduce la base y el exponente:\n" );

scanf( "%d %d", &base, &exp );
if(exp<0)
{
limit=-exp;
boolea=TRUE;
}
else
limit=exp;
while(cont<limit)
{
pot*=base;
cont++;
}
if(boolea)
pot=1.0/pot;
printf( "\nEl resultado es: %d^%d=%e;\n", base, exp, pot );

/* %e indica notacion cientifica Apendice B*/
pot=pow( (double) base, (double) exp );
printf( "\nEl resultado es: %d^%d=%e;\n", base, exp, pot );
/*Como podemos ver el codigo del problema se reduce a la llamada a una

funcion de la libreria math.h. En programas de mayor envergadura se
optara
por la segunda resolucion.*/
Escribir un programa que lea N números enteros y muestre el mayor y

el menor de todos ellos
/*Estructura while*/
#include <stdio.h>
void main()
{
int max,min,num,inum;
printf( "\nIntroduzca el primer numero:" );

scanf( "%d", &num );
max=num;
min=num;
while(inum!=-1)
{
printf( "\nIntroduzca el siguiente numero (-1 para acabar):" );
scanf( "%d", &inum );
if(inum!=-1)
{
max=(inum>=max)?inum:max;
min=(inum<=min)?inum:min;
}
}
printf( "El maximo es: %d\n", max );
printf( "El minimo es: %d\n", min );
}

/*El siguiente programa calcula el maximo y el minimo de una
secuencia de numeros introducida por teclado acabada en -1. Realizado
con estructura for*/
#include <stdio.h>
void main()
{
int num,max, min;
printf( "Introduzca el primer numero:\n" );

max=min=num;
for( ;num!=-1; )
{
printf( "Introduzca el siguiente:\n" );
if(num>max)
max=num;
else if(num<min)
min=num;
}
printf( "El maximo es %d y el minimo es %d\n", max, min );

}
Escribir un programa que escriba la tabla de multiplicar de un número

leído por teclado
#include<stdio.h>
void main()
{
int i,num;
printf( "\nEscribir el numero deseado:\n" );

printf( "La tabla es:\n" );
for(i=0;i<=10;i++)
printf( "\t%d*%d=%5d\n", num, i, num*i ); /*\t=tabulador*/
}
Escribir un programa que muestre la serie de Fibonacci hasta un

límite dado.
Recordar que la serie de Fibonacci se define como
F_0=1 F_1=1 F_i=F_(i-1)+F_(i-2)
#include <stdio.h>
void main()
{
int num,a,b,c,cont;
printf( "Introduzca el limite:\n" );

a=1;
printf( "\tElemento[1]:%d\n", a );
b=1;
printf( "\tElemento[2]:%d\n", b );
cont=3;
do
{
c=a+b;
printf( "\tElemento[%d]:%d\n", cont, c );
a=b;
b=c;
cont++;
} while((a+b)<num);
}
Escribir un programa que convierta un número entero positivo a

cualquier base de numeración dada, igual o inferior a 10.
/*Realizacion con vectores. Los vectores no se ven hasta el tema 7

por lo que se supone que hay que poder dise¤ar este programa con tipos
elementales. Ver T5-P6BIS*/
#include<stdio.h>
void main()
{
int i,num,base,res[100];
printf( "Introducir la base deseada:\n" );

printf( "Introducir el numero que se desea convertir:\n" );
for(i=0;base<=num;i++)
{
res[i]=num%base;
num=num/base;
}
res[i]=num;
do
{
printf( "%d", res[i] );
i--;
} while(i>=0);
printf( "\n" );
}
/*Realizacion por R.Vila*/
#include<stdio.h>
void main()
{
int num, base, cifra, tmp=1;
printf( "Introducir la base deseada:\n" );

scanf( "%d", &base);
/*Control de errores*/
if ( base>10 || base<2 )
{
printf( "Base erronea\n" );
exit(-1); /*provoca la interrupcion del programa*/
}
printf( "Introducir el numero que se desea convertir:\n" );

printf( "El numero %d en base %d es ", num, base );

while( (num/tmp)>=base )
tmp*=base;
while(tmp>=1)
{
cifra=num/tmp;
printf( "%d", cifra );
num%=tmp;
tmp/=base;
}
printf( "\n" );
}
Escribir un programa que determine si un número entero dado es primo

o no.
#include <stdio.h>
void main()
{
int num,cont,aux;
printf( "Introduzca un numero:\n" );

cont=0;
for(aux=num/2; aux>1 && cont==0; aux--)

{
if(num%aux==0)
cont++;
}
if(cont==0)
printf( "Es primo" );
else
printf( "No es primo" );
}
/*Programa que calcula si un numero es primo o no*/
#include <stdio.h>
int es_primo(int x)
/*Funcion que retorna 1 si es primo y 0 si no lo es*/
{
int divisor=2;
/*solo aumenta el divisor hasta la raiz cuadrada de x,*/

/*ya que el resto de operaciones es innecesario*/
while (divisor*divisor<=x)
{
if((x%divisor)==0)/*x multiplo de divisor*/
return(0);
else
divisor++;
}
return(1);
}
void main()
{
int a;
/*Pide el numero*/
printf("\nIntroduzca un numero:\n");
scanf("%d%*c",&a);
/*Antes comprueba que sea un numero natural*/

if(a<=0)
printf("\nError: numero no positivo\n");
else if(a==1)
printf("\n1 no es primo\n");
else
if (es_primo(a))
printf("\n%d es primo.\n", a);
else
printf("\n%d no es primo.\n", a);
}
Escribir un programa que calcule el factorial de un número entero

leído por teclado.
/*Calculo del factorial. Dado que el factorial crece muy rapidamente

es aconsejable utilizar double en vez de long int. Con long int,
dependiendo de la maquina en que corra el programa (32 o 64 bits)
dificlimente podremos calcular factoriales mayores de 20 (Tema 6).
Con double llegamos hasta 170!*/
#include<stdio.h>
void main()
{
int num,i;
double res=1;
printf( "\nIntroduce el numero deseado para calcular el factorial:\

n" );
if(num>1)
{
for(i=1;i<=num;i++)
res*=i;
}
printf( "El resultado es: %d!=%e\n", num, res );
}
Escribir un programa que calcule la suma de todos los números

múltiplos de 5 comprendidos entre dos enteros leídos por teclado.
#include <stdio.h>
void main()
{
int x,p,q;
long int suma;
printf( "Introduzca los dos enteros de menor a mayor:" );

scanf( "%d%d", &p, &q );
suma=0;
for (x=p; x<=q; x++)

{
if(x%5==0)
suma+=x;
}
printf( "La suma es: %ld", suma );
}
Escribir un programa que muestre los 15 primeros números de la serie

de Fibonacci.
#include<stdio.h>
void main()
{
int F0=1,F1=1,i,suma=0;
printf( "La serie de Fibonacci es:\n\tF[0]=1;\n\tF[1]=1;" );

for(i=2;i<15;i++)
{
suma=F0+F1;
printf( "\n\tF[%d]=%d", i, suma );
F0=F1;
F1=suma;
}
printf( "\n" );
}
INVERTIR DÍGITOS
1. Diseñar un programa que lea un número natural n y escriba sus

dígitos
invertidos.
2. Diseñar un programa que haga lo mismo que el anterior, pero

valiéndose de una función que retorne un natural con los dígitos de n
invertidos.
/*Programa que invierte los digitos de un numero */
/*No se sirve de la funcion invierte_digitos*/
#include <stdio.h>
void main()
{
int n;
/*Pide el numero*/
scanf("%d%*c",&n);
/*Antes comprueba que sea un numero no negativo*/

if(n<0)
printf("\nError: numero negativo\n");
else if(n==0)/*Caso especial*/

printf("\nNumero invertido: 0\n");
else/*Invierte el numero cifra por cifra*/

{
printf("\nNumero invertido: ");
while(n>0)
{
printf("%d", n%10);
n/=10;
}
}
}
/*Programa que invierte los digitos de un numero */

/*se sirve de la función invierte_digitos*/
#include <stdio.h>
/*Funcion que efectua la inversion*/

/*Retorna el numero invertido*/
int invierte_digitos(int num)
{
int inv=0;
if (num==0)/*Caso especial*/
return(0);
else
{
while(num>0)
{
inv=(inv*10) + (num%10);
num/=10;
}
return(inv);
}
}
void main()
{
int n;
/*Pide el numero*/
scanf("%d%*c",&n);
/*Antes comprueba que sea un numero no negativo*/

if(n<0)
printf("\nError: numero negativo\n");
else
printf("\nNumero invertido: %d\n",invierte_digitos(n));
}
FACTORIZACIÓN
Diseñar un programa que, dado un número natural n, lo escriba como

producto
de factores primos.
/*Programa que factoriza un numero*/
#include <stdio.h>
void main()
{
int a, i=2;
/*Pide el numero*/
scanf("%d%*c",&a);
/*Antes comprueba que sea un numero positivo*/

if(a<=0)
printf("\nError: numero no positivo\n");
else if(a==1)/*Caso sencillo*/

printf("\n1");
else
{
while(a!=1)
{
if ((a%i)==0)
/*Si i es divisor de a, lo muestra por
pantalla*/
{
printf("%d ", i);
a/=i;
i=2;
}
else
i++;
}
}
}
Td elementales
Escribir un programa que cuente el número de veces que aparece una

letra en una secuencia de caracteres acabada en '.'.
/*Cuenta el numero de veces que aparece un caracter en una secuencia*/
#include <stdio.h>
void main()
{
char lletra,c;
int cont;
printf( "\nIntroduzca la letra escogida:" );

scanf( "%c%*c", &lletra );
/*la funcion scanf en ocasiones presenta problemas a la hora de

identificar
el retorno de carro que marca la ejecucion de la funcion. Para
evitarlo en
esta llamada a la funcion se leen dos caracteres del buffer de
teclado, el
primero %c se asigna a la variable lletra, el segundo %*c corresponde
al
caracter \n y el asterisco indica a la funcion que lea el caracter
pero no lo
asigne. En principio el programa tambien funcionaria correctamente sin
este
peque¤o detalle. Sin ese detalle solo funciona mal si el caracter a
detectar
es el retorno de carro*/
printf("\nIntroduzca la secuencia de caracteres terminada en

'.':");
cont=0;
while(c!='.')
{
scanf( "%c", &c );
if(c==lletra)
cont++;
}
printf( "\n Ha aparecido %d veces \n", cont );
}
Escribir un programa que lea un carácter de teclado e informe de si

es alfabético, numérico, blanco o un signo de puntuación.
/*Identificacion de caracteres*/
#include<stdio.h>
void main()
{
char c;
printf( "Introducir el caracter a identificar\n" );

scanf( "%c", &c );
if((c>='a')&&(c<='z')||(c>='A')&&(c<='z'))
printf( "Letra\n" );
else if((c>='0')&&(c<='9'))
printf( "Numero\n" );
else if(c==' ')
printf( "Blanco\n" );
else if((c==',')||(c==';')||(c==':')||(c=='.'))
printf( "Signo de puntuacion\n" );
else
printf( "No lo se,ERROR\n" );
}
Escribir un programa que convierta una secuencia de dígitos entrados

por teclado al número entero correspondiente. Supóngase que el primer
dígito leído es el de mayor peso. Obsérvese también que el peso
efectivo de cada dígito leído es desconocido hasta haber concluido la
introducción de la secuencia.

/*Transformar una secuencia de cifras en un numero entero. Tras cada
llamada a la funcion scanf aparece entre comentarios una linea:
c=(char) getchar();
getchar es una funcion de la libreria stdio.h de c que recoge un
caracter
de la entrada estandar (teclado) devuelve su codigo ascii. Es por ello
por
lo que aparece el conversor char. Podeis comprobar que si convertis en
comentario las llamadas a scanf y las sustituis por las llamadas a
getchar
el programa sigue funcionando correctamente.
Si se excede el rango de long int el resultado que devuelve el
programa es
erroneo.*/
#include <stdio.h>
void main()
{
char c;
long int numero;
printf( "\nIntroduzca la secuencia de cifras y pulse return:\n\

t" );
scanf( "%c", &c );
/*c=(char) getchar();*/
/*control de errores*/
if( (int) c < (int) '0' || (int) c > (int) '9' || c=='\n' )
{
if(c=='\n')
printf( "\nNingun numero introducido\n" );
else
{
printf( "\nCaracter no valido\n" );
exit(-1); /*abortar programa*/
}
}
numero=((int) c) - ((int) '0');
scanf( "%c", &c );
/*c=(char)getchar();*/
while(c!='\n')
{
if( (int) c < (int) '0' || (int) c > (int) '9')
{
exit(-1);
}
numero*=10;
numero+=((int) c) - ((int) '0');
scanf( "%c", &c );
}
printf( "\nEl numero es %ld.\n", numero );

}
Escribir un programa que convierta una secuencia de dígitos entrados

por teclado al número entero correspondiente. Supóngase que el primer
dígito leído es el de mayor peso. Obsérvese también que el peso
efectivo de cada dígito leído es desconocido hasta haber concluido la
introducción de la secuencia.

/*Transformar una secuencia de cifras en un numero entero. Tras cada
llamada a la funcion scanf aparece entre comentarios una linea:
c=(char) getchar();
getchar es una funcion de la libreria stdio.h de c que recoge un
caracter
de la entrada estandar (teclado) devuelve su codigo ascii. Es por ello
por
lo que aparece el conversor char. Podeis comprobar que si convertis en
comentario las llamadas a scanf y las sustituis por las llamadas a
getchar
el programa sigue funcionando correctamente.
Si se excede el rango de long int el resultado que devuelve el
programa es
erroneo.*/
#include <stdio.h>
void main()
{
char c;
long int numero;
printf( "\nIntroduzca la secuencia de cifras y pulse return:\n\

t" );
scanf( "%c", &c );
if( (int) c < (int) '0' || (int) c > (int) '9' || c=='\n' )
{
if(c=='\n')
printf( "\nNingun numero introducido\n" );
else
{
exit(-1); /*abortar programa*/
}
}
numero=((int) c) - ((int) '0');
scanf( "%c", &c );
/*c=(char)getchar();*/
while(c!='\n')
{
if( (int) c < (int) '0' || (int) c > (int) '9')
{
exit(-1);
}
numero*=10;
numero+=((int) c) - ((int) '0');
scanf( "%c", &c );
}
printf( "\nEl numero es %ld.\n", numero );

}
Sean las variables enteras i y j con valores 5 y 7, respectivamente.

Y las variables de coma flotante f y g con valores 5.5 y -3.25,
respectivamente.
¿Cuál será el resultado de las siguientes asignaciones?
(a) i = i % 5;
(b) f = (f - g) / 2;
(c) j = j * (i - 3);
(d) f = f % g;
(e) i = i / (j - 2);

/*En este tipo de ejercicios lo mejor es intentar pensar el resultado
y
despues dise¤ar un programa que nos permita comprobar la validez de
nuestras
conclusiones. Si no se entiende el porque de un resultado puede ser
interesante ejecutar el programa paso a paso y visualizar el contenido
de
las variables. He considerado cada apartado independiente del
anterior*/
#include <stdio.h>
void main ()
{
int i=5,j=7;
float f=5.5,g=-3.25;
/*apartado a*/
i=i%5;
printf( "\nEl resultado del apartado (a) es:\n\t%d\n", i );
/*apartado b*/
f=(f-g)/2;
printf( "El resultado del apartado (b) es:\n\t%e\n", f );
/*apartado c*/
i=5;
j=j+(i-3);
printf( "El resultado del apartado (c) es:\n\t%d\n", j );
/*apartado d*/
f=5.5;
/*f=f%g;*/ /*El operador % solo tiene sentido con variables int*/
/*Al intentar ejecutar esta linea el compilador dara
error*/
printf( "El resultado del apartado (d) es:\n\tERROR\n" );
/*apartado e*/
j=7;
i=i/(j-2);
printf( "El resultado del apartado (e) es:\n\t%d\n", i );
}
/*El resultado de las siguientes asignaciones sera:
a) i=i%5 --> i=0

b) f=(f-g)/2 --> f=4.375
c) f=f%g --> f=2.25
d) j=j*(i-3) --> j=14
e) i=i/(j-2) --> i=1 */
Escribir un programa que calcule y muestre por pantalla las raíces

de una ecuación de segundo grado, leyendo previamente los
coeficientes A, B y C de la misma:
Ax^2 + Bx + C = 0.
#include <stdio.h>
#include <math.h>
void main()
{
double x,y,A,B,C,N;
printf( "Introduzca el coeficiente A:" );

scanf( "%lf%*c", &A );
printf( "Introduzca el coeficiente B:" );
scanf( "%lf%*c", &B );
printf( "Introduzca el coeficiente C:" );
scanf( "%lf%*c", &C );
C=4*A*C;
N=B*B-C;
A=2*A;
if(N<0)
printf( "Las raices son complejas\n" );
else
{
x=(-B+sqrt(N))/(A);
y=(-B-sqrt(N))/(A);
printf( "Las raices son:\n %lf \n %lf\n", x, y );
}
}

/*Este programa permite mostrar las raices de cualquier ecuacion de
segundo grado sean o no complejas*/
#include <stdio.h>
#include <math.h>
void main()
{
float a,b,c,discr;
double x,y;
printf( "\nIntroduzca los coeficientes de mayor a menor grado:\

n" );
scanf( "%f %f %f", &a, &b, &c );
discr=b*b-4*a*c;
if(discr>=0)
{
x=(-b+sqrt(discr))/(2*a);
printf( "\nLa primera solucion es %e\n", x );
x=(-b-sqrt(discr))/(2*a);
printf( "\nLa segunda solucion es %e\n", x );
exit(-1);
}
else
{
x=-b/(2*a); y=sqrt(discr)/(2*a);
printf( "\nLa primera solucion es %e+(%e)*i\n", x, y );
y=-y;
printf( "\nLa segunda solucion es %e+(%e)*i\n", x, y );
}
}
Escribir un programa que calcule el perímetro de una circunferencia y

que lo muestre por pantalla con cuatro decimales de precisión. Si el
radio introducido por el usuario es negativo, el perímetro resultante
será 0.
#include<stdio.h>
#define PI 3.1415926534
void main()
{
float r,p;
printf( "Introduce el radio de la circunferencia:\n" );

scanf( "%f", &r );
if(r>0)
p=2*PI*r;
else if(r<0)
p=0;
printf( "El perimetro de la circumferencia es: %.4f\n", p );
/*.4 indica que la presentacion sea con cuatro decimales*/
}
Escribir un programa para calcular de forma aproximada el número e.

Recordar que
e= sum ( i, 0, infinito, 1/i! )
#include <stdio.h>
#define LIMITE 5000
void main()
{
int i,fin;
double suma,eps,fact;
fin=0;
suma=1; /* 1/0! */
fact=1.0;
i=1;
printf( "Introduzca la epsilon:" );
scanf( "%lf", &eps );
/*sumatorio(1,limite,1/i!)*/
while(fin!=1)
{
fact=fact*i;
suma+=(1.0/fact);
i++;
fin=(((1.0/fact)<eps) || (i>=LIMITE));
}
printf( "La aproximacion de e es %.25lf\n", suma );
}
DIVISIÓN CON DECIMALES
Diseñar un programa que, mediante las operaciones entre enteros,

calcule la división real de dos números naturales (el segundo distinto
de cero) con una precisión determinada de decimales.
/*Programa que efectua la division entre 2 numeros enteros*/

/*con un numero de decimales pedido al usuario*/
/*Solo se sirve de operaciones entre enteros*/
/*Implementa el algoritmo aprendido en la educacion primaria*/
/*Utiliza la funcion division*/
#include <stdio.h>
/*Funcion que calcula la division con ndec decimales*/
void division(int divid, int divis, int ndec)
{
/*Calculo de la parte no decimal*/
printf("Resultado: %d.",divid/divis);
/*Calculo de los decimales uno por uno, si se piden*/

while(ndec>0)
{
/*El dividendo sera el resto de las divisiones "con un
0 detras"*/
divid=10*(divid%divis);
printf("%d", divid/divis);
ndec--;
}
}
void main()
{
int dividendo, divisor, numdec;
/*Pide el dividendo*/
printf("\nIntroduzca el dividendo:\n");
scanf("%d%*c",&dividendo);
/*Pide el divisor*/
printf("\nIntroduzca el divisor:\n");
scanf("%d%*c",&divisor);
/*Pide el numero de decimales*/

printf("\nIntroduzca el numero de decimales:\n");
scanf("%d%*c",&numdec);
/*Antes comprueba que sean numeros no negativos*/

/*El divisor no puede ser 0*/
if((dividendo<0)||(divisor<=0)||(numdec<0))
printf("\nError: datos incorrectos\n");
else
division(dividendo, divisor, numdec);
Td estructurados
¿Dónde está el error en el siguiente programa?
void main()
{
int vector[10];
int x=1;
for(x=1;x<=10;x++)
vector[x]=23;
}
/*Donde esta el error*/
void main()
{
int vector[10];
int x=1;
for(x=1;x<=10;x++)
vector[x]=23;
}
/*
El error esta en la condicion del for (x<=10) ya que si el vector que
hemos inicializado tenia 10 posiciones(de la 0 a la 9) el 10 seria la
posicion 11 y no entra dentro del rango de nuestro vector.*/
Escribir un programa que lea del teclado un vector de 10 números

enteros, lo invierta y finalmente lo muestre de nuevo.

/*Inversion de vectores. Notese que no es necesaria la definicion
de un vector auxiliar para realizar la inversion, sino que con una
variable temporal es suficiente. Ello hace que el programa sea mas
eficiente (menor memoria consumida y menor tiempo de ejecucion*/
#include <stdio.h>
#define N 10
void main()
{
int i, vector[N], tmp;
printf( "\nIntroduzca 10 numeros enteros:\n\t" );

for(i=0;i<10;i++)
{
scanf( "%d%*c", &vector[i] );
printf( "\t" );
}
printf( "\nEl vector original es:\n\t" );
for(i=0;i<10;i++)
printf( "v[%d]=%d\n\t", i, vector[i] );
for(i=0;i<5;i++)
{
tmp=vector[i];
vector[i]=vector[9-i];
vector[9-i]=tmp;
}
printf( "\nEl vector invertido es:\n\t" );
for(i=0;i<10;i++)
printf( "v[%d]=%d\n\t", i, vector[i] );
}
Escribir un programa que cuente el número de palabras de más de cuatro

caracteres en una frase. Ésta se almacena en forma de vector cuyo
último elemento es el carácter '.'.
#include<stdio.h>
#define MAX 100
void main()
{
int i=0,contllet=0,contpar=0;
char frase[MAX];
printf( "Introduce la frase terminada en punto(.):\n" );
scanf( "%c", &frase[i] );
while( frase[i]!='.' )
{
i++;
scanf( "%c",&frase[i] );
if ( i==99 && frase[i]!='.')
{
printf( "\nFrase demasiado larga. Error.\n" );
exit(-1);
}
}
i=0;
while(frase[i]!='.')
{
if(frase[i]!=' ')
{
contllet++;
i++;
if(contllet>4&&(frase[i]==' '||frase[i]=='.'))
{
contpar++;
contllet=0;
}
}
else
{
contllet=0;
i++;
}
}
printf( "La frase contiene %d palabras de mas de 4 caracteres.\n",
contpar );
}
Escribir un programa que lea del teclado dos números enteros de hasta
20 dígitos y los sume. Usar vectores para almacenar los dígitos de
cada número.

/*Este programa emula el algoritmo manual de la suma. Suponemos
que el primer digito introducido es el de mayor peso, por ello
introducimos los digitos en el vector de la posicion N a la 0 y no
al reves como es habitual. Ademas el codigo permite sumar numeros
que no sean exactamente de 20 digitos*/
#include <stdio.h>
#define N 20
void main()
{
int v1[N],v2[N],S[N+1];
int i=0,len1=0,len2=0,lens,max,min,carry=0;
/*Inicialitzacio del vector S*/

for(i=0;i<N+1;i++)
S[i]=0;
i=0;
printf( "\nIntroduzca los digitos del primer vector.\nPara
finalizar pulse '10'.\n" );
do
{
scanf( "%d%*c", &v1[N-1-i] );
if (v1[N-1-i]>10 || v1[N-1-i]<0)
{
printf( "\nError. %d no es un digito\n", v1[N-1-i] );
exit(-1);
}
i++; len1++; /*Al incrementar la i la condicion
es*/
}while( i<=N-1 && v1[N-i]!=10); /*respecto a v1[N-i]*/
if(i!=N)
len1--;
/*si no se ha llenado el vector el ultimo incremento de len1 se
debe al numero 10 que marca el final y hemos de compensar ese
incremento*/
i=0;
printf( "\nIntroduzca los digitos del segundo vector.\nPara
finalizar pulse '10'.\n" );
do
{
scanf( "%d%*c", &v2[N-1-i] );
if (v2[N-1-i]>10 || v2[N-1-i]<0)
{
printf( "\nError. %d no es un digito\n", v2[N-1-i] );
exit(-1);
}
i++; len2++;
}while( i<=N-1 && v2[N-i]!=10 );
if(i!=N)
len2--;
max= (len1>len2) ? len1 : len2;

min= (len1<len2) ? len1 : len2;
/*En el vector S el digito de menor peso esta en la posicion

cero y el de mayor en la posicion lens-1*/
for(i=0; i<min ; i++)

{
S[i]=v1[N-len1+i]+v2[N-len2+i]+carry;
carry=0;
if(S[i]>9)
{
S[i]-=10;
carry=1;
}
}
if (max==min) /*len1=len2*/
{
if (carry)
{
S[max]=1;
lens=len1+1;
}
else
lens=len1;
}
else
{
for(i=min;i<max;i++)
{
if(max==len1)
S[i]=v1[N-len1+i]+carry;
else
S[i]=v2[N-len2+i]+carry;
carry=0;
if(S[i]>9)
{
carry=1;
S[i]-=10;
}
}
if(carry)
{
S[max]=1;
lens=max+1;
}
else
lens=max;
}
/*Presentacion por pantalla*/
printf( "\nEl resultado es:\n\n\t" );
printf( "\t%30d", v1[N-len1] );

for(i=N-len1+1;i<N;i++)
printf( "\b\b%d", v1[i] ); /* '\b'=backspace */
printf( "\n\t+" );
printf( "\t%30d", v2[N-len2] );
for(i=N-len2+1;i<N;i++)
printf( "\b\b%d", v2[i] );
printf( "\n\t\t" );
for(i=0;i<30;i++)
{
if(i<30-lens)
printf( " " );
else
printf( "-" );
}
printf( "\n\t\t" );
printf( "%30d", S[0] );
for(i=1;i<lens;i++)
printf( "\b\b%d", S[i] );
printf(
"\n" );
}
Escribir un programa que decida si una palabra es palíndroma o no.

La palabra se almacena en un vector de caracteres acabado en '.'.
#include<stdio.h>
#define MAXLONG 30
void main()
{
int i,j;
char palabra[MAXLONG];
printf( "Introduce la palabra(acabada en'.'):" );
j=-1;
do
{
j++;
scanf( "%c", &palabra[j] );
} while (palabra[j]!='.');
i=0;
j--;
while((palabra[i]==palabra[j])&&(i<j))
{
i++;
j--;
}
if(i>=j)
printf( "\nLa palabra es palindroma\n" );
else
printf("\nLa palabra no es palindroma\n");
}
Escribir un programa para calcular la moda de un conjunto de números

enteros. La moda es el valor que se repite más veces.
#include <stdio.h>
#define N 20
void main()
{
int v1[N],v2[N],S[N],max;
int i,j,N1,moda;
printf("Introduzca el numero de elementos del vector:");

scanf("%d",&N1);
for(i=0; i<N1; i++)
{
printf("Element [%d]:",i);
scanf("%ld",&v1[i]);
}
for(i=0; i<N1; i++)
{
for(j=0; j<N1; j++)
{
if(v1[i]==v2[j])
{
S[j]++;
break;
}
else if(v2[j]==' ')
{
v2[j]=v1[i];
S[j]=1;
break;
}
else (v2[j]=v1[i]);
}
}
max=S[0];
moda=v2[0];
for(j=1;j<=N1;j++)
{
if(S[j]>max)
{
max=S[j];
moda=v2[j];
}
}
printf( "La moda es: %d\n", moda );
}

/* Calculo de la moda de un conjunto de numeros enteros poniendo
especial atencion al control de errores.
La funcion scanf presenta ciertas anomalias cuando se leen de forma
combinada
caracteres y enteros. Es por ello por lo que tras leer el entero
debemos eliminar
del buffer de teclado el caracter \n que queda y en la secuencia de
lectura
escribimos "%d%*c". %*c indica a la funcion que lea un caracter y que
no lo
asigne a ninguna variable.*/
#define MAXDIM 100

#define MAXINT 32767
#include <stdio.h>
void main()
{
char c;
int i=0,j;
short int vin[MAXDIM];
int moda=MAXINT, veces=0, modatmp, vecestmp;
/*Lectura de la secuencia*/
printf("\nIntroduzca el primer entero:\n");

do
{
scanf( "%d%*c", &vin[i] );
i++;
printf( "\nHa finalizado la secuencia (S/N):" );
scanf( "%c%*c", &c );
if( c=='n' || c=='N')
{
if(i==MAXDIM-1)
{
printf( "\nSecuencia demasiado larga.Error\n" );
exit(-1);
}
printf("\nIntroduzca el siguiente:\n");
}
} while( i<MAXDIM-1 && c!='s' && c!='S' );
vin[i]=MAXINT; /*Nos permitira detectar el final del vector*/
for(i=0; vin[i]!= MAXINT; i++)

{
modatmp=vin[i];
vecestmp=0;
if(modatmp!=moda)
{
for(j=0; vin[j]!= MAXINT; j++)
{
if(vin[j]==modatmp)
vecestmp++;
}
if(vecestmp>veces)
{
moda=modatmp;
veces=vecestmp;
}
}
}
printf( "\nLa moda es %d y ha aparecido %d veces.\n", moda,

veces );
}
¿Dónde está el error en el siguiente programa?
void main()
{
int matriz[10][3];
int x,y;
for(x=0;x<3;x++)
for(y=0;y<10;y++)
matriz[x][y]=0;
}
/*Donde esta el error en el siguiente programa?*/
void main()
{
int matriz[10][3];
int x,y;
for(x=0;x<3;x++)
for(y=0;y<10;y++)
matriz[x][y]=0;
}
/*El error esta al final ( matriz[x][y]).

El orden de la 'x' y la 'y' esta invertido ya que la 'y' es el nø de
filas
y la 'x' el nø de columnas.
La expresion correcta seria: matriz[y][x]=0*/
/*Razonese si a causa de este error se accederia o no a posiciones de

memoria
externas a la matriz o si por contra tan solo se accederia en orden
incorrecto
a algunas de las posiciones de la matriz. Pueden encontrar una ayuda
para
resolver esta cuestion viendo la figura 10.1 de la pag 99 del libro.
*/
Escribir un programa que inicialice cada elemento de una matriz de

enteros con el valor de la suma del número de fila y columna en que
está situado.
#include <stdio.h>
#define MAX 20
void main()
{
int matriz[MAX][MAX];
int i,j,nfil,ncol;
printf( "Inserte el numero de filas:" );

scanf( "%d", &nfil );
printf( "Inserte el numero de columnas:" );
scanf( "%d", &ncol );
if( nfil>MAX-1 || ncol>MAX-1 || nfil<0 || ncol<0 )
{
printf("\nDimension erronea\n");
exit(-1);
}
for(i=0; i<nfil; i++)

{
for(j=0; j<=ncol; j++)
matriz[i][j]=j+i;
}
printf( "\nLa matriz resultante es:\n" );
{
for(j=0; j<ncol; j++)
printf( "[%d][%d]=%d\n", i, j, matriz[i][j] );
}
/*Otra forma de presentar la matriz por pantalla*/
printf( "\n\n" );
for(i=0;i<nfil;i++)
{
printf("[");
for(j=0;j<ncol;j++)
{
printf("%5d",matriz[i][j]);
}
printf(" ]\n");
}
}
Escribir un programa que calcule la suma de dos matrices de enteros.
#include<stdio.h>
#define DIM 20
void main()
{
/*No declarar una tercera matriz es una forma de ahorrar memoria*/
int a[DIM][DIM],b[DIM][DIM];
int i,j,nfil,ncol;
printf( "\nIntroduce el numero de filas (<=20):\n" );

printf( "\nIntroduce el numero de columnas (<=20):\n" );
printf( "Introduce las dos matrices a sumar:\n" );
printf( "La matriz a es:\n" );
for(i=0;i<nfil;i++)
for(j=0;j<ncol;j++)
{
printf( "Introducir el elemento(%d,%d):\n", i+1, j+1 );
scanf( "%d", &a[i][j] );
}
printf( "La matriz b es:\n" );
for(i=0;i<nfil;i++)
for(j=0;j<ncol;j++)
{
printf( "Introducir el elemento(%d,%d):\n", i+1, j+1 );
scanf( "%d", &b[i][j] );
}
for(i=0;i<nfil;i++)
for(j=0;j<ncol;j++)
a[i][j]=a[i][j]+b[i][j];
printf( "La suma de las dos matrices es:\n\n" );

for(i=0;i<nfil;i++)
{
printf( "[" );
for(j=0;j<ncol;j++)
printf( "%5d", a[i][j] );
printf(" ]\n");
}
}
Escribir un programa que calcule los puntos de silla de una matriz de
enteros. Un elemento de una matriz es un punto de silla si es el
mínimo de su fila y el máximo de su columna.
#include <stdio.h>
#define MAXDIM 10
void main()
{
int nfil,ncol,i,j;
int mat[MAXDIM][MAXDIM],mins[MAXDIM],maxs[MAXDIM];
printf( "\nIntroduce el numero de filas: " );

printf( "\nIntroduce el numero de columnas: " );

{
{
printf( "\nmat[%d][%d]= ", i, j );
scanf( "%d", &mat[i][j] );
}
}
{
mins[i]=mat[i][0];
{
if (mat[i][j]<mins[i])
mins[i]=mat[i][j];
}
}
printf( "\nminfila[%d] = %d", i, mins[i] );
{
maxs[j]=mat[0][j];
{
if (mat[i][j]>maxs[j])
maxs[j]=mat[i][j];
}
}
printf("\nmaxcolumna[%d] = %d", j, maxs[j] );
{
{
if ((mat[i][j]==mins[i]) && (mat[i][j]==maxs[j]))
printf( "\nEl elemento mat[%d][%d] = %d, es un punto de
silla.", i, j, mat[i][j] );
}
}
}
Escribir un programa que determine si una matriz es simétrica.
#include<stdio.h>
#define FALSE 0
#define TRUE !FALSE
#define DIM 15
void main()
{
int mat[DIM][DIM];
int i,j,nfil,ncol,boolea=TRUE;
printf( "\nIntroduce el numero de filas(<15):\n" );
printf( "\nIntroduce el numero de columnas(<15):\n" );
if( nfil>DIM || ncol>DIM || nfil<0 || ncol<0)

{
printf( "Dimension erronea\n" );
exit(-1);
}
printf( "\nIntroducir la matriz:\n" );

for (i=0;i<nfil;i++)
for(j=0;j<ncol;j++)
{
printf( "Introducir el elemento(%d,%d): ", i+1, j+1 );
scanf( "%d", &mat[i][j] );
}
printf( "\n\n" );
for(i=0;i<nfil;i++)
{
printf( "[" );
for(j=0;j<ncol;j++)
printf( "%5d", mat[i][j] );
printf( " ]\n" );
}
if(nfil!=ncol)
{
printf( "\nMatriz no simetrica, no es cuadrada.\n" );
exit(-1);
}
for(i=0;i<nfil;i++)
for(j=0;j<ncol;j++)
{
if( mat[i][j] != mat[j][i])
boolea=FALSE;
}
if(boolea)
printf( "\nLa Matriz es simetrica\n" );
else
printf( "\nLa Matriz no es simetrica\n" );
}
Escribir un programa que multiplique dos matrices.
/*Aunque este programa funciona correctamente utiliza una serie de

recursos que en el capitulo 7 todavia no se han visto como los tipos
definidos por el usuario, las funciones y los punteros. Hemos dise¤ado
una
alternativa en la que solo aparecen las herramientas conocidas hasta
el
momento*/
#include <stdio.h>
#define N 10
typedef int matriu [N][N];
void llegir_matriu(matriu m, int *f, int *c)

{
int i, j;
printf("\nIntroduzca el numero de filas:");
scanf("%d",f);
printf("\nIntroduzca el numero de columnas:");
scanf("%d",c);
for(i=0; i<*f; i++){
for(j=0; j<*c; j++){
printf("\nIntroduzca el elemento [%d]
[%d]:",i,j);
scanf("%d",&m[i][j]);
}
}
}
void multiplicar_matrius(matriu m1, matriu m2, matriu m3 ,int f1, int

c1, int c2)
{
int i,j,x,suma;
for(i=0; i<f1; i++){

for(j=0; j<c2; j++){
suma=0;
for(x=0; x<c1; x++)
{
m3[i][j]=0;
suma+=m1[i][x]*m2[x][j];
}
m3[i][j]=suma;
}
}
}
void escriure_resultat(matriu m, int f, int c)

{
int i,j;
for(i=0; i<f; i++)

for(j=0; j<c; j++)
printf("\nEl elemento [%d][%d] es:%d",i,j,m[i]
[j]);
printf("\n");
}
void main()
{
matriu A,B,C;
int filA,colA,filB,colB;
llegir_matriu(A, &filA, &colA);

llegir_matriu(B, &filB, &colB);
if(colA==filB)
{
multiplicar_matrius(A, B, C, filA, colA, colB);
escriure_resultat(C, filA, colB);
}
else printf("\nERROR EN LAS DIMENSIONES DE LAS MATRICES\n");
}
#define MAXDIM 15
#include <stdio.h>
void main ()
{
int i,j,k,nfa,nca,nfb,ncb,nfc,ncc;
int a[MAXDIM][MAXDIM],b[MAXDIM][MAXDIM],c[MAXDIM][MAXDIM];
/*Lectura de matrices*/
printf( "\nIntroduzca la matriz A:\n" );
printf( "Numero de filas:\n" );
scanf( "%d", &nfa );
printf( "\nNumero de columnas:\n" );
scanf( "%d", &nca );
if( nfa>MAXDIM || nca>MAXDIM || nfa<0 ||nca<0)

{
printf( "\nDimension erronea.\n" );
exit(-1);
}
for(i=0;i<nfa;i++)
for(j=0;j<nca;j++)
{
printf( "\nElemento A[%d][%d]:", i, j );
scanf( "%d", &a[i][j] );
}
printf( "\nIntroduzca la matriz B:\n" );

printf( "Numero de filas:\n" );
scanf( "%d", &nfb );
printf( "\nNumero de columnas:\n" );
scanf( "%d", &ncb );
if( nfb>MAXDIM || ncb>MAXDIM || nfb<0 ||ncb<0)

{
printf( "\nDimension erronea.\n" );
exit(-1);
}
if( nca != nfb )

{
printf( "\nEstas matrices no se pueden multiplicar.\n" );
exit(-1);
}
for(i=0;i<nfb;i++)
for(j=0;j<ncb;j++)
{
printf( "\nElemento B[%d][%d]:", i, j );
scanf( "%d", &b[i][j] );
}
/*Algoritmo de multiplicacion*/
nfc=nfa;
ncc=ncb;
for(i=0;i<nfc;i++)
for(j=0;j<ncc;j++)
{
c[i][j]=0;
for(k=0;k<nca;k++)
c[i][j]+=a[i][k]*b[k][j];
}

printf( "\n\n" );
for(i=0;i<nfc;i++)
{
printf( "[" );
for(j=0;j<ncc;j++)
printf( "%4d", c[i][j] );
printf( " ]\n" );
}
}
Escribir un programa que lea una frase del teclado y cuente los
espacios en blanco.
#include<stdio.h>
#define MAX 100
void main()
{
int i=0,cont=0;
char frase[MAX];
printf( "Escribir la frase acabada en punto(.):\n" );
while(frase[i]!='.')
{
i++;
}
i=0;
while(i<MAX && frase[i]!='.')
{
if(frase[i]==' ')
cont++;
i++;
}
printf( "La frase contiene %d blancos", cont );
}
Escribir un programa que, dada una cadena de caracteres y un entero

correspondiente a una posición válida dentro de ella, genere una
nueva cadena de caracteres que contenga todos los caracteres a la
izquierda de dicha posición
#include <stdio.h>
#include <string.h>
void main()
{
char C1[10],C2[10];
int i,j,k,c;
printf( "\nIntroduzca la posicion:" );

scanf( "%d%*c", &k );
printf( "\nIntroduzca el numero de elementos de la cadena:" );
scanf( "%d%*c", &c );
if( k<c && k>0 )

{
printf( "\nIntroduzca la cadena:\n" );
for(i=0; i<=c; i++)
{
printf( "Elemento %d:", i );
scanf( "%c%*c", &C1[i] );
}
j=0;
i=k;
do
{
C2[j]=C1[i];
j++;
i--;
} while(i>=0);
for(j=0; j<=k; j++)
printf( "%c", C2[j] );
printf( "\n" );
}
else
printf( "\nERROR\n" );
}
#define MAX 100
#include <stdio.h>
#include <string.h>
void main()
{
char chain[MAX],chaininv[MAX];
int i=0,num,len;
printf( "\nIntroduzca un frase acabada en '.':\n" );

scanf( "%c", &chain[i] );
while(chain[i]!='.' && i<MAX-1)

{
i++;
scanf("%c",&chain[i]);
}
if(chain[i]!='.'&& i==MAX-1)
{
printf( "\nCadena demasiado larga.\n" );
exit(-1);
}
chain[i+1]='\0';
len=strlen( chain ); /*numero de caracteres sin contar \0 */
printf( "\nIntroduzca la posicion de la cadena:" );

if(num<1 || num>len-1)
{
printf("\nPosicion no valida.\n");
exit(-1);
}
/* Inversion de la cadena */
for(i=0;i<num;i++)
chaininv[num-1-i]=chain[i];
chaininv[num]='\0';
printf("\nEl resultado es:\n");

puts( chaininv );
}
Escribir un programa que lea dos cadenas de caracteres, las compare

e informe de si son iguales o diferentes. No usar la función de la
librería estándar strcmp.
#include <stdio.h>
#define MAX 20
void main()
{
char C1[MAX],C2[MAX];
int i;
printf( "\nIntroduzca la primera palabra y pulse enter:\n" );

gets( C1 );
printf( "\nIntroduzca la segunda palabra y pulse enter:\n" );
gets( C2 );
i=0;
while ((C1[i]==C2[i]) && (C1[i]!='\0') && (C2[i]!='\0'))
i++;
if((C1[i]=='\0') && (C2[i]=='\0'))
printf( "Son iguales\n" );
else
printf( "Son diferentes" );
}
CRIBA DE ERATÓSTENES
Diseñar un programa que escriba los números primos que hay hasta un
número
natural pedido n. Utilizar la criba de Eratóstenes.
Suponer, para simplificar, que n es menor que 1000.
/*Programa que muestra todos los numeros primos hasta un natural n

pedido*/
/*Se sirve de la funcion Criba_Eratostenes*/
#include <stdio.h>
/*Maximo tamaño del vector: 1000*/

#define MAXNUM 5000
/*Funcion que criba los multiplos del primo criba en el vector*/

void Criba_Eratostenes(int vector[MAXNUM], int criba, int lon)
{
int i;
for (i=0; i<lon; i++)

{
if(vector[i]!=0)/*Si no esta cribado ya*/
/*Si es multiplo pero no es el primo, se
criba*/
if(((vector[i]%criba)==0)&&((vector[i]/criba)!
=1))
vector[i]=0;
}
}
void main()
{
int i, n, vector[MAXNUM];
/*Introduce los datos*/

printf("\nIntroduzca el entero:\n");
scanf("%d%*c", &n);
/*Se comprueba que no haya errores*/

if((n<1)||(n>MAXNUM))
printf("\nError, entero incorrecto\n");
else if(n==1)/*Caso facil*/

printf("\nNo hay primos\n");
else{
/*Se inicializa el vector*/
for(i=0;i<n-1;i++)
vector[i]=i+2;/*El 1 no es necesario, ya que no
es primo*/
/*Solo se analiza hasta la raiz cuadrada de n*/

for(i=0;(vector[i]*vector[i])<=n;i++)
{
if(vector[i]!=0)/*Solo se criban los primos*/
Criba_Eratostenes(vector, vector[i], n-
1);
}
/*Se muestra el resultado*/

for(i=0;i<n-1;i++)
if(vector[i]!=0)
printf("%d ", vector[i]);
}
}
ELEMENTO PERDIDO
Diseñar un programa que lea un vector de enteros consecutivos desde 0

hasta
un natural n (se puede considerar, para simplificar, n menor que 100),
excepto uno. El programa deberá decir qué entero falta.
Indicación: Sumar los elementos del vector.
/*Programa que, dado un vector de enteros consecutivos 0....n*/

/*encuentra cual falta*/
#include <stdio.h>

#define MAXNUM 100
void main()
{
int i, n, vector[MAXNUM], suma=0;
/*Introduce los datos y los suma*/

printf("\nIntroduzca el entero final:\n");
scanf("%d%*c", &n);
printf( "\nIntroduzca los enteros consecutivos excepto uno:\

n" );
printf( "Recuerde que la serie comienza en 0\n" );
for(i=0;i<n;i++)
{
scanf("%d%*c", &vector[i]);
suma+=vector[i];
}
/*La suma de 0...n es (n*(n+1))/2*/

printf("\nFalta el numero %d.\n",((n*(n+1))/2)-suma);
}
GENERAR MATRICES
Diseñar un programa que pida la dimensión n de una matriz cuadrada

n*n, y
luego dé a elegir entre las siguientes opciones:
- Generar una matriz en espiral:
1 2 3 4 5 6 7 8 9
32 33 34 35 36 37 38 39 10
31 56 57 58 59 60 61 40 11
30 55 72 73 74 75 62 41 12
29 54 71 80 81 76 63 42 13
28 53 70 79 78 77 64 43 14
27 52 69 68 67 66 65 44 15
26 51 50 49 48 47 46 45 16
25 24 23 22 21 20 19 18 17
-Generar una matriz en ángulo recto:
1 2 3 4 5 6 7 8 9
2 2 3 4 5 6 7 8 9
3 3 3 4 5 6 7 8 9
4 4 4 4 5 6 7 8 9
5 5 5 5 5 6 7 8 9
6 6 6 6 6 6 7 8 9
7 7 7 7 7 7 7 8 9
8 8 8 8 8 8 8 8 9
9 9 9 9 9 9 9 9 9
-Generar una matriz en diagonal:
1 2 3 4 5 6 7 8 9
2 3 4 5 6 7 8 9 8
3 4 5 6 7 8 9 8 7
4 5 6 7 8 9 8 7 6
5 6 7 8 9 8 7 6 5
6 7 8 9 8 7 6 5 4
7 8 9 8 7 6 5 4 3
8 9 8 7 6 5 4 3 2
9 8 7 6 5 4 3 2 1
-Generar una matriz en antidiagonal:
1 2 3 4 5 6 7 8 9
2 1 2 3 4 5 6 7 8
3 2 1 2 3 4 5 6 7
4 3 2 1 2 3 4 5 6
5 4 3 2 1 2 3 4 5
6 5 4 3 2 1 2 3 4
7 6 5 4 3 2 1 2 3
8 7 6 5 4 3 2 1 2
9 8 7 6 5 4 3 2 1
/*Programa que genera una matriz cuadrada*/

/*Posibilidades: espiral, angulo recto, diagonal, antidiagonal*/
/*Utiliza las funciones genera_cuadrado, espiral, diag, adiag,
lista_matriz*/
#include <stdio.h>
/*Maximo tamaño de la matriz: 20*20*/

#define MAXCOL 20
#define MAXFIL 20
/*Funcion que genera una vuelta de la espiral*/

int genera_cuadrado(int m[MAXFIL][MAXCOL], int cont, int n, int num)
{
/*cont es el numero de cuadrados introducidos ya en la matriz*/
/*n es la longitud del lado del cuadrado*/
/*num es el numero a introducir en cada momento*/
int i=cont, j=cont;
/*Introduce el lado superior del cuadrado: tiene longitud n*/

while(j<(cont+n))
{
m[i][j]=num;
num++;
j++;
}
/*j acaba desfasada*/
j--;
/*se continuara en la fila inferior: i=cont+1*/
i++;
/*Introduce el lado derecho del cuadrado: tiene longitud n-1*/

while(i<(cont+n))
{
m[i][j]=num;
num++;
i++;
}
/*i acaba desfasada*/
i--;
/*se continuara en la columna anterior: j=cont+n-2*/
j--;
/*Introduce el lado inferior del cuadrado: tiene longitud n-1*/

while(j>=cont)
{
m[i][j]=num;
num++;
j--;
}
/*j acaba desfasada*/
j++;
/*se continuara en la fila superior: i=cont+n-2*/
i--;
/*Introduce el lado izquierdo del cuadrado: tiene longitud n-

2*/
while(i>cont)
{
m[i][j]=num;
num++;
i--;
}
return(num);
}
/*Funcion que genera una matriz en espiral*/

void espiral(int m[MAXFIL][MAXCOL], int dim)
{
/*num es el numero introducido en la casilla inicial del
cuadrado*/
/*cont es el numero de vueltas introducidas*/
/*n es la longitud del lado del cuadrado*/
int num=1, cont=0, n=dim;
while(n>1)
{
/*Se genera una vuelta de la espiral*/
num=genera_cuadrado(m,cont,n,num);
cont++;
/*Se han introducido 2 hileras y 2 columnas, por lo

tanto*/
/*el lado del siguiente cuadrado se reduce en dos
unidades*/
n-=2;
}
if(n==1)/*solo queda introducir el centro de la espiral*/

m[dim/2][dim/2]=num;
/*si n==0, ya no queda introducir nada*/

}
/*Funcion que genera una matriz en angulo recto*/

void angulo_recto(int m[MAXFIL][MAXCOL], int n)
{
int i, j;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
/*La casilla esta en la diagonal o en el lado
vertical*/
if(i>=j)
m[i][j]=i+1;
/*La casilla esta en el lado horizontal*/

else
m[i][j]=j+1;
}
}
/*Funcion que genera una matriz paralelamente a la diagonal*/

void diag(int m[MAXFIL][MAXCOL], int n)
{
int i, j, num;
/*num es el numero a introducir en la matriz en todo momento*/
/*se introducen los numeros de debajo de la diagonal*/

for(num=n; num>1; num--)
{
j=0;
for(i=(num-1);i<n;i++)
{
m[i][j]=num;
j++;
}
}
/*se acaba con num==1*/
/*se introducen los numeros de la diagonal y de encima*/

while(num<=n)
{
i=0;
for(j=(num-1);j<n;j++)
{
m[i][j]=num;
i++;
}
num++;
}
}
/*Funcion que genera una matriz paralelamente a la antidiagonal*/

void adiag(int m[MAXFIL][MAXCOL], int n)
{
int i, j;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
/*La casilla esta encima o en la antidiagonal*/
if((i+j)<n)
m[i][j]=i+j+1;
/*La casilla esta por debajo de la

antidiagonal*/
else
m[i][j]=(2*n)-(i+j+1);
}
}
/*Funcion que lista en pantalla una matriz*/

void lista_matriz(int m[MAXFIL][MAXCOL], int n)
{
int i, j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
printf("%d\t", m[i][j]);
printf("\n\n");
}
}
void main()
{
char opcion='\0';
int n, matriz[MAXFIL][MAXCOL];
do{
/*Pide la dimension*/
printf("\nIntroduzca la dimension de la matriz:\n");
scanf("%d%*c",&n);
/*Comprueba que la dimension sea correcta*/

if(n<1)
printf("\nDimension no correcta\n");
else if(n>MAXCOL)
printf("\nDimension demasiado grande\n");
else
{
/*Muestra menu y pide la opcion*/
printf("\nElija opcion generadora:\n");
printf("\n1. Espiral");
printf("\n2. Angulo recto");
printf("\n3. Diagonal");
printf("\n4. Antidiagonal");
printf("\n5. Finalizar programa\n\n");
scanf("%c%*c",&opcion);
switch (opcion)
{
case '1':/*Espiral*/
printf("\nEspiral\n");
espiral(matriz,n);
lista_matriz(matriz, n);
break;
case '2':/*Angulo_recto*/
printf("\nAngulo recto\n");
angulo_recto(matriz, n);
break;
case '3':/*Diagonal*/
printf("\nDiagonal\n");
diag(matriz, n);
break;
case '4':/*Antidiagonal*/
printf("\nAntidiagonal\n");
adiag(matriz, n);
break;
case '5':
printf("\nFin del programa\n");
break;
default:
printf("\nOpcion incorrecta\n");
}
}
}while(opcion!='5');
}
INTERCAMBIO DE SEGMENTOS
Diseñar un programa que lea un vector (se puede suponer de enteros,

aunque
no es necesario).
El programa deberá pedir los márgenes (posición del primer y último

elemento)
de dos segmentos del vector, y luego intercambiar dichos segmentos.
Para ello puede ser de utilidad primero diseñar una función que gire
los
elementos de un segmento.
El funcionamiento de la función podría ser:
Vector: 0 1 2 3 4 5 6 7 8 9 10
Márgenes del segmento: 3 7
Resultado: 0 1 2 7 6 5 4 3 8 9 10
Y el del programa:
Vector: 0 1 2 3 4 5 6 7 8 9 10
Márgenes del primer segmento: 2 4
Márgenes del segundo segmento: 6 9
Resultado: 0 1 6 7 8 9 5 2 3 4 10
/*Programa que lee un vector de enteros*/

/*Intercambia las posiciones de dos segmentos cualesquiera del
vector*/
/*No se vale de ningun vector auxiliar*/
/*Utiliza la funcion girar_segmento*/
#include <stdio.h>
/*Maximo tamaño de un vector: 100*/

#define MAXNUM 100
void girar_segmento(int a, int b, int v[MAXNUM])

{
int aux;
while(a<b)
{
/*Se intercambian desde fuera hacia adentro*/
aux=v[a];
v[a]=v[b];
v[b]=aux;
a++;
b--;
}
}
void main()
{
int i, i1, i2, j1, j2, n, vector[MAXNUM];

printf("\nIntroduzca la longitud del vector:\n");
scanf("%d%*c", &n);
if(n<1)
{
printf( "Error en la dimension\n" );
exit(-1);
}
printf("\nIntroduzca los numeros del vector:\n");

for(i=0;i<n;i++)
scanf("%d%*c", &vector[i]);
printf( "Recuerde que las posiciones del vector son de 0 a dim-
1\n" );
printf("\nIntroduzca los margenes del primer segmento:\n");
scanf("%d%*c", &i1);
scanf("%d%*c", &i2);
if( i1<0 || i2>n-1 )
{
printf( "El segmento 1 excede las dimensiones del
vector\n" );
exit(-1);
}
printf("\nIntroduzca los margenes del segundo segmento:\n");

scanf("%d%*c", &j1);
scanf("%d%*c", &j2);
if( j1<0 || j2>n-1 )

{
printf( "El segmento 2 excede las dimensiones del
vector\n" );
exit(-1);
}
if( ( i1<=j1 && j1<=i2 ) || ( i1<=j2 && j2<=i2 ) )

{
printf( "Los segmentos se solapan\n" );
exit(-1);
}
/*Se efectua el intercambio*/

girar_segmento(i1, j2, vector);
girar_segmento(i1, i1+j2-j1, vector);
girar_segmento(i1+j2-j1+1, j2-(i2-i1+1), vector);
girar_segmento(j2-(i2-i1), j2, vector);

for(i=0;i<n;i++)
printf("%d ", vector[i]);
MATRIZ DE CAMINOS
Diseñar un programa que cree una matriz m*n, de tal manera que en cada
casilla se halle el número de caminos posibles que hay para llegar
desde
la casilla (1,1), hasta la casilla (j,k), donde j y k son mayores que
0.
Nota: Se considera que los únicos movimientos posibles son hacia la

derecha
y hacia abajo.
/*Programa que genera una matriz m*n*/
/*En cada casilla hay el numero de caminos posibles*/
/*para ir desde [0][0] hasta ella*/
/*Movimientos posibles: derecha, abajo*/
/*Utiliza la funcion lista_matriz*/
#include <stdio.h>
/*Maximo tamaño de la matriz: 20*20*/

#define MAXCOL 20
#define MAXFIL 20
/*Funcion que lista en pantalla una matriz*/

void lista_matriz(int m[MAXFIL][MAXCOL], int dim1, int dim2)
{
int i, j;
for(i=0;i<dim1;i++)
{
for(j=0;j<dim2;j++)
printf("%d\t", m[i][j]);
printf("\n\n");
}
}
void main()
{
int m, n, i, j, matriz[MAXFIL][MAXCOL];
/*Pide las dimensiones*/

printf("\nIntroduzca las dimensiones de la matriz:\n");
printf("\nNum.fil: ");
scanf("%d%*c",&m);
printf("\nNum.col: ");
scanf("%d%*c",&n);
/*Comprueba que la dimensiones sean correctas*/

if((m<1)||(n<1))
printf("\nDimensiones incorrectas\n");
else if((m>MAXFIL)||(n>MAXCOL))
printf("\nDimensiones demasiado grandes\n");
else
{
/*Inicializa la matriz(fila 0 y col 0 solo tienen
unos)*/
for(i=0;i<m;i++)
matriz[i][0]=1;
for(j=1;j<n;j++)
matriz[0][j]=1;
/*Se genera el resto de la matriz*/

/*El numero en una casilla es la suma de los
precedentes*/
for(i=1;i<m;i++)
for(j=1;j<n;j++)
matriz[i][j]= matriz[i-1][j] + matriz[i]
[j-1];
lista_matriz(matriz,m,n);
}
}
MEZCLA
Diseñar un programa que lea dos vectores ordenados crecientemente de

enteros
y que escriba un vector también ordenado de enteros que contenga todos
los
elementos comunes a los dos vectores.
En el caso de que un elemento esté repetido varias veces en ambos

vectores,
en el nuevo aparecerá también
/*Programa que lee dos vectores ordenados de enteros*/

/*Confecciona otro vector ordenado con todos sus elementos*/
/*Los elementos del vector nuevo no estan repetidos*/
#include <stdio.h>
/*Maximo tamaño de un vector: 100*/

#define MAXNUM 100
void main()
{
int i, j=0, k=0, m, n, v1[MAXNUM], v2[MAXNUM], v3[MAXNUM];

printf("\nIntroduzca la longitud del vector 1:\n");
scanf("%d%*c", &m);
printf("\nIntroduzca la longitud del vector 2:\n");

scanf("%d%*c", &n);
printf("\nIntroduzca los numeros del vector 1:\n");

for(i=0;i<m;i++)
{
printf( "\nv1[%d]= ", i );
scanf("%d%*c", &v1[i]);
}
printf("\nIntroduzca los numeros del vector 2:\n");

for(i=0;i<n;i++)
{
printf( "\nv2[%d]= ", i );
scanf("%d%*c", &v2[i]);
}
i=0;
while((i<m)&&(j<n))
{
/*Si se hallan en ambos varias veces, se introducen
varias veces*/
if(v1[i]==v2[j])
{
v3[k]=v1[i];
i++;
j++;
k++;
}
/*Se aumenta el menor*/

else if(v1[i]>v2[j])
{
v3[k]=v2[j];
k++;
j++;
}
else
{
v3[k]=v1[i];
k++;
i++;
}
}
/*Se finaliza en caso de no acabar juntos*/

while(i<m)
{
v3[k]=v1[i];
k++;
i++;
}
while(j<n)
{
v3[k]=v2[j];
k++;
j++;
}

printf("\nEl resultado de la mezcla es:\n");
for(i=0;i<k;i++)
printf("%d ", v3[i]);
}
ELEMENTOS POSITIVOS Y NEGATIVOS
Diseñar un programa que lea un vector de enteros y diga cuántos

elementos
positivos y negativos contiene
/*Programa que lee un vector de enteros*/

/*Calcula cuantos enteros positivos y negativos contiene*/
#include <stdio.h>

#define MAXNUM 100
void main()
{
int i, lon, contpos=0, contneg=0, vector[MAXNUM];
/*Pide la longitud del vector*/

printf("\nIntroduzca la longitud del vector:\n");
scanf("%d%*c",&lon);
/*Comprueba que la longitud sea correcta*/

if((lon<1)||(lon>MAXNUM))
{
printf("\nLongitud incorrecta\n");
exit(-1);
}
else
{
printf( "Introduzca los elementos del vector\n" );
/*Lee el vector*/
for(i=0;i<lon;i++)
scanf("%d%*c",&vector[i]);
/*Actualiza los contadores*/

for(i=0;i<lon;i++)
{
if(vector[i]<0)
contneg++;
else if(vector[i]>0)
contpos++;
}
printf("\nEl vector tiene %d positivos y %d negativos\

n",contpos,contneg);
}
}
Escribir un programa que, dadas dos fechas, indique cuál de las dos
es anterior a la otra. Para ello, el programa deberá definir una
estructura para el tipo de datos fecha (día, mes y año).
#include<stdio.h>
typedef struct
{
int dia;
int mes;
int a;
} Tfecha;
void main()
{
Tfecha f1,f2,f;
printf( "\nIntroduce las fechas a comparar(D M A):\n" );

scanf( "%d%d%d", &f1.dia, &f1.mes, &f1.a );
if(f1.a>f2.a)
f=f2;
else
f=f1;
if(f1.a==f2.a)
{
if(f1.mes>f2.mes)
f=f2;
else
f=f1;
if(f1.mes==f2.mes)
{
if(f1.dia>f2.dia)
f=f2;
else
f=f1;
}
}
printf( "La fecha mas antigua es: %d-%d-%d", f.dia, f.mes, f.a );
}
Definir una estructura de datos para representar polinomios de hasta

grado 10. Escribir un programa capaz de sumar dos polinomios
expresados con dicha estructura.
#include <stdio.h>
#define N 10
typedef struct
{
int coeficiente[N];
int grado[N]; /*Notese que no es necesaria la declaracion*/
/*de un vector. Es suficiente un unico
entero*/
} Tpolinomio;
void main()
{
Tpolinomio x,y,z;
int i,j,k,p,q,r;
printf( "\nIntroduzca el grado mayor del primer polinomio:" );

scanf( "%d", &q );
for(i=q; i>=0; i--)
{
printf( "Introduzca el coeficiente de grado %d:",i );
scanf( "%d", &x.coeficiente[i] );
x.grado[i]=i;
}
printf( "\nIntroduzca el grado mayor del segundo polinomio:" );

scanf( "%d", &p );
for(j=p; j>=0; j--)
{
printf( "Introduzca el coeficiente de grado %d:", j );
scanf( "%d", &y.coeficiente[j] );
y.grado[j]=j;
}
if(p>q)
k=p;
else
k=q;
for(r=k; r>=0; r--)

{
z.coeficiente[r]=0;
z.grado[r]=r;
}
r=k;
i=q;
j=p;
while(z.grado[r]>=0)
{
if(x.grado[i]==y.grado[j])
{
z.coeficiente[r]=x.coeficiente[i]+x.coeficiente[j];
i--;
j--;
}
else if(x.grado[i]>y.grado[j])
{
z.coeficiente[r]=x.coeficiente[i];
i--;
}
else if(y.grado[j]>x.grado[i])
{
z.coeficiente[r]=y.coeficiente[j];
j--;
}
r--;
}
printf( "\nEl polinomio resultante es:\n" );

for(r=k; r>=0; r--)
{
if(r>0)
printf( "%dx^%d + ",z.coeficiente[r], r );
else
printf( "%d\n", z.coeficiente[r] );
}
}
/*Realizado R.Vila*/
/*Suma de polinomios utilizando structs.*/
/*El orden logico de un programa es fundamental. La comprension puede
resultar una tarea dificil si no se tiene presente. A¤adir comentarios
en el codigo que expliquen la funcion de cada fragmento del programa
facilita
la lectura del mismo por parte de terceras personas, ya sean otros
programadores que realicen el mantenimiento del programa, ya sea el
corrector
de nuestro examen de I.O.
Tengase tambien presente que no se debe reservar mas memoria de la
estrictamente necesaria por lo que no es recomendable declarar un
numero
excesivo de variables.*/
#define N 11 /*grado 10 son 11 coeficientes*/

#include <stdio.h>
typedef struct
{
int coef[N];
int grado;
} poly;
void main()
{
poly p1,p2,ps;
int i,min;
/*Lectura de datos*/
printf( "\nGrado del polinomio 1:\t" );

scanf( "%d", &p1.grado );
if(p1.grado>N-1 || p1.grado<0)
{
printf( "\nGrado del polinomio erroneo.\n");
exit(-1);
}
for(i=0;i<p1.grado+1;i++)
{
printf( "\nCoeficiente de x^%d:\t", i );
scanf( "%d", &p1.coef[i] );
}
printf( "\nGrado del polinomio 2:\t" );

scanf( "%d", &p2.grado );
if(p2.grado>N-1 || p2.grado<0)
{
printf( "\nGrado del polinomio erroneo.\n");
exit(-1);
}
for(i=0;i<p2.grado+1;i++)
{
printf( "\nCoeficiente de x^%d:\t", i );
scanf( "%d", &p2.coef[i] );
}
/*Suma de polinomios*/
min= (p1.grado<p2.grado) ? p1.grado : p2.grado;
if(min==p1.grado)
ps.grado=p2.grado;
else
ps.grado=p1.grado;
for(i=0;i<min+1;i++)
ps.coef[i]=p1.coef[i]+p2.coef[i]; /*sumo los coef de los dos
poly*/
for(i=min+1;i<ps.grado+1;i++) /*completo, si es necesario,
el*/
{ /*poly suma con los
coeficientes*/
if(min==p1.grado) /*del poly de grado mayor*/
ps.coef[i]=p2.coef[i];
else
ps.coef[i]=p1.coef[i];
}
printf( "\nEl polinomio suma es:\n\t" );

for(i=ps.grado;i>0;i--)
printf( "(%d)x^%d + ", ps.coef[i], i );
printf( "(%d)", ps.coef[0] );
Escribir un programa que, dadas dos fechas, indique cuál de las dos
es anterior a la otra. Para ello, el programa deberá definir una
estructura para el tipo de datos fecha (día, mes y año).
#include<stdio.h>
typedef struct
{
int dia;
int mes;
int a;
} Tfecha;
void main()
{
Tfecha f1,f2,f;
printf( "\nIntroduce las fechas a comparar(D M A):\n" );

if(f1.a>f2.a)
f=f2;
else
f=f1;
if(f1.a==f2.a)
{
if(f1.mes>f2.mes)
f=f2;
else
f=f1;
if(f1.mes==f2.mes)
{
if(f1.dia>f2.dia)
f=f2;
else
f=f1;
}
}
printf( "La fecha mas antigua es: %d-%d-%d", f.dia, f.mes, f.a );
}
Dada la siguiente definición de tipo de datos:
typedef struct
{
Tstring pais;
int temp\_max;
int temp\_min;
} Ttemp;
escribir un programa que defina un vector con los datos de N países

y permita introducirlos por teclado. Finalmente, el programa deberá
mostrar el nombre de los países cuya temperatura mínima sea inferior
a la media de las temperaturas mínimas.
#include <stdio.h>
#include <string.h>
#define N 10
typedef char Tstring[10];
typedef struct
{
Tstring pais;
int temp_max, temp_min;
} Ttemppais;
typedef Ttemppais Ttemp[N];
void main()
{
Ttemp x;
int i,k;
float minmedia,min;
printf( "Escriba el numero de paises que quiere introducir:" );

scanf( "%d%*c", &k );
min=0;
for(i=1; i<=k; i++)

{
printf( "\nIntroduzca el nombre del pais:" );
scanf( "%s%*c", x[i].pais );
printf( "\nIntroduzca la temperatura minima:" );
scanf( "%d%*c", &x[i].temp_min );
min=min+x[i].temp_min;
}
minmedia=min/k;
printf( "\n Los paises con una temperatura minima inferior a la
media de todas las minimas son:\n" );
for(i=1; i<=k; i++)
{
if(minmedia>x[i].temp_min)
printf( "%s\n", x[i].pais );
}
}
Dada la siguiente definición de tipos de datos:

typedef char Tstring [50];
typedef struct
{
long int num;
char letra;
} Tnif;
typedef struct
{
Tnif nif;
Tstring nombre;
Tstring direc;
long int telf;
} Tempresa;
escribir un programa que defina un vector con los datos de N

empresas y permita introducirlos por teclado. Dado el NIF de una
empresa, el programa deberá permitir mostrar los datos de la misma,
así como eliminarla del vector, reorganizándolo para no dejar
espacios vacíos.

/*En la lectura y escritura de la direccion de la empresa no se ha
utilizado %s porque una direccion puede contener mas de una palabra*/
#include<stdio.h>
#define N 20
#define DIM 50
#define FALSE 0
#define TRUE !FALSE
typedef char Tstring[DIM];
typedef struct
{
long int num;
char letra;
} Tnif;
typedef struct
{
Tnif nif;
Tstring nombre,direc;
long int telf;
} Tempresa;
void main()
{
int i,j,contemp=0,pos,boolea=FALSE;
char c;
long int nif;
Tempresa bus[N];
/*Lectura de datos*/
i=0;
do
{
printf( "\nDesea introducir los datos de una nueva empresa?
(s/n): " );
scanf( "%c%*c", &c );
if(c=='s'||c=='S')
{
printf( "\nNombre: " );
scanf( "%s%*c", bus[i].nombre );
printf( "\nDireccion (acabada en '.'): " );

j=0;
do
{
scanf( "%c", &bus[i].direc[j] );
j++;
} while( bus[i].direc[j-1]!='.' && j<DIM-1 );
bus[i].direc[j]='\0';
printf( "\nTelefono:
scanf( "%ld%*c", &bus[i].telf "\nNIF (numero):",
&bus[i].nif.num (letra): "%c%*c", &bus[i].nif.letra
contemp++; i++;
}
else
c='n' /*Precaucion ante usuarios impredecibles* while( i><N
&& c!='n' );
/*Busqueda de empresas*/
do
{
printf( "\nDesea buscar una empresa: (s/n)
scanf( "%c%*c", &c
if(c=='s' || c=='S') "\nIntrduzca el NIF (numero): "%ld%*c",
&nif
for(i=0;i><contemp;i++)
{
if(nif==bus[i].nif.num)
{
pos=i;
boolea=TRUE;
}
}
/*Escritura de datos*/
if(boolea==TRUE)
{
printf( "\nLa empresa solicitada es:\n\t" );
printf( "Nombre: %s\n\t", bus[pos].nombre );
printf( "Direccion: " );

puts(bus[pos].direc);
printf( "\t" );
printf( "Telefono: %ld\n\t", bus[pos].telf );

printf( "NIF (numero): %ld\n\t", bus[pos].nif.num );
printf( "NIF (letra): %c\n", bus[pos].nif.letra );
/*Reordenacion del vector*/
for(i=pos;i>contemp-1;i++)
bus[i]=bus[i+1];
boolea=FALSE; contemp--;
}
else
printf( "\nEmpresa no registrada.\n" );
}
else
c='n';
} while( contemp>0 && c!='n' && c!='N' );
if(contemp==0)
printf( "\nNo quedan mas empresas registradas.\n" );
}
Definir una máscara y escribir la operación apropiada de

enmascaramiento para cada una de las situaciones descritas a
continuación:
a) Copiar los bits impares (1,3,5,...,15) y colocar ceros en las

posiciones pares (0,2,4,...,14) de un entero sin signo de 16 bits
representado por la variable v. Suponer que el bit 0 es el de más
a la derecha.
b) Eliminar el bit más significativo (el de la izda) de un carácter

de 8 bits representado por la variable c.
c) Copiar los bits impares y colocar unos en las posiciones pares

de un entero sin signo de 16 bits representado por la variable v.
Suponer que el bit 0 es el de más a la derecha.
d) Conmutar (invertir) los valores de los bits 1 y 6 de una cantidad

entera sin signo de 16 bits representada por la variable v,
preservando
el resto de los bits. Asignar el nuevo patrón de bits a v. Suponer que
el bit 0 es el de más a la dcha.
e) Tomar todos los bits de una determinada variable y asignarlos a

otra pero invertiendo el orden de cada uno de los bits.
/*Observaciones:
inicializaremos las variables implicadas con valores arbitrarios.
Para conseguir que la variable v sea de 16 bits hemos definido el tipo
T escogiendo unsigned short int. Esto puede variar de un compilador a
otro y
tambien en funcion de la arquitectura interna del computadoro del
sistema
operativo. Si al ejecutar el programa no visualizas v como variable de
16
bits deberas modificar la instruccion typedef.*/
#include <stdio.h>
typedef unsigned short int T;
void imprimir ( T v, int nbits, char apartado )

{
int m, bit, i;
printf( "\nEl resultado del apartado (%c) es:\n", apartado );
for( i=nbits-1; i>=0; i--)
{
m = 1 << i;
bit = ( v & m ) ? 1 : 0;
printf( "%d", bit );
}
}
void apartadoa( T v)
{
T m;
int i, nbits;
nbits = sizeof ( v ) << 3; /*multiplicamos por 8 para

transformar bytes en bits*/
/*Construimos una mascara adecuada: m=1010...10*/

for ( i=0; i < ( nbits >> 1); i++) /*el bucle dura hasta la
mitad de la mascara*/
m = ( m << 2 ) | 0x0002;
v = v & m;
imprimir ( v, nbits, 'a' );
return;
}
void apartadob( char c )

{
char ma;
int i, nbits, bit, m;
nbits = sizeof ( c ) << 3;
/*Construcción de la máscara*/
ma = (char) 0;
ma = ~ma;
ma = ma >> 1;
c = c & ma;
/*mostramos el resultado por pantalla*/

printf( "\nEl resultado del apartado (b) es:\n" );
{
m = 1 << i;
bit = ( c & m ) ? 1 : 0;
}
return;
}
void apartadoc( T v)
{
T m;
int nbits, i;
nbits = sizeof ( v ) << 3; /*multiplicamos por 8 para

transformar bytes en bits*/
/*igual que en (a) pero pre y post-negando la variable v*/
v = ~v;
for ( i=0; i < ( nbits >> 1); i++) /*el bucle dura hasta la
mitad de la mascara*/
m = ( m << 2 ) | 0x0002;
v = v & m;
v = ~v;
imprimir ( v, nbits, 'c' );
return;
void apartadod( T v )
{
T m;
int nbits;
int bit1, bit6;
nbits = sizeof ( v ) << 3;
/*mascara par el bit 1 y extraccion del bit*/

m = 1 << 1; /*bit 1 on*/
bit1 = ( v & m ) ? 1 : 0;
/*mascara para el bit 6 y extraccion*/
m = 1 << 6; /*bit 6 on*/
bit6 = ( v & m ) ? 1 : 0;
/*insertamos bit1 en la posicion 6*/

if ( bit1 )
v = v | m;
else
v = v & ~m;
/*insertamos bit6 en la posicion 1*/
m = 1 << 1;
if ( bit6 )
v = v | m;
else
v = v & ~m;
imprimir ( v, nbits, 'd' );
return;
void apartadoe( T v )
{
T m;
int i, nbits;
int bit[50];
for( i=0; i < nbits; i++ )

{
m = 1 << i;
bit[i] = ( v & m ) ? 1 : 0;
}
for ( i=nbits-1; i>=0; i-- )
{
m = 1 << ( (nbits - 1) - i );
if( bit[i] )
v = v | m;
else
v = v & ~m;
}
imprimir ( v, nbits, 'e' );

return;
}
void main()
{
const T v=0xa27d; /*v=(1010 0010 0111 1101)binario*/
char c='a'; /* c=(97)decimal= (0110 0001)binario*/
int nbits, m, bit, i;
/*Imprimimos los valores iniciales*/

printf ( "Los valores iniciales de v y c son:\nv=" );
{
m = 1 << i;
bit = ( v & m ) ? 1 : 0;
}
printf ( "\nc=" );
nbits = sizeof ( c ) << 3;
{
m = 1 << i;
bit = ( c & m ) ? 1 : 0;
}
printf ( "\n" );
apartadoa( v );
apartadob( c );
apartadoc( v );
apartadod( v );
apartadoe( v );
}
http://studies.ac.upc.edu/ETSETB/IO/LIBROC/frsref.htm
Escribir un programa para calcular el importe de una venta en un supermercado. El
usuario debe indicar el nombre del producto, el precio por unidad y el nº de unidades y
el programa sacará por pantalla el nombre del producto, el nº de unidades vendidas y el
precio total. Preste especial atención a qué tipo de datos resulta más adecuado para cada
representar cada cantidad.
Solución: puntvent.c
/*Terminal Punto de Venta*/

#include<stdio.h>
main()
{
char prod[25];
float preuni,total,dinero,cambio;
int nuni;
clrscr();
printf("\nElija el Producto a Comprar : " );
scanf("%s",&prod);
printf("\nIntroduzca el Precio por unidad : ");
scanf("%f",&preuni);
printf("\nIntroduzca las unidades que desea comprar : ");
scanf("%d",&nuni);
total=preuni*nuni;
printf("\nEl Total a Pagar es : %6.2f ",total);
printf("\nIntroduzca el importe con el cual pagara :" );
scanf("%f",&dinero);
cambio=dinero - total;
printf("\nEl cambio a devolver es : %6.2f ",cambio);
getch();
return 0;
}
Escribir un programa que calcule la nómina de un trabajador de la manera siguiente. El

trabajador cobra un precio fijo por hora y se le retiene un 5% en concepto de IRPF. El
programa debe pedir el nombre del trabajador, las horas trabajadas y el precio que cobra
por hora. Como salida debe imprimir el sueldo bruto, la retención y el sueldo neto
Solución: nomina1.c
/*
Nom del programa: NOMINA1.C
Descripcio:
Programa rudimentari que calcula la nomina d'un treballador
*/
#include <stdio.h>
#include <conio.h>
#define nRETIRPF 0.15
int main(void)
{
char cNom[30];
long nHores,nPreu;
float nSouBrut,nRetencio,nSouNet;
// Inicialitzaci?
clrscr();
// Entrada de dades
printf("Nom del treballador ? ");

scanf("%s",cNom);
printf("Quantes hores ha treballat? ");
scanf("%ld",&nHores);
printf("Quant cobra per hora? ");
scanf("%ld",&nPreu);
// Proces de les dades

nSouBrut = nHores * nPreu;
nRetencio = nSouBrut * nRETIRPF;
nSouNet = nSouBrut - nRetencio;
// Sortida dels resultats

printf("\nNom del treballador: %s\n", cNom);
printf("Sou Brut : %f\n", nSouBrut);
printf("Retenci? : %f\n", nRetencio);
printf("Sou Net : %f\n", nSouNet);
// Finalitzacio del programa

printf("\nPrem una tecla per continuar");
getch();
return 0;
}
Tema 2. Operadores y expresiones
1. Evaluar las siguientes expresiones:

(a) 5 / 2 + 20 % 6 (b) 4 * 6 / 2 - 15 / 2 (c) 5 * 15 / 2 / (4 - 2) (d) 8 == 16 || 7 != 4 && 4 < 1 (e) (4 * 3 < 6
+ 2 < 12
2. Suponiendo que a, b, c son variables enteras que tienen asignados los valores a=8, b=3, c=-5 determinar
siguientes expresiones:
a) a+b+c b) 2 * b + 3 * (a-c) c) a/b d) a%b e) a/c f) a%c g) a * b /c h) a * (b/c) i) (a*c)%b j) a * (c%b)
3. Suponiendo que previamente se ha realizado la declaración x=7, y=2: enteros, calcular el valor de la vari
evaluar cada una de las siguientes sentencias de asignación:
(a) y = -2 + --x; (b) y += 2; (c) y = (y == x); (d) y = y++ - x;
4. Escribir un programa que pida un número entero y saque por pantalla el cociente y el resto de la división
ambos.

5. Escribir un programa que pida una hora en segundos y la saque por pantalla en el formato “hh:mm:ss”, e
minutos y segundos
Solución: segund.c
/*Calcular Segun Segundos las Horas,Minutos y Segundos*/

#include<stdio.h>
main()
{
int entrada,hor,min,rest;
long seg;
clrscr();
printf("\Introduce la Cantidad de Segundos a Convertir :");
scanf("%d",&entrada);
if (entrada>3600){
hor=entrada / 3600;
rest=entrada % 3600;
min=rest/60;
seg=rest % 60;
}
else
if (entrada >60)
{
hor=entrada / 60;
rest=entrada % 60;
min=rest/60;
seg=rest % 60;
}
if (entrada <60)
{
seg=entrada;
}
printf("\nSon %d H. %d Min, %d Seg.",hor,min,seg);

getch();
return 0;
}
Tema 3. Estructuras de control (1). Estructuras

alternativas (bifurcaciones)
Escribir un programa que pida dos números y saque el mayor de ellos por pantalla. Una versión mejorad
los dos números son iguales.
Solución::
/*Calcular el Mayor de dos N?meros*/
#include <stdio.h>
main()
{
float a,b,mayor;
clrscr();
printf("\nEscribe el 1er N?mero : ");
scanf("%f",&a);
printf("\nEscribe el 2do N?mero : ");
scanf("%f",&b);
if (a>b)
{
printf("\nEl N?mero Mayor es : %6.2f ",a);
}
if (a<b)
{
printf("\nEl N?mero Mayor es : %6.2f ",b);
}
if (a==b)
{
printf("\n\aLos N?meros son Iguales");
}
getch();
2. Escribir un programa que pida un número e indique si se trata de un número par

Solución:
/*Calcular si el N?mero es Par*/
#include <stdio.h>
main()
int num,resto;
clrscr();
printf("\nIntroduce un N?mero cualquiera : ");
scanf("%d",&num);
resto=(num % 2);
if (resto!=0)
{
printf("\El N?mero introducido es Impar");
}
else
{
printf("\nEl N?mero introducido es Par");
}
getch();
return 0;
3. Escribir un programa que pida una nota e imprima por pantalla la calificación en formato “Apto” o “No
nota es mayor o menor que 5.
4. Escribir un programa que permita jugar a doble o nada: El jugador apuesta una cantidad y tira una mone
obtiene el doble de la cantidad apostada. Si sale cruz la pierde todo.
Solución:
/*Doble o Nada*/
#include <stdio.h>
#include<stdlib.h>
#include<time.h>
main()
{
float cantid,total;
float prob;
clrscr();
printf("\nSi sale Cara ganas el Doble si sale Cruz lo pierdes Todo\n");

printf("\nIntroduce la cantidad a Apostar : ");
scanf("%f",&cantid);
randomize();
prob=random(100) % 100;
if (prob<=50)
{
total=cantid*2;
printf("\nEnorabuena, su Cantidad es : %8.2f ",total);
}
else
{
total=0;
printf("\nLo Siento ha perdido Todo, Su cantidad es : 0 ");
}
getch();
return 0;
}
5. Escribir un programa que lea tres valores enteros y muestre por pantalla el máximo y el mínimo de ellos.
6. Escribir un programa que pida un número entero y determine si es múltiplo de 2 y de 5.
7. Escribir un programa que pida la nota de un examen (un nº real entre 0 y 10) e imprima por pantalla la ca
formato “Suspenso”, si la nota es menor que 5, “Aprobado” si está entre 5 inclusive y 7 sin incluir, “Not
7 inclusive y 9 sin incluir, “Sobresaliente” si está entre 9 inclusive y 10 sin incluir y “Matrícula de honor
igual a 10.
8. Escribir un programa que, dado el nombre o número del mes, y la información de si el año es bisiesto sa
el número de dias del mes
9. Escribir un programa que, pida la fecha de nacimiento de una persona e imprima por pantalla su signo zo
Tema 4. Estructuras de control (2). Estructuras

iterativas (repeticiones)
1. Modificar el programa del juego de doble o nada para que permita ir jugando hasta que el jugador decida
juego. El programa debe sacar por pantalla el número de jugadas y el total ganado por el jugador (si ha p
una cantidad negativa).
Solución:
/*Doble o Nada*/
#include <stdio.h>
#include<stdlib.h>
#include<time.h>
main()
{
float cantid,total,tgan,tper;
float prob;
int jug,gan,perd,cont;
clrscr();
jug=0;
gan=0;
perd=0;
do
{
jug=jug+1;
printf("\nSi sale Cara ganas el Doble si sale Cruz lo pierdes Todo\n");
printf("\nIntroduce la cantidad a Apostar : ");
scanf("%f",&cantid);
randomize();
prob=random(100) % 100;
if (prob<=50)
{
total=cantid*2;
printf("\nEnorabuena, su Cantidad es : %8.2f ",total);
gan=gan+1;
tgan=tgan+total;
printf("\n? Quieres Volver a Jugar ? 1=si 2=no: ");
scanf("%d",&cont);
}
else
{
total=0;
printf("\nLo Siento ha perdido Todo, Su cantidad es : 0 ");
perd=perd+1;
tper=tper+cantid;
printf("\n? Quieres Volver a Jugar ? 1=si 2=no: ");
scanf("%d",&cont);
}
}
while (cont!=2);
printf("\nEl Total de Jugadas es de ... %d .",jug);

printf("\nEl Total Ganado es .... %f .",tgan);
printf("\nEl Total de Partidas Ganadas es de ... %d .",gan);
printf("\nEl Total Perdido es .... %f .",tper);
printf("\nEl Total de Partidas Perdidas es de ... %d .",perd);
getch();
return 0;
}
2. Escribir un programa para jugar a adivinar un número entre 1 y 10 (generado al azar por el ordenador) ha
decirlos todos.
Solución:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
main()
{
int num,resp,inte;
clrscr();
num=random(10)+1;
printf("\nAdivina un N? del 1 al 10 : ");
scanf("%d",&resp);
inte=1;
while (num!=resp);
{
clrscr();
scanf("%d",&resp);
inte++;
}
printf("\Enorabuena el N? era .... %d ",num);
printf("\nEl N? de Intentos ha sido de ... %d .",inte);
getch();
return 0;
}
3. Uno de los usos más habituales para los bucles condicionales es la validación de entradas. Escribir un pr
una contraseña y permita tres intentos. Si el usuario da la contraseña correcta responde "Enhorabuena!" y
con este mensaje. En caso contrario el programa escribe "Lo siento, contraseña equivocada" y se cierra d
Solución:
/* Pide Contrase?a Con Do-While*/
#include<stdio.h>
#include<stdlib.h>
main()
int intent,ok,tu;
const CONTR=1525;
tu=0;
intent=0;
ok=0;
clrscr();
do
{
printf("\Escriba su Contrase?a ... ");
scanf("%d",&tu);
if (CONTR==tu)
ok=1;
else
intent=intent+1;
}
while((intent<=3)||(ok!=1));
if (intent==3)
printf("\nLo Siento Amigo, No puedes Entrar !! ");
else
printf("\nEnorabuena Ya puedes destrozar el Ordenador!! ");
getch();
return 0;
}
4. Escribir un programa que pida un número y saque por pantalla su tabla de multiplicar.
Solución:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
main()
{
int num,resp,inte;
clrscr();
num=random(10)+1;
scanf("%d",&resp);
inte=1;
while (num!=resp);
{
clrscr();
scanf("%d",&resp);
inte++;
}
printf("\Enorabuena el N? era .... %d ",num);
printf("\nEl N? de Intentos ha sido de ... %d .",inte);
getch();
return 0;
}
5. Escribir un programa para calcular el promedio de una lista de números positivos acabada en un número
6. Escribir un programa para sumar los números enteros de 1 a 100 utilizando
a. estructura (repetir) ; b. estructura (mientras) ; c. estructura (des de).
7. Escribir un programa que lea una lista de números y determine cuantos son positivos, y cuantos son nega
8. Escribir un programa que dados dos números, uno real (base) y un entero positivo (exponente), saque po
las potencias con base el numero dado y exponentes entre uno y el exponente introducido
9. Escribir un programa que imprima por pantalla los codigos ASCII correspondientes a los nº 32 al 127
Solución:
/*
LstASCII.C
Exemple d'estructura for per llistar el codi ASCII
*/
#include <stdio.h>
void main ()
{
int i;
clrscr ();
for (i=32; i<=255; i++)
{
printf ("%d=%c\t",i,i);
if ((i-31 % 9 )==0)
printf ("\n");
}
getch();
}
Tema 5. Estructuras de datos (1). Vectores, matrices y

cadenas
Vectores y matrices
1. Escribir un programa que lea diez números, los guarde en un vector y a continuación los imprima en ord
su entrada
2 Escribir un programa que lea tres números y los guarde en un vector. A continuación los ordenará y guar
ordenados en otro vector. Finalmente sacará ambas listas de números por la pantalla
3 Repetir el ejercicio anterior con un número cualquiera de valores
4 Escribir un programa que llene una matriz de 5 por 5 de valores aleatorios. A continuación el programa d
por pantalla. Opcional: El programa puede tambien imprimir las sumas de las filas y las columnas
5 Escribir un programa que pida un número e imprima por pantalla su tabla de sumar. Por ejemplo si el nú
tabla deberia ser:

+ 0 1 2 3

0 0 1 2 3

1 1 2 3 4

2 2 3 4 5

3 3 4 5 6
Cadenas de caracteres
1. Escribir un programa que pida una frase acabada en un punto y cuente las palabras que contiene.
2 Escribir un programa que pida una palabra y cuente el número de vocales y consonantes que contiene.
3 Escribir un programa que lea una frase y la escriba en mayúsculas
4 Escribir un programa que sirva para generar códigos de usuario por el procedimiento siguiente: Tiene qu
y los dos apellidos de una persona y devolver un código de usuario formado por las tres primeras letras d
apellido, las tres primeras letras del segundo apellido y las tres primeras letras del nombre. Por ejemplo,
entrada es: “JORDI GUINOVART SANTS” debe devolver “GUISANJOR”.
Tema 6. Funciones
1. Diseñar una función que calcule el promedio de varios números introducidos por el teclado. Hacer dos v
para un número fijo de valores y otra para un número cualquiera.de valores.
2 Escribir una función que intercambie el valor de dos variables, es decir si X=5 e Y=7 tras aplicar la func
haciendo "intercambiar(X,Y)" se tiene que X=7 e Y=5.
3 Diseñar una función que calcule la potencia enésima de un número, es decir que calcule X n para X, real
4 Diseñar una función "aMayusculas()" que convierta una cadena de texto en mayúsculas
5 Diseñar dos funciones "EurosAPesetas()" y "PesetasAEuros()" que realicen las conversiones de moneda
puedan utilizar directamente dentro de una expresion del tipo: "Imprimir valEuros son EurosAPts(valEu
5 Diseñar una función "EsBisiesto()" que decida si un año es bisiesto o no
6 Escribir una función "EsMultiplo" que sirva para determinar si un número es múltiplo de otra. Utilizarla
que pida la antiguedad de un trabajador y calcule cuantos trienios de antiguedad tiene.
7 Modularizar el programa nomina1.c utilizando tres funciones. Una para la entrada, una para los cálculos
salida de resultados
Solución:
/*
Nom del programa: NOMINA2.C
Descripci0:
Versio 2: Fa servir funcions per agrupar codi.
*/
#include <stdio.h>
#include <conio.h>
void LlegeixDades();
void Calcula();
void ImprimeixResultats();
void pausa();
char cNom[30];
long nHores,nPreu;
float nSouBrut, nRetencio,nSouNet;
int main(void)
{
// Inicialitzacio
clrscr();
// Entrada de dades
LlegeixDades();

Calcula();

ImprimeixResultats();

pausa();
return 0;
}
void LlegeixDades()
{
scanf("%s",cNom);
scanf("%ld",&nHores);
scanf("%ld",&nPreu);
}
void Calcula()
{
nSouBrut = nHores * nPreu;
nRetencio = nSouBrut * nRETIRPF;
nSouNet = nSouBrut - nRetencio;
}
void ImprimeixResultats()
{
printf("\nNom del treballador: %s\n", cNom);
printf("Sou Brut : %f\n", nSouBrut);
printf("Retenci? : %f\n", nRetencio);
printf("Sou Net : %f\n", nSouNet);
}
void pausa()
{
getch();
}
8 Repetir la modularización anterior utilizando funciones que pasen parámetros

Solución:
/*
Nom del programa: NOMINA3A.C
Descripcio:
Versio 3: Fa servir funcions per agrupar codi i
passa parametres per referencia
Estil C
*/
#include <stdio.h>
#include <conio.h>
void LlegeixDades(char Nom[30], long * Hores, long * Preu);

void Calcula(long Hores, long Preu,
long * SouBrut, float * Retencio, float * SouNet);
void ImprimeixResultats(char Nom[30],long SouBrut,
float Retencio, float SouNet);
void pausa();
char cNom[30];
long nHores,nPreu,nSouBrut;
float nRetencio,nSouNet;
int main(void)
{
// Inicialitzaci?
clrscr();
// Entrada de dades
LlegeixDades( &cNom, &nHores, &nPreu);

Calcula(nHores,nPreu,&nSouBrut,&nRetencio,&nSouNet);

ImprimeixResultats(cNom,nSouBrut,nRetencio,nSouNet);
pausa();

return 0;
}
void LlegeixDades(char Nom[30],long * Hores, long * Preu)

{
scanf("%s",Nom);
scanf("%ld",Hores);
scanf("%ld",Preu);
}
void Calcula(long Hores, long Preu, long * SouBrut, float *Retencio, float *SouNet)
{
* SouBrut = Hores * Preu;
* Retencio = * SouBrut * nRETIRPF;
* SouNet = * SouBrut - (*Retencio);
}
void ImprimeixResultats(char Nom[30],long SouBrut, float Retencio, float SouNet)

{
printf("\nNom del treballador: %s\n", Nom);
printf("Sou Brut : %ld\n", SouBrut);
printf("Retenci? : %f\n", Retencio);
printf("Sou Net : %f\n", SouNet);
}
void pausa()
{
getch();
}
9 Hacer un programa salarios.c que utilice las funciones anteriores dentro de un bucle para calcular las no
numero indeterminado de trabajadores
10 Escribir dos funciones Entrada() y Salida() que incluyan todas las operaciones de entrada de datos y sali
para el programa del ejercicio nº 1.5 (terminal punto de venta)

Programas en C

Cargado por

Copyright:

Formatos disponibles

Programas en C

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programas en C

Cargado por

Copyright:

Formatos disponibles

Programa que convierte de metros a pies y pulgadas.

printf("\nValor en metros: ");

Programa que realiza las cuatro operaciones aritméticas fundamentales (+,-,*,/).

printf("\nPrimer numero: ");

printf("\nEl resultado de la operacion %d %c %d es

Programa que lee los tres lados de un triᮧulo y detecta el tipo.

printf("\nValor del primer lado: ");

printf("\nValor del segundo lado: ");

printf("\nValor del tercer lado: ");

if((uno==dos) && (dos==tres) && (uno==tres))

else if((uno!=dos) && (dos!=tres) && (uno!=tres))

Programa que lee las edades de un grupo de alumnos y encuentra el promedio.

printf("\nNumero de alumnos: ");

printf("\nEdad alumno %d: ",counter);

Función que lee calificaciones (0-10) de alumnos y cuente el numero de alumnos

int numreprob(int not);

int numreprob(int not){

printf("\nCalificacion de la nota %d: ",c);

void despliega(int *mats,char *califs,int numcap);

printf("\n *** Introduce la matricula y su calificacion. ***");

void despliega(int *mats,char *califs,int numcap){

Programa que despliega una tabla de conversión entre oC a oF y viceversa. El programa

void despliegaFC(int *ran1,int *ran2,int *inc);

printf(" TABLA DE CONVERSION DE GRADOS CENTIGRADOS A GRADOS

printf("\n\nTipo de Conversion (C o F): ");

void leeDatos(int *ran1,int *ran2,int *inc){

printf("\n\nValor inicial de la tabla: ");

printf("\n\nIncremento de los valores de la tabla: ");

void despliegaCF(int *ran1,int *ran2,int *inc){

void despliegaFC(int *ran1,int *ran2,int *inc){

int myatoi(char *s);

printf("Introduce la cadena: ");

int myatoi(char *s){

int mystrlen(char *s);

printf("Introduce la cadena: ");

int mystrlen(char *s){

void main(int np, char *ps[]){

Programa que recibe en la l�a de comando un n? flotante, un caracter que represente

void main(int narg,char *sarg[]){

printf("PROGRAMA QUE CALCULA UNA OPERACION ARITMETICA SIMPLE ENTRE

Editor de textos con arreglo de cadenas.

void inserta(char t[][50],int *ll,int act,int max);

void lista(char t[][50],int *ll){

void modif_actual(int *act,int ll){

printf("\n\nIndica el numero de la linea a posicionar: ");

if(v<=ll && v!=0){

void reemplaza_linea(char t[][50],int ll,int *act){

printf("\n\nIntroduce la nueva linea: ");

void inserta(char t[][50],int *ll,int act,int max){

Directorio telef󮩣o con manejo de archivos.

FILE *pack(FILE *a);

void imprime(FILE *a){

void lee(FILE *a){

long busca_Clave2(FILE *a,char buscado[]){

void consulta2(FILE *a){

void ordena(FILE *a){

FILE *pack(FILE *a){

printf("\n\nDame el nombre a dar de baja: ");

Pedir la base y la altura de un rectángulo, calcular su área y su

void despliega(int mats,char califs,int numcap);

printf("\n * Introduce la matricula y su calificacion. *");

void despliega(int mats,char califs,int numcap){

void despliegaFC(int ran1,int ran2,int *inc);

void leeDatos(int ran1,int ran2,int *inc){

void despliegaCF(int ran1,int ran2,int *inc){

void despliegaFC(int ran1,int ran2,int *inc){

FILE pack(FILE a);

FILE pack(FILE a){

area=(basealtura)/2.0; /notese que el 2 ahora es 2.0*/

/Realizaci¢n con el operador condicional ? punto 4.2 del libro/

/Realizado por R. Vila/

/Realizado por R.Vila/

/Realizado por R.Vila/

/Realizacion con estructura for/

/Realizado por R. Vila/

/Realizado por R.Vila/

/Realizacion por R.Vila/

/Programa que calcula si un numero es primo o no/

/solo aumenta el divisor hasta la raiz cuadrada de x,/

/Antes comprueba que sea un numero natural/