Informática I: Ejercicios Resueltos

2012
1
Informáticá I: Ejercicios Resueltos
Practica 1.........................................................................................................................................3
Ejercicio 1.1 ......................................................................................................................................... 3
Ejercicio 1.2 ......................................................................................................................................... 3
Ejercicio 1.3 ......................................................................................................................................... 4
Ejercicio 1.4 ......................................................................................................................................... 5
Ejercicio 1.5 ......................................................................................................................................... 6
Ejercicio 1.6 ......................................................................................................................................... 6
Ejercicio 1.7 ......................................................................................................................................... 7
Ejercicio 1.8 ......................................................................................................................................... 8
Ejercicio 1.9 ......................................................................................................................................... 9
Ejercicio 1.10 ..................................................................................................................................... 11
Ejercicio 1.11 ..................................................................................................................................... 13
Ejercicio 1.12 ..................................................................................................................................... 14
Ejercicio 1.13 ..................................................................................................................................... 16
Ejercicio 1.14 ..................................................................................................................................... 17
Ejercicio 1.15 ..................................................................................................................................... 19
Ejercicio 1.16 ..................................................................................................................................... 22
Ejercicio 1.17 ..................................................................................................................................... 23
Ejercicio 1.18 ..................................................................................................................................... 25
Ejercicio 1.19 ..................................................................................................................................... 26
Ejercicio 1.20 ..................................................................................................................................... 29
Practica 2......................................................................................................................................31
Estructuras de repetición.......................................................................................................31
Ejercicio 2.1 ....................................................................................................................................... 31
Ejercicio 2.2 ....................................................................................................................................... 31
Ejercicio 2.3 ....................................................................................................................................... 32
Ejercicio 2.4 ....................................................................................................................................... 33
Ejercicio 2.5 ....................................................................................................................................... 34
Ejercicio 2.6 ....................................................................................................................................... 35
Ejercicio 2.7 ....................................................................................................................................... 36
Ejercicio 2.8 ....................................................................................................................................... 38
Ejercicio 2.9 ....................................................................................................................................... 39
Ejercicio 2.10 ..................................................................................................................................... 40
Ejercicio 2.11 ..................................................................................................................................... 42
Ejercicio 2.12 ..................................................................................................................................... 44
Ejercicio 2.13 ..................................................................................................................................... 46
Ejercicio 2.14 ..................................................................................................................................... 47
Ejercicio 2.15 ..................................................................................................................................... 49

2012
2
Ejercicio 2.16 ..................................................................................................................................... 50
Ejercicio 2.17 ..................................................................................................................................... 52
Ejercicio 2.18 ..................................................................................................................................... 54
Ejercicio 2.19 ..................................................................................................................................... 55
Ejercicio 2.20 ..................................................................................................................................... 56
Ejercicio 2.21 ..................................................................................................................................... 57
Practica 3......................................................................................................................................59
Arreglos ........................................................................................................................................59
Ejercicio 3.1 ....................................................................................................................................... 59
Ejercicio 3.2 ....................................................................................................................................... 60
Ejercicio 3.3 ....................................................................................................................................... 60
Ejercicio 3.4 ....................................................................................................................................... 66
Ejercicio 3.5 ....................................................................................................................................... 75
Ejercicio 3.6 ....................................................................................................................................... 77
Ejercicio 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
3
Practica 1
Ejercicio 1.1
Elaborar un programa en el que se ingrese un número 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=%dn 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 triángulo e informe su
superficie. El programa debe imprimir una leyenda que incluya los datos de entrada y el
resultado
con una precisión de 2 dígitos decimales.
Ejemplo:
Ingrese la base del triángulo: 8
Ingrese la altura del triángulo: 5
La superficie del triangulo de base 7 y altura 5 es 17.50
#include <stdio.h>
#include <stdlib.h>

2012
4
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 número real y, a continuación, se
muestre la parte entera de dicho número 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;

2012
5
Enum=num-Fnum;
printf("Parte entera: %gn", Enum);
printf("Parte fraccionaria: %gn", Fnum);
return 0;
}
Ejercicio 1.4
Desarrollar un programa en el que se ingrese un número de 5 dígitos y que luego muestre
cada
dígito separado por un guión.
Ejemplo:
Ingrese numero: 45212
Separacion en dígitos: 4-5-2-1-2.
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num, num1, num2, num3, num4, num5;
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;

