2012

Informtica I: Ejercicios
Resueltos
Practica 1...............................................................................3
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio

1.1........................................................................................................ 3
1.2........................................................................................................ 3
1.3........................................................................................................ 4
1.4........................................................................................................ 5
1.5........................................................................................................ 6
1.6........................................................................................................ 6
1.7........................................................................................................ 7
1.8........................................................................................................ 8
1.9........................................................................................................ 9
1.10.................................................................................................... 11
1.11.................................................................................................... 13
1.12.................................................................................................... 14
1.13.................................................................................................... 16
1.14.................................................................................................... 17
1.15.................................................................................................... 19
1.16.................................................................................................... 22
1.17.................................................................................................... 23
1.18.................................................................................................... 25
1.19.................................................................................................... 26
1.20.................................................................................................... 29

Practica 2.............................................................................31
Estructuras de repeticin......................................................31
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio

2.1...................................................................................................... 31
2.2...................................................................................................... 31
2.3...................................................................................................... 32
2.4...................................................................................................... 33
2.5...................................................................................................... 34
2.6...................................................................................................... 35
2.7...................................................................................................... 36
2.8...................................................................................................... 38
2.9...................................................................................................... 39
2.10.................................................................................................... 40
2.11.................................................................................................... 42
2.12.................................................................................................... 44
2.13.................................................................................................... 46
2.14.................................................................................................... 47

2012
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio

2.15.................................................................................................... 49
2.16.................................................................................................... 50
2.17.................................................................................................... 52
2.18.................................................................................................... 54
2.19.................................................................................................... 55
2.20.................................................................................................... 56
2.21.................................................................................................... 57

Practica 3.............................................................................59
Arreglos...............................................................................59
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio
Ejercicio

3.1...................................................................................................... 59
3.2...................................................................................................... 60
3.3...................................................................................................... 60
3.4...................................................................................................... 66
3.5...................................................................................................... 75
3.6...................................................................................................... 77
3.7...................................................................................................... 79

Practica 4.............................................................................81
Funciones.............................................................................81
Ejercicio 4.1...................................................................................................... 81
Ejercicio 4.2...................................................................................................... 82
Ejercicio 4.3...................................................................................................... 84
Ejercicio 4.4...................................................................................................... 86
Ejercicio 4.5...................................................................................................... 88
Ejercicio 4.6...................................................................................................... 88
Ejercicio 4.7...................................................................................................... 90
Ejercicio 4.8...................................................................................................... 92
Ejercicio 4.9...................................................................................................... 94
Ejercicio 4.10.................................................................................................... 95
Ejercicio 4.11.................................................................................................... 96
Ejercicio 4.12.................................................................................................... 98
Ejercicio 4.13.................................................................................................. 107
Ejercicio 4. 14................................................................................................. 112

2012

Practica 1
Ejercicio 1.1
Elaborar un programa en el que se ingrese un nmero y que muestre el resto de dividirlo por
2. Lo
debe mostrar justificado hacia la derecha en 10 espacios.
#include <stdio.h>
#include <stdlib.h>

