Upcoming SlideShare
×

# Informática I: Ejercicios Resueltos

6,875 views

Published on

Ejercicios resueltos informatica I UCA

Published in: Engineering
2 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
Your message goes here
• Be the first to comment

Views
Total views
6,875
On SlideShare
0
From Embeds
0
Number of Embeds
514
Actions
Shares
0
133
0
Likes
2
Embeds 0
No embeds

No notes for slide

### Informática I: Ejercicios Resueltos

1. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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);
43. 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;
45. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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:");
64. 64. 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:");
65. 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. 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. 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:");
68. 68. 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++)
69. 69. 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:
70. 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 {
71. 71. 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;
72. 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. 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) {
74. 74. 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]);
75. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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';
102. 102. 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
103. 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. 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. 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. 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. 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. 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. 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. 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. 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[])
112. 112. 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:
113. 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. 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. 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. 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. 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]))
118. 118. 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'); }
119. 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..