2012
6
//lo hice asi choto a proposito podria haber validado y usado un while. includo un arreglo.
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 triángulo rectángulo y
que
se calcule y muestre el perímetro de dicho triángulo. Incluir math.h a fin de utilizar la función
sqrt(expresión) que calcula la raíz cuadrada de un número.
#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 días, horas, minutos y segundos.
Ejemplo:

2012
7
Ingrese tiempo en segundos: 93714
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 números enteros positivos y que genere y
muestre un tercer numero que esté compuesto por las unidades del primer número 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
8
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 raíces reales de una ecuación cuadrática. El usuario
ingresará
los coeficientes a, b y c tal que ax² + bx + c=0. Cuando las raíces no sean reales, se mostrará un
mensaje indicando esta situación.
Ejemplo:
Ingrese coeficiente a: 2
Ingrese coeficiente b: 3
Ingrese coeficiente c: 1
La raíz 1 es: 0.50
La raíz 2 es: 1.00
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()

2012
9
{
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 raíz 1 es: %.2lf", x1);
printf("nLa raíz 2 es: %.2lf", x2);
}
return 0;
}
Ejercicio 1.9
Escriba un programa en el que se ingresen 2 números y un carácter (+,-,*,/) e informe el
resultado
de la operación.
Ejemplo:

2012
10
Ingrese el primer número: 8
Ingrese el segundo número: 2
Ingrese la operación (+,-,
*, /): +
8 + 2 =10
#include <stdio.h>
#include <conio.h>
int main()
{
int num1, num2;
char sign;
scanf("%d", &num1);
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;

2012
11
case '*':
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 mayúsculas o
minúsculas (no necesariamente todas del mismo tipo). A continuación el programa deberá
indicar
cuál 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;

2012
12
printf("Ingrese la primer letra: ");
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;

2012
13
}
if(let1<let2&&let1<let3)
printf("nLa letra que aparece primero en el alfabeto es '%c'", l1);
else
{
else
{
}
}
return 0;
}
Ejercicio 1.11
Hacer un programa en el que se ingrese un número real y que se muestre si el número es
positivo, negativo o cero. Adicionalmente deberá indicar si es natural, entero o real.
Ejemplo:
Ingrese un número: 13.4
El número es positivo y real.
#include <stdio.h>
#include <stdlib.h>
int main()
{
double num;
printf("Ingrese numeron");

2012
14
scanf("%lf", &num);
if(num>0)
{
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;
}
número es positivo y real.
Ejercicio 1.12
Realizar un programa que solicite al usuario ingresar una letra. Si la letra es mayúscula, debe
convertirla a minúscula 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

2012
15
La letra ingresada es una vocal. Su mayúscula es A.
Ejemplo 2:
Ingrese una letra: $
No se ingresó una letra.
#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

2012
16
printf("La letra ingresada el consonante. Su minuscula es %c", letr+32);
}
else
printf("El caracter no es una letra");
}
return 0;
}
Ejercicio 1.13
Realizar un programa en el que se ingresen dos números enteros positivos. Luego deberá
restar
el mayor del menor e indicar si dicha diferencia es un valor que está entre ambos números (es
decir, es mayor que el más chico y menor que el más 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");

2012
17
else
printf("nEl numero resultante de la resta NO esta entre los dos intresados");
}
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 múltiplo de 5 centavos. Es decir, si el importe fuera
de
$5,17.- entonces la suma a abonar sería $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>

2012
18
//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;}
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;

2012
19
else
num=0;
}
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 día, el mes y el año por
separado. Luego el programa mostrará una leyenda que indique si la fecha ingresada es
válida.
Ejemplo:
Ingrese el día: 29
Ingrese el mes: 2
Ingrese el año: 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
Ayuda: Para saber si un año es bisiesto: Si el año es divisible por 4, es bisiesto siempre y cuando
no sea divisible por 100. Cuando el año es divisible por 100 también debe ser divisible por 400.
Por ejemplo: el año 2000 es bisiesto pero el 1800 no lo es.
#include <stdio.h>
#include <stdlib.h>
int main()
{
int dia, mes, anio, sen=0;

2012
20
printf("Ingrese el dia: ");
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);

2012
21
}
else
{
if(mes==2)
{
if(dia<=28)
else
{
if(sen==1&&dia<=29)
else
}
}
else
{
if(dia<=30)
else
}
}
}
return 0;