int main()
{
int num;
printf("Por favor, ingrese el numero:\n");
scanf("%d", &num);
printf("

%d/2=%d\n

resto:%d", num, num/2, num%2);

return 0;
}

Ejercicio 1.2
Realizar un programa en el que se ingrese la base y la altura de un tringulo e informe su
superficie. El programa debe imprimir una leyenda que incluya los datos de entrada y el
resultado
con una precisin de 2 dgitos decimales.
Ejemplo:
Ingrese la base del tringulo: 8
Ingrese la altura del tringulo: 5
La superficie del triangulo de base 7 y altura 5 es 17.50
#include <stdio.h>
#include <stdlib.h>

2012
int main()
{
double base, alt, sup;
printf("Ingrese la base del triangulo:");
scanf("%lf", &base);
printf("Ingrese la altura del triangulo:");
scanf("%lf", &alt);
sup=base*alt/2;
printf("La superficie del triangulo de base %.2lf y altura %.2lf es %.2lf", base,
alt, sup);
return 0;
}

Ejercicio 1.3
Elaborar un programa en el que se ingrese por teclado un nmero real y, a continuacin, se
muestre la parte entera de dicho nmero y la parte fraccionaria (por separado).
Ejemplo:
Ingrese numero: 48.151
Parte entera: 48
Parte fraccionaria: 0.151
#include <stdio.h>
#include <stdlib.h>

int main()
{
double num, Fnum, Enum;
printf("Ingrese numero: ");
scanf("%lf", &num);
Fnum=num-(int)num;
Enum=num-Fnum;

2012
printf("Parte entera: %g\n", Enum);
printf("Parte fraccionaria: %g\n", Fnum);
return 0;
}

Ejercicio 1.4
Desarrollar un programa en el que se ingrese un nmero de 5 dgitos y que luego muestre
cada
dgito separado por un guin.
Ejemplo:
Ingrese numero: 45212
Separacion en dgitos: 4-5-2-1-2.
#include <stdio.h>
#include <stdlib.h>

int main()
{
int num, num1, num2, num3, num4, num5;
printf("Ingrese numero: ");
scanf("%d", &num);
num5=num%10;
num=num/10;
num4=num%10;
num=num/10;
num3=num%10;
num=num/10;
num2=num%10;
num=num/10;
num1=num%10;
//lo hice asi choto a proposito podria haber validado y usado un while. includo un
arreglo.

2012
printf("Separacion en digitos: %d-%d-%d-%d-%d.\n", num1, num2, num3, num4,
num5);
return 0;
}

Ejercicio 1.5
Hacer un programa en el que se ingrese la medida de los catetos de un tringulo rectngulo
y que
se calcule y muestre el permetro de dicho tringulo. Incluir math.h a fin de utilizar la funcin
sqrt(expresin) que calcula la raz cuadrada de un nmero.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main()
{
double ct1,ct2, perim;
printf("Ingrese el primer cateto: ");
scanf("%lf", &ct1);
printf("Ingrese el segundo cateto: ");
scanf("%lf", &ct2);
perim=ct1+ct2+sqrt(ct1*ct1+ct2*ct2);
printf("El perimetro del triangulo ingresado mide %.2lf", perim);

return 0;
}

Ejercicio 1.6
Elaborar un programa en el que se ingrese una cantidad expresada en segundos y luego la
exprese en das, horas, minutos y segundos.
Ejemplo:
Ingrese tiempo en segundos: 93714
6

2012
1 dia(s), 2 hora(s), 1 minuto(s), 54 segundo(s).
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main()
{
int num, seg, dias, horas, min;
printf("Ingrese tiempo en segundos: ");
scanf("%d", &num);
seg=num%60;
num=num/60;
min=num%60;
num=num/60;
horas=num%24;
dias=num/24;
printf("%d dia(s), %d hora(s), %d minuto(s), %dsegundo(s)", dias, horas, min,
seg);
return 0;
}

Ejercicio 1.7
Desarrollar un programa en el que se ingresen dos nmeros enteros positivos y que genere
y
muestre un tercer numero que est compuesto por las unidades del primer nmero y por las
decenas del segundo.
Ejemplo:
Ingrese el primer numero: 427
Ingrese el segundo numero: 52
El numero resultante es: 57
#include <stdio.h>
#include <stdlib.h>

2012

int main()
{
int num1, num2, res;
printf("Ingrese el primer numero: ");
scanf("%d", &num1);
printf("Ingrese el segundo numero: ");
scanf("%d", &num2);
num2=num2/10;
num2=num2%10;
num1=num1%10;
res=num1+num2*10;
printf("El numero resultante es: %d", res);
return 0;
}

Ejercicio 1.8
Hacer un programa que calcule las races reales de una ecuacin cuadrtica. El usuario
ingresar
los coeficientes a, b y c tal que ax + bx + c=0. Cuando las races no sean reales, se
mostrar un
mensaje indicando esta situacin.
Ejemplo:
Ingrese coeficiente a: 2
Ingrese coeficiente b: 3
Ingrese coeficiente c: 1
La raz 1 es: 0.50
La raz 2 es: 1.00
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main()

2012
{
double a, b, c, x1, x2, d;
printf("Ingrese coeficiente a: ");
scanf("%lf", &a);
printf("Ingrese coeficiente b: ");
scanf("%lf", &b);
printf("Ingrese coeficiente c: ");
scanf("%lf", &c);
d=b*b-4*a*c;
if(d<0)
{
printf("Las raices no son reales.");
}
else
{
d=sqrt(d);
x1=(b+d)/(2*a);
x2=(b-d)/(2*a);
printf("La raz 1 es: %.2lf", x1);
printf("\nLa raz 2 es: %.2lf", x2);
}

return 0;
}

Ejercicio 1.9
Escriba un programa en el que se ingresen 2 nmeros y un carcter (+,-,*,/) e informe el
resultado
de la operacin.
Ejemplo:
9

2012
Ingrese el primer nmero: 8
Ingrese el segundo nmero: 2
Ingrese la operacin (+,-,
*, /): +
8 + 2 =10

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

int main()
{
int num1, num2;
char sign;
printf("Ingrese el primer numero: ");
scanf("%d", &num1);
printf("Ingrese el segundo numero: ");
scanf("%d", &num2);
printf("Ingrese la operacion (+,-,*, /): ");
sign=getche();
printf("\n");
switch (sign)
{
case '+':
printf("%d+%d=%d",num1, num2, num1+num2);
break;
case '-':
printf("%d-%d=%d",num1, num2, num1-num2);
break;
case '*':

10

2012
printf("%d*%d=%d",num1, num2, num1*num2);
break;
case '/':
if (num2!=0)
printf("%d/%d=%d",num1, num2, num1/num2);
else
printf("El denominador no puede ser igual a 0");
break;
default:
printf("El caracter ingresado es incompatible");
break;
}

return 0;
}

Ejercicio 1.10
Realizar un programa en el que se ingresen por teclado 3 letras que pueden ser maysculas
o
minsculas (no necesariamente todas del mismo tipo). A continuacin el programa deber
indicar
cul se encuentra primero en el alfabeto.
#include <stdio.h>
#include <conio.h>
//el programa verifica el dato pero muy primitivamente... necesitaria un while
para hacerlo en serio.
int main()
{
char let1, let2, let3,l1, l2, l3;
printf("Ingrese la primer letra: ");

11

2012
l1=getche();
if(l1>='a'&&l1<='z')
let1=l1;
else
{
if(l1>='A'&&l1<='Z')
let1=l1+32;
}
printf("\nIngrese la segunda letra: ");
l2=getche();
if(l2>='a'&&l2<='z')
let2=l2;
else
{
if(l2>='A'&&l2<='Z')
let2=l2+32;
}
printf("\nIngrese la tercera letra: ");
l3=getche();
if(l3>='a'&&l3<='z')
let3=l3;
else
{
if(l3>='A'&&l3<='Z')
let3=l3+32;
}

12

2012
if(let1<let2&&let1<let3)
printf("\nLa letra que aparece primero en el alfabeto es '%c'", l1);
else
{
if(let2<let1&&let2<let3)
printf("\nLa letra que aparece primero en el alfabeto es '%c'", l2);
else
{
if(let3<let2&&let3<let1)
printf("\nLa letra que aparece primero en el alfabeto es '%c'", l3);
}
}
return 0;
}

Ejercicio 1.11
Hacer un programa en el que se ingrese un nmero real y que se muestre si el nmero es
positivo, negativo o cero. Adicionalmente deber indicar si es natural, entero o real.
Ejemplo:
Ingrese un nmero: 13.4
El nmero es positivo y real.
#include <stdio.h>
#include <stdlib.h>

int main()
{
double num;
printf("Ingrese numero\n");
scanf("%lf", &num);
if(num>0)
13

2012
{
if(num-(int)num==0)
printf("el numero es positivo y natural");
else
printf("el numero es positivo y real");
}
else
{
if(num==0)
printf("el numero es 0");
else
if(num-(int)num==0)
printf("el numero es negativo y entero");
else
printf("el numero es negativo y real");
}
return 0;
}
nmero es positivo y real.

Ejercicio 1.12
Realizar un programa que solicite al usuario ingresar una letra. Si la letra es mayscula,
debe
convertirla a minscula y viceversa. Luego deber informar si la letra ingresada es una vocal
o una
consonante. Cualquier otro caracter ingresado debe ser impreso sin modificaciones pero
indicando que no se trata de una letra.
Ejemplo 1:
Ingrese una letra: a
La letra ingresada es una vocal. Su mayscula es A.
Ejemplo 2:
Ingrese una letra: $
No se ingres una letra.

14

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

int main()
{
char letr;
printf("Ingrese una letra: ");
letr=getche();
printf("\n");
if(letr>='a'&&letr<='z')
{
if(letr=='a'||letr=='e'||letr=='i'||letr=='o'||letr=='u')
printf("la letra ingresada el vocal. Su mayuscula es %c", letr-32);
else
printf("La letra ingresada el consonante. Su mayuscula es %c", letr-32);
}
else
{
if(letr>='A'&&letr<='Z')
{
if(letr=='A'||letr=='E'||letr=='I'||letr=='O'||letr=='U')
printf("la letra ingresada el vocal. Su minuscula es %c", letr+32);
else
printf("La letra ingresada el consonante. Su minuscula es %c", letr+32);
}
else

15

2012
printf("El caracter no es una letra");
}
return 0;
}

Ejercicio 1.13
Realizar un programa en el que se ingresen dos nmeros enteros positivos. Luego deber
restar
el mayor del menor e indicar si dicha diferencia es un valor que est entre ambos nmeros
(es
decir, es mayor que el ms chico y menor que el ms grande de los ingresados).
#include <stdio.h>
#include <stdlib.h>

int main()
{
int num1, num2, res;
printf("Ingrese un numero: ");
scanf("%d", &num1);
printf("Ingrese otro numero: ");
scanf("%d", &num2);
if(num1>=num2)
{
res=num1-num2;
if(res>=num2&&res<=num1)
printf("\nEl numero resultante de la resta esta entre los dos intresados");
else
printf("\nEl numero resultante de la resta NO esta entre los dos
intresados");
}

16

2012
else
{
res=num2-num1;
if(res>=num1&&res<=num2)
printf("\nEl numero resultante de la resta esta entre los dos intresados");
else
printf("\nEl numero resultante de la resta NO esta entre los dos
intresados");
}

return 0;
}

Ejercicio 1.14
Elaborar un programa que calcule el impuesto que se aplica a una cierta compra de la
siguiente
forma:
Si el importe de una compra es mayor a $500.- el impuesto ser del 16%.
En caso contrario, el impuesto ser del 18%.
Sin embargo, ante la escasez de monedas de 1 centavo, el importe final de la compra debe
ser
redondeado, en favor del cliente, hasta un mltiplo de 5 centavos. Es decir, si el importe
fuera de
$5,17.- entonces la suma a abonar sera $5,15.-. El programa debe solicitar el ingreso de la
compra y calcular y mostrar el subtotal (compra + impuesto) y el total a abonar (subtotal
redondeado).
Ejemplo:
Valor de la compra: 521
Subtotal: 604.36
Importe a abonar: 604.35
#include <stdio.h>
#include <stdlib.h>
//lo hice pensando en el redondeo clasico. si queres redondeo del tipo q hacen
en el supermercado, hasta seria mas facil. if(num>5){num=5;}else{num=0;}

17

2012
int main()
{
double compra, subtotal, importe, num;
printf("Valor de la compra: ");
scanf("%lf", &compra);
if(compra>500)
{
subtotal=compra+compra*0.16;
}
else
{
subtotal=compra+compra*0.18;
}
num=subtotal*10;
importe=(int)num;
num=subtotal*100-importe*10;
if(num>=2.5&&num<=7.5)
{
num=5;
}
else
{
if(num>7.5)
num=10;
else
num=0;

18

2012
}
importe=importe/10+num/100;
printf("\nSubtotal: %.2lf", subtotal);
printf("\nImporte a abonar: %.2lf", importe);

return 0;
}

Ejercicio 1.15
Realizar un programa que solicite una fecha. El usuario ingresar el da, el mes y el ao por
separado. Luego el programa mostrar una leyenda que indique si la fecha ingresada es
vlida.
Ejemplo:
Ingrese el da: 29
Ingrese el mes: 2
Ingrese el ao: 2000
La fecha es correcta.
Casos de prueba para (verificar si el ejercicio fue hecho correctamente)
29/2/2000 es correcta
31/4/2008 es incorrecta
28/2/2000 es correcta
32/7/2005 es incorrecta
29/2/2012 es correcta
8/13/2007 es incorrecta
5/12/1903 es correcta
29/2/1900 es incorrecta
Ayuda: Para saber si un ao es bisiesto: Si el ao es divisible por 4, es bisiesto
siempre y cuando
no sea divisible por 100. Cuando el ao es divisible por 100 tambin debe ser
divisible por 400.
Por ejemplo: el ao 2000 es bisiesto pero el 1800 no lo es.
#include <stdio.h>
#include <stdlib.h>

int main()
{
int dia, mes, anio, sen=0;
printf("Ingrese el dia: ");

19

2012
scanf("%d", &dia);
printf("Ingrese el mes: ");
scanf("%d", &mes);
printf("Ingrese el anio: ");
scanf("%d", &anio);
if(anio%4==0)
{
if(anio%100==0)
{
if(anio%400==0)
sen=1;
}
else
{
sen=1;
}
}
if(mes<=12)
{
if(mes==1||mes==3||mes==5||mes==7||mes==8||mes==10||
mes==12)
{
if(dia<=31)
printf("%d/%d/%d es correcta", dia, mes, anio);
else
printf("%d/%d/%d es incorrecta", dia, mes, anio);
}

20

2012
else
{
if(mes==2)
{
if(dia<=28)
printf("%d/%d/%d es correcta", dia, mes, anio);
else
{
if(sen==1&&dia<=29)
printf("%d/%d/%d es correcta", dia, mes, anio);
else
printf("%d/%d/%d es incorrecta", dia, mes, anio);
}

}
else
{
if(dia<=30)
printf("%d/%d/%d es correcta", dia, mes, anio);
else
printf("%d/%d/%d es incorrecta", dia, mes, anio);
}
}
}
return 0;
}

21

2012

Ejercicio 1.16
Elaborar un programa que solicite al usuario que ingrese un nmero real y luego muestre el
Redondeo al entero ms prximo de dicho nmero, el Piso y el Techo.
Definiciones
Redondeo: Si la parte decimal es mayor o igual a 0,5, se redondea hacia arriba. Caso
contrario,
hacia abajo.
Piso: El entero ms prximo hacia abajo.
Techo: El entero ms prximo hacia arriba.
Casos de prueba para (verificar si el ejercicio fue hecho correctamente):
Ejemplo 1:
Ingrese un numero real: 5.3
Redondeo = 5
Piso = 5
Techo = 6
Ejemplo 2:
Ingrese un numero real: 8
Piso = 8
Techo = 8
Redondeo = 8
Ejemplo 3:
Ingrese un numero real: 8.92
Piso = 8
Techo = 9
Redondeo = 9
Ejemplo 4:
Ingrese un numero real: 8.6
Piso = 9
Techo = 8
Redondeo = 9
#include <stdio.h>
#include <stdlib.h>

int main()
{
double num;
int piso, techo, redondeo;
printf("Ingrese el numero: ");
scanf("%lf", &num);

22

2012
if(num-(int)num>=0.5)
redondeo=num+1;
else
redondeo=num;
piso=num;
techo=num+1;
printf("\nRedondeo: %d", redondeo);
printf("\nTecho: %d", techo);
printf("\nPiso: %d", piso);
return 0;
}

Ejercicio 1.17
Realizar un programa que solicite 3 notas de parciales obtenidas por un alumno. A
continuacin
se mostrar por pantalla un mensaje que indique la situacin del alumno:
Si el alumno aprob los 3 parciales (nota 4 o ms) y su promedio es mayor a 7,
promociona la materia con la nota promedio.
Si el alumno aprob los 3 parciales pero su promedio no supera los 7 puntos, debe rendir
examen final.
Si el alumno no aprob uno o ms parciales, se solicitar que se ingrese la nota de un
recuperatorio. Si ste hubiera sido aprobado, se informar el promedio general (3 parciales
+ el recuperatorio) y su condicin de aprobado (an cuando el promedio no supere los 4
puntos). Si no hubiera aprobado el recuperatorio se informar que el alumno fue aplazado.
Ejemplo:
Ingrese la nota del primer parcial: 2
Ingrese la nota del segundo parcial: 6
Ingrese la nota del tercer parcial: 2
Ingrese la nota del recuperatorio: 4
Promedio general = 3.5. El alumno deber rendir final.

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

int main()
{
23

2012
int nota1, nota2, nota3, notar;
double prom;
printf("Ingrese la nota del primer parcial: ");
scanf("%d", &nota1);
printf("Ingrese la nota del segundo parcial: ");
scanf("%d", &nota2);
printf("Ingrese la nota del tercer parcial: ");
scanf("%d", &nota3);

if(nota1<4||nota2<4||nota3<4)
{
printf("Ingrese la nota del recuperatorio: ");
scanf("%d", &notar);
prom=(nota1+nota2+nota3+notar)/4.0;
}
else
prom=(nota1+nota2+nota3)/3.0;
printf("Promedio general: %.2lf.", prom);
if(prom<4)
printf(" El alumno debera presentarse a final:");
else
printf(" El alumno ha aprovado y no debe presentarse a final.");
return 0;
}

Ejercicio 1.18
Una empresa necesita calcular un bono que dar a sus empleados a fin de este ao. Para
ello se
sigue el siguiente criterio:
24

2012
Si el sueldo supera los $2000, el bono ser del 15%. De lo contrario, el bono ser del 20%.
Si el empleado tiene hijos se suma un plus del 5% del sueldo.
Si el empleado pertenece a la categora 1, 2 3, recibe un 10% del sueldo. Si pertenece a
la categora 4, 5 6, recibe un 12% del sueldo. Si es de la categora 7, 8 9, recibe un
20% del sueldo pero no cobra el plus por tener hijos.
Realizar el programa que solicite la informacin necesaria para calcular el sueldo final.
Finalmente
el programa mostrar el total a pagarle al empleado (sueldo + bono).
Ejemplo:
Ingrese el sueldo: 1000
Tiene hijos (s/n)?: s
Ingrese categora (19):
2
El sueldo total ser de $1350.00
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

int main()
{
int sueldo, categoria;
char op;
double bono;
printf("Ingrese el sueldo: ");
scanf("%d", &sueldo);
printf("Tiene hijos (s/n)?: ");
op=getche();
printf("\nIngrese categoria (1-9): ");
scanf("%d", &categoria);
if(sueldo>2000)
bono=sueldo*0.15;
else

25

2012
bono=sueldo*0.2;
if(op=='s'&&categoria!=7&&categoria!=8&&categoria!=9)
bono=bono+sueldo*0.05;
if(categoria==1||categoria==2||categoria==3)
bono=bono+sueldo*0.1;
else
{
if(categoria==4||categoria==5||categoria==6)
bono=bono+sueldo*0.12;
else
bono=bono+sueldo*0.2;
}
printf("El sueldo total sera de %.2lf", bono+sueldo);

return 0;
}

Ejercicio 1.19
Segn las normas de trnsito, un automvil no puede superar la velocidad mxima ni
circular a
menos que la velocidad mnima (que es la mitad de la velocidad mxima). Por una cuestin
de
errores de medicin (tanto en el automvil como en los dispositivos de control) hay un 15%
de tolerancia. Sin embargo, se permite que los vehculos en emergencia (ambulancias,
patrulleros,
etc.) superen la velocidad mxima (no as, circular a menos que la velocidad mnima). Hacer
un
programa en el que se ingrese la velocidad a la que circula un vehculo, la velocidad mxima
permitida y si se trata o no de un vehculo en emergencia (contestando con S o N en
mayscula o minscula). Luego determinar el tipo de multa e imprimir el correspondiente
mensaje
segn el siguiente criterio:
Si la velocidad est entre la mxima y la mnima (ambas inclusive), No recibe multa.
Si la velocidad est dentro de la tolerancia mxima (superando la mxima hasta el 15%,
por ejemplo, para mxima de 60 km/h la tolerancia llega hasta 69 km/h), Recibe

26

2012
advertencia. No se aplica si es un vehculo en emergencia que, en este caso, No recibe
multa.
Si la velocidad dentro de la tolerancia mnima (hasta 15% por debajo de la velocidad
mnima), Recibe advertencia. Este caso es independiente del tipo de vehculo.
Si supera la velocidad mxima y el lmite de tolerancia, Recibe multa por exceso de
velocidad. No se aplica si es un vehculo en emergencia que, en este caso, No recibe
multa.
Si excede la tolerancia de velocidad mnima, Recibe multa por entorpecer el trnsito.
Este
caso es independiente del tipo de vehculo.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

int main()
{
char categoria;
double veiculo, velmax;
printf("Ingrese la velocidad del veiculo: ");
scanf("%lf", &veiculo);
printf("Es un veiculo de emergencia (s/n)?: ");
categoria=getche();
printf("\nIngrese la velocidad maxima: ");
scanf("%lf", &velmax);
if(categoria=='n'||categoria=='N')
{
if(veiculo<=velmax&&veiculo>=velmax/2)
printf("No recibe multa");
else
{

27

2012
if(veiculo<=velmax+velmax*0.15&&veiculo>=velmax/2((velmax/2)*0.15))
printf("Recive advertencia");
else
{
if(veiculo>velmax+velmax*0.15)
printf("Recibe multa por exceso de velocidad");
else
printf("Recibe multa por entorpecer el trnsito");
}
}

}
else
{
if(categoria=='s'||categoria=='S')
{
if(veiculo>=velmax/2)
printf("No recibe multa");
else
{
if(veiculo>=velmax/2-((velmax/2)*0.15))
printf("Recive advertencia");
else
printf("Recibe multa por entorpecer el trnsito");
}

28

2012
}
else
printf("\nCaracter ingresado incompatible");
}

return 0;
}

Ejercicio 1.20
Hacer un programa que ayude a decidir a un alumno si debe o no debe atender su telfono
celular
cuando suena, en base a las condiciones que se enumeran a continuacin. El programa
debe
preguntar al alumno lo siguiente:
Es de maana?
El llamado es de tu casa?
Ests en clase en este momento?
El usuario debe contestar a esas preguntas con s o n (tener en cuenta que el usuario
puede
contestar en minsculas o maysculas.) El criterio para decidir si se atiende o no el telfono
es el
siguiente: El alumno normalmente atiende el telfono, con excepcin de los llamados
recibidos
durante la maana (que no los atiende.) Ahora bien, si lo estn llamando de la casa, el
alumno
debe atender igual sin importar el momento del da, a menos que en el momento que suena
se
encuentre en clase, en cuyo caso no atiende (NUNCA se debe atender el telfono cuando
se est
en clase.). Realizar el programa que haga esas preguntas al usuario y que muestre el
mensaje
DEBE ATENDER o NO DEBE ATENDER segn corresponda.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

int main()
{

29

2012
char manana, casa, clase;
printf("Por favor, responda las siguientes preguntas con 's' o 'n' segun
corresponda\n");
printf("\nEs de maniana?: ");
manana=getche();
printf("\nEl llamado es de tu casa?: ");
casa=getche();
printf("\nEstas en clase en este momento?: ");
clase=getche();
printf("\n");
if(clase=='s'||clase=='S')
{
printf("NO DEBE ATENDER");
}
else
{
if(casa=='s'||casa=='S')
{
printf("DEBE ATENDER");
}
else
{
if(manana=='s'||manana=='S')
{
printf("NO DEBE ATENDER");
}
else

30

2012
{
printf("DEBE ATENDER");
}
}
}
return 0;
}

Practica 2
Estructuras de repeticin
Ejercicio 2.1
Elaborar un programa que solicite al usuario que ingrese un nmero
entero y determine si el mismo es un nmero primo.
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num, cont=0, div;
printf("Ingrese el numero:");
scanf("%d", &num);
for(div=1; div<=num; div++)
{
if(num%div==0)
cont++;
}
if(cont<=2)
printf("Es primo");
else
printf("No es primo");
return 0;
}

31

2012

Ejercicio 2.2
Escribir un programa que encuentre los primeros 4 nmeros perfectos.
Un nmero perfecto es un
entero positivo, que es igual a la suma de todos los enteros positivos
(excluido l mismo) que son
divisores del nmero. Por ejemplo, el primer nmero perfecto es 6, ya
que los divisores de 6 son 1,
2, 3 y 1 + 2 + 3 = 6.
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num, cont=0, cont2=1, div;
for(num=2; cont2<=4 ; num++)
{
for(div=1;div<num;div++)
{
if(num%div==0)
cont=cont+div;
}
if(cont==num)
{
cont2++;
printf("El %d es un numero perfecto\n", num);
}
cont=0;
}
return 0;
}

Ejercicio 2.3
Hacer un programa que encuentre e imprima un listado con todos los
nmeros de 4 cifras que
cumplan la condicin de que la suma de las cifras de orden impar es
igual a la suma de las cifras de
orden par. Por ejemplo, el nmero 7821 cumple esta condicin ya que 7
+ 2 = 8 + 1.
#include <stdio.h>
#include <stdlib.h>

32

2012

int main()
{
int num, s1,s2,s3,s4;
for(num=1000; num<10000; num++)
{
s1=num%10;
s2=(num%100-s1)/10;
s3=(num%1000-s2*10-s1)/100;
s4=(num-s1-s2*10-s3*100)/1000;
if(s1+s2==s3+s4)
printf("%d\n", num);
}
return 0;
}

Ejercicio 2.4
Realizar un programa en el que se ingresa una letra a buscar y luego un
texto de tamao indefinido
(hasta ingresar punto). Luego, el programa debe informar cuntas
apariciones de la letra hay en ese
texto.
Ejemplo:
Ingrese la letra a contar: a
Ingrese el texto: La bella y graciosa moza, marchose a lavar la
ropa.
La letra a aparece 11 veces.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

33

2012
int main()
{
char letra, texto;
int cont=0;
printf("Ingrese la letra a buscar: ");
letra=getche();
printf("\nIngrese el texto: (punto para terminar) \n");
do
{
texto=getche();
if(texto==letra)
cont++;
}while(texto!='.');
printf("\nla letra '%c' aparece %d veces en el texto.", letra, cont);

return 0;
}

Ejercicio 2.5
Realizar un programa en el que se ingresa un texto de longitud
indefinida (hasta ingresar asterisco).
Luego debe informarse por pantalla cuntas de sus letras fueron
maysculas y cuntas fueron
minsculas. Por ejemplo, para el texto Hola Mundo debe obtenerse 2
maysculas y 7 minsculas
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

int main()
34

2012
{
char texto;
int contmin=0, contmay=0;
printf("\nIngrese el texto: ('*' para terminar) \n");
do
{
texto=getche();
if(texto>='a'&&texto<='z')
contmin++;
else
{
if(texto>='A'&&texto<='Z')
contmay++;
}
}while(texto!='*');
printf("\nEn el texto ingresado hay %d minusculas y %d mayusculas ",
contmin, contmay);

return 0;
}

Ejercicio 2.6
Realizar un programa en el que se ingresa un texto de longitud
indefinida (hasta ingresar ENTER).
Luego informar cuntas de las letras ingresadas fueron vocales (contar
tanto maysculas como
minsculas) y cuntas fueron consonantes (contar tanto maysculas
como minsculas). Por
ejemplo, para el texto Kate Austen fue una de las 6 sobrevivientes del
Oceanic 815 debe
informarse que hay 22 vocales y 23 consonantes.

35

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

int main()
{
char texto;
int contvoc=0, contcons=0;
printf("\nIngrese el texto: (ENTER para terminar) \n");
do
{
texto=getche();
if(texto>='a'&&texto<='z'||texto>='A'&&texto<='Z')
{
if(texto=='a'||texto=='A'||texto=='e'||texto=='E'||texto=='i'||
texto=='I'||texto=='o'||texto=='O'||texto=='u'||texto=='U')
contvoc++;
else
contcons++;
}
}while(texto!='\r');
printf("\nEn el texto ingresado hay %d vocales y %d consonantes ", contvoc,
contcons);

return 0;
}

36

2012

Ejercicio 2.7
Construir un programa en el que se ingresen nmeros enteros hasta que
se hayan ingresado 5
nmeros pares e informar si alguno de ellos es tambin mltiplo de
cuatro.
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num, cont=0, sen=0, div;
do
{
printf("Ingrese numero: ");
scanf("%d", &num);
if (num%2==0&&num!=0)
cont++;
if(num>=0)
{
div=0;
do
{
div++;
if(div*4==num)
sen=1;
}while(div*4<=num);
}
else
{

37

2012
div=0;
do
{
div--;
if(div*4==num)
sen=1;
}while(div*4>=num);
}

}while(cont<=4);
if(sen==1)
printf("Hay por lo menos un multiplo de 4\n");
else
printf("No hay multiplos de 4");

return 0;
}

Ejercicio 2.8
Escribir un programa que reciba una cantidad indefinida de nmeros
enteros positivos hasta que se
ingresa el 0. A continuacin el programa debe indicar cul fue el mayor y
cul el menor.
#include <stdio.h>
#include <stdlib.h>

int main()
{
int num, may, men, sen=0;

38

2012
printf("Ingrese numero: ");
scanf("%d", &num);
if(num!=0)
{
may=num;
men=num;
}
else
{
printf("No se ingresaron valores utiles.");
sen=1;
}
while(num!=0)
{
printf("Ingrese numero: ");
scanf("%d", &num);
if(num>may)
may=num;
if(num<men&&num!=0)
men=num;
}
if(sen==0)
printf("El mayor fue %d y el menor fue %d", may, men);
return 0;
}

39

2012

Ejercicio 2.9
Armar un programa en el que se ingrese un nmero entero decimal
(base diez) y convertirlo a
binario.
#include <stdio.h>
#include <stdlib.h>

int main()
{
int num, pot=1, bin=0, guard_num;
printf("Ingrese numero: ");
scanf("%d", &num);
guard_num=num;
while(num>0)
{
bin=bin+(num%2*pot);
pot=pot*10;
num=num/2;
}
printf("El numero %d(10) es igual al numero %d(2)", guard_num, bin);
return 0;
}

Ejercicio 2.10
Para encontrar el mximo comn divisor (MCD) de dos nmeros se
emplea el algoritmo de
Euclides, que se puede describir as: Dados dos enteros a y b (siendo a
> b), se divide a por b. Si el
resto de la divisin es cero, el nmero b es el mximo comn divisor. Si
la divisin no es exacta, el
valor de a pasa a ser b y el nuevo valor de b ser el resto de la divisin
anterior. Se repite el
40

2012

procedimiento hasta obtener un resto cero. El ltimo divisor (b) es el

mcd buscado. Escribir un
programa que calcule el mcd de dos nmeros enteros. Por ejemplo, si a
= 2366 y b=273, se divide a
por b y el resto es 182; como no es cero, se divide el nuevo a que ser
273 por el nuevo b que ser
182 y da como resto 91; como no es cero se divide 182 por 91 y da
como resto cero; se concluye
entonces que 91 es el MCD entre 2366 y 273.
#include <stdio.h>
#include <stdlib.h>

int main()
{
int a, b, aux, resto, guarda, guardb;
printf("Ingrese el primer numero: ");
scanf("%d", &a);
guarda=a;
printf("Ingrese el segundo numero: ");
scanf("%d", &b);
guardb=b;
if(b>a)
{
aux=b;
b=a;
a=aux;
}
while(a%b!=0)
{
resto=a%b;

41

2012
a=b;
b=resto;
}

printf("El MCD entre %d y %d es: %d",guarda , guardb, b);

return 0;
}

Ejercicio 2.11
Escribir un programa que permita ingresar las notas de una cantidad
indefinida de alumnos. A
continuacin el programa deber mostrar la cantidad de alumnos
aplazados (nota menor a 4), la
cantidad de alumnos aprobados (nota entre 4 y 7 inclusive) y la cantidad
de alumnos que
promocionan la materia (nota superior a 7). En cada caso, se mostrar el
porcentaje del total de
notas cargadas que cada caso representa y el promedio general de
todas las notas. Las notas pueden
ser valores reales y la carga finaliza cuando la nota ingresada es 0.
Ignorar las notas no vlidas
(fuera del rango de 1 a 10).
Ejemplo:
Ingrese nota: 5
Ingrese nota: 4
Ingrese nota: 2
Ingrese nota: 8
...
Ingrese nota: 0
Cantidad de aplazos: 5 (10%)
Cantidad de aprobados: 15 (30%)
Cantidad de promocionados: 30 (60%)
Promedio general: 6.72
#include <stdio.h>
#include <stdlib.h>

int main()
{
42

2012
int nota, aplazados=0, aprovados=0, promocionantes=0, total, pcapl,
pcapr,pcpro;
do
{
printf("Ingrese nota: ");
scanf("%d", &nota);
if(nota!=0)
{

if(nota<4&&nota>=1)
aplazados++;
else
{
if(nota>=4&&nota<=7)
aprovados++;
else
{
if(nota>7&&nota<=10)
promocionantes++;
else
printf("\nDato incorrecto! ingrese notas del 1 al 10 por favor.\n");
}
}
}
}while(nota!=0);
if(aplazados==0&&aprovados==0&&promocionantes==0)
printf("\nNo se han ingresado datos relevantes");

43

2012
else
{
total=aplazados+aprovados+promocionantes;
pcpro=(promocionantes*100)/total;
pcapr=(aprovados*100)/total;
pcapl=(aplazados*100)/total;
printf("\nCantidad de aplazos: %d (%d%%)",aplazados, pcapl);
printf("\nCantidad de aprobados: %d (%d%%)",aprovados,pcapr);
printf("\nCantidad de promocionados: %d (%d%%)",promocionantes,
pcpro);
}
return 0;
}

Ejercicio 2.12
Realizar un programa que permita el ingreso de letras en minscula y
que brinde al usuario tres
operaciones posibles a travs de un men de opciones. La primera
opcin devolver la mayscula
correspondiente. La segunda opcin devolver la letra siguiente en el
alfabeto (si la letra ingresada
fuera z se debe informar que es la ltima). La tercera opcin devolver
la letra anterior en el
alfabeto siempre que la letra ingresada no sea a. Validar que
efectivamente el carcter ingresado
sea una letra minscula o * (este ltimo determina el final de la serie de
opciones).
Ejemplo:
Ingrese letra: f
1 Convertir a mayscula
2 Obtener la siguiente
3 Obtener la anterior
Escoja una operacin (1 3): 1
La mayscula es F.
#include <stdio.h>
#include <stdlib.h>

44

2012
#include <conio.h>

int main()
{
char letra;
int menu;
do
{
printf("Ingrese la letra: ");
letra=getche();
printf("\n");
}while(letra<'a'||letra>'z');
do
{
printf("1 - Convertir a mayuscula\n");
printf("2 - Obtener la siguiente\n");
printf("3 - Obtener la anterior\n");
printf("Escoja una operacion (1 - 3): ");
scanf("%d", &menu);
if(menu<1||menu>3)
printf("Error!\n");
}while(menu<1||menu>3);
switch(menu)
{
case 1:
letra=letra-32;

45

2012
printf("La mayuscula es %c", letra);
break;
case 2:
letra=letra+1;
printf("La siguiente es: %c", letra);
break;
case 3:
letra=letra-1;
printf("La anterior es: %c", letra);
break;
}

return 0;
}

Ejercicio 2.13
Realizar un programa para calcular utilidades de inversin en plazos
fijos. Para esto, se ingresarn
las cantidades que sern los importes mensuales que el cliente desea
invertir (cantidad = 0 para
terminar). Luego se debe obtener el resultado de la colocacin total en
plazos fijos.
Primero se debe solicitar la Tasa Nominal Anual (TNA) al principio de la
serie de importes, a partir
de la cual se obtiene la Tasa Efectiva Mensual (TEM = TNA /12). En cada
mes, se calculan los
intereses multiplicando la TEM por el total de montos acumulados hasta
dicho mes.
Al finalizar la carga, se imprimir el monto final (suma de montos
invertidos) ms los intereses
acumulados durante cada mes.
Ejemplo: Se desea invertir tres sumas (durante tres meses seguidos) en
plazos fijos.
Ingrese porcentaje de TNA: 8
Ingrese monto del mes 1: 2000
Ingrese monto del mes 2: 3000
46

2012

Ingrese monto del mes 3: 1000

Ingrese monto del mes 4: 0
El monto final es: 6086.67
Ayuda:
Ej.: TNA = 8% = 0.08. TEM = TNA /12 = 0.08/12 = 0.0067
Intereses = 2000 * 0.0067 + (2000+3000) * 0.0067 +
(2000+3000+1000) * 0.0067
Monto total = Inversin + Intereses = 2000 + 3000 + 1000 + 86.67 =
6086.67
#include <stdio.h>
#include <stdlib.h>

int main()
{
int monto, cont=1, inversion=0;
double tna,intereses=0;
printf("Ingrese porcentaje de TNA: ");
scanf("%lf", &tna);
tna=tna/100;
do
{
printf("Ingrese monto del mes %d: ", cont);
scanf("%d", &monto);
if(monto!=0)
{
cont++;
inversion=inversion+monto;
intereses=intereses+inversion*(tna/12);
}

47

2012
}while(monto!=0);

printf("Monto total = Inversion + Intereses = %d + %.2lf = %.2lf", inversion,

intereses, inversion+intereses);
return 0;
}

Ejercicio 2.14
Efectuar un programa que solicite al usuario que ingrese un nmero
entero impar (validar el valor
ingresado). El programa tendr que dibujar en la ventana un tringulo
de asteriscos cuya base sea el
valor ingresado.
Ejemplo:
Ingrese nmero: 8
Nmero no vlido. Ingrese nmero: 11
*
***
*****
*******
*********
***********
#include <stdio.h>
#include <stdlib.h>

int main()
{
int num, f, c, ast=1, blancos;

do
{
printf("Ingrese el numero: ");
scanf("%d", &num);
if(num%2!=1)

48

2012
printf("Error!");
}while(num%2!=1||num<3);
blancos=num/2;

for(f=1; f<=num/2+1; f++)

{
for(c=1; c<=blancos; c++)
{
printf(" ");
}
blancos--;
for(c=1;c<=ast;c++)
{
printf("*");

}
ast+=2;
printf("\n");
}
return 0;
}

Ejercicio 2.15
Efectuar un programa que solicite al usuario que ingrese la base de un
tringulo rectngulo. Luego
dibujar en la ventana dicho tringulo como se muestra en el ejemplo.
Ejemplo:
Ingrese base: 5
*
49

2012

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

int main()
{
int num, f, c;
do{
printf("Ingrese el numero: ");
scanf("%d", &num);
}while(num<2);
for(f=1; f<=num; f++)
{
for(c=1; c<=f; c++)
{
printf("*");
}
printf("\n");
}
return 0;
}

Ejercicio 2.16
Efectuar un programa que solicite al usuario que ingrese la base de un
tringulo rectngulo. Luego
dibujar en la ventana dicho tringulo como se muestra en el ejemplo.
Ejemplo:
Ingrese base: 5

50

2012

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

int main()
{
int num, f, c, blancos, ast=1;
do{
printf("Ingrese el numero: ");
scanf("%d", &num);
}while(num<2);
blancos=num-1;

for(f=1; f<=num; f++)

{
for(c=1; c<=blancos; c++)
{
printf(" ");
}
blancos--;
for(c=1; c<=ast; c++)
{
printf("*");
}

51

2012
ast++;
printf("\n");
}
return 0;
}

Ejercicio 2.17
Efectuar un programa que solicite al usuario que ingrese la diagonal de
un rombo (validar que el
valor ingresado sea impar). Luego deber dibujar dicho rombo en la
ventana.
Ejemplo:
Ingrese diagonal: 8
Valor incorrecto. Ingrese diagonal: 7
*
***
*****
*******
*****
***
*
#include <stdio.h>
#include <stdlib.h>

int main()
{
int num, f, c, blancos, ast=1;

do{
printf("Ingrese el numero: ");
scanf("%d", &num);
blancos=num/2;
}while(num<3||num%2!=1);

52

2012

for(f=1; f<=num/2+1; f++)

{
for(c=1; c<=blancos; c++)
{
printf(" ");
}
blancos--;
for(c=1; c<=ast; c++)
{
printf("*");
}
ast+=2;
printf("\n");
}
blancos+=2;
ast-=4;
for(f=1; f<=num/2; f++)
{
for(c=1; c<=blancos; c++)
{
printf(" ");
}
blancos++;
for(c=1; c<=ast; c++)

53

2012
{
printf("*");
}
ast-=2;
printf("\n");
}
return 0;
}

Ejercicio 2.18
Efectuar un programa que solicite al usuario que ingrese la base y la
altura de un rectngulo. Luego
deber dibujar en la ventana el rectngulo hueco.
Ejemplo:
Ingrese base: 7
Ingrese altura: 4
*******
*
*
*
*
*******
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num, f, c;
do{
printf("Ingrese el numero: ");
scanf("%d", &num);
}while(num<3);
for(f=1; f<=num; f++)
{
for(c=1; c<=num ; c++)
{
if(c==1||f==1||f==num||c==num)
printf("*");
else
54

2012

printf(" ");
}
printf("\n");
}
return 0;
}

