informática i: ejercicios resueltos

2012

1

Informática 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=%d\n resto:%d", num, num/2, num%2);

return 0;

}

Ejercicio 1.2 Realizar un programa en el que se ingrese la base y la altura de un 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: %g\n", Enum);

printf("Parte fraccionaria: %g\n", Fnum);

return 0;

}

Ejercicio 1.4 Desarrollar un programa en el que se ingrese un número de 5 dígitos y que luego muestre cada dígito separado por un guión. Ejemplo: Ingrese numero: 45212 Separacion en dígitos: 4-‐5-‐2-‐1-‐2.

#include <stdio.h>

#include <stdlib.h>

int main()

{

int num, num1, num2, num3, num4, num5;


scanf("%d", &num);

num5=num%10;

num=num/10;

num4=num%10;

num=num/10;

num3=num%10;

num=num/10;

num2=num%10;

num=num/10;

num1=num%10;

2012

6

//lo hice asi choto a proposito podria haber validado y usado un while. includo un arreglo.

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

return 0;

}

Ejercicio 1.5 Hacer un programa en el que se ingrese la medida de los catetos de un triángulo rectángulo y que se calcule y muestre el perímetro de dicho triángulo. Incluir math.h a fin de utilizar la función sqrt(expresión) que calcula la raíz cuadrada de un número.

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

int main()

{

double ct1,ct2, perim;

printf("Ingrese el primer cateto: ");

scanf("%lf", &ct1);

printf("Ingrese el segundo cateto: ");

scanf("%lf", &ct2);

perim=ct1+ct2+sqrt(ct1*ct1+ct2*ct2);

printf("El perimetro del triangulo ingresado mide %.2lf", perim);

return 0;

}

Ejercicio 1.6 Elaborar un programa en el que se ingrese una cantidad expresada en segundos y luego la exprese en días, horas, minutos y segundos. Ejemplo:

2012

7

Ingrese tiempo en segundos: 93714 1 dia(s), 2 hora(s), 1 minuto(s), 54 segundo(s).

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

int main()

{

int num, seg, dias, horas, min;

printf("Ingrese tiempo en segundos: ");

scanf("%d", &num);

seg=num%60;

num=num/60;

min=num%60;

num=num/60;

horas=num%24;

dias=num/24;

printf("%d dia(s), %d hora(s), %d minuto(s), %dsegundo(s)", dias, horas, min, seg);

return 0;

}

Ejercicio 1.7 Desarrollar un programa en el que se ingresen dos números enteros positivos y que genere y muestre un tercer numero que esté compuesto por las unidades del primer número y por las decenas del segundo.

Ejemplo: Ingrese el primer numero: 427 Ingrese el segundo numero: 52 El numero resultante es: 57

#include <stdio.h>

#include <stdlib.h>

2012

8

int main()

{

int num1, num2, res;

printf("Ingrese el primer numero: ");

scanf("%d", &num1);

printf("Ingrese el segundo numero: ");

scanf("%d", &num2);

num2=num2/10;

num2=num2%10;

num1=num1%10;

res=num1+num2*10;

printf("El numero resultante es: %d", res);

return 0;

}

Ejercicio 1.8 Hacer un programa que calcule las raíces reales de una ecuación cuadrática. El usuario ingresará los coeficientes a, b y c tal que ax² + bx + c=0. Cuando las raíces no sean reales, se mostrará un mensaje indicando esta situación. Ejemplo: Ingrese coeficiente a: 2 Ingrese coeficiente b: 3 Ingrese coeficiente c: 1 La raíz 1 es: 0.50 La raíz 2 es: 1.00

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

int main()

2012

9

{

double a, b, c, x1, x2, d;

printf("Ingrese coeficiente a: ");

scanf("%lf", &a);

printf("Ingrese coeficiente b: ");

scanf("%lf", &b);

printf("Ingrese coeficiente c: ");

scanf("%lf", &c);

d=b*b-‐4*a*c;

if(d<0)

{

printf("Las raices no son reales.");

}

else

{

d=sqrt(d);

x1=(b+d)/(2*a);

x2=(b-‐d)/(2*a);

printf("La raíz 1 es: %.2lf", x1);

printf("\nLa raíz 2 es: %.2lf", x2);

}

return 0;

}

Ejercicio 1.9 Escriba un programa en el que se ingresen 2 números y un carácter (+,-‐,*,/) e informe el resultado de la operación. Ejemplo:

2012

10

Ingrese el primer número: 8 Ingrese el segundo número: 2 Ingrese la operación (+,-‐, *, /): + 8 + 2 =10

#include <stdio.h>

#include <conio.h>

int main()

{

int num1, num2;

char sign;


scanf("%d", &num1);


scanf("%d", &num2);

printf("Ingrese la operacion (+,-‐,*, /): ");

sign=getche();

printf("\n");

switch (sign)

{

case '+':

printf("%d+%d=%d",num1, num2, num1+num2);

break;

case '-‐':

printf("%d-‐%d=%d",num1, num2, num1-‐num2);

break;

2012

11

case '*':

printf("%d*%d=%d",num1, num2, num1*num2);

break;

case '/':

if (num2!=0)

printf("%d/%d=%d",num1, num2, num1/num2);

else

printf("El denominador no puede ser igual a 0");

break;

default:

printf("El caracter ingresado es incompatible");

break;

}

return 0;

}

Ejercicio 1.10 Realizar un programa en el que se ingresen por teclado 3 letras que pueden ser mayúsculas o minúsculas (no necesariamente todas del mismo tipo). A continuación el programa deberá indicar cuál se encuentra primero en el alfabeto.

#include <stdio.h>

#include <conio.h>

//el programa verifica el dato pero muy primitivamente... necesitaria un while para hacerlo en serio.

int main()

{

char let1, let2, let3,l1, l2, l3;

2012

12

printf("Ingrese la primer letra: ");

l1=getche();

if(l1>='a'&&l1<='z')

let1=l1;

else

{

if(l1>='A'&&l1<='Z')

let1=l1+32;

}

printf("\nIngrese la segunda letra: ");

l2=getche();

if(l2>='a'&&l2<='z')

let2=l2;

else

{

if(l2>='A'&&l2<='Z')

let2=l2+32;

}

printf("\nIngrese la tercera letra: ");

l3=getche();

if(l3>='a'&&l3<='z')

let3=l3;

else

{

if(l3>='A'&&l3<='Z')

let3=l3+32;

2012

13

}

if(let1<let2&&let1<let3)

printf("\nLa letra que aparece primero en el alfabeto es '%c'", l1);

else

{



else

{



}

}

return 0;

}