2012
22
}
Ejercicio 1.16
Elaborar un programa que solicite al usuario que ingrese un número real y luego muestre el
Redondeo al entero más próximo de dicho número, 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 más próximo hacia abajo.
Techo: El entero más próximo 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:
Piso = 8
Techo = 9
Redondeo = 9
Ejemplo 4:
Piso = 9
Techo = 8
Redondeo = 9
#include <stdio.h>
#include <stdlib.h>
int main()
{
double num;
int piso, techo, redondeo;
printf("Ingrese el numero: ");

2012
23
scanf("%lf", &num);
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
continuación
se mostrará por pantalla un mensaje que indique la situación del alumno:
• Si el alumno aprobó los 3 parciales (nota 4 o más) 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 más 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 condición de aprobado (aún 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>

2012
24
int main()
{
int nota1, nota2, nota3, notar;
double prom;
printf("Ingrese la nota del primer parcial: ");
scanf("%d", &nota1);
printf("Ingrese la nota del segundo parcial: ");
printf("Ingrese la nota del tercer parcial: ");
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;
}

2012
25
Ejercicio 1.18
Una empresa necesita calcular un bono que dará a sus empleados a fin de este año. Para ello
se
sigue el siguiente criterio:
• 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 categoría 1, 2 ó 3, recibe un 10% del sueldo. Si pertenece a
la categoría 4, 5 ó 6, recibe un 12% del sueldo. Si es de la categoría 7, 8 ó 9, recibe un
20% del sueldo pero no cobra el plus por tener hijos.
Realizar el programa que solicite la información 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 categoría (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)

2012
26
bono=sueldo*0.15;
else
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)
else
{
if(categoria==4||categoria==5||categoria==6)
else
}
printf("El sueldo total sera de %.2lf", bono+sueldo);
return 0;
}
Ejercicio 1.19
Según las normas de tránsito, un automóvil no puede superar la velocidad máxima ni circular
a
menos que la velocidad mínima (que es la mitad de la velocidad máxima). Por una cuestión de
errores de medición (tanto en el automóvil como en los dispositivos de control) hay un 15%
de tolerancia. Sin embargo, se permite que los vehículos en emergencia (ambulancias,
patrulleros,
etc.) superen la velocidad máxima (no así, circular a menos que la velocidad mínima). Hacer
un
programa en el que se ingrese la velocidad a la que circula un vehículo, la velocidad máxima
permitida y si se trata o no de un vehículo en emergenciá (contestándo con “S” o “N” en
mayúscula o minúscula). Luego determinar el tipo de multa e imprimir el correspondiente
mensaje
según el siguiente criterio:

2012
27
• Si lá velocidád está entre lá máximá y lá mínimá (ámbás inclusive), “No recibe multá”.
• Si la velocidad está dentro de la tolerancia máxima (superando la máxima hasta el 15%,
por ejemplo, párá máximá de 60 km/h lá toleránciá llegá hástá 69 km/h), “Recibe
ádvertenciá”. No se áplicá si es un vehículo en emergenciá que, en este cáso, “No recibe
multá”.
• Si la velocidad dentro de la tolerancia mínima (hasta 15% por debajo de la velocidad
mínimá), “Recibe ádvertenciá”. Este cáso es independiente del tipo de vehículo.
• Si superá lá velocidád máximá y el límite de toleránciá, “Recibe multá por exceso de
velocidád”. No se áplicá si es un vehículo en emergenciá que, en este cáso, “No recibe
multá”.
• Si excede lá toleránciá de velocidád mínimá, “Recibe multá por entorpecer el tránsito”. Este
caso es independiente del tipo de vehículo.
#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

2012
28
{
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 tránsito");
}
}
}
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 tránsito");
}