Ejercicio 2.19
Efectuar un programa que solicite al usuario que ingrese la base y la
altura de un rectngulo. Luego
deber dibujar en la ventana dicho rectngulo.
Ejemplo:
Ingrese base: 8
Ingrese altura: 3
********
********
********
#include <stdio.h>
#include <stdlib.h>

int main()
{
int alt, base, f, c;

do{
printf("Ingrese la base: ");
scanf("%d", &base);
}while(base<2);
do{
printf("Ingrese la altura: ");
scanf("%d", &alt);
}while(alt<2);

55

2012

for(f=1; f<=alt; f++)

{
for(c=1; c<=base ; c++)
{
printf("*");
}
printf("\n");
}
return 0;
}

Ejercicio 2.20
La operacin factorial de un nmero entero positivo n (expresado
como n!) es el producto que
resulta de multiplicar n por todos los enteros inferiores a l hasta el
uno. Por ejemplo:
5! = 5 * 4 * 3 * 2 * 1
10! = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
n! = n * (n-1) * (n-2) * * 3 * 2 * 1
Como salvedad se define 0! = 1.
Elaborar un programa que calcule el factorial de un nmero entero. El
programa principal debe
solicitar el ingreso de un nmero entero, verificar si se trata de un
nmero mayor o igual a 0 y
calcular su factorial. En caso de que el usuario ingresara un nmero
negativo, imprimir una
advertencia.
Ejemplos:
Ingrese un nmero entero: 5
El factorial de 5 es: 120
Ingrese un nmero entero: -10
No se puede calcular el factorial de un nmero negativo.
#include <stdio.h>
#include <stdlib.h>