Ejercicio 1.11 Hacer un programa en el que se ingrese un número real y que se muestre si el número es positivo, negativo o cero. Adicionalmente deberá indicar si es natural, entero o real. Ejemplo: Ingrese un número: 13.4 El número es positivo y real.

#include <stdio.h>

#include <stdlib.h>

int main()

{

double num;

printf("Ingrese numero\n");

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)


else

{

if(sen==1&&dia<=29)


else


}

}

else

{

if(dia<=30)


else


}

}

}

return 0;

2012

22

}

Ejercicio 1.16 Elaborar un programa que solicite al usuario que ingrese un número real y luego muestre el Redondeo al entero más próximo de dicho número, el Piso y el Techo. Definiciones Redondeo: Si la parte decimal es mayor o igual a 0,5, se redondea hacia arriba. Caso contrario, hacia abajo. Piso: El entero más próximo hacia abajo. Techo: El entero más próximo hacia arriba. Casos de prueba para (verificar si el ejercicio fue hecho correctamente): Ejemplo 1: Ingrese un numero real: 5.3 Redondeo = 5 Piso = 5 Techo = 6 Ejemplo 2: Ingrese un numero real: 8 Piso = 8 Techo = 8 Redondeo = 8 Ejemplo 3: 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: ");


printf("Ingrese la nota del tercer parcial: ");


if(nota1<4||nota2<4||nota3<4)

{

printf("Ingrese la nota del recuperatorio: ");

scanf("%d", &notar);

prom=(nota1+nota2+nota3+notar)/4.0;

}

else

prom=(nota1+nota2+nota3)/3.0;

printf("Promedio general: %.2lf.", prom);

if(prom<4)

printf(" El alumno debera presentarse a final:");

else

printf(" El alumno ha aprovado y no debe presentarse a final.");

return 0;

}

2012

25

Ejercicio 1.18 Una empresa necesita calcular un bono que dará a sus empleados a fin de este año. Para ello se sigue el siguiente criterio: • Si el sueldo supera los $2000, el bono será del 15%. De lo contrario, el bono será del 20%. • Si el empleado tiene hijos se suma un plus del 5% del sueldo. • Si el empleado pertenece a la categoría 1, 2 ó 3, recibe un 10% del sueldo. Si pertenece a la categoría 4, 5 ó 6, recibe un 12% del sueldo. Si es de la categoría 7, 8 ó 9, recibe un 20% del sueldo pero no cobra el plus por tener hijos. Realizar el programa que solicite la información necesaria para calcular el sueldo final. Finalmente el programa mostrará el total a pagarle al empleado (sueldo + bono). Ejemplo: Ingrese el sueldo: 1000 Tiene hijos (s/n)?: s Ingrese categoría (19): 2 El sueldo total será de $1350.00

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

int main()

{

int sueldo, categoria;

char op;

double bono;

printf("Ingrese el sueldo: ");

scanf("%d", &sueldo);

printf("Tiene hijos (s/n)?: ");

op=getche();

printf("\nIngrese categoria (1-‐9): ");

scanf("%d", &categoria);

if(sueldo>2000)

2012

26

bono=sueldo*0.15;

else

bono=sueldo*0.2;

if(op=='s'&&categoria!=7&&categoria!=8&&categoria!=9)

bono=bono+sueldo*0.05;

if(categoria==1||categoria==2||categoria==3)


else

{

if(categoria==4||categoria==5||categoria==6)


else


}

printf("El sueldo total sera de %.2lf", bono+sueldo);

return 0;

}