2012
29
}
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 teléfono
celular
cuando suena, en base a las condiciones que se enumeran a continuación. El programa debe
preguntar al alumno lo siguiente:
¿Es de mañana?
¿El llamado es de tu casa?
¿Estás en clase en este momento?
El usuário debe contestár á esás preguntás con ‘s’ o ‘n’ (tener en cuentá que el usuário puede
contestar en minúsculas o mayúsculas.) El criterio para decidir si se atiende o no el teléfono es
el
siguiente: El alumno normalmente atiende el teléfono, con excepción de los llamados
recibidos
durante la mañana (que no los atiende.) Ahora bien, si lo están llamando de la casa, el alumno
debe atender igual sin importar el momento del día, a menos que en el momento que suena se
encuentre en clase, en cuyo caso no atiende (NUNCA se debe atender el teléfono 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” según correspondá.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main()
{
char manana, casa, clase;

2012
30
printf("Por favor, responda las siguientes preguntas con 's' o 'n' segun correspondan");
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
{

2012
31
printf("DEBE ATENDER");
}
}
}
return 0;
}
Practica 2
Estructuras de repetición
Ejercicio 2.1
Elaborar un programa que solicite al usuario que ingrese un número entero y determine si el
mismo es un número 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;
}
Ejercicio 2.2
Escribir un programa que encuentre los primeros 4 números perfectos. Un número perfecto
es un

2012
32
entero positivo, que es igual a la suma de todos los enteros positivos (excluido él mismo)
que son
divisores del número. Por ejemplo, el primer número 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 perfecton", num);
}
cont=0;
}
return 0;
}
Ejercicio 2.3
Hacer un programa que encuentre e imprima un listado con todos los números de 4 cifras
que
cumplan la condición de que la suma de las cifras de orden impar es igual a la suma de las
cifras de
orden par. Por ejemplo, el número 7821 cumple esta condición ya que 7 + 2 = 8 + 1.
#include <stdio.h>
#include <stdlib.h>
int main()