56

2012
int main()
{
int num, cont, res;

do{
printf("Ingrese el numero: ");
scanf("%d", &num);
if(num<0)
printf("No se puede calcular el factorial de un numero negativo.\n");
}while(num<0);
if(num==0)
res=1;
else
{
res=num;
for(cont=1; cont<num; cont++)
res=res*(num-cont);
}
printf("El factorial de %d es: %d", num, res);
return 0;
}

Ejercicio 2.21
Elaborar un programa en el que se ingrese un nmero entero positivo
(de cualquier cantidad de
cifras) y determine si es un nmero capica. Un nmero capica es
aquel que ledo de izquierda a
derecha es igual que ledo de derecha a izquierda. Por ejemplo: 82428.
Considere invertir el nmero
y luego compararlo con el nmero original. Si resultan iguales, ser
capica.
57

2012

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

int main()
{
int num, aux, res=0;

do{
printf("Ingrese el numero: ");
scanf("%d", &num);
if(num<=0)
printf("Error!\n");
}while(num<=0);
aux=num;
while(aux>0)
{
res=res*10+(aux%10);
aux/=10;
}
if(num==res)
printf("El numero %d es capicua", num);
else
printf("El numero %d NO es capicua", num);
return 0;
}

58

2012

Practica 3
Arreglos
Ejercicio 3.1
Realice un programa que permita cargar nmeros enteros positivos en
un arreglo (de hasta 1000
elementos) hasta que el usuario ingrese 0 (este valor marca el final de
los valores tiles).
Luego, se deber obtener otro arreglo que contenga los mismos valores
pero en forma inversa y a
continuacin imprimir este ltimo.
Ejemplo:
Ingrese nmero: 20
Ingrese nmero: 21
Ingrese nmero: 14
Ingrese nmero: 0
El arreglo revertido contiene: 14, 21, 20.
#include <stdio.h>
#include <stdlib.h>
#define N 1000

