SlideShare uma empresa Scribd logo
1 de 119
Baixar para ler offline
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;
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;
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;
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;
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
{
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 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
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 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)
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;
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:
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: ");
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: ");
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;
}
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)
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
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
{
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
{
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;
printf("Ingrese numero: ");
scanf("%d", &num);
if(num!=0)
{
2012
39
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;
}
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;
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 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;
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;
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
Ingrese monto del mes 2: 3000
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 = 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
{
printf("Ingrese el numero: ");
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{
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 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{
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("*");
}
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{
printf("Ingrese el numero: ");
scanf("%d", &num);
blancos=num/2;
}while(num<3||num%2!=1);
for(f=1; f<=num/2+1; f++)
{
for(c=1; c<=blancos; c++)
2012
53
{
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++)
{
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{
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
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{
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 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{
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;
}
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{
printf("Ingrese numero: ");
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;
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:");
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';
printf("nEl arreglo resultante es: %s", r);
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';
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: ");
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");
printf("4 - SALIRn");
scanf("%d", &menu);
2012
67
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--;
printf("nIngrese el segundo arreglo:");
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;
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
{
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++;
}
}
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)
sen=1;
2012
73
}
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)
{
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++;
}
}
printf("El arreglo resultante es: ");
for(i=0;i<p;i++)
{
printf("%d-", r[i]);
2012
75
}
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 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
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, $@
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);
printf("Ingrese lado 2: n");
2012
82
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
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%).
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
{
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");
printf("4 - SALIRn");
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;
2012
100
case 2:
printf("nIngrese el primer arreglo:");
ingrese(v);
printf("nIngrese el segundo arreglo:");
ingrese(b);
OR(v,b,r);
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;
}
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");
printf("4 - SALIRn");
scanf("%d", &menu);
switch(menu)
{
case 1:
2012
104
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++)
{
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:");
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++;
}
}
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];
2012
106
m++;
}
}
imprimir_resultado(r,m);
break;
case 4:
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++;
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)
{
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:
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;
while(es_separador(texto[i])&&texto[i]!='0')
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[])
2012
112
{
int 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')
{
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..

Mais conteúdo relacionado

Destaque

Ejercicios informatica
Ejercicios informaticaEjercicios informatica
Ejercicios informaticaroyers500
 
Informática I: Ejercicios Resueltos
Informática I:   Ejercicios ResueltosInformática I:   Ejercicios Resueltos
Informática I: Ejercicios ResueltosAlvin Jacobs
 
Ejercicios resueltos Practica 4 informatica II
Ejercicios resueltos Practica 4 informatica IIEjercicios resueltos Practica 4 informatica II
Ejercicios resueltos Practica 4 informatica IIAlvin Jacobs
 
Informática ii ejercicios resueltos - practica 3
Informática ii   ejercicios resueltos - practica 3Informática ii   ejercicios resueltos - practica 3
Informática ii ejercicios resueltos - practica 3Alvin Jacobs
 
Visual basic 2010 data por codigo
Visual basic 2010 data por codigoVisual basic 2010 data por codigo
Visual basic 2010 data por codigojuan fernandez
 
Ejercicios de unidades de medidad de la información (5)
Ejercicios de unidades de medidad de la información (5)Ejercicios de unidades de medidad de la información (5)
Ejercicios de unidades de medidad de la información (5)Katherine Hernandez
 
Informatica II - 2 Metodologia de Solucion de Problemas
Informatica II - 2 Metodologia de Solucion de ProblemasInformatica II - 2 Metodologia de Solucion de Problemas
Informatica II - 2 Metodologia de Solucion de ProblemasGabriel Ruiz
 
Muerte por powerpoint y como diseñar presentaciones efectivas
Muerte por powerpoint  y como diseñar presentaciones efectivasMuerte por powerpoint  y como diseñar presentaciones efectivas
Muerte por powerpoint y como diseñar presentaciones efectivasdaniel silverman
 
Practica 9 informatica
Practica 9 informaticaPractica 9 informatica
Practica 9 informaticaarelitalaura
 
catalunya en miniatura
catalunya en miniaturacatalunya en miniatura
catalunya en miniaturanuni13524
 
Ejercicios de informática básica
Ejercicios de informática básicaEjercicios de informática básica
Ejercicios de informática básicaDaniel Lebron
 
Ejercicios de informatica
Ejercicios de informaticaEjercicios de informatica
Ejercicios de informaticaKatya Cabanilla
 
Informatica practica 1 copia
Informatica practica 1   copiaInformatica practica 1   copia
Informatica practica 1 copiamario4biscar2010
 

Destaque (20)

Ejercicios informatica
Ejercicios informaticaEjercicios informatica
Ejercicios informatica
 
Informática I: Ejercicios Resueltos
Informática I:   Ejercicios ResueltosInformática I:   Ejercicios Resueltos
Informática I: Ejercicios Resueltos
 
manual visual basic 02
manual visual basic 02 manual visual basic 02
manual visual basic 02
 
manual visual basic 01
manual visual basic 01manual visual basic 01
manual visual basic 01
 
Ejercicios resueltos Practica 4 informatica II
Ejercicios resueltos Practica 4 informatica IIEjercicios resueltos Practica 4 informatica II
Ejercicios resueltos Practica 4 informatica II
 
Informática ii ejercicios resueltos - practica 3
Informática ii   ejercicios resueltos - practica 3Informática ii   ejercicios resueltos - practica 3
Informática ii ejercicios resueltos - practica 3
 
Visual basic 2010 data por codigo
Visual basic 2010 data por codigoVisual basic 2010 data por codigo
Visual basic 2010 data por codigo
 
Ejercicios de unidades de medidad de la información (5)
Ejercicios de unidades de medidad de la información (5)Ejercicios de unidades de medidad de la información (5)
Ejercicios de unidades de medidad de la información (5)
 
Informatica II - 2 Metodologia de Solucion de Problemas
Informatica II - 2 Metodologia de Solucion de ProblemasInformatica II - 2 Metodologia de Solucion de Problemas
Informatica II - 2 Metodologia de Solucion de Problemas
 
Muerte por powerpoint y como diseñar presentaciones efectivas
Muerte por powerpoint  y como diseñar presentaciones efectivasMuerte por powerpoint  y como diseñar presentaciones efectivas
Muerte por powerpoint y como diseñar presentaciones efectivas
 
Practica 9 informatica
Practica 9 informaticaPractica 9 informatica
Practica 9 informatica
 
catalunya en miniatura
catalunya en miniaturacatalunya en miniatura
catalunya en miniatura
 
Ejercicios de informática básica
Ejercicios de informática básicaEjercicios de informática básica
Ejercicios de informática básica
 
Ejercicios de informatica
Ejercicios de informaticaEjercicios de informatica
Ejercicios de informatica
 
4.cuarto ejercicio
4.cuarto ejercicio4.cuarto ejercicio
4.cuarto ejercicio
 
5.quinto ejercicio emu8086
5.quinto ejercicio emu80865.quinto ejercicio emu8086
5.quinto ejercicio emu8086
 
Informatica practica 1 copia
Informatica practica 1   copiaInformatica practica 1   copia
Informatica practica 1 copia
 
ejercios
ejerciosejercios
ejercios
 
1.primer ejercicio emu8086
1.primer ejercicio emu80861.primer ejercicio emu8086
1.primer ejercicio emu8086
 
3.tercer ejercicio emu8086
3.tercer ejercicio emu80863.tercer ejercicio emu8086
3.tercer ejercicio emu8086
 

Semelhante a Informática I: Ejercicios Resueltos

El Libro Blanco del Teletrabajo en España
El Libro Blanco del Teletrabajo en EspañaEl Libro Blanco del Teletrabajo en España
El Libro Blanco del Teletrabajo en EspañaEnrique Ramos Ortiz
 
Manual de seguridad supersprint finalizado
Manual de seguridad supersprint finalizadoManual de seguridad supersprint finalizado
Manual de seguridad supersprint finalizadoSalvador Abrego
 
Guía Innovación
Guía InnovaciónGuía Innovación
Guía Innovaciónguestdf1540
 
=?UTF8?B?YW7DoWxpc2lzLCBtYW50ZW5pbWllbnRvIHkgb3BlcmE=?= =?UTF8?B?Y2nDs24gZGUg...
=?UTF8?B?YW7DoWxpc2lzLCBtYW50ZW5pbWllbnRvIHkgb3BlcmE=?= =?UTF8?B?Y2nDs24gZGUg...=?UTF8?B?YW7DoWxpc2lzLCBtYW50ZW5pbWllbnRvIHkgb3BlcmE=?= =?UTF8?B?Y2nDs24gZGUg...
=?UTF8?B?YW7DoWxpc2lzLCBtYW50ZW5pbWllbnRvIHkgb3BlcmE=?= =?UTF8?B?Y2nDs24gZGUg...Claudia Barriga
 
Planificación de experiencia educación física 2022
Planificación de experiencia educación física 2022Planificación de experiencia educación física 2022
Planificación de experiencia educación física 2022Walter VELLANEDA AMBROSIO
 
CHAMILO MANUAL PARA EL DOCENTE
CHAMILO MANUAL PARA EL DOCENTECHAMILO MANUAL PARA EL DOCENTE
CHAMILO MANUAL PARA EL DOCENTEDamelys Fernández
 
Chamilo 1.8.7.1-docente-manual-v0.1.2
Chamilo 1.8.7.1-docente-manual-v0.1.2Chamilo 1.8.7.1-docente-manual-v0.1.2
Chamilo 1.8.7.1-docente-manual-v0.1.2Jazmin Ramirez
 
Chamilo 1.8.7.1-docente-manual-v0.1.2
Chamilo 1.8.7.1-docente-manual-v0.1.2Chamilo 1.8.7.1-docente-manual-v0.1.2
Chamilo 1.8.7.1-docente-manual-v0.1.2Elio Laureano
 
Ejercicios Resueltos en C
Ejercicios Resueltos en CEjercicios Resueltos en C
Ejercicios Resueltos en Csolucionescip
 
Guía docente módulo i 2015. v01
Guía docente módulo i 2015. v01Guía docente módulo i 2015. v01
Guía docente módulo i 2015. v01Klaudia Medina
 
Etapas de la vida
Etapas de la vida Etapas de la vida
Etapas de la vida lauris13
 
Netex learningCentral | Student Manual v4.4 [Es]
Netex learningCentral | Student Manual v4.4 [Es]Netex learningCentral | Student Manual v4.4 [Es]
Netex learningCentral | Student Manual v4.4 [Es]Netex Learning
 
SurvivorDR Reglamento 2012
SurvivorDR Reglamento 2012SurvivorDR Reglamento 2012
SurvivorDR Reglamento 2012SurvivorDR
 

Semelhante a Informática I: Ejercicios Resueltos (20)

Ambiente windows
Ambiente windowsAmbiente windows
Ambiente windows
 
El Libro Blanco del Teletrabajo en España
El Libro Blanco del Teletrabajo en EspañaEl Libro Blanco del Teletrabajo en España
El Libro Blanco del Teletrabajo en España
 
Manual de seguridad supersprint finalizado
Manual de seguridad supersprint finalizadoManual de seguridad supersprint finalizado
Manual de seguridad supersprint finalizado
 
Guía Innovación
Guía InnovaciónGuía Innovación
Guía Innovación
 
Experiencia 01-Educacion Física
Experiencia 01-Educacion FísicaExperiencia 01-Educacion Física
Experiencia 01-Educacion Física
 
=?UTF8?B?YW7DoWxpc2lzLCBtYW50ZW5pbWllbnRvIHkgb3BlcmE=?= =?UTF8?B?Y2nDs24gZGUg...
=?UTF8?B?YW7DoWxpc2lzLCBtYW50ZW5pbWllbnRvIHkgb3BlcmE=?= =?UTF8?B?Y2nDs24gZGUg...=?UTF8?B?YW7DoWxpc2lzLCBtYW50ZW5pbWllbnRvIHkgb3BlcmE=?= =?UTF8?B?Y2nDs24gZGUg...
=?UTF8?B?YW7DoWxpc2lzLCBtYW50ZW5pbWllbnRvIHkgb3BlcmE=?= =?UTF8?B?Y2nDs24gZGUg...
 
Tutorial microsoft
Tutorial microsoft Tutorial microsoft
Tutorial microsoft
 
formatos posgrado.pdf
formatos posgrado.pdfformatos posgrado.pdf
formatos posgrado.pdf
 
Experiencia 6
Experiencia 6Experiencia 6
Experiencia 6
 
Planificación de experiencia educación física 2022
Planificación de experiencia educación física 2022Planificación de experiencia educación física 2022
Planificación de experiencia educación física 2022
 
íNdice
íNdiceíNdice
íNdice
 
Memòria d'activitat docent 2011 - 2012
Memòria d'activitat docent 2011 - 2012Memòria d'activitat docent 2011 - 2012
Memòria d'activitat docent 2011 - 2012
 
CHAMILO MANUAL PARA EL DOCENTE
CHAMILO MANUAL PARA EL DOCENTECHAMILO MANUAL PARA EL DOCENTE
CHAMILO MANUAL PARA EL DOCENTE
 
Chamilo 1.8.7.1-docente-manual-v0.1.2
Chamilo 1.8.7.1-docente-manual-v0.1.2Chamilo 1.8.7.1-docente-manual-v0.1.2
Chamilo 1.8.7.1-docente-manual-v0.1.2
 
Chamilo 1.8.7.1-docente-manual-v0.1.2
Chamilo 1.8.7.1-docente-manual-v0.1.2Chamilo 1.8.7.1-docente-manual-v0.1.2
Chamilo 1.8.7.1-docente-manual-v0.1.2
 
Ejercicios Resueltos en C
Ejercicios Resueltos en CEjercicios Resueltos en C
Ejercicios Resueltos en C
 
Guía docente módulo i 2015. v01
Guía docente módulo i 2015. v01Guía docente módulo i 2015. v01
Guía docente módulo i 2015. v01
 
Etapas de la vida
Etapas de la vida Etapas de la vida
Etapas de la vida
 
Netex learningCentral | Student Manual v4.4 [Es]
Netex learningCentral | Student Manual v4.4 [Es]Netex learningCentral | Student Manual v4.4 [Es]
Netex learningCentral | Student Manual v4.4 [Es]
 
SurvivorDR Reglamento 2012
SurvivorDR Reglamento 2012SurvivorDR Reglamento 2012
SurvivorDR Reglamento 2012
 

Mais de Alvin Jacobs

Carbohidratos 14 22_1589
Carbohidratos 14 22_1589Carbohidratos 14 22_1589
Carbohidratos 14 22_1589Alvin Jacobs
 
Ejercicios resueltos practica 2 (nueva 2014) informática ii
Ejercicios resueltos practica 2 (nueva 2014) informática iiEjercicios resueltos practica 2 (nueva 2014) informática ii
Ejercicios resueltos practica 2 (nueva 2014) informática iiAlvin Jacobs
 
Preguntas para final de Etica
Preguntas para final de EticaPreguntas para final de Etica
Preguntas para final de EticaAlvin Jacobs
 
Probabilidad y Estadistica Para Ingenieros 6ta Edicion - Ronald E. Walpole ...
Probabilidad y Estadistica Para Ingenieros   6ta Edicion - Ronald E. Walpole ...Probabilidad y Estadistica Para Ingenieros   6ta Edicion - Ronald E. Walpole ...
Probabilidad y Estadistica Para Ingenieros 6ta Edicion - Ronald E. Walpole ...Alvin Jacobs
 
Informática ii – practica 2
Informática ii – practica 2Informática ii – practica 2
Informática ii – practica 2Alvin Jacobs
 
Practica 1 informática ii
Practica 1 informática iiPractica 1 informática ii
Practica 1 informática iiAlvin Jacobs
 
Resumen introducción a la filosofía y antropología filosófica 2º parcia...
Resumen introducción a la filosofía y antropología filosófica   2º parcia...Resumen introducción a la filosofía y antropología filosófica   2º parcia...
Resumen introducción a la filosofía y antropología filosófica 2º parcia...Alvin Jacobs
 

Mais de Alvin Jacobs (11)

Carbohidratos 14 22_1589
Carbohidratos 14 22_1589Carbohidratos 14 22_1589
Carbohidratos 14 22_1589
 
3er parcialito
3er parcialito3er parcialito
3er parcialito
 
Ejercicios resueltos practica 2 (nueva 2014) informática ii
Ejercicios resueltos practica 2 (nueva 2014) informática iiEjercicios resueltos practica 2 (nueva 2014) informática ii
Ejercicios resueltos practica 2 (nueva 2014) informática ii
 
Preguntas para final de Etica
Preguntas para final de EticaPreguntas para final de Etica
Preguntas para final de Etica
 
Probabilidad y Estadistica Para Ingenieros 6ta Edicion - Ronald E. Walpole ...
Probabilidad y Estadistica Para Ingenieros   6ta Edicion - Ronald E. Walpole ...Probabilidad y Estadistica Para Ingenieros   6ta Edicion - Ronald E. Walpole ...
Probabilidad y Estadistica Para Ingenieros 6ta Edicion - Ronald E. Walpole ...
 
Informática ii – practica 2
Informática ii – practica 2Informática ii – practica 2
Informática ii – practica 2
 
Practica 1 informática ii
Practica 1 informática iiPractica 1 informática ii
Practica 1 informática ii
 
Ingeco unidad 4
Ingeco unidad 4Ingeco unidad 4
Ingeco unidad 4
 
Ingeco unidad 2
Ingeco unidad 2Ingeco unidad 2
Ingeco unidad 2
 
Ingeco unidad 1
Ingeco unidad 1Ingeco unidad 1
Ingeco unidad 1
 
Resumen introducción a la filosofía y antropología filosófica 2º parcia...
Resumen introducción a la filosofía y antropología filosófica   2º parcia...Resumen introducción a la filosofía y antropología filosófica   2º parcia...
Resumen introducción a la filosofía y antropología filosófica 2º parcia...
 

Último

Poder puedo, pero no lo haré - T3chfest
Poder puedo, pero no lo haré - T3chfestPoder puedo, pero no lo haré - T3chfest
Poder puedo, pero no lo haré - T3chfestSilvia España Gil
 
Principios de Circuitos Eléctricos (Thomas L. Floyd) (Z-Library).pdf
Principios de Circuitos Eléctricos (Thomas L. Floyd) (Z-Library).pdfPrincipios de Circuitos Eléctricos (Thomas L. Floyd) (Z-Library).pdf
Principios de Circuitos Eléctricos (Thomas L. Floyd) (Z-Library).pdfYADIRAXIMENARIASCOSV
 
TAREA 1 - Parada de Planta compresoras de gas
TAREA 1 - Parada de Planta compresoras de gasTAREA 1 - Parada de Planta compresoras de gas
TAREA 1 - Parada de Planta compresoras de gasroberto264045
 
Diseño de Algoritmos Paralelos con la maestra Rina
Diseño de Algoritmos Paralelos con la maestra RinaDiseño de Algoritmos Paralelos con la maestra Rina
Diseño de Algoritmos Paralelos con la maestra RinaLuisAlfredoPascualPo
 
IA T3 Elaboración e interpretación de planos.pptx
IA T3 Elaboración e interpretación de planos.pptxIA T3 Elaboración e interpretación de planos.pptx
IA T3 Elaboración e interpretación de planos.pptxcecymendozaitnl
 
PPT_Conferencia OBRAS PUBLICAS x ADMNISTRACION DIRECTA.pdf
PPT_Conferencia OBRAS PUBLICAS x ADMNISTRACION DIRECTA.pdfPPT_Conferencia OBRAS PUBLICAS x ADMNISTRACION DIRECTA.pdf
PPT_Conferencia OBRAS PUBLICAS x ADMNISTRACION DIRECTA.pdfANGHELO JJ. MITMA HUAMANÌ
 
CV_SOTO_SAUL 30-01-2024 (1) arquitecto.pdf
CV_SOTO_SAUL 30-01-2024  (1) arquitecto.pdfCV_SOTO_SAUL 30-01-2024  (1) arquitecto.pdf
CV_SOTO_SAUL 30-01-2024 (1) arquitecto.pdfsd3700445
 
Fundamentos - Curso Desarrollo Web (HTML, JS, PHP, JS, SQL)
Fundamentos - Curso Desarrollo Web (HTML, JS, PHP, JS, SQL)Fundamentos - Curso Desarrollo Web (HTML, JS, PHP, JS, SQL)
Fundamentos - Curso Desarrollo Web (HTML, JS, PHP, JS, SQL)EmanuelMuoz11
 
1_Tipos Básicos de Motores - funcionamientos
1_Tipos Básicos de Motores - funcionamientos1_Tipos Básicos de Motores - funcionamientos
1_Tipos Básicos de Motores - funcionamientosMaicoPinelli
 
concreto pretensado y postensado- reseña historica
concreto pretensado y postensado- reseña historicaconcreto pretensado y postensado- reseña historica
concreto pretensado y postensado- reseña historicaamira520031
 
aplicacion-del-metodo-cientifico-de-roberto-hernandez-carlos-fernandez-y-pila...
aplicacion-del-metodo-cientifico-de-roberto-hernandez-carlos-fernandez-y-pila...aplicacion-del-metodo-cientifico-de-roberto-hernandez-carlos-fernandez-y-pila...
aplicacion-del-metodo-cientifico-de-roberto-hernandez-carlos-fernandez-y-pila...AmeliaJul
 
analisis matematico 2 elon lages lima .pdf
analisis matematico 2 elon lages lima .pdfanalisis matematico 2 elon lages lima .pdf
analisis matematico 2 elon lages lima .pdfJOHELSANCHEZINCA
 
CALCULISTA AGUA POTABLE ALCANTARILLADO RURAL CURACAVÍ
CALCULISTA AGUA POTABLE ALCANTARILLADO RURAL CURACAVÍCALCULISTA AGUA POTABLE ALCANTARILLADO RURAL CURACAVÍ
CALCULISTA AGUA POTABLE ALCANTARILLADO RURAL CURACAVÍArquitecto Chile
 
Modulo 4 - Monitoreo Hidrobiológico de monitoreo ambiental
Modulo 4 - Monitoreo Hidrobiológico de monitoreo ambientalModulo 4 - Monitoreo Hidrobiológico de monitoreo ambiental
Modulo 4 - Monitoreo Hidrobiológico de monitoreo ambientalAcountsStore1
 
Mecánica vectorial para ingenieros estática. Beer - Johnston. 11 Ed.pdf
Mecánica vectorial para ingenieros estática. Beer - Johnston. 11 Ed.pdfMecánica vectorial para ingenieros estática. Beer - Johnston. 11 Ed.pdf
Mecánica vectorial para ingenieros estática. Beer - Johnston. 11 Ed.pdfaaaaaaaaaaaaaaaaa
 
Cuadro de las web 1.0, 2.0 y 3.0 pptx
Cuadro de las web 1.0, 2.0 y 3.0     pptxCuadro de las web 1.0, 2.0 y 3.0     pptx
Cuadro de las web 1.0, 2.0 y 3.0 pptxecarmariahurtado
 
BROCHURE EDIFICIO MULTIFAMILIAR LIMA. PERU
BROCHURE EDIFICIO MULTIFAMILIAR LIMA. PERUBROCHURE EDIFICIO MULTIFAMILIAR LIMA. PERU
BROCHURE EDIFICIO MULTIFAMILIAR LIMA. PERUSharonRojas28
 
Modulo 5 - Monitoreo de Ruido Ambiental de monitoreo ambiental
Modulo 5 - Monitoreo de Ruido Ambiental de monitoreo ambientalModulo 5 - Monitoreo de Ruido Ambiental de monitoreo ambiental
Modulo 5 - Monitoreo de Ruido Ambiental de monitoreo ambientalAcountsStore1
 
Método inductivo.pdf-lizzeh cuellar cardenas
Método inductivo.pdf-lizzeh cuellar cardenasMétodo inductivo.pdf-lizzeh cuellar cardenas
Método inductivo.pdf-lizzeh cuellar cardenas182136
 
Presentación de Ciencia, Cultura y Progreso.pptx
Presentación de Ciencia, Cultura y Progreso.pptxPresentación de Ciencia, Cultura y Progreso.pptx
Presentación de Ciencia, Cultura y Progreso.pptxwilliam atao contreras
 

Último (20)

Poder puedo, pero no lo haré - T3chfest
Poder puedo, pero no lo haré - T3chfestPoder puedo, pero no lo haré - T3chfest
Poder puedo, pero no lo haré - T3chfest
 
Principios de Circuitos Eléctricos (Thomas L. Floyd) (Z-Library).pdf
Principios de Circuitos Eléctricos (Thomas L. Floyd) (Z-Library).pdfPrincipios de Circuitos Eléctricos (Thomas L. Floyd) (Z-Library).pdf
Principios de Circuitos Eléctricos (Thomas L. Floyd) (Z-Library).pdf
 
TAREA 1 - Parada de Planta compresoras de gas
TAREA 1 - Parada de Planta compresoras de gasTAREA 1 - Parada de Planta compresoras de gas
TAREA 1 - Parada de Planta compresoras de gas
 
Diseño de Algoritmos Paralelos con la maestra Rina
Diseño de Algoritmos Paralelos con la maestra RinaDiseño de Algoritmos Paralelos con la maestra Rina
Diseño de Algoritmos Paralelos con la maestra Rina
 
IA T3 Elaboración e interpretación de planos.pptx
IA T3 Elaboración e interpretación de planos.pptxIA T3 Elaboración e interpretación de planos.pptx
IA T3 Elaboración e interpretación de planos.pptx
 
PPT_Conferencia OBRAS PUBLICAS x ADMNISTRACION DIRECTA.pdf
PPT_Conferencia OBRAS PUBLICAS x ADMNISTRACION DIRECTA.pdfPPT_Conferencia OBRAS PUBLICAS x ADMNISTRACION DIRECTA.pdf
PPT_Conferencia OBRAS PUBLICAS x ADMNISTRACION DIRECTA.pdf
 
CV_SOTO_SAUL 30-01-2024 (1) arquitecto.pdf
CV_SOTO_SAUL 30-01-2024  (1) arquitecto.pdfCV_SOTO_SAUL 30-01-2024  (1) arquitecto.pdf
CV_SOTO_SAUL 30-01-2024 (1) arquitecto.pdf
 
Fundamentos - Curso Desarrollo Web (HTML, JS, PHP, JS, SQL)
Fundamentos - Curso Desarrollo Web (HTML, JS, PHP, JS, SQL)Fundamentos - Curso Desarrollo Web (HTML, JS, PHP, JS, SQL)
Fundamentos - Curso Desarrollo Web (HTML, JS, PHP, JS, SQL)
 
1_Tipos Básicos de Motores - funcionamientos
1_Tipos Básicos de Motores - funcionamientos1_Tipos Básicos de Motores - funcionamientos
1_Tipos Básicos de Motores - funcionamientos
 
concreto pretensado y postensado- reseña historica
concreto pretensado y postensado- reseña historicaconcreto pretensado y postensado- reseña historica
concreto pretensado y postensado- reseña historica
 
aplicacion-del-metodo-cientifico-de-roberto-hernandez-carlos-fernandez-y-pila...
aplicacion-del-metodo-cientifico-de-roberto-hernandez-carlos-fernandez-y-pila...aplicacion-del-metodo-cientifico-de-roberto-hernandez-carlos-fernandez-y-pila...
aplicacion-del-metodo-cientifico-de-roberto-hernandez-carlos-fernandez-y-pila...
 
analisis matematico 2 elon lages lima .pdf
analisis matematico 2 elon lages lima .pdfanalisis matematico 2 elon lages lima .pdf
analisis matematico 2 elon lages lima .pdf
 
CALCULISTA AGUA POTABLE ALCANTARILLADO RURAL CURACAVÍ
CALCULISTA AGUA POTABLE ALCANTARILLADO RURAL CURACAVÍCALCULISTA AGUA POTABLE ALCANTARILLADO RURAL CURACAVÍ
CALCULISTA AGUA POTABLE ALCANTARILLADO RURAL CURACAVÍ
 
Modulo 4 - Monitoreo Hidrobiológico de monitoreo ambiental
Modulo 4 - Monitoreo Hidrobiológico de monitoreo ambientalModulo 4 - Monitoreo Hidrobiológico de monitoreo ambiental
Modulo 4 - Monitoreo Hidrobiológico de monitoreo ambiental
 
Mecánica vectorial para ingenieros estática. Beer - Johnston. 11 Ed.pdf
Mecánica vectorial para ingenieros estática. Beer - Johnston. 11 Ed.pdfMecánica vectorial para ingenieros estática. Beer - Johnston. 11 Ed.pdf
Mecánica vectorial para ingenieros estática. Beer - Johnston. 11 Ed.pdf
 
Cuadro de las web 1.0, 2.0 y 3.0 pptx
Cuadro de las web 1.0, 2.0 y 3.0     pptxCuadro de las web 1.0, 2.0 y 3.0     pptx
Cuadro de las web 1.0, 2.0 y 3.0 pptx
 
BROCHURE EDIFICIO MULTIFAMILIAR LIMA. PERU
BROCHURE EDIFICIO MULTIFAMILIAR LIMA. PERUBROCHURE EDIFICIO MULTIFAMILIAR LIMA. PERU
BROCHURE EDIFICIO MULTIFAMILIAR LIMA. PERU
 
Modulo 5 - Monitoreo de Ruido Ambiental de monitoreo ambiental
Modulo 5 - Monitoreo de Ruido Ambiental de monitoreo ambientalModulo 5 - Monitoreo de Ruido Ambiental de monitoreo ambiental
Modulo 5 - Monitoreo de Ruido Ambiental de monitoreo ambiental
 
Método inductivo.pdf-lizzeh cuellar cardenas
Método inductivo.pdf-lizzeh cuellar cardenasMétodo inductivo.pdf-lizzeh cuellar cardenas
Método inductivo.pdf-lizzeh cuellar cardenas
 
Presentación de Ciencia, Cultura y Progreso.pptx
Presentación de Ciencia, Cultura y Progreso.pptxPresentación de Ciencia, Cultura y Progreso.pptx
Presentación de Ciencia, Cultura y Progreso.pptx
 

Informática I: Ejercicios Resueltos

  • 1. 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
  • 2. 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
  • 3. 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>
  • 4. 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;
  • 5. 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; 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;
  • 6. 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:
  • 7. 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>
  • 8. 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()
  • 9. 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:
  • 10. 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; 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;
  • 11. 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;
  • 12. 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;
  • 13. 2012 13 } 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 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");
  • 14. 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
  • 15. 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
  • 16. 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");
  • 17. 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>
  • 18. 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;
  • 19. 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 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 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;
  • 20. 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);
  • 21. 2012 21 } 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;
  • 22. 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: 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: ");
  • 23. 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>
  • 24. 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: "); 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; }
  • 25. 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)
  • 26. 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) 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 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:
  • 27. 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
  • 28. 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"); }
  • 29. 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;
  • 30. 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 {
  • 31. 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
  • 32. 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()
  • 33. 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() {
  • 34. 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() {
  • 35. 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>
  • 36. 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>
  • 37. 2012 37 #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 { div=0; do { div--;
  • 38. 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; printf("Ingrese numero: "); scanf("%d", &num); if(num!=0) {
  • 39. 2012 39 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; } 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>
  • 40. 2012 40 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 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.
  • 41. 2012 41 #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; a=b; b=resto; } printf("El MCD entre %d y %d es: %d",guarda , guardb, b);
  • 42. 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);
  • 43. 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;
  • 44. 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;
  • 45. 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;
  • 46. 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 Ingrese monto del mes 2: 3000 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 = Inversión + Intereses = 2000 + 3000 + 1000 + 86.67 = 6086.67 #include <stdio.h> #include <stdlib.h>
  • 47. 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
  • 48. 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 { printf("Ingrese el numero: "); 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++) {
  • 49. 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() {
  • 50. 2012 50 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 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()
  • 51. 2012 51 { 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("*"); } ast++; printf("n"); } return 0; }
  • 52. 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{ printf("Ingrese el numero: "); scanf("%d", &num); blancos=num/2; }while(num<3||num%2!=1); for(f=1; f<=num/2+1; f++) { for(c=1; c<=blancos; c++)
  • 53. 2012 53 { 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++) { printf("*"); } ast-=2; printf("n");
  • 54. 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{ 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 printf(" "); } printf("n"); } return 0; }
  • 55. 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++) {
  • 56. 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;
  • 57. 2012 57 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 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>
  • 58. 2012 58 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; }
  • 59. 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{ printf("Ingrese numero: "); scanf("%d", &v[i]); i++; }while(v[i-1]!=0); i-=2; while(i>=0)
  • 60. 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
  • 61. 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) {
  • 62. 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);
  • 63. 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; 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:");
  • 65. 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'; 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: ");
  • 66. 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"); printf("4 - SALIRn"); scanf("%d", &menu);
  • 67. 2012 67 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--; printf("nIngrese el segundo arreglo:");
  • 70. 2012 70 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 {
  • 72. 2012 72 } 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) sen=1;
  • 73. 2012 73 } 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) {
  • 75. 2012 75 } 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 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() {
  • 76. 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') {
  • 77. 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 La bella y graciosa moza marchose a lavar la ropa #include <stdio.h> #include <stdlib.h>
  • 78. 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;
  • 79. 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, $@ 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++; }
  • 80. 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++; } }
  • 81. 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); printf("Ingrese lado 2: n");
  • 82. 2012 82 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
  • 83. 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);
  • 84. 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
  • 85. 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);
  • 86. 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
  • 87. 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;
  • 88. 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>
  • 89. 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);
  • 90. 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') {
  • 91. 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
  • 92. 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);
  • 93. 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; }
  • 94. 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)
  • 95. 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%). 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 {
  • 96. 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>
  • 97. 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++) {
  • 98. 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[]);
  • 99. 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"); printf("4 - SALIRn"); 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;
  • 100. 2012 100 case 2: printf("nIngrese el primer arreglo:"); ingrese(v); printf("nIngrese el segundo arreglo:"); ingrese(b); OR(v,b,r); 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; }
  • 101. 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';
  • 103. 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"); printf("4 - SALIRn"); scanf("%d", &menu); switch(menu) { case 1:
  • 104. 2012 104 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++) { 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:");
  • 105. 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++; } } 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];
  • 106. 2012 106 m++; } } imprimir_resultado(r,m); break; case 4: 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++;
  • 107. 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) { 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:
  • 108. 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);
  • 109. 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)
  • 110. 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
  • 111. 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; while(es_separador(texto[i])&&texto[i]!='0') 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[])
  • 113. 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()
  • 114. 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
  • 115. 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;
  • 116. 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;
  • 117. 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]))
  • 119. 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..