2012
33
{
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("%dn", num);
}
return 0;
}
Ejercicio 2.4
Realizar un programa en el que se ingresa una letra a buscar y luego un texto de tamaño
indefinido
(hasta ingresar punto). Luego, el programa debe informar cuántas 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>
int main()
{

2012
34
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 cuántas de sus letras fueron mayúsculas y cuántas
fueron
minúsculas. Por ejemplo, para el texto “Hola Mundo” debe obtenerse 2 mayúsculas y 7
minúsculas
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main()
{

2012
35
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 cuántas de las letras ingresadas fueron vocales (contar tanto mayúsculas
como
minúsculas) y cuántas fueron consonantes (contar tanto mayúsculas como minúsculas). 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.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

2012
36
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;
}
Ejercicio 2.7
Construir un programa en el que se ingresen números enteros hasta que se hayan ingresado
5
números pares e informar si alguno de ellos es también múltiplo de cuatro.
#include <stdio.h>

2012
37
#include <stdlib.h>
int main()
{
int num, cont=0, sen=0, div;
do
{
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
{
div=0;
do
{
div--;

2012
38
if(div*4==num)
sen=1;
}while(div*4>=num);
}
}while(cont<=4);
if(sen==1)
printf("Hay por lo menos un multiplo de 4n");
else
printf("No hay multiplos de 4");
return 0;
}
Ejercicio 2.8
Escribir un programa que reciba una cantidad indefinida de números enteros positivos hasta
que se
ingresa el 0. A continuación el programa debe indicar cuál fue el mayor y cuál el menor.
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num, may, men, sen=0;
scanf("%d", &num);
if(num!=0)
{

2012
39
may=num;
men=num;
}
else
{
printf("No se ingresaron valores utiles.");
sen=1;
}
while(num!=0)
{
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;
}
Ejercicio 2.9
Armar un programa en el que se ingrese un número entero decimal (base diez) y convertirlo
a
binario.
#include <stdio.h>
#include <stdlib.h>

2012
40
int main()
{
int num, pot=1, bin=0, guard_num;
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 máximo común divisor (MCD) de dos números 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 división es cero, el número b es el máximo común divisor. Si la división no es
exacta, el
valor de a pasa a ser b y el nuevo valor de b será el resto de la división anterior. Se repite el
procedimiento hasta obtener un resto cero. El último divisor (b) es el mcd buscado. Escribir
un
programa que calcule el mcd de dos números 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.

2012
41
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a, b, aux, resto, guarda, guardb;
scanf("%d", &a);
guarda=a;
scanf("%d", &b);
guardb=b;
if(b>a)
{
aux=b;
b=a;
a=aux;
}
while(a%b!=0)
{
resto=a%b;
a=b;
b=resto;
}
printf("El MCD entre %d y %d es: %d",guarda , guardb, b);

2012
42
return 0;
}
Ejercicio 2.11
Escribir un programa que permita ingresar las notas de una cantidad indefinida de alumnos.
A
continuación 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
válidas
(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()
{
int nota, aplazados=0, aprovados=0, promocionantes=0, total, pcapl, pcapr,pcpro;
do
{
printf("Ingrese nota: ");
scanf("%d", &nota);

2012
43
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");
else
{
total=aplazados+aprovados+promocionantes;
pcpro=(promocionantes*100)/total;
pcapr=(aprovados*100)/total;

2012
44
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 minúscula y que brinde al usuario
tres
operaciones posibles a través de un menú de opciones. La primera opción devolverá la
mayúscula
correspondiente. La segunda opción devolverá la letra siguiente en el alfabeto (si la letra
ingresada
fuera “z” se debe informar que es la última). La tercera opción devolverá la letra anterior en
el
alfabeto siempre que la letra ingresada no sea “a”. Validar que efectivamente el carácter
ingresado
sea una letra minúscula o * (este último determina el final de la serie de opciones).
Ejemplo:
Ingrese letra: f
1 – Convertir a mayúscula
2 – Obtener la siguiente
3 – Obtener la anterior
Escoja una operación (1 – 3): 1
La mayúscula es F.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main()
{
char letra;
int menu;

2012
45
do
{
printf("Ingrese la letra: ");
letra=getche();
printf("n");
}while(letra<'a'||letra>'z');
do
{
printf("1 - Convertir a mayusculan");
printf("2 - Obtener la siguienten");
printf("3 - Obtener la anteriorn");
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;
printf("La mayuscula es %c", letra);
break;
case 2:
letra=letra+1;
printf("La siguiente es: %c", letra);
break;

2012
46
case 3:
letra=letra-1;
printf("La anterior es: %c", letra);
break;
}
return 0;
}
Ejercicio 2.13
Realizar un programa para calcular utilidades de inversión en plazos fijos. Para esto, se
ingresarán
las cantidades que serán los importes mensuales que el cliente desea invertir (cantidad = 0
para
terminar). Luego se debe obtener el resultado de la colocación 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) más 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
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 = Inversión + Intereses = 2000 + 3000 + 1000 + 86.67 = 6086.67
#include <stdio.h>
#include <stdlib.h>

2012
47
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);
}
}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 número entero impar (validar el
valor
ingresado). El programa tendrá que dibujar en la ventana un triángulo de asteriscos cuya
base sea el

2012
48
valor ingresado.
Ejemplo:
Ingrese número: 8
Número no válido. Ingrese número: 11
*
***
*****
*******
*********
***********
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num, f, c, ast=1, blancos;
do
{
scanf("%d", &num);
if(num%2!=1)
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++)
{

2012
49
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 triángulo rectángulo.
Luego
dibujar en la ventana dicho triángulo como se muestra en el ejemplo.
Ejemplo:
Ingrese base: 5
*
**
***
****
*****
#include <stdio.h>
#include <stdlib.h>
int main()
{

2012
50
int num, f, c;
do{
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 triángulo rectángulo.
Luego
dibujar en la ventana dicho triángulo como se muestra en el ejemplo.
Ejemplo:
Ingrese base: 5
*
**
***
****
*****
#include <stdio.h>
#include <stdlib.h>
int main()

2012
51
{
int num, f, c, blancos, ast=1;
do{
scanf("%d", &num);
}while(num<2);
blancos=num-1;
{
{
printf(" ");
}
blancos--;
for(c=1; c<=ast; c++)
{
printf("*");
}
ast++;
printf("n");
}
return 0;
}

2012
52
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{
scanf("%d", &num);
blancos=num/2;
}while(num<3||num%2!=1);
for(f=1; f<=num/2+1; f++)
{

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

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

2012
55
Ejercicio 2.19
Efectuar un programa que solicite al usuario que ingrese la base y la altura de un
rectángulo. Luego
deberá dibujar en la ventana dicho rectángulo.
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);
for(f=1; f<=alt; f++)
{

2012
56
for(c=1; c<=base ; c++)
{
printf("*");
}
printf("n");
}
return 0;
}
Ejercicio 2.20
La operación factorial de un número 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 número entero. El programa principal
debe
solicitar el ingreso de un número entero, verificar si se trata de un número mayor o igual a 0
y
calcular su factorial. En caso de que el usuario ingresara un número negativo, imprimir una
advertencia.
Ejemplos:
Ingrese un número entero: 5
El factorial de 5 es: 120
Ingrese un número entero: -10
No se puede calcular el factorial de un número negativo.
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num, cont, res;

2012
57
do{
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 número entero positivo (de cualquier cantidad
de
cifras) y determine si es un número capicúa. Un número capicúa es aquel que leído de
izquierda a
derecha es igual que leído de derecha a izquierda. Por ejemplo: 82428. Considere invertir el
número
y luego compararlo con el número original. Si resultan iguales, será capicúa.
#include <stdio.h>
#include <stdlib.h>

2012
58
int main()
{
int num, aux, res=0;
do{
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;
}

2012
59
Practica 3
Arreglos
Ejercicio 3.1
Realice un programa que permita cargar números 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
continuación imprimir este último.
Ejemplo:
Ingrese número: 20
Ingrese número: 21
Ingrese número: 14
Ingrese número: 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{
scanf("%d", &v[i]);
i++;
}while(v[i-1]!=0);
i-=2;
while(i>=0)

2012
60
{
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 números 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 opción elegida el programa deberá permitir la carga de uno o dos (según
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 opción: 1

2012
61
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 opción: 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("nMenun");
printf("1 - ANDn");
printf("2 - ORn");
printf("3 - NOTn");
printf("4 - SALIRn");
scanf("%d", &menu);
switch(menu)
{

2012
62
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);

2012
63
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;
do
{
l=getche();
if(l=='0'||l=='1')
{
v[i]=l;
i++;
}
}while(i<6);
v[i]='0';

2012
64
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';
break;
case 3:
i=0;
printf("nIngrese el arreglo:");

2012
65
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';
break;
case 4:
printf("nTerminado. Tenga un buen dia!.");
break;
default:
printf("nOpcion no valida. Por favor reintente: ");

2012
66
break;
}
}while(menu!=4);
return 0;
}
Ejercicio 3.4
Elaborar un programa que permita cargar dos arreglos numéricos 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 continuación se efectuara la operación 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("nMenun");
printf("1 - UNIONn");
printf("2 - INTERSECCIONn");
printf("3 - DIFERENCIAn");
scanf("%d", &menu);

2012
67
switch(menu)
{
case 1:
i=0;
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--;

2012
68
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;
for(j=0;j<k;j++)

2012
69
{
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;
case 2:

2012
70
i=0;
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--;
k=0;
do
{

2012
71
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])
sen=1;

2012
72
}
if(sen==1)
{
r[p]=v[n];
p++;
}
}
for(i=0;i<p;i++)
{
}
break;
case 3:
i=0;
do
{
sen=0;
scanf("%d", &l);
for(j=0;j<i;j++)
{
if(v[j]==l)
sen=1;

2012
73
}
if(sen==0)
{
v[i]=l;
i++;
}
}while(i<N-1&&v[i-1]!=0);
i--;
k=0;
do
{
sen=0;
scanf("%d", &l);
for(j=0;j<k;j++)
{
if(b[j]==l)
sen=1;
}
if(sen==0)
{

2012
74
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++;
}
}
for(i=0;i<p;i++)
{

2012
75
}
break;
case 4:
break;
default:
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 carácter a reemplazar: a
Ingrese carácter de reemplazo: e
Resultado: Le mer estebe serene
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define N 101
int main()
{

2012
76
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')
{

2012
77
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: %sn", 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
#include <stdio.h>
#include <stdlib.h>

2012
78
#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("%sn", text);
for(cont=0;cont<80-i;cont++)
printf(" ");
printf("%sn", text);
return 0;

2012
79
}
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, $@
#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++;
}

2012
80
}while (l!='r'&&i<N);
trans (text, i);
printf("n%sn", 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++;
}
}

2012
81
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( p - a)( p - b)( p - c)
siendo p =(a +b +c) ÷2
#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);

2012
82
do
{
scanf("%d", &b);
}while (b<=0);
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

2012
83
La raiz 3 de 14 es = 2.410142
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);