int main()
{
int v[N], i=0, b[N], j=0;

do{
printf("Ingrese numero: ");
scanf("%d", &v[i]);
i++;
}while(v[i-1]!=0);
i-=2;
while(i>=0)

59

2012
{
b[j]=v[i];
j++;
i--;
}
j--;
printf("El arreglo revertido contiene: ");
for(i=0; i<=j; i++)
printf("%d-", b[i]);

return 0;
}

Ejercicio 3.2
Realice un programa que permita cargar nmeros enteros positivos en
un arreglo (de hasta 1000
elementos) hasta que el usuario ingrese 0 (este valor marca el final de
los valores utiles). No se
permitir al usuario cargar 2 veces el mismo valor, en dicho caso se
mostrara un mensaje. Luego,
imprima el arreglo resultante.

Ejercicio 3.3
Elaborar un programa que presente un men con las siguientes
opciones: AND, OR, NOT,SALIR.
Luego, para cada opcin elegida el programa deber permitir la carga de
uno o dos (segn
corresponda) arreglos booleanos de 6 elementos cada uno. El 0 tendra
un valor de verdad FALSO y
el 1 VERDADERO. Se pide obtener el arreglo booleano resultante de la
operacion logica sobre
el/los arreglo/s correspondiente/s..
Ejemplo:
1 AND
2 OR
3 NOT
4 SALIR
Seleccione una opcin: 1
60

2012

Ingrese los elementos del primer arreglo: 1 1 1 0 0 0

Ingrese los elementos del segundo arreglo: 1 1 0 0 0 1
El arreglo resultante es: 1 1 0 0 0 0
1 AND
2 OR
3 NOT
4 SALIR
Seleccione una opcin: 3
Ingrese los elementos del arreglo: 1 1 1 0 0 0
El arreglo resultante es: 0 0 0 1 1 1
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define N 7

int main()
{
int i, menu;
char v[N], b[N], r[N], l;
do{
printf("\nMenu\n");
printf("1 - AND\n");
printf("2 - OR\n");
printf("3 - NOT\n");
printf("4 - SALIR\n");
scanf("%d", &menu);

switch(menu)
{

61

2012
case 1:
i=0;
printf("\nIngrese el primer arreglo:");
do
{
l=getche();

if(l=='0'||l=='1')
{
v[i]=l;
i++;
}
}while(i<6);
v[i]='\0';
printf("\nIngrese el segundo arreglo:");
i=0;
do
{
l=getche();

if(l=='0'||l=='1')
{
b[i]=l;
i++;
}
}while(i<6);

62

2012
b[i]='\0';
for(i=0;i<6;i++)
{
if(v[i]=='1'&&b[i]=='1')
r[i]='1';
else
r[i]='0';
}
r[i]='\0';
printf("\nEl arreglo resultante es: %s", r);
break;
case 2:
i=0;
printf("\nIngrese el primer arreglo:");
do
{
l=getche();

if(l=='0'||l=='1')
{
v[i]=l;
i++;
}
}while(i<6);
v[i]='\0';
printf("\nIngrese el segundo arreglo:");

63

2012
i=0;
do
{
l=getche();

if(l=='0'||l=='1')
{
b[i]=l;
i++;
}
}while(i<6);
b[i]='\0';
for(i=0;i<6;i++)
{
if(v[i]=='1'||b[i]=='1')
r[i]='1';
else
r[i]='0';
}
r[i]='\0';
printf("\nEl arreglo resultante es: %s", r);

break;
case 3:
i=0;
printf("\nIngrese el arreglo:");

64

2012
do
{
l=getche();

if(l=='0'||l=='1')
{
v[i]=l;
i++;
}
}while(i<6);
v[i]='\0';
for(i=0;i<6;i++)
{
if(v[i]=='1')
r[i]='0';
else
r[i]='1';
}
r[i]='\0';
printf("\nEl arreglo resultante es: %s", r);
break;
case 4:
printf("\nTerminado. Tenga un buen dia!.");
break;
default:
printf("\nOpcion no valida. Por favor reintente: ");

65

2012
break;
}
}while(menu!=4);
return 0;
}

Ejercicio 3.4
Elaborar un programa que permita cargar dos arreglos numricos de
hasta 1000 elementos. Se
efectuara la carga de cada uno (hasta que se ingrese 0 o se complete la
capacidad del arreglo).
Luego se presenta el siguiente men con las siguientes opciones:
UNION, INTERSECCION,
DIFERENCIA, SALIR. A continuacin se efectuara la operacin entre
ambos arreglos como si
fueran conjuntos (considerar que los conjuntos no pueden tener
elementos repetidos).
#include <stdio.h>
#include <stdlib.h>
#define N 1000