Ejercicio 1.19 Según las normas de tránsito, un automóvil no puede superar la velocidad máxima ni circular a menos que la velocidad mínima (que es la mitad de la velocidad máxima). Por una cuestión de errores de medición (tanto en el automóvil como en los dispositivos de control) hay un 15% de tolerancia. Sin embargo, se permite que los vehículos en emergencia (ambulancias, patrulleros, etc.) superen la velocidad máxima (no así, circular a menos que la velocidad mínima). Hacer un programa en el que se ingrese la velocidad a la que circula un vehículo, la velocidad máxima permitida y si se trata o no de un vehículo en emergencia (contestando 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 la velocidad está entre la máxima y la mínima (ambas inclusive), “No recibe multa”. • Si la velocidad está dentro de la tolerancia máxima (superando la máxima hasta el 15%, por ejemplo, para máxima de 60 km/h la tolerancia llega hasta 69 km/h), “Recibe advertencia”. No se aplica si es un vehículo en emergencia que, en este caso, “No recibe multa”. • Si la velocidad dentro de la tolerancia mínima (hasta 15% por debajo de la velocidad mínima), “Recibe advertencia”. Este caso es independiente del tipo de vehículo. • Si supera la velocidad máxima y el límite de tolerancia, “Recibe multa por exceso de velocidad”. No se aplica si es un vehículo en emergencia que, en este caso, “No recibe multa”. • Si excede la tolerancia de velocidad mínima, “Recibe multa 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 usuario debe contestar a esas preguntas con ‘s’ o ‘n’ (tener en cuenta que el usuario 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 corresponda.

#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 corresponda\n");

printf("\nEs de maniana?: ");

manana=getche();

printf("\nEl llamado es de tu casa?: ");

casa=getche();

printf("\nEstas en clase en este momento?: ");

clase=getche();

printf("\n");

if(clase=='s'||clase=='S')

{

printf("NO DEBE ATENDER");

}

else

{

if(casa=='s'||casa=='S')

{

printf("DEBE ATENDER");

}

else

{

if(manana=='s'||manana=='S')

{

printf("NO DEBE ATENDER");

}

else

{

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 perfecto\n", 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("%d\n", num);

}

return 0;

}

Ejercicio 2.4 Realizar un programa en el que se ingresa una letra a buscar y luego un texto de tamaño indefinido (hasta ingresar punto). Luego, el programa debe informar cuántas apariciones de la letra hay en ese texto. Ejemplo: Ingrese la letra a contar: a Ingrese el texto: La bella y graciosa moza, marchose a lavar la ropa. La letra “a” aparece 11 veces.

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

int main()

{

2012

34

char letra, texto;

int cont=0;

printf("Ingrese la letra a buscar: ");

letra=getche();

printf("\nIngrese el texto: (punto para terminar) \n");

do

{

texto=getche();

if(texto==letra)

cont++;

}while(texto!='.');

printf("\nla letra '%c' aparece %d veces en el texto.", letra, cont);

return 0;

}

Ejercicio 2.5 Realizar un programa en el que se ingresa un texto de longitud indefinida (hasta ingresar asterisco). Luego debe informarse por pantalla cuántas de sus letras fueron mayúsculas y cuántas fueron minúsculas. Por ejemplo, para el texto “Hola Mundo” debe obtenerse 2 mayúsculas y 7 minúsculas

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

int main()

{

2012

35

char texto;

int contmin=0, contmay=0;

printf("\nIngrese el texto: ('*' para terminar) \n");

do

{

texto=getche();

if(texto>='a'&&texto<='z')

contmin++;

else

{

if(texto>='A'&&texto<='Z')

contmay++;

}

}while(texto!='*');

printf("\nEn el texto ingresado hay %d minusculas y %d mayusculas ", contmin, contmay);

return 0;

}

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

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

2012

36

int main()

{

char texto;

int contvoc=0, contcons=0;

printf("\nIngrese el texto: (ENTER para terminar) \n");

do

{

texto=getche();

if(texto>='a'&&texto<='z'||texto>='A'&&texto<='Z')

{

if(texto=='a'||texto=='A'||texto=='e'||texto=='E'||texto=='i'||texto=='I'||texto=='o'||texto=='O'||texto=='u'||texto=='U')

contvoc++;

else

contcons++;

}

}while(texto!='\r');

printf("\nEn el texto ingresado hay %d vocales y %d consonantes ", contvoc, contcons);

return 0;

}

Ejercicio 2.7 Construir un programa en el que se ingresen números enteros hasta que se hayan ingresado 5 números pares e informar si alguno de ellos es también múltiplo de cuatro.

#include <stdio.h>

2012

37

#include <stdlib.h>

int main()

{

int num, cont=0, sen=0, div;

do

{


scanf("%d", &num);

if (num%2==0&&num!=0)

cont++;

if(num>=0)

{

div=0;

do

{

div++;

if(div*4==num)

sen=1;

}while(div*4<=num);

}

else

{

div=0;

do

{

div-‐-‐;

2012

38

if(div*4==num)

sen=1;

}while(div*4>=num);

}

}while(cont<=4);

if(sen==1)

printf("Hay por lo menos un multiplo de 4\n");

else

printf("No hay multiplos de 4");

return 0;

}

Ejercicio 2.8 Escribir un programa que reciba una cantidad indefinida de números enteros positivos hasta que se ingresa el 0. A continuación el programa debe indicar cuál fue el mayor y cuál el menor.

#include <stdio.h>

#include <stdlib.h>

int main()

{

int num, may, men, sen=0;


scanf("%d", &num);

if(num!=0)

{

2012

39

may=num;

men=num;

}

else

{

printf("No se ingresaron valores utiles.");

sen=1;

}

while(num!=0)

{


scanf("%d", &num);

if(num>may)

may=num;

if(num<men&&num!=0)

men=num;

}

if(sen==0)

printf("El mayor fue %d y el menor fue %d", may, men);

return 0;

}

Ejercicio 2.9 Armar un programa en el que se ingrese un número entero decimal (base diez) y convertirlo a binario.

#include <stdio.h>

#include <stdlib.h>

2012

40

int main()

{

int num, pot=1, bin=0, guard_num;


scanf("%d", &num);

guard_num=num;

while(num>0)

{

bin=bin+(num%2*pot);

pot=pot*10;

num=num/2;

}

printf("El numero %d(10) es igual al numero %d(2)", guard_num, bin);

return 0;

}

Ejercicio 2.10 Para encontrar el máximo común divisor (MCD) de dos números se emplea el algoritmo de Euclides, que se puede describir así: Dados dos enteros a y b (siendo a > b), se divide a por b. Si el resto de la división es cero, el número b es el máximo común divisor. Si la división no es exacta, el valor de a pasa a ser b y el nuevo valor de b será el resto de la división anterior. Se repite el procedimiento hasta obtener un resto cero. El último divisor (b) es el mcd buscado. Escribir un programa que calcule el mcd de dos números enteros. Por ejemplo, si a = 2366 y b=273, se divide a por b y el resto es 182; como no es cero, se divide el nuevo a que será 273 por el nuevo b que será 182 y da como resto 91; como no es cero se divide 182 por 91 y da como resto cero; se concluye entonces que 91 es el MCD entre 2366 y 273.

2012

41

#include <stdio.h>

#include <stdlib.h>

int main()

{

int a, b, aux, resto, guarda, guardb;


scanf("%d", &a);

guarda=a;


scanf("%d", &b);

guardb=b;

if(b>a)

{

aux=b;

b=a;

a=aux;

}

while(a%b!=0)

{

resto=a%b;

a=b;

b=resto;

}

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

2012

42

return 0;

}

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

#include <stdio.h>

#include <stdlib.h>

int main()

{

int nota, aplazados=0, aprovados=0, promocionantes=0, total, pcapl, pcapr,pcpro;

do

{

printf("Ingrese nota: ");

scanf("%d", &nota);

2012

43

if(nota!=0)

{

if(nota<4&&nota>=1)

aplazados++;

else

{

if(nota>=4&&nota<=7)

aprovados++;

else

{

if(nota>7&&nota<=10)

promocionantes++;

else

printf("\nDato incorrecto! ingrese notas del 1 al 10 por favor.\n");

}

}

}

}while(nota!=0);

if(aplazados==0&&aprovados==0&&promocionantes==0)

printf("\nNo se han ingresado datos relevantes");

else

{

total=aplazados+aprovados+promocionantes;

pcpro=(promocionantes*100)/total;

pcapr=(aprovados*100)/total;

2012

44

pcapl=(aplazados*100)/total;

printf("\nCantidad de aplazos: %d (%d%%)",aplazados, pcapl);

printf("\nCantidad de aprobados: %d (%d%%)",aprovados,pcapr);

printf("\nCantidad de promocionados: %d (%d%%)",promocionantes, pcpro);

}

return 0;

}

Ejercicio 2.12 Realizar un programa que permita el ingreso de letras en minúscula y que brinde al usuario tres operaciones posibles a través de un menú de opciones. La primera opción devolverá la mayúscula correspondiente. La segunda opción devolverá la letra siguiente en el alfabeto (si la letra ingresada fuera “z” se debe informar que es la última). La tercera opción devolverá la letra anterior en el alfabeto siempre que la letra ingresada no sea “a”. Validar que efectivamente el carácter ingresado sea una letra minúscula o * (este último determina el final de la serie de opciones). Ejemplo: Ingrese letra: f 1 – Convertir a mayúscula 2 – Obtener la siguiente 3 – Obtener la anterior Escoja una operación (1 – 3): 1 La mayúscula es F.

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

int main()

{

char letra;

int menu;

2012

45

do

{

printf("Ingrese la letra: ");

letra=getche();

printf("\n");

}while(letra<'a'||letra>'z');

do

{

printf("1 -‐ Convertir a mayuscula\n");

printf("2 -‐ Obtener la siguiente\n");

printf("3 -‐ Obtener la anterior\n");

printf("Escoja una operacion (1 -‐ 3): ");

scanf("%d", &menu);

if(menu<1||menu>3)

printf("Error!\n");

}while(menu<1||menu>3);

switch(menu)

{

case 1:

letra=letra-‐32;

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

{


scanf("%d", &num);

if(num%2!=1)

printf("Error!");

}while(num%2!=1||num<3);

blancos=num/2;

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

{

for(c=1; c<=blancos; c++)

{

2012

49

printf(" ");

}

blancos-‐-‐;

for(c=1;c<=ast;c++)

{

printf("*");

}

ast+=2;

printf("\n");

}

return 0;

}

Ejercicio 2.15 Efectuar un programa que solicite al usuario que ingrese la base de un triángulo rectángulo. Luego dibujar en la ventana dicho triángulo como se muestra en el ejemplo. Ejemplo: Ingrese base: 5 * ** *** **** ***** #include <stdio.h>

#include <stdlib.h>

int main()

{

2012

50

int num, f, c;

do{


scanf("%d", &num);

}while(num<2);

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

{

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

{

printf("*");

}

printf("\n");

}

return 0;

}

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

#include <stdio.h>

#include <stdlib.h>

int main()

2012

51

{

int num, f, c, blancos, ast=1;

do{


scanf("%d", &num);

}while(num<2);

blancos=num-‐1;

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

{


{

printf(" ");

}

blancos-‐-‐;

for(c=1; c<=ast; c++)

{

printf("*");

}

ast++;

printf("\n");

}

return 0;

}

2012

52

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

#include <stdlib.h>

int main()

{

int num, f, c, blancos, ast=1;

do{


scanf("%d", &num);

blancos=num/2;

}while(num<3||num%2!=1);

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

{


2012

53

{

printf(" ");

}

blancos-‐-‐;


{

printf("*");

}

ast+=2;

printf("\n");

}

blancos+=2;

ast-‐=4;

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

{


{

printf(" ");

}

blancos++;


{

printf("*");

}

ast-‐=2;

printf("\n");

2012

54

}

return 0;

}

Ejercicio 2.18 Efectuar un programa que solicite al usuario que ingrese la base y la altura de un rectángulo. Luego deberá dibujar en la ventana el rectángulo hueco. Ejemplo: Ingrese base: 7 Ingrese altura: 4 ******* * * * * *******

#include <stdio.h> #include <stdlib.h> int main() { int num, f, c; do{ 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{


scanf("%d", &num);

if(num<0)

printf("No se puede calcular el factorial de un numero negativo.\n");

}while(num<0);

if(num==0)

res=1;

else

{

res=num;

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

res=res*(num-‐cont);

}

printf("El factorial de %d es: %d", num, res);

return 0;

}

Ejercicio 2.21 Elaborar un programa en el que se ingrese un número entero positivo (de cualquier cantidad de cifras) y determine si es un número capicúa. Un número capicúa es aquel que leído de izquierda a derecha es igual que leído de derecha a izquierda. Por ejemplo: 82428. Considere invertir el número y luego compararlo con el número original. Si resultan iguales, será capicúa.

#include <stdio.h>

#include <stdlib.h>

2012

58

int main()

{

int num, aux, res=0;

do{


scanf("%d", &num);

if(num<=0)

printf("Error!\n");

}while(num<=0);

aux=num;

while(aux>0)

{

res=res*10+(aux%10);

aux/=10;

}

if(num==res)

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

else

printf("El numero %d NO es capicua", num);

return 0;

}

2012

59

Practica 3

Arreglos

Ejercicio 3.1 Realice un programa que permita cargar números enteros positivos en un arreglo (de hasta 1000 elementos) hasta que el usuario ingrese 0 (este valor marca el final de los valores útiles). Luego, se deberá obtener otro arreglo que contenga los mismos valores pero en forma inversa y a continuación imprimir este último. Ejemplo: Ingrese número: 20 Ingrese número: 21 Ingrese número: 14 Ingrese número: 0 El arreglo revertido contiene: 14, 21, 20. #include <stdio.h>

#include <stdlib.h>

#define N 1000

int main()

{

int v[N], i=0, b[N], j=0;

do{


scanf("%d", &v[i]);

i++;

}while(v[i-‐1]!=0);

i-‐=2;

while(i>=0)

2012

60

{

b[j]=v[i];

j++;

i-‐-‐;

}

j-‐-‐;

printf("El arreglo revertido contiene: ");

for(i=0; i<=j; i++)

printf("%d-‐", b[i]);

return 0;

}

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

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

2012

61

Ingrese los elementos del primer arreglo: 1 1 1 0 0 0 Ingrese los elementos del segundo arreglo: 1 1 0 0 0 1 El arreglo resultante es: 1 1 0 0 0 0 1 – AND 2 – OR 3 – NOT 4 – SALIR Seleccione una opción: 3 Ingrese los elementos del arreglo: 1 1 1 0 0 0 El arreglo resultante es: 0 0 0 1 1 1 #include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#define N 7

int main()

{

int i, menu;

char v[N], b[N], r[N], l;

do{

printf("\nMenu\n");

printf("1 -‐ AND\n");

printf("2 -‐ OR\n");

printf("3 -‐ NOT\n");

printf("4 -‐ SALIR\n");

scanf("%d", &menu);

switch(menu)

{

2012

62

case 1:

i=0;

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

do

{

l=getche();

if(l=='0'||l=='1')

{

v[i]=l;

i++;

}

}while(i<6);

v[i]='\0';

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

i=0;

do

{

l=getche();

if(l=='0'||l=='1')

{

b[i]=l;

i++;

}

}while(i<6);

2012

63

b[i]='\0';

for(i=0;i<6;i++)

{

if(v[i]=='1'&&b[i]=='1')

r[i]='1';

else

r[i]='0';

}

r[i]='\0';

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

break;

case 2:

i=0;


do

{

l=getche();

if(l=='0'||l=='1')

{

v[i]=l;

i++;

}

}while(i<6);

v[i]='\0';


2012

64

i=0;

do

{

l=getche();

if(l=='0'||l=='1')

{

b[i]=l;

i++;

}

}while(i<6);

b[i]='\0';

for(i=0;i<6;i++)

{

if(v[i]=='1'||b[i]=='1')

r[i]='1';

else

r[i]='0';

}

r[i]='\0';


break;

case 3:

i=0;

printf("\nIngrese el arreglo:");

2012

65

do

{

l=getche();

if(l=='0'||l=='1')

{

v[i]=l;

i++;

}

}while(i<6);

v[i]='\0';

for(i=0;i<6;i++)

{

if(v[i]=='1')

r[i]='0';

else

r[i]='1';

}

r[i]='\0';


break;

case 4:

printf("\nTerminado. Tenga un buen dia!.");

break;

default:

printf("\nOpcion no valida. Por favor reintente: ");

2012

66

break;

}

}while(menu!=4);

return 0;

}

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

#include <stdlib.h>

#define N 1000

int main()

{

int i, j, k, m, sen=0, menu, l, v[N], b[N], r[N*2];

do{

printf("\nMenu\n");

printf("1 -‐ UNION\n");

printf("2 -‐ INTERSECCION\n");

printf("3 -‐ DIFERENCIA\n");


scanf("%d", &menu);

2012

67

switch(menu)

{

case 1:

i=0;


do

{

sen=0;

scanf("%d", &l);

for(j=0;j<i;j++)

{

if(v[j]==l)

sen=1;

}

if(sen==0)

{

v[i]=l;

i++;

}

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

i-‐-‐;


2012

68

k=0;

do

{

sen=0;

scanf("%d", &l);

for(j=0;j<k;j++)

{

if(b[j]==l)

sen=1;

}

if(sen==0)

{

b[k]=l;

k++;

}

}while(k<N-‐1&&b[k-‐1]!=0);

for(m=0;m<i;m++)

{

r[m]=v[m];

}

int n;

for(j=0;j<k;j++)

2012

69

{

l=b[j];

sen=0;

for(i=0;i<m;i++)

{

if(l==r[i])

sen=1;

}

for(n=0;n<=i;n++)

{

if(v[n]==l)

sen=1;

}

if(sen==0)

{

r[m]=l;

m++;

}

}

printf("El arreglo resultante es: ");

for(i=0;i<m;i++)

{

printf("%d-‐", r[i]);

}

break;

case 2:

2012

70

i=0;


do

{

sen=0;

scanf("%d", &l);

for(j=0;j<i;j++)

{

if(v[j]==l)

sen=1;

}

if(sen==0)

{

v[i]=l;

i++;

}

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

i-‐-‐;


k=0;

do

{

2012

71

sen=0;

scanf("%d", &l);

for(j=0;j<k;j++)

{

if(b[j]==l)

sen=1;

}

if(sen==0)

{

b[k]=l;

k++;

}

}while(k<N-‐1&&b[k-‐1]!=0);

k-‐-‐;

int o, p=0;

for(n=0;n<i;n++)

{

sen=0;

for(o=0; o<k;o++)

{

if(v[n]==b[o])

sen=1;

2012

72

}

if(sen==1)

{

r[p]=v[n];

p++;

}

}


for(i=0;i<p;i++)

{


}

break;

case 3:

i=0;


do

{

sen=0;

scanf("%d", &l);

for(j=0;j<i;j++)

{

if(v[j]==l)

sen=1;

2012

73

}

if(sen==0)

{

v[i]=l;

i++;

}

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

i-‐-‐;


k=0;

do

{

sen=0;

scanf("%d", &l);

for(j=0;j<k;j++)

{

if(b[j]==l)

sen=1;

}

if(sen==0)

{

2012

74

b[k]=l;

k++;

}

}while(k<N-‐1&&b[k-‐1]!=0);

k-‐-‐;

p=0;

for(n=0;n<i;n++)

{

sen=0;

for(o=0; o<k;o++)

{

if(v[n]==b[o])

sen=1;

}

if(sen==0)

{

r[p]=v[n];

p++;

}

}


for(i=0;i<p;i++)

{


2012

75

}

break;

case 4:


break;

default:


break;

}

}while(menu!=4);

return 0;

}

Ejercicio 3.5 Realizar un programa en el que se ingrese un texto de hasta 100 caracteres finalizando con ENTER (utilizar ‘\r’ para detectar el ingreso de ENTER). Luego, el usuario deberá elegir un caracter al cual reemplazar y con que caracter reemplazarlo.

Ejemplo: Ingrese texto: La mar estaba serena Ingrese carácter a reemplazar: a Ingrese carácter de reemplazo: e Resultado: Le mer estebe serene #include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#define N 101

int main()

{

2012

76

char l, lo='0',lc='0',texto[N];

int i=0;

printf("\nIngrese la letra a reemplazar: ");

do

{

l=getche();

if(l>='a'&&l<='z'||l>='A'&&l<='Z')

lo=l;

else

printf("\nError!. Reintente: ");

}while(lo=='0');

printf("\nIngrese la letra a ser reemplazada: ");

do

{

l=getche();

if(l>='a'&&l<='z'||l>='A'&&l<='Z')

lc=l;

else

printf("\nError!. Reintente: ");

}while(lc=='0');

printf("\nIngrese el texto: \n");

do

{

l=getche();

if(l!='\r')

{

2012

77

texto[i]=l;

i++;

}

}while(l!='\r'&&i<N-‐1);

texto[i]='\0';

int j;

for(j=0;j<i;j++)

{

if(texto[j]==lo)

texto[j]=lc;

}

printf("\ntexto modificado: %s\n", texto);

return 0;

}

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

#include <stdlib.h>

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("%s\n", text);

for(cont=0;cont<80-‐i;cont++)

printf(" ");

printf("%s\n", 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%s\n", text);

return 0;

}

void trans (char text[], int i)

{

int j=0, k=0, sen=0;

while(j<i)

{

if(text[j]>='A'&&text[j]<='Z'||text[j]>='a'&&text[j]<='z'||text[j]==' ')

{

sen=1;

text[k]=text[j];

k++;

}

else

{

if(sen==1)

text[k]='\0';

}

j++;

}

}

2012

81

Practica 4

Funciones

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

#include <stdlib.h>

#include <math.h>

double area (int, int, int);

int main()

{

int a,b,c;

double areatri;

printf("Ingrese lado 1: \n");

do

{

scanf("%d", &a);

}while (a<=0);


2012

82

do

{

scanf("%d", &b);

}while (b<=0);


do

{

scanf("%d", &c);

}while (c<=0);

areatri=area(a,b,c);

printf("El area del triangulo es = %.2lf", areatri);

return 0;

}

double area (int a, int b, int c)

{

double areatri,p;

p=(a+b+c)/2.0;

areatri=sqrt((double)p*(p-‐a)*(p-‐b)*(p-‐c));

return areatri;

}

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

2012

83

La raiz 3 de 14 es = 2.410142 Ayuda: Utilizar la funcion pow de la libreria math.h cuyo prototipo es double pow(double base, double exponente); #include <stdio.h>

#include <stdlib.h>

#include <math.h>

double raiz (double, int);

int main()

{

double x, resultado;

int n;

printf("Ingrese el numero a radicar: \n");

do

{

scanf("%lf", &x);

if(x<0)

printf("Error! No existe la raiz de un numero negativo en reales. Reingrese: ");

}while (x<0);

printf("Ingrese la raiz a efectuar: \n");

do

{

scanf("%d", &n);

if(n<=0)

printf("Error! Reingrese un numero positivo: ");

}while (n<=0);

2012

84

resultado=raiz(x, n);

printf("La raiz %d de %g es = %g", n, x, resultado);

return 0;

}

double raiz (double x, int n)

{

double resultado;

resultado=pow(x,1.0/n);

return resultado;

}

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

#include <stdlib.h>

int cambio_base (int, int);

int main()

{

int decimal, base, cambiado;

printf("Ingrese el numero en sistema decimal: \n");

do

2012

85

{

scanf("%d", &decimal);

if(decimal<0)

printf("Error! Reingrese un numero positivo: ");

}while (decimal<0);

printf("Ingrese la base en que lo quiere: \n");

do

{

scanf("%d", &base);

if(base<2||base>9)

printf("Error! Reingrese un numero positivo (entre 2 y 9): ");

}while (base<2||base>9);

cambiado=cambio_base(decimal, base);

printf("El numero %d(10) es igual a %d(%d)", decimal, cambiado, base);

return 0;

}

int cambio_base (int d, int b)

{

int c=0, pot=1;

do

{

c=c+(d%b)*pot;

d/=b;

pot*=10;

}while(d>0);

2012

86

return c;

}

Ejercicio 4.4 Programar una funcion que reciba como parametros 2 numeros enteros y que retorne un numero aleatorio entre estos 2 numeros (inclusive). Por ejemplo, si se invocara la funcion con parametros 1 y 6, debera devolver un numero aleatorio entre 1 y 6 inclusive. Validar que el valor maximo no sea superior al valor maximo que es capaz de generar la funcion rand. Implementarla en un programa que solicite al usuario que ingrese el rango de valores aleatorios y la cantidad deseada de valor. A continuacion imprimir la lista de numeros aleatorios segun el criterio solicitado. Ejemplo: Ingrese minimo: 1 Ingrese maximo: 20 Ingrese cantida de valores: 10 1, 8, 20, 14, 11, 17, 2, 1, 5, 6. #include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define N 99999

int aleatorio (int, int);

int main()

{

int max, min,i,j ,v[N];

srand(time(NULL));

printf("Ingrese el maximo: \n");

scanf("%d", &max);

printf("Ingrese el minimo: \n");

do

2012

87

{

scanf("%d", &min);

if(min>max)

printf("Error! Reingrese un numero menor al maximo: ");

}while (min>max);

printf("Ingrese la cantidad de valores: \n");

do

{

scanf("%d", &i);

if(i<0)

printf("no se puede mostrar una cantidad negativa de veces. reingrese: ");

}while (i<0);

printf("\n");

for(j=0;j<i;j++)

{

v[j]=aleatorio(max, min);

printf("%d, ", v[j]);

}

return 0;

}

int aleatorio (int max, int min)

{

int c;

c=rand()%(max-‐min+1)+min;

return c;

2012

88

}

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

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

#include <stdio.h>

2012

89

void dibujar_fila(int);

void dibujar_rectangulo(int, int);

int main()

{

int alto, ancho;

printf("Ingrese ancho:");

scanf("%d", &ancho);

printf("Ingrese altura:");

scanf("%d", &alto);

dibujar_rectangulo(ancho, alto);

return 0;

}

void dibujar_fila(int anch)

{

int c;

for(c=0;c<anch;c++)

{

printf("*");

}

}

void dibujar_rectangulo(int anch, int alt)

{

int f;

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

{

dibujar_fila (anch);

2012

90

printf("\n");

}

}

Ejercicio 4.7 Programar una funcion que tome como parametro un texto y que convierta sus letras mayusculas en minusculas y todo lo que no sean ni letras ni numeros, se conviertan en espacios. Utilizarla en un programa en el que se ingrese un texto de hasta 1000 caracteres y luego se imprima la version modificada del texto. El texto debe contener ‘\0’ como caracter final a fin de que pueda imprimirse con printf(“%s”, texto); #include <stdio.h>

#include <conio.h>

#define N 1000

int es_letra_o_numero(char);

int es_mayuscula(char);

void trans_texto(char[], int);

int main()

{

int i=0, l;

char texto[N];

printf("Ingrese el texto:\n");

do

{

l=getche();

if(l!='\r')

{

2012

91

texto[i]=l;

i++;

}

}while(l!='\r');

texto[i]='\0';

trans_texto(texto, i);

printf("\ntexto modificado: %s", texto);

return 0;

}

int es_letra_o_numero(char a)

{

return((a>='a'&&a<='z')||(a>='A'&&a<='Z')||(a>='0'&&a<='9'));

}

int es_mayuscula (char l)

{

return(l>='A'&&l<='Z');

}

void trans_texto(char texto[], int i)

{

int j;

for(j=0;j<i;j++)

{

if(!es_letra_o_numero(texto[j]))

texto[j]=' ';

else

2012

92

{

if(es_mayuscula(texto[j]))

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

}

}

}

Ejercicio 4.8 Realizar una funcion que permita ingresar en un arreglo de caracteres (string) solamente caracteres numericos (ignorar y no mostrar en pantalla cuando se ingrese un caracter que no sea numero). Luego, programar otra funcion que tome ese arreglo de caracteres y lo convierta a un valor numerico entero. Utilizar ambas funciones en un programa en que se ingrese un numero y luego se convierta a entero para ser impreso mediante printf(“%d”, numero). #include <stdio.h>

#include <conio.h>

#define N 1000

int number(char[], int);

int main()

{

int i=0;

char numero[N]={0}, l;

printf("Ingrese los numeros:\n");

do

{

l=getch();

if(l>='0'&&l<='9')

{

printf("%c", l);

2012

93

numero[i]=l;

i++;

}

}while(l!='\r'&&i<N-‐2);

numero[i]='\0';

int j=0;

j=number(numero,i);

printf("\nnumero: %s\n", numero);

printf("\nnumero: %d\n", j);

for(j=0;j<i;j++)

printf("%d", numero[j]);

return 0;

}

int number (char numero[], int i)

{

int num=0, j;

for(j=0;j<i;j++)

{

num=num*10+(numero[j]-‐48);

}

return num;

}

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: %d\n", max);

printf("\nminimo: %d\n", 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("\nMenu\n");

printf("1 -‐ AND\n");

printf("2 -‐ OR\n");

printf("3 -‐ NOT\n");


scanf("%d", &menu);

switch(menu)

{

case 1:


ingrese (v);


ingrese(b);

AND(v,b,r);


break;

2012

100

case 2:


ingrese(v);


ingrese(b);

OR(v,b,r);


break;

case 3:

i=0;

printf("\nIngrese el arreglo:");

ingrese(v);

NOT(v,b,r);


break;

case 4:


break;

default:


break;

}

2012

101

}while(menu!=4);

return 0;

}

ingrese(char v[])

{

int i=0;

char l;

do

{

l=getche();

if(l=='0'||l=='1')

{

v[i]=l;

i++;

}

}while(i<6);

v[i]='\0';

}

AND(char v[],char b[], char r[])

{

int i;

for(i=0;i<6;i++)

{

if(v[i]=='1'&&b[i]=='1')

r[i]='1';

2012

102

else

r[i]='0';

}

r[i]='\0';

}

OR(char[],char[], char[])

{

int i;

for(i=0;i<6;i++)

{

if(v[i]=='1'||b[i]=='1')

r[i]='1';

else

r[i]='0';

}

r[i]='\0';

}

NOT(char[],char[], char[])

{

int i;

for(i=0;i<6;i++)

{

if(v[i]=='1')

r[i]='0';

else

2012

103

r[i]='1';

}

r[i]='\0';

}

3.4:

#include <stdio.h>

#include <stdlib.h>

#define N 1000

int repetido (int[], int, int);

int ingrese (int[]);

imprimir_resultado(int[], int);

int main()

{

int i, j, k, m, sen=0, menu, l, v[N], b[N], r[N*2];

do{

printf("\nMenu\n");

printf("1 -‐ UNION\n");

printf("2 -‐ INTERSECCION\n");

printf("3 -‐ DIFERENCIA\n");


scanf("%d", &menu);

switch(menu)

{

case 1:

2012

104


i=ingrese(v);


k=ingrese(b);

//pedaso que checkea si guardar en el arreglo solucion o no.

for(m=0;m<i;m++)

{

r[m]=v[m];

}

for(j=0;j<k;j++)

{

sen=0;

sen=repetido(r,m,b[j]);

sen=repetido(v,m,b[j]);

if(sen==0)

{

r[m]=b[j];

m++;

}

}

imprimir_resultado(r,m);

break;

case 2:


i=ingrese(v);


2012

105

k=ingrese(b);

m=0;

for(j=0;j<i;j++)

{

sen=0;

sen=repetido(b,k,v[j]);

if(sen==1)

{

r[m]=v[j];

m++;

}

}


break;

case 3:


i=ingrese(v);


k=ingrese(b);

for(j=0;j<i;j++)

{

sen=repetido(b,k,v[j]);

if(sen==0)

{

r[m]=v[j];

2012

106

m++;

}

}


break;

case 4:


break;

default:


break;

}

}while(menu!=4);

return 0;

}

int ingrese(int v[])

{

int i=0, sen, l;

do

{

scanf("%d", &l);

sen=repetido(v,i,l);

if(sen==0)

{

v[i]=l;

i++;

2012

107

}

}while(i<N-‐1&&l!=0);

i-‐-‐;

return i;

}

int repetido (int v[], int i, int l)

{

int j, sen=0;

for(j=0;j<i;j++)

{

if(v[j]==l)

sen=1;

}

return sen;

}

imprimir_resultado(int r[], int m)

{


int i;

for(i=0;i<m;i++)

{


}

}

Ejercicio 4.13 Realizar un programa que contenga las siguientes funciones:

2012

108

a. Una funcion que permita cargar un texto de hasta 1000 caracteres finalizando dicha carga con ENTER. El arreglo debe contener el caracter ‘\0’ como marca de finalizacion de acuerdo con la convencion utilizada en el lenguaje C. b. Una funcion que reciba como parametro una frase y que retorne cuantas palabras tiene esa frase. c. Una funcion que reciba como parametro una frase y que retorne la longitud promedio de las palabras de esa frase. d. Una funcion que reciba como parametro una frase y que modifique el contenido de dicha frase de modo que la primera letra de cada palabra quede en mayuscula. En base a estas funciones, Realizar un programa en el que se ingrese una frase y a continuacion se muestren por pantalla los resultados obtenidos mediante las funciones creadas en los puntos b, c y d. Considere programar funciones adicionales. #include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#define N 1001

a (char[]);

int b(char[]);

double c (char[]);

d (char[]);

int es_separador(char);

int es_minuscula(char);

int main()

{

char texto[N];

int cantidad_palabras;

double promedio;

a(texto);

2012

109

printf("\nTexto original:%s", texto);

cantidad_palabras=b(texto);

printf("\nCantidad de palabras: %d", cantidad_palabras);

promedio=c(texto);

printf("\nPromedio de longitud de las palabras: %.2lf", promedio);

d(texto);

printf("\nTexto modificado: %s", texto);

return 0;

}

a(char texto[])

{

int i=0;

char l;

printf("Ingrese el texto: ");

do

{

l=getche();

if(l!='\r')

{

texto[i]=l;

i++;

}

}while(i<N-‐1&&l!='\r');

texto[i]='\0';

}

int es_separador(char l)

2012

110

{

return(l==' '||l==','||l==';'||l=='?'||l=='!');

}

int b (char texto[])

{

int cont=0, sen=0, i;

for(i=0;i<N-‐1&&texto[i]!='\0';)

{

sen=0;

while(es_separador(texto[i])&&texto[i]!='\0')

i++;

while(!es_separador(texto[i])&&texto[i]!='\0')

{

sen=1;

i++;

}

if(sen==1)

cont++;

}

return cont;

}

double c (char texto[])

{

/*c. Una funcion que reciba como parametro una frase y que retorne la longitud promedio de las

2012

111

palabras de esa frase.*/

int cant_pal[N/2]={0}, i, suma=0, j=0, sen;

for(i=0;(i<N-‐1)&&(texto[i]!='\0');)

{

sen=0;


i++;


{

cant_pal[j]++;

sen=1;

i++;

}

if(sen==1)

{

suma=suma+cant_pal[j];

j++;

}

}

double resultado;

resultado=suma/(double)j;

return resultado;

}

d (char texto[])

2012

112

{

int sen=0, i;

for(i=0;i<N-‐1&&texto[i]!='\0';)

{

sen=0;


i++;


{

if(sen==0)

{

if(es_minuscula(texto[i]))

texto[i]-‐=32;

}

sen=1;

i++;

}

}

}

int es_minuscula(char l)

{

return(l>='a'||l<='z');

}

Ejercicio 4. 14 Realizar un programa que contenga las siguientes funciones:

2012

113

a. Una funcion que permita cargar un texto de hasta 1000 caracteres finalizando dicha carga con ENTER. El arreglo debe contener el caracter ‘\0’ como marca de finalizacion de acuerdo con la convencion utilizada en el lenguaje C. b. Una funcion booleana que reciba como parametros dos palabras (en dos arreglos independientes) y que indique si ambas palabras son iguales (considerar mayusculas y minusculas como iguales). c. Una funcion que reciba como parametros una frase y una palabra (considerar mayusculas y minusculas como iguales) y que retorne cuantas veces aparece dicha palabra en la frase. d. Una funcion booleana que reciba como parametros dos frases (en dos arreglos independientes) y que determine si ambas frases son iguales. Es decir, cuando contengan las mismas palabras en el mismo orden. Por ejemplo: “Hola, como te va?” debe ser considerada igual a “hola… Como te va!” En base a estas funciones, Realizar un programa en el que se ingresen por teclado dos frases y una palabra. A continuacion, el programa debera mostrar por pantalla cuantas veces aparece la palabra ingresada en cada una de las frases ingresadas y si ambas frases son iguales. Considere programar funciones adicionales y utilizar la funcion del punto b en los puntos c y d.

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#define N 1001

void a (char[]);

int b(char[], char[]);

int c (char[], char[]);

int d (char[], char[]);

int es_separador(char);

int es_minuscula(char);

int es_letra(char);

int main()

2012

114

{

char texto1[N], texto2[N], palabra[N], sen;

int cant_pal_rep1,cant_pal_rep2;

a(texto1);

printf("\n");

a(texto2);

printf("\n");

a(palabra);

cant_pal_rep1=c(texto1, palabra);

printf("\ncantidad de veces que se repite la palabra en el texto 1: %d", cant_pal_rep1);

cant_pal_rep2=c(texto2, palabra);

printf("\ncantidad de veces que se repite la palabra en el texto 2: %d", cant_pal_rep2);

sen=d(texto1,texto2);

if(sen==1)

printf("\nlos textos son iguales");

else

printf("\nlos textos son distintos");

return 0;

}

void a(char texto[])

{

int i=0;

char l;

printf("Ingrese el texto: ");

do

2012

115

{

l=getche();

if(l!='\r')

{

texto[i]=l;

i++;

}

}while(i<N-‐1&&l!='\r');

texto[i]='\0';

}

int es_separador(char l)

{

return(l==' '||l==','||l==';'||l=='?'||l=='!');

}

int b (char palabra1[],char palabra2[])

{

/*b. Una funcion booleana que reciba como parametros dos palabras (en dos arreglos

independientes) y que indique si ambas palabras son iguales (considerar mayusculas y

minusculas como iguales).*/

int sen=1, i;

for(i=0;palabra1[i]!='\0'&&palabra2[i]!='\0'&&sen==1;i++)

{

if(palabra1[i]==palabra2[i])

sen=1;

else

sen=0;

2012

116

}

return sen;

}

int c (char texto[], char palabra[])

{

/*c. Una funcion que reciba como parametros una frase y una palabra (considerar mayusculas y

minusculas como iguales) y que retorne cuantas veces aparece dicha palabra en la frase.*/

int sen=1, i, cont=0, j;

for(i=0;texto[i]!='\0';i++)

{

sen=1;

j=0;

if(es_minuscula(palabra[j]))

palabra[j]-‐=32;

if(texto[i]==palabra[j]||texto[i]==palabra[j]+32)

{

i++;

j++;

while(palabra[j]!='\0'&&sen==1)

{

if(es_minuscula(palabra[j]))

palabra[j]-‐=32;

if(texto[i]==palabra[j]||texto[i]==palabra[j]+32)

sen=1;

else

sen=0;

2012

117

j++;

i++;

}

if(es_separador(texto[i])||texto[i]=='\0')

sen=1;

else

sen=0;

if(sen==1)

cont++;

}

}

return cont;

}

int d (char texto1[],char texto2[])

{

/*d. Una funcion booleana que reciba como parametros dos frases (en dos arreglos

independientes) y que determine si ambas frases son iguales. Es decir, cuando contengan las

mismas palabras en el mismo orden. Por ejemplo: “Hola, como te va?” debe ser considerada

igual a “hola… Como te va!”*/

int i=0, j=0, sen=1;

while(texto1[i]!='\0'&&texto2[i]!='\0'&&sen==1)

{

if(es_letra(texto1[i]))

{

if(es_minuscula(texto1[i]))

2012

118

texto1[i]-‐=32;

if(es_letra(texto2[j]))

{

if(es_minuscula(texto2[j]))

texto2[j]-‐=32;

if(texto1[i]!=texto2[j])

sen=0;

else

{

j++;

i++;

}

}

else

j++;

}

else

i++;

}

return sen;

}

int es_minuscula(char l)

{

return (l>='a'&&l<='z');

}

2012

119

int es_letra(char l)

{

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

}

En este programita tengo q avisar q ni use una función asique probablemente no sea asi como tendría que estar hecho, pero no se me ocurrio de otra manera..

informática i: ejercicios resueltos

Engineering