2012
84
resultado=raiz(x, n);
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

2012
85
{
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);

2012
86
return c;
}
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

2012
87
{
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;

2012
88
}
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>

2012
89
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;
}
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);

2012
90
printf("n");
}
}
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')
{

2012
91
texto[i]=l;
i++;
}
}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

2012
92
{
if(es_mayuscula(texto[j]))
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);

2012
93
numero[i]=l;
i++;
}
}while(l!='r'&&i<N-2);
numero[i]='0';
int j=0;
j=number(numero,i);
printf("nnumero: %sn", numero);
printf("nnumero: %dn", 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;
}

2012
94
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>
#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)

2012
95
min=numero[j];
}
}
printf("nmaximo: %dn", max);
printf("nminimo: %dn", min);
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%).
#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
{

2012
96
j=rand()%37;
numero[j]++;
cont++;
}while(cont<=i);
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>

2012
97
#include <math.h>
#define N 10
double promedio (int[]);
double desvio_estandard (int[],double);
int main()
{
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++)
{

2012
98
m=m+numero[i];
}
m=m/N;
return m;
}
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[]);

2012
99
OR(char[],char[], char[]);
NOT(char[],char[], char[]);
int main()
{
int i, menu;
char v[N], b[N], r[N], l;
do{
printf("nMenun");
printf("1 - ANDn");
printf("2 - ORn");
printf("3 - NOTn");
scanf("%d", &menu);
switch(menu)
{
case 1:
ingrese (v);
ingrese(b);
AND(v,b,r);
break;

2012
100
case 2:
ingrese(v);
ingrese(b);
OR(v,b,r);
break;
case 3:
i=0;
printf("nIngrese el arreglo:");
ingrese(v);
NOT(v,b,r);
break;
case 4:
break;
default:
break;
}

2012
101
}while(menu!=4);
return 0;
}
ingrese(char v[])
{
int i=0;
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';

2012
102
else
r[i]='0';
}
r[i]='0';
}
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