int main()
{
int i, j, k, m, sen=0, menu, l, v[N], b[N], r[N*2];
do{
printf("\nMenu\n");
printf("1 - UNION\n");
printf("2 - INTERSECCION\n");
printf("3 - DIFERENCIA\n");
printf("4 - SALIR\n");
scanf("%d", &menu);

66

2012

switch(menu)
{
case 1:
i=0;
printf("\nIngrese el primer arreglo:");
do
{

sen=0;
scanf("%d", &l);
for(j=0;j<i;j++)
{
if(v[j]==l)
sen=1;
}
if(sen==0)
{

v[i]=l;
i++;
}

}while(i<N-1&&v[i-1]!=0);
i--;

67

2012
printf("\nIngrese el segundo arreglo:");
k=0;
do
{

sen=0;
scanf("%d", &l);
for(j=0;j<k;j++)
{
if(b[j]==l)
sen=1;
}

if(sen==0)
{
b[k]=l;
k++;
}

}while(k<N-1&&b[k-1]!=0);
for(m=0;m<i;m++)
{
r[m]=v[m];
}
int n;

68

2012
for(j=0;j<k;j++)
{
l=b[j];
sen=0;
for(i=0;i<m;i++)
{
if(l==r[i])
sen=1;
}
for(n=0;n<=i;n++)
{
if(v[n]==l)
sen=1;
}
if(sen==0)
{
r[m]=l;
m++;
}
}
printf("El arreglo resultante es: ");
for(i=0;i<m;i++)
{
printf("%d-", r[i]);
}
break;

69

2012
case 2:
i=0;
printf("\nIngrese el primer arreglo:");
do
{

sen=0;
scanf("%d", &l);
for(j=0;j<i;j++)
{
if(v[j]==l)
sen=1;
}
if(sen==0)
{

v[i]=l;
i++;
}

}while(i<N-1&&v[i-1]!=0);
i--;
printf("\nIngrese el segundo arreglo:");
k=0;
do

70

2012
{

sen=0;
scanf("%d", &l);
for(j=0;j<k;j++)
{
if(b[j]==l)
sen=1;
}

if(sen==0)
{
b[k]=l;
k++;
}

}while(k<N-1&&b[k-1]!=0);
k--;
int o, p=0;
for(n=0;n<i;n++)
{
sen=0;
for(o=0; o<k;o++)
{
if(v[n]==b[o])

71

2012
sen=1;
}
if(sen==1)
{
r[p]=v[n];
p++;
}
}
printf("El arreglo resultante es: ");
for(i=0;i<p;i++)
{
printf("%d-", r[i]);
}

break;
case 3:
i=0;
printf("\nIngrese el primer arreglo:");
do
{

sen=0;
scanf("%d", &l);
for(j=0;j<i;j++)
{
if(v[j]==l)

72

2012
sen=1;
}
if(sen==0)
{

v[i]=l;
i++;
}

}while(i<N-1&&v[i-1]!=0);
i--;
printf("\nIngrese el segundo arreglo:");
k=0;
do
{

sen=0;
scanf("%d", &l);
for(j=0;j<k;j++)
{
if(b[j]==l)
sen=1;
}

if(sen==0)

73

2012
{
b[k]=l;
k++;
}

}while(k<N-1&&b[k-1]!=0);
k--;
p=0;
for(n=0;n<i;n++)
{
sen=0;
for(o=0; o<k;o++)
{
if(v[n]==b[o])
sen=1;
}
if(sen==0)
{
r[p]=v[n];
p++;
}
}
printf("El arreglo resultante es: ");
for(i=0;i<p;i++)
{

74

2012
printf("%d-", r[i]);
}
break;
case 4:
printf("\nTerminado. Tenga un buen dia!.");
break;
default:
printf("\nOpcion no valida. Por favor reintente: ");
break;
}
}while(menu!=4);
return 0;
}

Ejercicio 3.5
Realizar un programa en el que se ingrese un texto de hasta 100
caracteres finalizando con ENTER
(utilizar \r para detectar el ingreso de ENTER). Luego, el usuario deber
elegir un caracter al cual
reemplazar y con que caracter reemplazarlo.
Ejemplo:
Ingrese texto: La mar estaba serena
Ingrese carcter a reemplazar: a
Ingrese carcter de reemplazo: e
Resultado: Le mer estebe serene
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define N 101

int main()

75

2012
{
char l, lo='0',lc='0',texto[N];
int i=0;
printf("\nIngrese la letra a reemplazar: ");
do
{
l=getche();
if(l>='a'&&l<='z'||l>='A'&&l<='Z')
lo=l;
else
printf("\nError!. Reintente: ");
}while(lo=='0');
printf("\nIngrese la letra a ser reemplazada: ");
do
{
l=getche();
if(l>='a'&&l<='z'||l>='A'&&l<='Z')
lc=l;
else
printf("\nError!. Reintente: ");
}while(lc=='0');
printf("\nIngrese el texto: \n");
do
{
l=getche();
if(l!='\r')

76

2012
{
texto[i]=l;
i++;
}

}while(l!='\r'&&i<N-1);
texto[i]='\0';
int j;
for(j=0;j<i;j++)
{
if(texto[j]==lo)
texto[j]=lc;
}
printf("\ntexto modificado: %s\n", texto);
return 0;
}

Ejercicio 3.6
Realizar un programa en el que se ingrese un texto de hasta 75
caracteres finalizando con ENTER
(utilizar el caracter \r para detectarlo). Luego imprimir dicho texto
centrado y, en la siguiente
linea, alineado hacia la derecha. Tener en cuenta que el ancho de la
pantalla de texto es de 80
columnas.
El texto debe contener \0 como caracter final a fin de que pueda
imprimirse con printf(%s,
texto);
Ejemplo:
Ingrese texto: La bella y graciosa moza marchose a lavar la ropa
La bella y graciosa moza marchose a lavar la ropa
La bella y graciosa moza marchose a lavar la ropa
#include <stdio.h>
#include <stdlib.h>
77

2012
#include <conio.h>
#define N 76

int main()
{
char text[N], l;
int cont ,i=0;
printf("Ingrese texto: \n");
do
{
l=getche();
if(l!='\r')
{
text[i]=l;
i++;
}
}while (l!='\r'&&i<N);
text[i]='\0';
printf("\n");
for(cont=0;cont<40-i/2;cont++)
printf(" ");
printf("%s\n", text);
for(cont=0;cont<80-i;cont++)
printf(" ");
printf("%s\n", text);
return 0;

78

2012
}

Ejercicio 3.7
Programar una funcion que reciba como parametro un texto y que
elimine todo lo que no sean letras
que encuentre al principio y al final del texto. Utilizarla en un programa
en el que se ingrese un
texto de hasta 1000 caracteres y luego se imprima la version limpia
del texto. El texto debe
contener \0 como caracter final a fin de que pueda imprimirse con
printf(%s, texto);
Ejemplo:
Ingrese texto:... La bella y graciosa moza marchose a lavar la
ropa, $@
La bella y graciosa moza marchose a lavar la ropa
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define N 1000
void trans (char[], int);
int main()
{
char text[N], l;
int cont ,i=0;
printf("Ingrese texto: \n");
do
{
l=getche();
if(l!='\r')
{
text[i]=l;
i++;

79

2012
}
}while (l!='\r'&&i<N);
trans (text, i);
printf("\n%s\n", text);
return 0;
}
void trans (char text[], int i)
{
int j=0, k=0, sen=0;
while(j<i)
{
if(text[j]>='A'&&text[j]<='Z'||text[j]>='a'&&text[j]<='z'||text[j]==' ')
{
sen=1;
text[k]=text[j];
k++;
}
else
{
if(sen==1)
text[k]='\0';
}
j++;
}
}

80

2012

Practica 4
Funciones
Ejercicio 4.1
Escribir una funcion que reciba como parametros la longitud de los lados
de un triangulo y que
retorne el area del mismo. Implementarla en un programa que reciba
los parametros como datos e
informe el area calculada.
Ejemplo:
Ingrese lado 1: 2
Ingrese lado 1: 6
Ingrese lado 1: 7
El area del triangulo es = 5.56
Ayuda: El area de un triangulo se puede calcular como
( p - c)
siendo p =(a +b +c) 2

p( p - a)( p - b)

#include <stdio.h>

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

double area (int, int, int);

int main()
{
int a,b,c;
double areatri;
printf("Ingrese lado 1: \n");
do
{
scanf("%d", &a);
}while (a<=0);
printf("Ingrese lado 2: \n");

81

2012
do
{
scanf("%d", &b);
}while (b<=0);
printf("Ingrese lado 3: \n");
do
{
scanf("%d", &c);
}while (c<=0);
areatri=area(a,b,c);
printf("El area del triangulo es = %.2lf", areatri);
return 0;
}
double area (int a, int b, int c)
{
double areatri,p;
p=(a+b+c)/2.0;
areatri=sqrt((double)p*(p-a)*(p-b)*(p-c));
return areatri;
}

Ejercicio 4.2
Programar una funcion que reciba como parametros un numero real x y
otro entero positivo n
mayor que 0. Esta funcion debera retornar la raiz enesima de x.
Utilizarla en un programa que
solicite el numero real, la raiz y luego imprima el valor calculado.
Ejemplo:
Ingrese un numero real: 14
Ingrese la raiz a calcular: 3
La raiz 3 de 14 es = 2.410142

82

2012

Ayuda: Utilizar la funcion pow de la libreria math.h cuyo prototipo es

double pow(double base, double exponente);
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

double raiz (double, int);