2012
103
r[i]='1';
}
r[i]='0';
}
3.4:
#include <stdio.h>
#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("nMenun");
printf("1 - UNIONn");
printf("2 - INTERSECCIONn");
printf("3 - DIFERENCIAn");
scanf("%d", &menu);
switch(menu)
{
case 1:

2012
104
i=ingrese(v);
k=ingrese(b);
//pedaso que checkea si guardar en el arreglo solucion o no.
for(m=0;m<i;m++)
{
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:
i=ingrese(v);

2012
105
k=ingrese(b);
m=0;
for(j=0;j<i;j++)
{
sen=0;
sen=repetido(b,k,v[j]);
if(sen==1)
{
r[m]=v[j];
m++;
}
}
break;
case 3:
i=ingrese(v);
k=ingrese(b);
for(j=0;j<i;j++)
{
sen=repetido(b,k,v[j]);
if(sen==0)
{
r[m]=v[j];

2012
106
m++;
}
}
break;
case 4:
break;
default:
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++;

2012
107
}
}while(i<N-1&&l!=0);
i--;
return i;
}
int repetido (int v[], int i, int l)
{
int j, sen=0;
for(j=0;j<i;j++)
{
if(v[j]==l)
sen=1;
}
return sen;
}
imprimir_resultado(int r[], int m)
{
int i;
for(i=0;i<m;i++)
{
}
}
Ejercicio 4.13
Realizar un programa que contenga las siguientes funciones:

2012
108
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.
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);

2012
109
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);
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)

2012
110
{
return(l==' '||l==','||l==';'||l=='?'||l=='!');
}
int b (char texto[])
{
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

2012
111
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;
i++;
{
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[])

2012
112
{
int sen=0, i;
for(i=0;i<N-1&&texto[i]!='0';)
{
sen=0;
i++;
{
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:

2012
113
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
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()

2012
114
{
char texto1[N], texto2[N], palabra[N], sen;
int cant_pal_rep1,cant_pal_rep2;
a(texto1);
printf("n");
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

2012
115
{
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 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;

2012
116
}
return sen;
}
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;

2012
117
j++;
i++;
}
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]))

2012
118
texto1[i]-=32;
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');
}

2012
119
int es_letra(char l)
{
return ((l>='A'&&l<='Z')||(l>='a'&&l<='z'));
}
En este programita tengo q avisar q ni use una función asique probablemente no sea asi como
tendría que estar hecho, pero no se me ocurrio de otra manera..

Informática I: Ejercicios Resueltos

Más contenido relacionado

Destacado

Similar a Informática I: Ejercicios Resueltos

Más de Alvin Jacobs

Último

Informática I: Ejercicios Resueltos