int main()
{
double x, resultado;
int n;
printf("Ingrese el numero a radicar: \n");
do
{
scanf("%lf", &x);
if(x<0)
printf("Error! No existe la raiz de un numero negativo en reales. Reingrese:
");

}while (x<0);
printf("Ingrese la raiz a efectuar: \n");
do
{
scanf("%d", &n);
if(n<=0)
printf("Error! Reingrese un numero positivo: ");
}while (n<=0);
resultado=raiz(x, n);
83

2012
printf("La raiz %d de %g es = %g", n, x, resultado);
return 0;
}
double raiz (double x, int n)
{
double resultado;
resultado=pow(x,1.0/n);
return resultado;
}

Ejercicio 4.3
Realizar una funcion que reciba como parametros un numero entero
positivo (en sistema decimal) y
otro entero positivo entre 2 y 9. Luego, la funcion debera retornar el
numero decimal convertido a
la base solicitada. Aplicar dicha funcion a un programa que solicite el
numero decimal, la base a
convertir y luego imprima el valor calculado.
Ejemplo:
Ingrese el numero decimal: 527
Ingrese la base: 8
527 (10) = 1017 (8)
#include <stdio.h>
#include <stdlib.h>

int cambio_base (int, int);

int main()
{
int decimal, base, cambiado;
printf("Ingrese el numero en sistema decimal: \n");
do
{

84

2012
scanf("%d", &decimal);
if(decimal<0)
printf("Error! Reingrese un numero positivo: ");

}while (decimal<0);
printf("Ingrese la base en que lo quiere: \n");
do
{
scanf("%d", &base);
if(base<2||base>9)
printf("Error! Reingrese un numero positivo (entre 2 y 9): ");
}while (base<2||base>9);
cambiado=cambio_base(decimal, base);
printf("El numero %d(10) es igual a %d(%d)", decimal, cambiado, base);
return 0;
}
int cambio_base (int d, int b)
{
int c=0, pot=1;
do
{
c=c+(d%b)*pot;
d/=b;
pot*=10;
}while(d>0);
return c;

85

2012
}

Ejercicio 4.4
Programar una funcion que reciba como parametros 2 numeros enteros
y que retorne un numero
aleatorio entre estos 2 numeros (inclusive).
Por ejemplo, si se invocara la funcion con parametros 1 y 6, debera
devolver un numero aleatorio
entre 1 y 6 inclusive. Validar que el valor maximo no sea superior al
valor maximo que es capaz de
generar la funcion rand.
Implementarla en un programa que solicite al usuario que ingrese el
rango de valores aleatorios y la
cantidad deseada de valor. A continuacion imprimir la lista de numeros
aleatorios segun el criterio
solicitado.
Ejemplo:
Ingrese minimo: 1
Ingrese maximo: 20
Ingrese cantida de valores: 10
1, 8, 20, 14, 11, 17, 2, 1, 5, 6.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 99999
int aleatorio (int, int);
int main()
{
int max, min,i,j ,v[N];
srand(time(NULL));
printf("Ingrese el maximo: \n");
scanf("%d", &max);
printf("Ingrese el minimo: \n");
do
{

86

2012
scanf("%d", &min);
if(min>max)
printf("Error! Reingrese un numero menor al maximo: ");
}while (min>max);
printf("Ingrese la cantidad de valores: \n");
do
{
scanf("%d", &i);
if(i<0)
printf("no se puede mostrar una cantidad negativa de veces. reingrese: ");
}while (i<0);
printf("\n");
for(j=0;j<i;j++)
{
v[j]=aleatorio(max, min);
printf("%d, ", v[j]);
}

return 0;
}
int aleatorio (int max, int min)
{
int c;
c=rand()%(max-min+1)+min;
return c;
}

87

2012

Ejercicio 4.5
Dado el siguiente programa, construir las funciones cuyos prototipos se
indican y de modo que el
programa genere la salida correspondiente. Todas las funciones cuyos
prototipos figuran deben ser
programadas y utilizadas sin modificar los tipos de los parametros ni el
tipo de dato de retorno.
#include <stdio.h>
void dibujar_fila(int);
void dibujar_rectangulo(int, int);
int main()
{
int alto, ancho;
printf("Ingrese ancho:");
scanf("%d", &ancho);
printf("Ingrese altura:");
scanf("%d", &alto);
dibujar_rectangulo(ancho, alto);
return 0;
}

Ejercicio 4.6
Dado el siguiente programa, construir las funciones cuyos prototipos se
indican y de modo que el
programa genere la salida correspondiente. Todas las funciones cuyos
prototipos figuran deben ser
programadas y utilizadas sin modificar los tipos de los parametros ni el
tipo de dato de retorno.
#include <stdio.h>
int ingresar_texto(void);
int es_letra(unsigned char);
int main()
{
int len;
printf("Ingrese texto (punto para finalizar):");
len = ingresar_texto();
printf("\nEl texto tiene %d letras.", len);
return 0;
}
#include <stdio.h>
void dibujar_fila(int);

88

2012
void dibujar_rectangulo(int, int);
int main()
{
int alto, ancho;
printf("Ingrese ancho:");
scanf("%d", &ancho);
printf("Ingrese altura:");
scanf("%d", &alto);
dibujar_rectangulo(ancho, alto);
return 0;
}
void dibujar_fila(int anch)
{
int c;
for(c=0;c<anch;c++)
{
printf("*");
}
}
void dibujar_rectangulo(int anch, int alt)
{
int f;
for(f=0;f<alt;f++)
{
dibujar_fila (anch);
printf("\n");

89

2012
}
}

Ejercicio 4.7
Programar una funcion que tome como parametro un texto y que
convierta sus letras mayusculas en
minusculas y todo lo que no sean ni letras ni numeros, se conviertan en
espacios. Utilizarla en un
programa en el que se ingrese un texto de hasta 1000 caracteres y
luego se imprima la version
modificada del texto. El texto debe contener \0 como caracter final a fin
de que pueda imprimirse
con printf(%s, texto);
#include <stdio.h>
#include <conio.h>
#define N 1000
int es_letra_o_numero(char);
int es_mayuscula(char);
void trans_texto(char[], int);
int main()
{
int i=0, l;
char texto[N];
printf("Ingrese el texto:\n");
do
{
l=getche();
if(l!='\r')
{
texto[i]=l;
i++;

90

2012
}

}while(l!='\r');
texto[i]='\0';
trans_texto(texto, i);
printf("\ntexto modificado: %s", texto);
return 0;
}
int es_letra_o_numero(char a)
{
return((a>='a'&&a<='z')||(a>='A'&&a<='Z')||(a>='0'&&a<='9'));
}
int es_mayuscula (char l)
{
return(l>='A'&&l<='Z');
}
void trans_texto(char texto[], int i)
{
int j;
for(j=0;j<i;j++)
{
if(!es_letra_o_numero(texto[j]))
texto[j]=' ';
else
{
if(es_mayuscula(texto[j]))

91

2012
texto[j]=texto[j]+32;
}
}
}

Ejercicio 4.8
Realizar una funcion que permita ingresar en un arreglo de caracteres
(string) solamente caracteres
numericos (ignorar y no mostrar en pantalla cuando se ingrese un
caracter que no sea numero).
Luego, programar otra funcion que tome ese arreglo de caracteres y lo
convierta a un valor numerico entero. Utilizar ambas funciones en un
programa en que se ingrese un numero y luego se
convierta a entero para ser impreso mediante printf(%d, numero).
#include <stdio.h>
#include <conio.h>
#define N 1000
int number(char[], int);
int main()
{
int i=0;
char numero[N]={0}, l;
printf("Ingrese los numeros:\n");
do
{
l=getch();
if(l>='0'&&l<='9')
{
printf("%c", l);
numero[i]=l;
i++;

92

2012
}

}while(l!='\r'&&i<N-2);
numero[i]='\0';
int j=0;
j=number(numero,i);
printf("\nnumero: %s\n", numero);
printf("\nnumero: %d\n", j);
for(j=0;j<i;j++)
printf("%d", numero[j]);
return 0;
}

int number (char numero[], int i)

{
int num=0, j;
for(j=0;j<i;j++)
{
num=num*10+(numero[j]-48);
}
return num;
}

Ejercicio 4.9
Elabore un programa que cargue un arreglo con 100 numeros al azar
entre 1 y 100. Luego obtener el
valor maximo y el valor minimo presentes en el arreglo.
#include <stdio.h>
#include <stdlib.h>

93

2012
#include <time.h>
#define N 100

int main()
{
int numero[N]={0},i=0, j, max, min;
srand(time(NULL));
do
{
numero[i]=rand()%100+1;
i++;
}while(i<N);
max=numero[0];
min=numero[0];
for(j=0;j<i;j++)
{
if(numero[j]>max)
max=numero[j];
else
{
if(numero[j]<min)
min=numero[j];
}
}
printf("\nmaximo: %d\n", max);
printf("\nminimo: %d\n", min);

94

2012

Ejercicio 4.10
Realizar un programa que solicite al usuario una cantidad de numeros al
azar que se generara entre el
0 y el 36. Presentar luego un informe que indique que cantidad de veces
salio cada valor y el
porcentaje que representa. No mostrar aquellos numeros que no hayan
salido.
Ejemplo:
Ingrese cantidad de valores: 10
Informe:
El numero 8 salio 1 vez (10%).
El numero 14 salio 2 veces (20%).
El numero 20 salio 4 veces (40%).
El numero 23 salio 1 veces (10%).
El numero 30 salio 2 veces (20%).
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 99999

int main()
{
int numero[N]={0},i, j=0, cont=0;
srand(time(NULL));
printf("ingrese la cantidad de valores: ");
scanf("%d", &i);
do
{
j=rand()%37;
numero[j]++;
cont++;

}while(cont<=i);
95

2012
int k;
for(j=0;j<37;j++)
{
if(numero[j]>0)
printf("\nEl numero %d salio %d veces (%%%d)\n", j, numero[j],
(numero[j]*100)/i);

return 0;
}

Ejercicio 4.11
Realice una funcion que reciba como parametro un arreglo de hasta 10
enteros y luego calcule
el desvio estandar de esos valores. Programar otra funcion que calcule el
promedio de un arreglo.
Aplicar ambas funciones en un programa en el que se carguen los
valores del arreglo y luego
imprima el desvio estandar de dicho arreglo.
Ayuda:
El desvio estandar () es una medida estadistica de dispersion y la
formula usual para su calculo es:
N = Cantidad de valores
Xi = Cada uno de los valores
m = Es el promedio
(ver imagen de la formulita en el apunte de lirweb)
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define N 10
double promedio (int[]);
double desvio_estandard (int[],double);
int main()

96

2012
{
int numero[N],i=0;
double de, m;
printf("ingrese los valores: ");

do
{
scanf("%d", &numero[i]);
i++;
}while(i<N);
m=promedio(numero);
de=desvio_estandard(numero, m);
printf("La desviacion estandard de los valores ingresados es: %g", de);
return 0;
}
double promedio (int numero[])
{
int i;
double m=0;
for(i=0;i<N;i++)
{
m=m+numero[i];
}
m=m/N;
return m;
}

97

2012
double desvio_estandard(int numero[],double m)
{
int s=0, i;
for(i=0;i<N;i++)
s=s+((numero[i]-m)*(numero[i]-m));

double solucion;
solucion=sqrt((double)s/N);
return solucion;
}

Ejercicio 4.12
Rehacer los ejercicios 3.3 y 3.4 de la practica de arreglos, utilizando
funciones. Preste especial
atencion al codigo que se repite; identifiquelo, transcribalo a una funcion
y reescriba el main para
utilizarla.
3.3:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define N 7
ingrese(char[]);
AND(char[],char[], char[]);
OR(char[],char[], char[]);
NOT(char[],char[], char[]);
int main()
{
int i, menu;
char v[N], b[N], r[N], l;

98

2012
do{
printf("\nMenu\n");
printf("1 - AND\n");
printf("2 - OR\n");
printf("3 - NOT\n");
printf("4 - SALIR\n");
scanf("%d", &menu);

switch(menu)
{

case 1:
printf("\nIngrese el primer arreglo:");
ingrese (v);
printf("\nIngrese el segundo arreglo:");
ingrese(b);
AND(v,b,r);
printf("\nEl arreglo resultante es: %s", r);
break;

case 2:
printf("\nIngrese el primer arreglo:");
ingrese(v);
printf("\nIngrese el segundo arreglo:");
ingrese(b);
OR(v,b,r);

99

2012
printf("\nEl arreglo resultante es: %s", r);

break;

case 3:
i=0;
printf("\nIngrese el arreglo:");
ingrese(v);
NOT(v,b,r);
printf("\nEl arreglo resultante es: %s", r);
break;

case 4:
printf("\nTerminado. Tenga un buen dia!.");
break;

default:
printf("\nOpcion no valida. Por favor reintente: ");
break;
}
}while(menu!=4);
return 0;
}
ingrese(char v[])
{
int i=0;

100

2012
char l;
do
{
l=getche();

if(l=='0'||l=='1')
{
v[i]=l;
i++;
}
}while(i<6);
v[i]='\0';
}
AND(char v[],char b[], char r[])
{
int i;
for(i=0;i<6;i++)
{
if(v[i]=='1'&&b[i]=='1')
r[i]='1';
else
r[i]='0';
}
r[i]='\0';

101

2012
OR(char[],char[], char[])
{
int i;
for(i=0;i<6;i++)
{
if(v[i]=='1'||b[i]=='1')
r[i]='1';
else
r[i]='0';
}
r[i]='\0';
}
NOT(char[],char[], char[])
{
int i;
for(i=0;i<6;i++)
{
if(v[i]=='1')
r[i]='0';
else
r[i]='1';
}
r[i]='\0';
}
3.4:
#include <stdio.h>

102

2012
#include <stdlib.h>
#define N 1000
int repetido (int[], int, int);
int ingrese (int[]);
imprimir_resultado(int[], int);
int main()
{
int i, j, k, m, sen=0, menu, l, v[N], b[N], r[N*2];
do{
printf("\nMenu\n");
printf("1 - UNION\n");
printf("2 - INTERSECCION\n");
printf("3 - DIFERENCIA\n");
printf("4 - SALIR\n");
scanf("%d", &menu);

switch(menu)
{
case 1:

printf("\nIngrese el primer arreglo:");

i=ingrese(v);
printf("\nIngrese el segundo arreglo:");
k=ingrese(b);
//pedaso que checkea si guardar en el arreglo solucion o no.
for(m=0;m<i;m++)

103

2012
{
r[m]=v[m];
}
for(j=0;j<k;j++)
{
sen=0;
sen=repetido(r,m,b[j]);
sen=repetido(v,m,b[j]);
if(sen==0)
{
r[m]=b[j];
m++;
}
}
imprimir_resultado(r,m);
break;
case 2:
printf("\nIngrese el primer arreglo:");
i=ingrese(v);
printf("\nIngrese el segundo arreglo:");
k=ingrese(b);
m=0;
for(j=0;j<i;j++)
{
sen=0;
sen=repetido(b,k,v[j]);

104

2012
if(sen==1)
{
r[m]=v[j];
m++;
}
}
imprimir_resultado(r,m);

break;
case 3:
printf("\nIngrese el primer arreglo:");
i=ingrese(v);
printf("\nIngrese el segundo arreglo:");
k=ingrese(b);
for(j=0;j<i;j++)
{
sen=repetido(b,k,v[j]);
if(sen==0)
{
r[m]=v[j];
m++;
}
}
imprimir_resultado(r,m);
break;
case 4:

105

2012
printf("\nTerminado. Tenga un buen dia!.");
break;
default:
printf("\nOpcion no valida. Por favor reintente: ");
break;
}
}while(menu!=4);
return 0;
}
int ingrese(int v[])
{
int i=0, sen, l;
do
{
scanf("%d", &l);
sen=repetido(v,i,l);
if(sen==0)
{
v[i]=l;
i++;
}
}while(i<N-1&&l!=0);
i--;
return i;
}
int repetido (int v[], int i, int l)

106

2012
{
int j, sen=0;
for(j=0;j<i;j++)
{
if(v[j]==l)
sen=1;
}
return sen;
}
imprimir_resultado(int r[], int m)
{
printf("El arreglo resultante es: ");
int i;
for(i=0;i<m;i++)
{
printf("%d-", r[i]);
}
}

Ejercicio 4.13
Realizar un programa que contenga las siguientes funciones:
a. Una funcion que permita cargar un texto de hasta 1000 caracteres
finalizando dicha carga con
ENTER. El arreglo debe contener el caracter \0 como marca de
finalizacion de acuerdo con la
convencion utilizada en el lenguaje C.
b. Una funcion que reciba como parametro una frase y que retorne
cuantas palabras tiene esa
frase.
c. Una funcion que reciba como parametro una frase y que retorne la
longitud promedio de las
palabras de esa frase.

107

2012

d. Una funcion que reciba como parametro una frase y que modifique el
contenido de dicha
frase de modo que la primera letra de cada palabra quede en
mayuscula.
En base a estas funciones, Realizar un programa en el que se ingrese
una frase y a continuacion se
muestren por pantalla los resultados obtenidos mediante las funciones
creadas en los puntos b, c y d.
Considere programar funciones adicionales.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define N 1001
a (char[]);
int b(char[]);
double c (char[]);
d (char[]);
int es_separador(char);
int es_minuscula(char);
int main()
{
char texto[N];
int cantidad_palabras;
double promedio;
a(texto);
printf("\nTexto original:%s", texto);
cantidad_palabras=b(texto);
printf("\nCantidad de palabras: %d", cantidad_palabras);
promedio=c(texto);
printf("\nPromedio de longitud de las palabras: %.2lf", promedio);

108

2012
d(texto);
printf("\nTexto modificado: %s", texto);
return 0;
}
a(char texto[])
{
int i=0;
char l;
printf("Ingrese el texto: ");
do
{
l=getche();
if(l!='\r')
{
texto[i]=l;
i++;
}
}while(i<N-1&&l!='\r');
texto[i]='\0';
}
int es_separador(char l)
{
return(l==' '||l==','||l==';'||l=='?'||l=='!');
}
int b (char texto[])
{

109

2012
int cont=0, sen=0, i;
for(i=0;i<N-1&&texto[i]!='\0';)
{
sen=0;
while(es_separador(texto[i])&&texto[i]!='\0')
i++;
while(!es_separador(texto[i])&&texto[i]!='\0')
{
sen=1;
i++;
}
if(sen==1)
cont++;

}
return cont;
}
double c (char texto[])
{
/*c. Una funcion que reciba como parametro una frase y que retorne la
longitud promedio de las
palabras de esa frase.*/
int cant_pal[N/2]={0}, i, suma=0, j=0, sen;
for(i=0;(i<N-1)&&(texto[i]!='\0');)
{
sen=0;
while(es_separador(texto[i])&&texto[i]!='\0')

110

2012
i++;
while(!es_separador(texto[i])&&texto[i]!='\0')
{
cant_pal[j]++;
sen=1;
i++;
}
if(sen==1)
{
suma=suma+cant_pal[j];
j++;
}

}
double resultado;
resultado=suma/(double)j;

return resultado;
}
d (char texto[])
{
int sen=0, i;
for(i=0;i<N-1&&texto[i]!='\0';)
{
sen=0;
while(es_separador(texto[i])&&texto[i]!='\0')

111

2012
i++;
while(!es_separador(texto[i])&&texto[i]!='\0')
{
if(sen==0)
{
if(es_minuscula(texto[i]))
texto[i]-=32;
}
sen=1;
i++;
}
}
}
int es_minuscula(char l)
{
return(l>='a'||l<='z');
}

Ejercicio 4. 14
Realizar un programa que contenga las siguientes funciones:
a. Una funcion que permita cargar un texto de hasta 1000 caracteres
finalizando dicha carga con
ENTER. El arreglo debe contener el caracter \0 como marca de
finalizacion de acuerdo con
la convencion utilizada en el lenguaje C.
b. Una funcion booleana que reciba como parametros dos palabras (en
dos arreglos
independientes) y que indique si ambas palabras son iguales (considerar
mayusculas y
minusculas como iguales).
c. Una funcion que reciba como parametros una frase y una palabra
(considerar mayusculas y
112

2012

minusculas como iguales) y que retorne cuantas veces aparece dicha

palabra en la frase.
d. Una funcion booleana que reciba como parametros dos frases (en dos
arreglos
independientes) y que determine si ambas frases son iguales. Es decir,
cuando contengan las
mismas palabras en el mismo orden. Por ejemplo: Hola, como te va?
debe ser considerada
igual a hola Como te va!
En base a estas funciones, Realizar un programa en el que se ingresen
por teclado dos frases y una
palabra. A continuacion, el programa debera mostrar por pantalla
cuantas veces aparece la palabra
ingresada en cada una de las frases ingresadas y si ambas frases son
iguales. Considere programar
funciones adicionales y utilizar la funcion del punto b en los puntos c y d.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define N 1001
void a (char[]);
int b(char[], char[]);
int c (char[], char[]);
int d (char[], char[]);
int es_separador(char);
int es_minuscula(char);
int es_letra(char);
int main()
{
char texto1[N], texto2[N], palabra[N], sen;
int cant_pal_rep1,cant_pal_rep2;
a(texto1);
printf("\n");

113

2012
a(texto2);
printf("\n");
a(palabra);
cant_pal_rep1=c(texto1, palabra);
printf("\ncantidad de veces que se repite la palabra en el texto 1: %d",
cant_pal_rep1);
cant_pal_rep2=c(texto2, palabra);
printf("\ncantidad de veces que se repite la palabra en el texto 2: %d",
cant_pal_rep2);
sen=d(texto1,texto2);
if(sen==1)
printf("\nlos textos son iguales");
else
printf("\nlos textos son distintos");

return 0;
}
void a(char texto[])
{
int i=0;
char l;
printf("Ingrese el texto: ");
do
{
l=getche();
if(l!='\r')
{

114

2012
texto[i]=l;
i++;
}
}while(i<N-1&&l!='\r');
texto[i]='\0';
}
int es_separador(char l)
{
return(l==' '||l==','||l==';'||l=='?'||l=='!');
}
int b (char palabra1[],char palabra2[])
{
/*b. Una funcion booleana que reciba como parametros dos palabras (en dos
arreglos
independientes) y que indique si ambas palabras son iguales (considerar
mayusculas y
minusculas como iguales).*/
int sen=1, i;
for(i=0;palabra1[i]!='\0'&&palabra2[i]!='\0'&&sen==1;i++)
{
if(palabra1[i]==palabra2[i])
sen=1;
else
sen=0;
}
return sen;
}

115

2012
int c (char texto[], char palabra[])
{
/*c. Una funcion que reciba como parametros una frase y una palabra
(considerar mayusculas y
minusculas como iguales) y que retorne cuantas veces aparece dicha palabra
en la frase.*/
int sen=1, i, cont=0, j;
for(i=0;texto[i]!='\0';i++)
{
sen=1;
j=0;
if(es_minuscula(palabra[j]))
palabra[j]-=32;
if(texto[i]==palabra[j]||texto[i]==palabra[j]+32)
{
i++;
j++;
while(palabra[j]!='\0'&&sen==1)
{
if(es_minuscula(palabra[j]))
palabra[j]-=32;
if(texto[i]==palabra[j]||texto[i]==palabra[j]+32)
sen=1;
else
sen=0;
j++;
i++;

116

2012
}
if(es_separador(texto[i])||texto[i]=='\0')
sen=1;
else
sen=0;
if(sen==1)
cont++;
}

}
return cont;
}
int d (char texto1[],char texto2[])
{
/*d. Una funcion booleana que reciba como parametros dos frases (en dos
arreglos
independientes) y que determine si ambas frases son iguales. Es decir, cuando
contengan las
mismas palabras en el mismo orden. Por ejemplo: Hola, como te va? debe ser
considerada
igual a hola Como te va!*/
int i=0, j=0, sen=1;
while(texto1[i]!='\0'&&texto2[i]!='\0'&&sen==1)
{
if(es_letra(texto1[i]))
{
if(es_minuscula(texto1[i]))
texto1[i]-=32;
117

2012
if(es_letra(texto2[j]))
{
if(es_minuscula(texto2[j]))
texto2[j]-=32;
if(texto1[i]!=texto2[j])
sen=0;
else
{
j++;
i++;
}
}
else
j++;
}
else
i++;

}
return sen;
}
int es_minuscula(char l)
{
return (l>='a'&&l<='z');
}
int es_letra(char l)

118

2012
{
return ((l>='A'&&l<='Z')||(l>='a'&&l<='z'));
}

En este programita tengo q avisar q ni use una funcin asique probablemente

no sea asi como tendra que estar hecho, pero no se me ocurrio de otra
manera..

119