SlideShare una empresa de Scribd logo

Informática I: Ejercicios Resueltos

Alvin Jacobs, profile picture
Alvin Jacobs

Este documento contiene las prácticas y ejercicios resueltos de la asignatura Informática I. Presenta 20 ejercicios de práctica 1 sobre operaciones básicas, 20 ejercicios de práctica 2 sobre estructuras de repetición, y 7 ejercicios de práctica 3 y 4 sobre arreglos y funciones respectivamente.

Ingeniería
1 de 119
Descargado 122 veces
1
2
3
4
Lo más leído
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
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=%dn                    resto:%d",  num,  num/2,  num%2);          return  0;   }   Ejercicio  1.2   Realizar  un  programa  en  el  que  se  ingrese  la  base  y  la  altura  de  un  triángulo  e  informe  su   superficie.  El  programa  debe  imprimir  una  leyenda  que  incluya  los  datos  de  entrada  y  el   resultado   con  una  precisión  de  2  dígitos  decimales.   Ejemplo:   Ingrese  la  base  del  triángulo:  8   Ingrese  la  altura  del  triángulo:  5   La  superficie  del  triangulo  de  base  7  y  altura  5  es  17.50   #include  <stdio.h>   #include  <stdlib.h>  
2012   4     int  main()   {          double  base,  alt,  sup;          printf("Ingrese  la  base  del  triangulo:");          scanf("%lf",  &base);          printf("Ingrese  la  altura  del  triangulo:");          scanf("%lf",  &alt);          sup=base*alt/2;          printf("La  superficie  del  triangulo  de  base  %.2lf  y  altura  %.2lf  es  %.2lf",  base,  alt,  sup);          return  0;   }   Ejercicio  1.3   Elaborar  un  programa  en  el  que  se  ingrese  por  teclado  un  número  real  y,  a  continuación,  se   muestre  la  parte  entera  de  dicho  número  y  la  parte  fraccionaria  (por  separado).   Ejemplo:   Ingrese  numero:  48.151   Parte  entera:  48   Parte  fraccionaria:  0.151   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          double  num,  Fnum,  Enum;          printf("Ingrese  numero:  ");          scanf("%lf",  &num);          Fnum=num-­‐(int)num;  
2012   5          Enum=num-­‐Fnum;          printf("Parte  entera:  %gn",  Enum);          printf("Parte  fraccionaria:  %gn",  Fnum);          return  0;   }   Ejercicio  1.4   Desarrollar  un  programa  en  el  que  se  ingrese  un  número  de  5  dígitos  y  que  luego  muestre   cada   dígito  separado  por  un  guión.   Ejemplo:   Ingrese  numero:  45212   Separacion  en  dígitos:  4-­‐5-­‐2-­‐1-­‐2.   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num,  num1,  num2,  num3,  num4,  num5;          printf("Ingrese  numero:  ");          scanf("%d",  &num);          num5=num%10;          num=num/10;          num4=num%10;          num=num/10;          num3=num%10;          num=num/10;          num2=num%10;          num=num/10;          num1=num%10;  
2012   6          //lo  hice  asi  choto  a  proposito  podria  haber  validado  y  usado  un  while.  includo  un  arreglo.          printf("Separacion  en  digitos:  %d-­‐%d-­‐%d-­‐%d-­‐%d.n",  num1,  num2,  num3,  num4,  num5);          return  0;   }   Ejercicio  1.5   Hacer  un  programa  en  el  que  se  ingrese  la  medida  de  los  catetos  de  un  triángulo  rectángulo  y   que   se  calcule  y  muestre  el  perímetro  de  dicho  triángulo.  Incluir  math.h  a  fin  de  utilizar  la  función   sqrt(expresión)  que  calcula  la  raíz  cuadrada  de  un  número.   #include  <stdio.h>   #include  <stdlib.h>   #include  <math.h>     int  main()   {          double  ct1,ct2,  perim;          printf("Ingrese  el  primer  cateto:  ");          scanf("%lf",  &ct1);          printf("Ingrese  el  segundo  cateto:  ");          scanf("%lf",  &ct2);          perim=ct1+ct2+sqrt(ct1*ct1+ct2*ct2);          printf("El  perimetro  del  triangulo  ingresado  mide  %.2lf",  perim);              return  0;   }   Ejercicio  1.6   Elaborar  un  programa  en  el  que  se  ingrese  una  cantidad  expresada  en  segundos  y  luego  la   exprese  en  días,  horas,  minutos  y  segundos.   Ejemplo:  
2012   7   Ingrese  tiempo  en  segundos:  93714   1  dia(s),  2  hora(s),  1  minuto(s),  54  segundo(s).   #include  <stdio.h>   #include  <stdlib.h>   #include  <math.h>     int  main()   {          int  num,  seg,  dias,  horas,  min;          printf("Ingrese  tiempo  en  segundos:  ");          scanf("%d",  &num);          seg=num%60;          num=num/60;          min=num%60;          num=num/60;          horas=num%24;          dias=num/24;          printf("%d  dia(s),  %d  hora(s),  %d  minuto(s),  %dsegundo(s)",  dias,  horas,  min,  seg);          return  0;   }   Ejercicio  1.7   Desarrollar  un  programa  en  el  que  se  ingresen  dos  números  enteros  positivos  y  que  genere  y   muestre  un  tercer  numero  que  esté  compuesto  por  las  unidades  del  primer  número  y  por  las   decenas  del  segundo.   Ejemplo:   Ingrese  el  primer  numero:  427   Ingrese  el  segundo  numero:  52   El  numero  resultante  es:  57   #include  <stdio.h>   #include  <stdlib.h>  
2012   8     int  main()   {          int  num1,  num2,  res;          printf("Ingrese  el  primer  numero:  ");          scanf("%d",  &num1);          printf("Ingrese  el  segundo  numero:  ");          scanf("%d",  &num2);          num2=num2/10;          num2=num2%10;          num1=num1%10;          res=num1+num2*10;          printf("El  numero  resultante  es:  %d",  res);          return  0;   }   Ejercicio  1.8   Hacer  un  programa  que  calcule  las  raíces  reales  de  una  ecuación  cuadrática.  El  usuario   ingresará   los  coeficientes  a,  b  y  c  tal  que  ax²  +  bx  +  c=0.  Cuando  las  raíces  no  sean  reales,  se  mostrará  un   mensaje  indicando  esta  situación.   Ejemplo:   Ingrese  coeficiente  a:  2   Ingrese  coeficiente  b:  3   Ingrese  coeficiente  c:  1   La  raíz  1  es:  0.50   La  raíz  2  es:  1.00   #include  <stdio.h>   #include  <stdlib.h>   #include  <math.h>     int  main()  
2012   9   {          double  a,  b,  c,  x1,  x2,  d;          printf("Ingrese  coeficiente  a:  ");          scanf("%lf",  &a);          printf("Ingrese  coeficiente  b:  ");          scanf("%lf",  &b);          printf("Ingrese  coeficiente  c:  ");          scanf("%lf",  &c);          d=b*b-­‐4*a*c;          if(d<0)          {                printf("Las  raices  no  son  reales.");          }          else          {                  d=sqrt(d);                  x1=(b+d)/(2*a);                  x2=(b-­‐d)/(2*a);                  printf("La  raíz  1  es:  %.2lf",  x1);                  printf("nLa  raíz  2  es:  %.2lf",  x2);          }            return  0;   }   Ejercicio  1.9   Escriba  un  programa  en  el  que  se  ingresen  2  números  y  un  carácter  (+,-­‐,*,/)  e  informe  el   resultado   de  la  operación.   Ejemplo:  
2012   10   Ingrese  el  primer  número:  8   Ingrese  el  segundo  número:  2   Ingrese  la  operación  (+,-­‐,   *,  /):  +   8  +  2  =10   #include  <stdio.h>   #include  <conio.h>       int  main()   {          int  num1,  num2;          char  sign;          printf("Ingrese  el  primer  numero:  ");          scanf("%d",  &num1);          printf("Ingrese  el  segundo  numero:  ");          scanf("%d",  &num2);          printf("Ingrese  la  operacion  (+,-­‐,*,  /):  ");          sign=getche();          printf("n");          switch  (sign)          {                  case  '+':                  printf("%d+%d=%d",num1,  num2,  num1+num2);                  break;                  case  '-­‐':                  printf("%d-­‐%d=%d",num1,  num2,  num1-­‐num2);                  break;  
2012   11                  case  '*':                  printf("%d*%d=%d",num1,  num2,  num1*num2);                  break;                  case  '/':                  if  (num2!=0)                  printf("%d/%d=%d",num1,  num2,  num1/num2);                  else                  printf("El  denominador  no  puede  ser  igual  a  0");                  break;                  default:                  printf("El  caracter  ingresado  es  incompatible");                  break;          }            return  0;   }   Ejercicio  1.10   Realizar  un  programa  en  el  que  se  ingresen  por  teclado  3  letras  que  pueden  ser  mayúsculas  o   minúsculas  (no  necesariamente  todas  del  mismo  tipo).  A  continuación  el  programa  deberá   indicar   cuál  se  encuentra  primero  en  el  alfabeto.   #include  <stdio.h>   #include  <conio.h>   //el  programa  verifica  el  dato  pero  muy  primitivamente...  necesitaria  un  while  para  hacerlo  en   serio.   int  main()   {          char  let1,  let2,  let3,l1,  l2,  l3;  
2012   12          printf("Ingrese  la  primer  letra:  ");          l1=getche();          if(l1>='a'&&l1<='z')                  let1=l1;          else          {                  if(l1>='A'&&l1<='Z')                          let1=l1+32;          }          printf("nIngrese  la  segunda  letra:  ");                  l2=getche();          if(l2>='a'&&l2<='z')                  let2=l2;          else          {                  if(l2>='A'&&l2<='Z')                          let2=l2+32;          }          printf("nIngrese  la  tercera  letra:  ");          l3=getche();          if(l3>='a'&&l3<='z')                  let3=l3;          else          {                  if(l3>='A'&&l3<='Z')                          let3=l3+32;  
2012   13          }          if(let1<let2&&let1<let3)                  printf("nLa  letra  que  aparece  primero  en  el  alfabeto  es  '%c'",  l1);          else          {                  if(let2<let1&&let2<let3)                          printf("nLa  letra  que  aparece  primero  en  el  alfabeto  es  '%c'",  l2);                  else                  {                          if(let3<let2&&let3<let1)                          printf("nLa  letra  que  aparece  primero  en  el  alfabeto  es  '%c'",  l3);                  }          }          return  0;   }   Ejercicio  1.11   Hacer  un  programa  en  el  que  se  ingrese  un  número  real  y  que  se  muestre  si  el  número  es   positivo,  negativo  o  cero.  Adicionalmente  deberá  indicar  si  es  natural,  entero  o  real.   Ejemplo:   Ingrese  un  número:  13.4   El  número  es  positivo  y  real.   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          double  num;          printf("Ingrese  numeron");  
2012   14          scanf("%lf",  &num);          if(num>0)          {                  if(num-­‐(int)num==0)                  printf("el  numero  es  positivo  y  natural");                  else                  printf("el  numero  es  positivo  y  real");          }          else          {                  if(num==0)                  printf("el  numero  es  0");                  else                  if(num-­‐(int)num==0)                  printf("el  numero  es  negativo  y  entero");                  else                  printf("el  numero  es  negativo  y  real");          }          return  0;   }   número  es  positivo  y  real.   Ejercicio  1.12   Realizar  un  programa  que  solicite  al  usuario  ingresar  una  letra.  Si  la  letra  es  mayúscula,  debe   convertirla  a  minúscula  y  viceversa.  Luego  deberá  informar  si  la  letra  ingresada  es  una  vocal  o   una   consonante.  Cualquier  otro  caracter  ingresado  debe  ser  impreso  sin  modificaciones  pero   indicando  que  no  se  trata  de  una  letra.   Ejemplo  1:   Ingrese  una  letra:  a  
2012   15   La  letra  ingresada  es  una  vocal.  Su  mayúscula  es  A.   Ejemplo  2:   Ingrese  una  letra:  $   No  se  ingresó  una  letra.   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          char  letr;          printf("Ingrese  una  letra:  ");          letr=getche();          printf("n");          if(letr>='a'&&letr<='z')          {                  if(letr=='a'||letr=='e'||letr=='i'||letr=='o'||letr=='u')                  printf("la  letra  ingresada  el  vocal.  Su  mayuscula  es  %c",  letr-­‐32);                  else                  printf("La  letra  ingresada  el  consonante.  Su  mayuscula  es  %c",  letr-­‐32);          }          else          {                  if(letr>='A'&&letr<='Z')                  {                          if(letr=='A'||letr=='E'||letr=='I'||letr=='O'||letr=='U')                          printf("la  letra  ingresada  el  vocal.  Su  minuscula  es  %c",  letr+32);                          else  
2012   16                          printf("La  letra  ingresada  el  consonante.  Su  minuscula  es  %c",  letr+32);                  }                  else                  printf("El  caracter  no  es  una  letra");          }          return  0;   }   Ejercicio  1.13   Realizar  un  programa  en  el  que  se  ingresen  dos  números  enteros  positivos.  Luego  deberá   restar   el  mayor  del  menor  e  indicar  si  dicha  diferencia  es  un  valor  que  está  entre  ambos  números  (es   decir,  es  mayor  que  el  más  chico  y  menor  que  el  más  grande  de  los  ingresados).   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num1,  num2,  res;          printf("Ingrese  un  numero:  ");          scanf("%d",  &num1);          printf("Ingrese  otro  numero:  ");          scanf("%d",  &num2);          if(num1>=num2)          {                  res=num1-­‐num2;                  if(res>=num2&&res<=num1)                  printf("nEl  numero  resultante  de  la  resta  esta  entre  los  dos  intresados");  
2012   17                  else                  printf("nEl  numero  resultante  de  la  resta  NO  esta  entre  los  dos  intresados");          }          else          {                  res=num2-­‐num1;                  if(res>=num1&&res<=num2)                  printf("nEl  numero  resultante  de  la  resta  esta  entre  los  dos  intresados");                  else                  printf("nEl  numero  resultante  de  la  resta  NO  esta  entre  los  dos  intresados");          }              return  0;   }   Ejercicio  1.14   Elaborar  un  programa  que  calcule  el  impuesto  que  se  aplica  a  una  cierta  compra  de  la   siguiente   forma:   •  Si  el  importe  de  una  compra  es  mayor  a  $500.-­‐  el  impuesto  será  del  16%.   •  En  caso  contrario,  el  impuesto  será  del  18%.   Sin  embargo,  ante  la  escasez  de  monedas  de  1  centavo,  el  importe  final  de  la  compra  debe  ser   redondeado,  en  favor  del  cliente,  hasta  un  múltiplo  de  5  centavos.  Es  decir,  si  el  importe  fuera   de   $5,17.-­‐  entonces  la  suma  a  abonar  sería  $5,15.-­‐.  El  programa  debe  solicitar  el  ingreso  de  la   compra  y  calcular  y  mostrar  el  subtotal  (compra  +  impuesto)  y  el  total  a  abonar  (subtotal   redondeado).   Ejemplo:   Valor  de  la  compra:  521   Subtotal:  604.36   Importe  a  abonar:  604.35   #include  <stdio.h>   #include  <stdlib.h>  
2012   18   //lo  hice  pensando  en  el  redondeo  clasico.  si  queres  redondeo  del  tipo  q  hacen  en  el   supermercado,  hasta  seria  mas  facil.  if(num>5){num=5;}else{num=0;}   int  main()   {          double  compra,  subtotal,  importe,  num;          printf("Valor  de  la  compra:  ");          scanf("%lf",  &compra);          if(compra>500)          {                  subtotal=compra+compra*0.16;          }          else          {                  subtotal=compra+compra*0.18;          }          num=subtotal*10;          importe=(int)num;          num=subtotal*100-­‐importe*10;          if(num>=2.5&&num<=7.5)          {                  num=5;          }          else          {                  if(num>7.5)                  num=10;  
2012   19                  else                  num=0;          }          importe=importe/10+num/100;          printf("nSubtotal:  %.2lf",  subtotal);          printf("nImporte  a  abonar:  %.2lf",  importe);            return  0;   }   Ejercicio  1.15   Realizar  un  programa  que  solicite  una  fecha.  El  usuario  ingresará  el  día,  el  mes  y  el  año  por   separado.  Luego  el  programa  mostrará  una  leyenda  que  indique  si  la  fecha  ingresada  es   válida.   Ejemplo:   Ingrese  el  día:  29   Ingrese  el  mes:  2   Ingrese  el  año:  2000   La  fecha  es  correcta.   Casos  de  prueba  para  (verificar  si  el  ejercicio  fue  hecho  correctamente)   29/2/2000  es  correcta   31/4/2008  es  incorrecta   28/2/2000  es  correcta   32/7/2005  es  incorrecta   29/2/2012  es  correcta   8/13/2007  es  incorrecta   5/12/1903  es  correcta   29/2/1900  es  incorrecta   Ayuda:  Para  saber  si  un  año  es  bisiesto:  Si  el  año  es  divisible  por  4,  es  bisiesto  siempre  y  cuando   no  sea  divisible  por  100.  Cuando  el  año  es  divisible  por  100  también  debe  ser  divisible  por  400.   Por  ejemplo:  el  año  2000  es  bisiesto  pero  el  1800  no  lo  es.   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  dia,  mes,  anio,  sen=0;  
2012   20          printf("Ingrese  el  dia:  ");          scanf("%d",  &dia);          printf("Ingrese  el  mes:  ");          scanf("%d",  &mes);          printf("Ingrese  el  anio:  ");          scanf("%d",  &anio);          if(anio%4==0)          {                  if(anio%100==0)                  {                          if(anio%400==0)                          sen=1;                  }                  else                  {                          sen=1;                  }          }          if(mes<=12)          {                  if(mes==1||mes==3||mes==5||mes==7||mes==8||mes==10||mes==12)                  {                          if(dia<=31)                          printf("%d/%d/%d  es  correcta",  dia,  mes,  anio);                          else                          printf("%d/%d/%d  es  incorrecta",  dia,  mes,  anio);  
2012   21                  }                  else                  {                        if(mes==2)                        {                                if(dia<=28)                                printf("%d/%d/%d  es  correcta",  dia,  mes,  anio);                                else                                {                                        if(sen==1&&dia<=29)                                          printf("%d/%d/%d  es  correcta",  dia,  mes,  anio);                                          else                                          printf("%d/%d/%d  es  incorrecta",  dia,  mes,  anio);                                }                          }                          else                          {                                  if(dia<=30)                                  printf("%d/%d/%d  es  correcta",  dia,  mes,  anio);                                  else                                  printf("%d/%d/%d  es  incorrecta",  dia,  mes,  anio);                          }                  }          }          return  0;  
2012   22   }     Ejercicio  1.16   Elaborar  un  programa  que  solicite  al  usuario  que  ingrese  un  número  real  y  luego  muestre  el   Redondeo  al  entero  más  próximo  de  dicho  número,  el  Piso  y  el  Techo.   Definiciones   Redondeo:  Si  la  parte  decimal  es  mayor  o  igual  a  0,5,  se  redondea  hacia  arriba.  Caso  contrario,   hacia  abajo.   Piso:  El  entero  más  próximo  hacia  abajo.   Techo:  El  entero  más  próximo  hacia  arriba.   Casos  de  prueba  para  (verificar  si  el  ejercicio  fue  hecho  correctamente):   Ejemplo  1:   Ingrese  un  numero  real:  5.3   Redondeo  =  5   Piso  =  5   Techo  =  6   Ejemplo  2:   Ingrese  un  numero  real:  8   Piso  =  8   Techo  =  8   Redondeo  =  8   Ejemplo  3:   Ingrese  un  numero  real:  8.92   Piso  =  8   Techo  =  9   Redondeo  =  9   Ejemplo  4:   Ingrese  un  numero  real:  8.6   Piso  =  9   Techo  =  8   Redondeo  =  9   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          double  num;          int  piso,  techo,  redondeo;          printf("Ingrese  el  numero:  ");  
2012   23          scanf("%lf",  &num);          if(num-­‐(int)num>=0.5)          redondeo=num+1;          else          redondeo=num;          piso=num;          techo=num+1;          printf("nRedondeo:  %d",  redondeo);          printf("nTecho:  %d",  techo);          printf("nPiso:  %d",  piso);          return  0;   }   Ejercicio  1.17   Realizar  un  programa  que  solicite  3  notas  de  parciales  obtenidas  por  un  alumno.  A   continuación   se  mostrará  por  pantalla  un  mensaje  que  indique  la  situación  del  alumno:   •  Si  el  alumno  aprobó  los  3  parciales  (nota  4  o  más)  y  su  promedio  es  mayor  a  7,   promociona  la  materia  con  la  nota  promedio.   •  Si  el  alumno  aprobó  los  3  parciales  pero  su  promedio  no  supera  los  7  puntos,  debe  rendir   examen  final.   •  Si  el  alumno  no  aprobó  uno  o  más  parciales,  se  solicitará  que  se  ingrese  la  nota  de  un   recuperatorio.  Si  éste  hubiera  sido  aprobado,  se  informará  el  promedio  general  (3  parciales   +  el  recuperatorio)  y  su  condición  de  aprobado  (aún  cuando  el  promedio  no  supere  los  4   puntos).  Si  no  hubiera  aprobado  el  recuperatorio  se  informará  que  el  alumno  fue  aplazado.   Ejemplo:   Ingrese  la  nota  del  primer  parcial:  2   Ingrese  la  nota  del  segundo  parcial:  6   Ingrese  la  nota  del  tercer  parcial:  2   Ingrese  la  nota  del  recuperatorio:  4   Promedio  general  =  3.5.  El  alumno  deberá  rendir  final.   #include  <stdio.h>   #include  <stdlib.h>    
2012   24   int  main()   {          int  nota1,  nota2,  nota3,  notar;          double  prom;          printf("Ingrese  la  nota  del  primer  parcial:  ");          scanf("%d",  &nota1);          printf("Ingrese  la  nota  del  segundo  parcial:  ");          scanf("%d",  &nota2);          printf("Ingrese  la  nota  del  tercer  parcial:  ");          scanf("%d",  &nota3);            if(nota1<4||nota2<4||nota3<4)          {                  printf("Ingrese  la  nota  del  recuperatorio:  ");                  scanf("%d",  &notar);                  prom=(nota1+nota2+nota3+notar)/4.0;          }          else          prom=(nota1+nota2+nota3)/3.0;          printf("Promedio  general:  %.2lf.",  prom);          if(prom<4)          printf("  El  alumno  debera  presentarse  a  final:");          else          printf("  El  alumno  ha  aprovado  y  no  debe  presentarse  a  final.");          return  0;   }  
2012   25   Ejercicio  1.18   Una  empresa  necesita  calcular  un  bono  que  dará  a  sus  empleados  a  fin  de  este  año.  Para  ello   se   sigue  el  siguiente  criterio:   •  Si  el  sueldo  supera  los  $2000,  el  bono  será  del  15%.  De  lo  contrario,  el  bono  será  del  20%.   •  Si  el  empleado  tiene  hijos  se  suma  un  plus  del  5%  del  sueldo.   •  Si  el  empleado  pertenece  a  la  categoría  1,  2  ó  3,  recibe  un  10%  del  sueldo.  Si  pertenece  a   la  categoría  4,  5  ó  6,  recibe  un  12%  del  sueldo.  Si  es  de  la  categoría  7,  8  ó  9,  recibe  un   20%  del  sueldo  pero  no  cobra  el  plus  por  tener  hijos.   Realizar  el  programa  que  solicite  la  información  necesaria  para  calcular  el  sueldo  final.   Finalmente   el  programa  mostrará  el  total  a  pagarle  al  empleado  (sueldo  +  bono).   Ejemplo:   Ingrese  el  sueldo:  1000   Tiene  hijos  (s/n)?:  s   Ingrese  categoría  (19):   2   El  sueldo  total  será  de  $1350.00   #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>     int  main()   {          int  sueldo,  categoria;          char  op;          double  bono;          printf("Ingrese  el  sueldo:  ");          scanf("%d",  &sueldo);          printf("Tiene  hijos  (s/n)?:  ");          op=getche();          printf("nIngrese  categoria  (1-­‐9):  ");          scanf("%d",  &categoria);          if(sueldo>2000)  
2012   26          bono=sueldo*0.15;          else          bono=sueldo*0.2;          if(op=='s'&&categoria!=7&&categoria!=8&&categoria!=9)          bono=bono+sueldo*0.05;          if(categoria==1||categoria==2||categoria==3)          bono=bono+sueldo*0.1;          else          {                  if(categoria==4||categoria==5||categoria==6)                  bono=bono+sueldo*0.12;                  else                  bono=bono+sueldo*0.2;          }          printf("El  sueldo  total  sera  de  %.2lf",  bono+sueldo);            return  0;   }   Ejercicio  1.19   Según  las  normas  de  tránsito,  un  automóvil  no  puede  superar  la  velocidad  máxima  ni  circular   a   menos  que  la  velocidad  mínima  (que  es  la  mitad  de  la  velocidad  máxima).  Por  una  cuestión  de   errores  de  medición  (tanto  en  el  automóvil  como  en  los  dispositivos  de  control)  hay  un  15%   de  tolerancia.  Sin  embargo,  se  permite  que  los  vehículos  en  emergencia  (ambulancias,   patrulleros,   etc.)  superen  la  velocidad  máxima  (no  así,  circular  a  menos  que  la  velocidad  mínima).  Hacer   un   programa  en  el  que  se  ingrese  la  velocidad  a  la  que  circula  un  vehículo,  la  velocidad  máxima   permitida  y  si  se  trata  o  no  de  un  vehículo  en  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  correspondan");          printf("nEs  de  maniana?:  ");          manana=getche();          printf("nEl  llamado  es  de  tu  casa?:  ");          casa=getche();          printf("nEstas  en  clase  en  este  momento?:  ");          clase=getche();          printf("n");          if(clase=='s'||clase=='S')          {                  printf("NO  DEBE  ATENDER");          }          else          {                  if(casa=='s'||casa=='S')                  {                          printf("DEBE  ATENDER");                  }                  else                  {                          if(manana=='s'||manana=='S')                          {                                  printf("NO  DEBE  ATENDER");                          }                          else                          {  
2012   31                                  printf("DEBE  ATENDER");                          }                  }          }          return  0;   }   Practica  2   Estructuras  de  repetición   Ejercicio  2.1   Elaborar un programa que solicite al usuario que ingrese un número entero y determine si el mismo es un número primo. #include <stdio.h> #include <stdlib.h> int main() { int num, cont=0, div; printf("Ingrese el numero:"); scanf("%d", &num); for(div=1; div<=num; div++) { if(num%div==0) cont++; } if(cont<=2) printf("Es primo"); else printf("No es primo"); return 0; } Ejercicio  2.2   Escribir un programa que encuentre los primeros 4 números perfectos. Un número perfecto es un
2012   32   entero positivo, que es igual a la suma de todos los enteros positivos (excluido él mismo) que son divisores del número. Por ejemplo, el primer número perfecto es 6, ya que los divisores de 6 son 1, 2, 3 y 1 + 2 + 3 = 6. #include <stdio.h> #include <stdlib.h> int main() { int num, cont=0, cont2=1, div; for(num=2; cont2<=4 ; num++) { for(div=1;div<num;div++) { if(num%div==0) cont=cont+div; } if(cont==num) { cont2++; printf("El %d es un numero perfecton", num); } cont=0; } return 0; }   Ejercicio  2.3   Hacer un programa que encuentre e imprima un listado con todos los números de 4 cifras que cumplan la condición de que la suma de las cifras de orden impar es igual a la suma de las cifras de orden par. Por ejemplo, el número 7821 cumple esta condición ya que 7 + 2 = 8 + 1. #include  <stdio.h>   #include  <stdlib.h>     int  main()  
2012   33   {          int  num,  s1,s2,s3,s4;          for(num=1000;  num<10000;  num++)          {                  s1=num%10;                  s2=(num%100-­‐s1)/10;                  s3=(num%1000-­‐s2*10-­‐s1)/100;                  s4=(num-­‐s1-­‐s2*10-­‐s3*100)/1000;                  if(s1+s2==s3+s4)                  printf("%dn",  num);          }          return  0;   }   Ejercicio  2.4   Realizar un programa en el que se ingresa una letra a buscar y luego un texto de tamaño indefinido (hasta ingresar punto). Luego, el programa debe informar cuántas apariciones de la letra hay en ese texto. Ejemplo: Ingrese la letra a contar: a   Ingrese el texto: La  bella  y  graciosa  moza,  marchose  a  lavar  la   ropa.   La letra “a” aparece 11 veces. #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>     int  main()   {  
2012   34          char  letra,  texto;          int  cont=0;          printf("Ingrese  la  letra  a  buscar:  ");          letra=getche();          printf("nIngrese  el  texto:  (punto  para  terminar)  n");          do          {                  texto=getche();                  if(texto==letra)                  cont++;          }while(texto!='.');          printf("nla  letra  '%c'  aparece  %d  veces  en  el  texto.",  letra,  cont);            return  0;   }   Ejercicio  2.5   Realizar un programa en el que se ingresa un texto de longitud indefinida (hasta ingresar asterisco). Luego debe informarse por pantalla cuántas de sus letras fueron mayúsculas y cuántas fueron minúsculas. Por ejemplo, para el texto “Hola Mundo” debe obtenerse 2 mayúsculas y 7 minúsculas #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>     int  main()   {  
2012   35          char  texto;          int  contmin=0,  contmay=0;          printf("nIngrese  el  texto:  ('*'  para  terminar)  n");          do          {                  texto=getche();                  if(texto>='a'&&texto<='z')                  contmin++;                  else                  {                          if(texto>='A'&&texto<='Z')                          contmay++;                  }          }while(texto!='*');          printf("nEn  el  texto  ingresado  hay  %d  minusculas  y  %d  mayusculas  ",  contmin,  contmay);            return  0;   }   Ejercicio  2.6   Realizar un programa en el que se ingresa un texto de longitud indefinida (hasta ingresar ENTER). Luego informar cuántas de las letras ingresadas fueron vocales (contar tanto mayúsculas como minúsculas) y cuántas fueron consonantes (contar tanto mayúsculas como minúsculas). Por ejemplo, para el texto “Kate Austen fue una de las 6 sobrevivientes del Oceanic 815” debe informarse que hay 22 vocales y 23 consonantes. #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>  
2012   36     int  main()   {          char  texto;          int  contvoc=0,  contcons=0;          printf("nIngrese  el  texto:  (ENTER  para  terminar)  n");          do          {                  texto=getche();                  if(texto>='a'&&texto<='z'||texto>='A'&&texto<='Z')                  {                           if(texto=='a'||texto=='A'||texto=='e'||texto=='E'||texto=='i'||texto=='I'||texto=='o'||texto=='O'| |texto=='u'||texto=='U')                          contvoc++;                          else                          contcons++;                  }          }while(texto!='r');          printf("nEn  el  texto  ingresado  hay  %d  vocales  y  %d  consonantes  ",  contvoc,  contcons);            return  0;   }   Ejercicio  2.7   Construir un programa en el que se ingresen números enteros hasta que se hayan ingresado 5 números pares e informar si alguno de ellos es también múltiplo de cuatro. #include  <stdio.h>  
2012   37   #include  <stdlib.h>   int  main()   {          int  num,  cont=0,  sen=0,  div;          do          {                  printf("Ingrese  numero:  ");                  scanf("%d",  &num);                  if  (num%2==0&&num!=0)                  cont++;                  if(num>=0)                  {                          div=0;                          do                          {                          div++;                          if(div*4==num)                          sen=1;                          }while(div*4<=num);                  }                  else                  {                          div=0;                          do                          {                          div-­‐-­‐;  
2012   38                          if(div*4==num)                          sen=1;                          }while(div*4>=num);                  }            }while(cont<=4);          if(sen==1)          printf("Hay  por  lo  menos  un  multiplo  de  4n");          else          printf("No  hay  multiplos  de  4");            return  0;   }   Ejercicio  2.8   Escribir un programa que reciba una cantidad indefinida de números enteros positivos hasta que se ingresa el 0. A continuación el programa debe indicar cuál fue el mayor y cuál el menor. #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num,  may,  men,  sen=0;          printf("Ingrese  numero:  ");                  scanf("%d",  &num);          if(num!=0)          {  
2012   39                  may=num;                  men=num;          }          else          {                  printf("No  se  ingresaron  valores  utiles.");                  sen=1;          }          while(num!=0)          {                  printf("Ingrese  numero:  ");                  scanf("%d",  &num);                  if(num>may)                  may=num;                  if(num<men&&num!=0)                  men=num;          }          if(sen==0)          printf("El  mayor  fue  %d  y  el  menor  fue  %d",  may,  men);          return  0;   }   Ejercicio  2.9   Armar un programa en el que se ingrese un número entero decimal (base diez) y convertirlo a binario. #include  <stdio.h>   #include  <stdlib.h>  
2012   40     int  main()   {          int  num,  pot=1,  bin=0,  guard_num;          printf("Ingrese  numero:  ");          scanf("%d",  &num);          guard_num=num;          while(num>0)          {                bin=bin+(num%2*pot);                pot=pot*10;                num=num/2;          }          printf("El  numero  %d(10)  es  igual  al  numero  %d(2)",  guard_num,  bin);          return  0;   }   Ejercicio  2.10   Para encontrar el máximo común divisor (MCD) de dos números se emplea el algoritmo de Euclides, que se puede describir así: Dados dos enteros a  y b  (siendo a  > b), se divide a  por b. Si el resto de la división es cero, el número b  es el máximo común divisor. Si la división no es exacta, el valor de a  pasa a ser b  y el nuevo valor de b  será el resto de la división anterior. Se repite el procedimiento hasta obtener un resto cero. El último divisor (b) es el mcd buscado. Escribir un programa que calcule el mcd de dos números enteros. Por ejemplo, si a  = 2366 y b=273, se divide a   por b  y el resto es 182; como no es cero, se divide el nuevo a  que será 273 por el nuevo b   que será 182 y da como resto 91; como no es cero se divide 182 por 91 y da como resto cero; se concluye entonces que 91 es el MCD entre 2366 y 273.
2012   41   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  a,  b,  aux,  resto,  guarda,  guardb;          printf("Ingrese  el  primer  numero:  ");          scanf("%d",  &a);          guarda=a;          printf("Ingrese  el  segundo  numero:  ");          scanf("%d",  &b);          guardb=b;          if(b>a)          {                  aux=b;                  b=a;                  a=aux;          }          while(a%b!=0)          {                  resto=a%b;                  a=b;                  b=resto;          }            printf("El  MCD  entre  %d  y  %d  es:  %d",guarda  ,  guardb,  b);  
2012   42          return  0;   }   Ejercicio  2.11   Escribir un programa que permita ingresar las notas de una cantidad indefinida de alumnos. A continuación el programa deberá mostrar la cantidad de alumnos aplazados (nota menor a 4), la cantidad de alumnos aprobados (nota entre 4 y 7 inclusive) y la cantidad de alumnos que promocionan la materia (nota superior a 7). En cada caso, se mostrará el porcentaje del total de notas cargadas que cada caso representa y el promedio general de todas las notas. Las notas pueden ser valores reales y la carga finaliza cuando la nota ingresada es 0. Ignorar las notas no válidas (fuera del rango de 1 a 10). Ejemplo: Ingrese nota: 5 Ingrese nota: 4 Ingrese nota: 2 Ingrese nota: 8 ... Ingrese nota: 0 Cantidad de aplazos: 5 (10%) Cantidad de aprobados: 15 (30%) Cantidad de promocionados: 30 (60%) Promedio general: 6.72 #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  nota,  aplazados=0,  aprovados=0,  promocionantes=0,  total,  pcapl,  pcapr,pcpro;          do          {                  printf("Ingrese  nota:  ");                  scanf("%d",  &nota);  
2012   43                  if(nota!=0)                  {                            if(nota<4&&nota>=1)                          aplazados++;                          else                          {                                  if(nota>=4&&nota<=7)                                  aprovados++;                                  else                                  {                                          if(nota>7&&nota<=10)                                          promocionantes++;                                          else                                          printf("nDato  incorrecto!  ingrese  notas  del  1  al  10  por  favor.n");                                  }                          }                  }          }while(nota!=0);          if(aplazados==0&&aprovados==0&&promocionantes==0)          printf("nNo  se  han  ingresado  datos  relevantes");          else          {                  total=aplazados+aprovados+promocionantes;                  pcpro=(promocionantes*100)/total;                  pcapr=(aprovados*100)/total;  
2012   44                  pcapl=(aplazados*100)/total;                  printf("nCantidad  de  aplazos:  %d  (%d%%)",aplazados,  pcapl);                  printf("nCantidad  de  aprobados:  %d  (%d%%)",aprovados,pcapr);                  printf("nCantidad  de  promocionados:  %d  (%d%%)",promocionantes,  pcpro);          }          return  0;   }   Ejercicio  2.12   Realizar un programa que permita el ingreso de letras en minúscula y que brinde al usuario tres operaciones posibles a través de un menú de opciones. La primera opción devolverá la mayúscula correspondiente. La segunda opción devolverá la letra siguiente en el alfabeto (si la letra ingresada fuera “z” se debe informar que es la última). La tercera opción devolverá la letra anterior en el alfabeto siempre que la letra ingresada no sea “a”. Validar que efectivamente el carácter ingresado sea una letra minúscula o *  (este último determina el final de la serie de opciones). Ejemplo: Ingrese letra: f   1 – Convertir a mayúscula 2 – Obtener la siguiente 3 – Obtener la anterior Escoja una operación (1 – 3): 1 La mayúscula es F. #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>     int  main()   {          char  letra;          int  menu;  
2012   45          do          {                  printf("Ingrese  la  letra:  ");                  letra=getche();                  printf("n");          }while(letra<'a'||letra>'z');          do          {                  printf("1  -­‐  Convertir  a  mayusculan");                  printf("2  -­‐  Obtener  la  siguienten");                  printf("3  -­‐  Obtener  la  anteriorn");                  printf("Escoja  una  operacion  (1  -­‐  3):  ");                  scanf("%d",  &menu);                  if(menu<1||menu>3)                  printf("Error!n");          }while(menu<1||menu>3);          switch(menu)          {                  case  1:                  letra=letra-­‐32;                  printf("La  mayuscula  es  %c",  letra);                  break;                  case  2:                  letra=letra+1;                  printf("La  siguiente  es:  %c",  letra);                  break;  
2012   46                  case  3:                  letra=letra-­‐1;                  printf("La  anterior  es:  %c",  letra);                  break;          }            return  0;   }   Ejercicio  2.13   Realizar un programa para calcular utilidades de inversión en plazos fijos. Para esto, se ingresarán las cantidades que serán los importes mensuales que el cliente desea invertir (cantidad = 0 para terminar). Luego se debe obtener el resultado de la colocación total en plazos fijos. Primero se debe solicitar la Tasa Nominal Anual (TNA) al principio de la serie de importes, a partir de la cual se obtiene la Tasa Efectiva Mensual (TEM = TNA /12). En cada mes, se calculan los intereses multiplicando la TEM por el total de montos acumulados hasta dicho mes. Al finalizar la carga, se imprimirá el monto final (suma de montos invertidos) más los intereses acumulados durante cada mes. Ejemplo: Se desea invertir tres sumas (durante tres meses seguidos) en plazos fijos. Ingrese porcentaje de TNA: 8   Ingrese monto del mes 1: 2000   Ingrese monto del mes 2: 3000   Ingrese monto del mes 3: 1000   Ingrese monto del mes 4: 0   El monto final es: 6086.67 Ayuda: • Ej.: TNA = 8% = 0.08. TEM = TNA /12 = 0.08/12 = 0.0067 • Intereses = 2000 * 0.0067 + (2000+3000) * 0.0067 + (2000+3000+1000) * 0.0067 • Monto total = Inversión + Intereses = 2000 + 3000 + 1000 + 86.67 = 6086.67 #include  <stdio.h>   #include  <stdlib.h>    
2012   47   int  main()   {          int    monto,  cont=1,  inversion=0;          double  tna,intereses=0;          printf("Ingrese  porcentaje  de  TNA:  ");          scanf("%lf",  &tna);          tna=tna/100;          do          {              printf("Ingrese  monto  del  mes  %d:  ",  cont);              scanf("%d",  &monto);              if(monto!=0)              {                  cont++;                  inversion=inversion+monto;                  intereses=intereses+inversion*(tna/12);              }          }while(monto!=0);            printf("Monto  total  =  Inversion  +  Intereses  =  %d  +  %.2lf  =  %.2lf",  inversion,  intereses,   inversion+intereses);          return  0;   }   Ejercicio  2.14   Efectuar un programa que solicite al usuario que ingrese un número entero impar (validar el valor ingresado). El programa tendrá que dibujar en la ventana un triángulo de asteriscos cuya base sea el
2012   48   valor ingresado. Ejemplo: Ingrese número: 8   Número no válido. Ingrese número: 11 * *** ***** ******* ********* *********** #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num,  f,  c,  ast=1,  blancos;            do          {              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);              if(num%2!=1)              printf("Error!");          }while(num%2!=1||num<3);          blancos=num/2;            for(f=1;  f<=num/2+1;  f++)          {                  for(c=1;  c<=blancos;  c++)                  {  
2012   49                          printf("  ");                  }                  blancos-­‐-­‐;                  for(c=1;c<=ast;c++)                  {                          printf("*");                    }                  ast+=2;                  printf("n");          }          return  0;   }   Ejercicio  2.15   Efectuar un programa que solicite al usuario que ingrese la base de un triángulo rectángulo. Luego dibujar en la ventana dicho triángulo como se muestra en el ejemplo. Ejemplo: Ingrese base: 5   * ** *** **** ***** #include  <stdio.h>   #include  <stdlib.h>     int  main()   {  
2012   50          int  num,  f,  c;   do{              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);   }while(num<2);          for(f=1;  f<=num;  f++)          {                  for(c=1;  c<=f;  c++)                  {                          printf("*");                  }                  printf("n");          }          return  0;   }   Ejercicio  2.16   Efectuar un programa que solicite al usuario que ingrese la base de un triángulo rectángulo. Luego dibujar en la ventana dicho triángulo como se muestra en el ejemplo. Ejemplo: Ingrese base: 5   * ** *** **** *****   #include  <stdio.h>   #include  <stdlib.h>     int  main()  
2012   51   {          int  num,  f,  c,  blancos,  ast=1;   do{              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);   }while(num<2);              blancos=num-­‐1;            for(f=1;  f<=num;  f++)          {                  for(c=1;  c<=blancos;  c++)                  {                          printf("  ");                  }                  blancos-­‐-­‐;                  for(c=1;  c<=ast;  c++)                  {                          printf("*");                  }                  ast++;                  printf("n");          }          return  0;   }  
2012   52   Ejercicio  2.17   Efectuar un programa que solicite al usuario que ingrese la diagonal de un rombo (validar que el valor ingresado sea impar). Luego deberá dibujar dicho rombo en la ventana. Ejemplo: Ingrese diagonal: 8   Valor incorrecto. Ingrese diagonal: 7   * *** ***** ******* ***** *** * #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num,  f,  c,  blancos,  ast=1;            do{              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);              blancos=num/2;          }while(num<3||num%2!=1);              for(f=1;  f<=num/2+1;  f++)          {                  for(c=1;  c<=blancos;  c++)  
2012   53                  {                          printf("  ");                  }                  blancos-­‐-­‐;                  for(c=1;  c<=ast;  c++)                  {                          printf("*");                  }                  ast+=2;                  printf("n");          }          blancos+=2;          ast-­‐=4;          for(f=1;  f<=num/2;  f++)          {                  for(c=1;  c<=blancos;  c++)                  {                          printf("  ");                  }                  blancos++;                  for(c=1;  c<=ast;  c++)                  {                          printf("*");                  }                  ast-­‐=2;                  printf("n");  
2012   54          }          return  0;   }   Ejercicio  2.18   Efectuar un programa que solicite al usuario que ingrese la base y la altura de un rectángulo. Luego deberá dibujar en la ventana el rectángulo hueco. Ejemplo: Ingrese base: 7   Ingrese altura: 4   ******* * * * * *******   #include <stdio.h> #include <stdlib.h> int main() { int num, f, c; do{ printf("Ingrese el numero: "); scanf("%d", &num); }while(num<3); for(f=1; f<=num; f++) { for(c=1; c<=num ; c++) { if(c==1||f==1||f==num||c==num) printf("*"); else printf(" "); } printf("n"); } return 0; }
2012   55   Ejercicio  2.19   Efectuar un programa que solicite al usuario que ingrese la base y la altura de un rectángulo. Luego deberá dibujar en la ventana dicho rectángulo. Ejemplo: Ingrese base: 8   Ingrese altura: 3   ******** ******** ********   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  alt,  base,  f,  c;            do{              printf("Ingrese  la  base:  ");              scanf("%d",  &base);          }while(base<2);          do{              printf("Ingrese  la  altura:  ");              scanf("%d",  &alt);          }while(alt<2);              for(f=1;  f<=alt;  f++)          {  
2012   56                  for(c=1;  c<=base  ;  c++)                  {                          printf("*");                  }                  printf("n");          }          return  0;   }   Ejercicio  2.20   La operación factorial de un número entero positivo “n” (expresado como n!) es el producto que resulta de multiplicar “n” por todos los enteros inferiores a él hasta el uno. Por ejemplo: 5! = 5 * 4 * 3 * 2 * 1 10! = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 n! = n * (n-1) * (n-2) * … * 3 * 2 * 1 Como salvedad se define 0! = 1. Elaborar un programa que calcule el factorial de un número entero. El programa principal debe solicitar el ingreso de un número entero, verificar si se trata de un número mayor o igual a 0 y calcular su factorial. En caso de que el usuario ingresara un número negativo, imprimir una advertencia. Ejemplos: Ingrese un número entero: 5   El factorial de 5 es: 120 Ingrese un número entero: -­‐10   No se puede calcular el factorial de un número negativo. #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num,  cont,  res;    
2012   57          do{              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);              if(num<0)              printf("No  se  puede  calcular  el  factorial  de  un  numero  negativo.n");          }while(num<0);          if(num==0)          res=1;          else          {                  res=num;                  for(cont=1;  cont<num;  cont++)                          res=res*(num-­‐cont);          }          printf("El  factorial  de  %d  es:  %d",  num,  res);          return  0;   }   Ejercicio  2.21   Elaborar un programa en el que se ingrese un número entero positivo (de cualquier cantidad de cifras) y determine si es un número capicúa. Un número capicúa es aquel que leído de izquierda a derecha es igual que leído de derecha a izquierda. Por ejemplo: 82428. Considere invertir el número y luego compararlo con el número original. Si resultan iguales, será capicúa.     #include  <stdio.h>   #include  <stdlib.h>    
2012   58   int  main()   {          int  num,  aux,  res=0;            do{              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);              if(num<=0)              printf("Error!n");          }while(num<=0);          aux=num;          while(aux>0)          {                  res=res*10+(aux%10);                  aux/=10;          }          if(num==res)          printf("El  numero  %d  es  capicua",  num);          else          printf("El  numero  %d  NO  es  capicua",  num);          return  0;   }  
2012   59   Practica  3   Arreglos   Ejercicio  3.1   Realice un programa que permita cargar números enteros positivos en un arreglo (de hasta 1000 elementos) hasta que el usuario ingrese 0 (este valor marca el final de los valores útiles). Luego, se deberá obtener otro arreglo que contenga los mismos valores pero en forma inversa y a continuación imprimir este último. Ejemplo: Ingrese número: 20   Ingrese número: 21   Ingrese número: 14   Ingrese número: 0   El arreglo revertido contiene: 14, 21, 20. #include  <stdio.h>   #include  <stdlib.h>   #define  N  1000     int  main()   {          int  v[N],  i=0,  b[N],  j=0;            do{              printf("Ingrese  numero:  ");              scanf("%d",  &v[i]);              i++;          }while(v[i-­‐1]!=0);          i-­‐=2;          while(i>=0)  
2012   60          {                  b[j]=v[i];                  j++;                  i-­‐-­‐;          }          j-­‐-­‐;          printf("El  arreglo  revertido  contiene:  ");          for(i=0;  i<=j;  i++)          printf("%d-­‐",  b[i]);            return  0;   }   Ejercicio  3.2   Realice un programa que permita cargar números enteros positivos en un arreglo (de hasta 1000 elementos) hasta que el usuario ingrese 0 (este valor marca el final de los valores utiles). No se permitirá al usuario cargar 2 veces el mismo valor, en dicho caso se mostrara un mensaje. Luego, imprima el arreglo resultante. Ejercicio  3.3   Elaborar un programa que presente un menú con las siguientes opciones: AND,  OR,   NOT,SALIR. Luego, para cada opción elegida el programa deberá permitir la carga de uno o dos (según corresponda) arreglos booleanos de 6 elementos cada uno. El 0 tendra un valor de verdad FALSO y el 1 VERDADERO. Se pide obtener el arreglo booleano resultante de la operacion logica sobre el/los arreglo/s correspondiente/s.. Ejemplo: 1 – AND 2 – OR 3 – NOT 4 – SALIR Seleccione una opción: 1  
2012   61   Ingrese los elementos del primer arreglo: 1  1  1  0  0  0   Ingrese los elementos del segundo arreglo: 1  1  0  0  0  1   El arreglo resultante es: 1 1 0 0 0 0 1 – AND 2 – OR 3 – NOT 4 – SALIR Seleccione una opción: 3   Ingrese los elementos del arreglo: 1  1  1  0  0  0   El arreglo resultante es: 0 0 0 1 1 1 #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  7     int  main()   {          int  i,  menu;          char  v[N],  b[N],  r[N],  l;          do{          printf("nMenun");          printf("1  -­‐  ANDn");          printf("2  -­‐  ORn");          printf("3  -­‐  NOTn");          printf("4  -­‐  SALIRn");          scanf("%d",  &menu);            switch(menu)          {    
2012   62                  case  1:                  i=0;                  printf("nIngrese  el  primer  arreglo:");                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  v[i]=l;                                  i++;                          }                  }while(i<6);                  v[i]='0';                  printf("nIngrese  el  segundo  arreglo:");                  i=0;                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  b[i]=l;                                  i++;                          }                  }while(i<6);  
2012   63                  b[i]='0';                  for(i=0;i<6;i++)                  {                          if(v[i]=='1'&&b[i]=='1')                                  r[i]='1';                          else                                  r[i]='0';                  }                  r[i]='0';                  printf("nEl  arreglo  resultante  es:  %s",  r);                  break;                  case  2:                  i=0;                  printf("nIngrese  el  primer  arreglo:");                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  v[i]=l;                                  i++;                          }                  }while(i<6);                  v[i]='0';                  printf("nIngrese  el  segundo  arreglo:");  
2012   64                  i=0;                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  b[i]=l;                                  i++;                          }                  }while(i<6);                  b[i]='0';                  for(i=0;i<6;i++)                  {                          if(v[i]=='1'||b[i]=='1')                                  r[i]='1';                          else                                  r[i]='0';                  }                  r[i]='0';                  printf("nEl  arreglo  resultante  es:  %s",  r);                    break;                  case  3:                  i=0;                  printf("nIngrese  el  arreglo:");  
2012   65                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  v[i]=l;                                  i++;                          }                  }while(i<6);                  v[i]='0';                  for(i=0;i<6;i++)                  {                          if(v[i]=='1')                                  r[i]='0';                          else                                  r[i]='1';                  }                  r[i]='0';                  printf("nEl  arreglo  resultante  es:  %s",  r);                  break;                  case  4:                  printf("nTerminado.  Tenga  un  buen  dia!.");                  break;                  default:                  printf("nOpcion  no  valida.  Por  favor  reintente:  ");  
2012   66                  break;          }          }while(menu!=4);          return  0;   }   Ejercicio  3.4   Elaborar un programa que permita cargar dos arreglos numéricos de hasta 1000 elementos. Se efectuara la carga de cada uno (hasta que se ingrese 0 o se complete la capacidad del arreglo). Luego se presenta el siguiente menú con las siguientes opciones: UNION,  INTERSECCION,   DIFERENCIA,  SALIR. A continuación se efectuara la operación entre ambos arreglos como si fueran conjuntos (considerar que los conjuntos no pueden tener elementos repetidos). #include  <stdio.h>   #include  <stdlib.h>   #define  N  1000     int  main()   {          int    i,  j,  k,  m,  sen=0,  menu,  l,  v[N],  b[N],  r[N*2];          do{          printf("nMenun");          printf("1  -­‐  UNIONn");          printf("2  -­‐  INTERSECCIONn");          printf("3  -­‐  DIFERENCIAn");          printf("4  -­‐  SALIRn");          scanf("%d",  &menu);    
2012   67          switch(menu)          {                  case  1:                  i=0;                  printf("nIngrese  el  primer  arreglo:");                  do                  {                            sen=0;                          scanf("%d",  &l);                          for(j=0;j<i;j++)                          {                                  if(v[j]==l)                                  sen=1;                          }                          if(sen==0)                          {                                    v[i]=l;                                  i++;                          }                      }while(i<N-­‐1&&v[i-­‐1]!=0);                  i-­‐-­‐;                  printf("nIngrese  el  segundo  arreglo:");  
2012   68                  k=0;                  do                  {                            sen=0;                          scanf("%d",  &l);                          for(j=0;j<k;j++)                          {                                  if(b[j]==l)                                  sen=1;                          }                            if(sen==0)                          {                                  b[k]=l;                                  k++;                          }                      }while(k<N-­‐1&&b[k-­‐1]!=0);                  for(m=0;m<i;m++)                  {                          r[m]=v[m];                  }                  int  n;                  for(j=0;j<k;j++)  
2012   69                  {                          l=b[j];                          sen=0;                          for(i=0;i<m;i++)                          {                                  if(l==r[i])                                  sen=1;                          }                          for(n=0;n<=i;n++)                          {                                  if(v[n]==l)                                  sen=1;                          }                          if(sen==0)                          {                                  r[m]=l;                                  m++;                          }                  }                  printf("El  arreglo  resultante  es:  ");                  for(i=0;i<m;i++)                  {                          printf("%d-­‐",  r[i]);                  }                  break;                  case  2:  
2012   70                                  i=0;                  printf("nIngrese  el  primer  arreglo:");                  do                  {                            sen=0;                          scanf("%d",  &l);                          for(j=0;j<i;j++)                          {                                  if(v[j]==l)                                  sen=1;                          }                          if(sen==0)                          {                                    v[i]=l;                                  i++;                          }                      }while(i<N-­‐1&&v[i-­‐1]!=0);                  i-­‐-­‐;                  printf("nIngrese  el  segundo  arreglo:");                  k=0;                  do                  {  
2012   71                            sen=0;                          scanf("%d",  &l);                          for(j=0;j<k;j++)                          {                                  if(b[j]==l)                                  sen=1;                          }                            if(sen==0)                          {                                  b[k]=l;                                  k++;                          }                      }while(k<N-­‐1&&b[k-­‐1]!=0);                  k-­‐-­‐;                  int  o,  p=0;                  for(n=0;n<i;n++)                  {                          sen=0;                          for(o=0;  o<k;o++)                          {                                  if(v[n]==b[o])                                          sen=1;  
2012   72                          }                          if(sen==1)                          {                                  r[p]=v[n];                                  p++;                          }                  }                  printf("El  arreglo  resultante  es:  ");                  for(i=0;i<p;i++)                  {                          printf("%d-­‐",  r[i]);                  }                    break;                  case  3:                  i=0;                  printf("nIngrese  el  primer  arreglo:");                  do                  {                            sen=0;                          scanf("%d",  &l);                          for(j=0;j<i;j++)                          {                                  if(v[j]==l)                                  sen=1;  
2012   73                          }                          if(sen==0)                          {                                    v[i]=l;                                  i++;                          }                      }while(i<N-­‐1&&v[i-­‐1]!=0);                  i-­‐-­‐;                  printf("nIngrese  el  segundo  arreglo:");                  k=0;                  do                  {                            sen=0;                          scanf("%d",  &l);                          for(j=0;j<k;j++)                          {                                  if(b[j]==l)                                  sen=1;                          }                            if(sen==0)                          {  
2012   74                                  b[k]=l;                                  k++;                          }                      }while(k<N-­‐1&&b[k-­‐1]!=0);                  k-­‐-­‐;                  p=0;                  for(n=0;n<i;n++)                  {                          sen=0;                          for(o=0;  o<k;o++)                          {                                  if(v[n]==b[o])                                          sen=1;                          }                          if(sen==0)                          {                                  r[p]=v[n];                                  p++;                          }                  }                  printf("El  arreglo  resultante  es:  ");                  for(i=0;i<p;i++)                  {                          printf("%d-­‐",  r[i]);  
2012   75                  }                  break;                  case  4:                  printf("nTerminado.  Tenga  un  buen  dia!.");                  break;                  default:                  printf("nOpcion  no  valida.  Por  favor  reintente:  ");                  break;          }          }while(menu!=4);          return  0;   }   Ejercicio  3.5   Realizar un programa en el que se ingrese un texto de hasta 100 caracteres finalizando con ENTER (utilizar ‘r’ para detectar el ingreso de ENTER). Luego, el usuario deberá elegir un caracter al cual reemplazar y con que caracter reemplazarlo. Ejemplo: Ingrese texto: La  mar  estaba  serena   Ingrese carácter a reemplazar: a   Ingrese carácter de reemplazo: e   Resultado: Le mer estebe serene #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  101     int  main()   {  
2012   76          char  l,  lo='0',lc='0',texto[N];          int  i=0;          printf("nIngrese  la  letra  a  reemplazar:  ");          do          {                  l=getche();                  if(l>='a'&&l<='z'||l>='A'&&l<='Z')                  lo=l;                  else                  printf("nError!.  Reintente:  ");          }while(lo=='0');          printf("nIngrese  la  letra  a  ser  reemplazada:  ");          do          {                  l=getche();                  if(l>='a'&&l<='z'||l>='A'&&l<='Z')                  lc=l;                  else                  printf("nError!.  Reintente:  ");          }while(lc=='0');          printf("nIngrese  el  texto:  n");          do          {                  l=getche();                  if(l!='r')                  {  
2012   77                          texto[i]=l;                          i++;                  }            }while(l!='r'&&i<N-­‐1);          texto[i]='0';          int  j;          for(j=0;j<i;j++)          {                  if(texto[j]==lo)                  texto[j]=lc;          }          printf("ntexto  modificado:  %sn",  texto);          return  0;   }   Ejercicio  3.6   Realizar un programa en el que se ingrese un texto de hasta 75 caracteres finalizando con ENTER (utilizar el caracter ‘r’ para detectarlo). Luego imprimir dicho texto centrado y, en la siguiente linea, alineado hacia la derecha. Tener en cuenta que el ancho de la pantalla de texto es de 80 columnas. El texto debe contener ‘0’ como caracter final a fin de que pueda imprimirse con printf(“%s”, texto); Ejemplo: Ingrese texto: La  bella  y  graciosa  moza  marchose  a  lavar  la  ropa   La bella y graciosa moza marchose a lavar la ropa La bella y graciosa moza marchose a lavar la ropa #include  <stdio.h>   #include  <stdlib.h>  
2012   78   #include  <conio.h>   #define  N  76     int  main()   {          char  text[N],  l;          int  cont  ,i=0;          printf("Ingrese  texto:  n");          do          {                          l=getche();                          if(l!='r')                          {                                  text[i]=l;                                  i++;                          }          }while  (l!='r'&&i<N);          text[i]='0';          printf("n");          for(cont=0;cont<40-­‐i/2;cont++)          printf("  ");          printf("%sn",  text);          for(cont=0;cont<80-­‐i;cont++)          printf("  ");          printf("%sn",  text);          return  0;  
2012   79   }   Ejercicio  3.7   Programar una funcion que reciba como parametro un texto y que elimine todo lo que no sean letras que encuentre al principio y al final del texto. Utilizarla en un programa en el que se ingrese un texto de hasta 1000 caracteres y luego se imprima la version “limpia” del texto. El texto debe contener ‘0’ como caracter final a fin de que pueda imprimirse con printf(“%s”, texto); Ejemplo: Ingrese texto:... La  bella  y  graciosa  moza  marchose  a  lavar  la  ropa,  $@   La bella y graciosa moza marchose a lavar la ropa #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  1000   void  trans  (char[],  int);   int  main()   {          char  text[N],  l;          int  cont  ,i=0;          printf("Ingrese  texto:  n");          do          {                          l=getche();                          if(l!='r')                          {                                  text[i]=l;                                  i++;                          }  
2012   80          }while  (l!='r'&&i<N);          trans  (text,  i);          printf("n%sn",  text);          return  0;   }   void  trans  (char  text[],  int  i)   {          int  j=0,  k=0,  sen=0;          while(j<i)          {                  if(text[j]>='A'&&text[j]<='Z'||text[j]>='a'&&text[j]<='z'||text[j]=='  ')                  {                          sen=1;                          text[k]=text[j];                          k++;                  }                  else                  {                          if(sen==1)                          text[k]='0';                  }                  j++;          }   }  
2012   81   Practica  4 Funciones   Ejercicio  4.1   Escribir una funcion que reciba como parametros la longitud de los lados de un triangulo y que retorne  el area del mismo. Implementarla en un programa que reciba los parametros como datos e informe el area calculada. Ejemplo: Ingrese lado 1: 2   Ingrese lado 1: 6   Ingrese lado 1: 7   El area del triangulo es = 5.56 Ayuda: El area de un triangulo se puede calcular como √ p( p  - a)( p  - b)( p  - c) siendo p  =(a +b +c) ÷2 #include  <stdio.h>   #include  <stdlib.h>   #include  <math.h>     double  area  (int,  int,  int);   int  main()   {          int  a,b,c;          double  areatri;          printf("Ingrese  lado  1:  n");          do          {                  scanf("%d",  &a);          }while  (a<=0);          printf("Ingrese  lado  2:  n");  
2012   82          do          {                  scanf("%d",  &b);          }while  (b<=0);          printf("Ingrese  lado  3:  n");          do          {                  scanf("%d",  &c);          }while  (c<=0);          areatri=area(a,b,c);          printf("El  area  del  triangulo  es  =  %.2lf",  areatri);          return  0;   }   double  area  (int  a,  int  b,  int  c)   {          double  areatri,p;          p=(a+b+c)/2.0;          areatri=sqrt((double)p*(p-­‐a)*(p-­‐b)*(p-­‐c));          return  areatri;   }   Ejercicio  4.2   Programar una funcion que reciba como parametros un numero real ‘x’ y otro entero positivo ‘n’ mayor que 0. Esta funcion debera retornar  la raiz enesima de x. Utilizarla en un programa que solicite el numero real, la raiz y luego imprima el valor calculado. Ejemplo: Ingrese un numero real: 14   Ingrese la raiz a calcular: 3  
2012   83   La raiz 3 de 14 es = 2.410142 Ayuda: Utilizar la funcion pow de la libreria math.h cuyo prototipo es double  pow(double  base, double  exponente); #include  <stdio.h>   #include  <stdlib.h>   #include  <math.h>     double  raiz  (double,  int);   int  main()   {          double  x,  resultado;          int  n;          printf("Ingrese  el  numero  a  radicar:  n");          do          {                  scanf("%lf",  &x);                  if(x<0)                  printf("Error!  No  existe  la  raiz  de  un  numero  negativo  en  reales.  Reingrese:  ");            }while  (x<0);          printf("Ingrese  la  raiz  a  efectuar:  n");          do          {                  scanf("%d",  &n);                  if(n<=0)                  printf("Error!  Reingrese  un  numero  positivo:  ");          }while  (n<=0);  
2012   84          resultado=raiz(x,  n);          printf("La  raiz  %d  de  %g  es  =  %g",  n,  x,  resultado);          return  0;   }   double  raiz  (double  x,  int  n)   {          double  resultado;          resultado=pow(x,1.0/n);          return  resultado;   }   Ejercicio  4.3   Realizar una funcion que reciba como parametros un numero entero positivo (en sistema decimal) y otro entero positivo entre 2 y 9. Luego, la funcion debera retornar  el numero decimal convertido a la base solicitada. Aplicar dicha funcion a un programa que solicite el numero decimal, la base a convertir y luego imprima el valor calculado. Ejemplo: Ingrese el numero decimal: 527   Ingrese la base: 8   527 (10) = 1017 (8) #include  <stdio.h>   #include  <stdlib.h>     int  cambio_base  (int,  int);   int  main()   {          int  decimal,  base,  cambiado;          printf("Ingrese  el  numero  en  sistema  decimal:  n");          do  
2012   85          {                  scanf("%d",  &decimal);                  if(decimal<0)                  printf("Error!  Reingrese  un  numero  positivo:  ");            }while  (decimal<0);          printf("Ingrese  la  base  en  que  lo  quiere:  n");          do          {                  scanf("%d",  &base);                  if(base<2||base>9)                  printf("Error!  Reingrese  un  numero  positivo  (entre  2  y  9):  ");          }while  (base<2||base>9);          cambiado=cambio_base(decimal,  base);          printf("El  numero  %d(10)  es  igual  a  %d(%d)",  decimal,  cambiado,  base);          return  0;   }   int  cambio_base  (int  d,  int  b)   {          int  c=0,  pot=1;          do          {                  c=c+(d%b)*pot;                  d/=b;                  pot*=10;          }while(d>0);  
2012   86          return  c;   }   Ejercicio  4.4   Programar una funcion que reciba como parametros 2 numeros enteros y que retorne  un numero aleatorio entre estos 2 numeros (inclusive). Por ejemplo, si se invocara la funcion con parametros 1 y 6, debera devolver un numero aleatorio entre 1 y 6 inclusive. Validar que el valor maximo no sea superior al valor maximo que es capaz de generar la funcion rand. Implementarla en un programa que solicite al usuario que ingrese el rango de valores aleatorios y la cantidad deseada de valor. A continuacion imprimir la lista de numeros aleatorios segun el criterio solicitado. Ejemplo: Ingrese minimo: 1   Ingrese maximo: 20   Ingrese cantida de valores: 10   1, 8, 20, 14, 11, 17, 2, 1, 5, 6. #include  <stdio.h>   #include  <stdlib.h>   #include  <time.h>   #define  N  99999   int  aleatorio  (int,  int);   int  main()   {          int  max,  min,i,j  ,v[N];          srand(time(NULL));          printf("Ingrese  el  maximo:  n");          scanf("%d",  &max);          printf("Ingrese  el  minimo:  n");          do  
2012   87          {                  scanf("%d",  &min);                  if(min>max)                  printf("Error!  Reingrese  un  numero  menor  al  maximo:  ");          }while  (min>max);          printf("Ingrese  la  cantidad  de  valores:  n");          do          {                  scanf("%d",  &i);                  if(i<0)                  printf("no  se  puede  mostrar  una  cantidad  negativa  de  veces.  reingrese:  ");          }while  (i<0);          printf("n");          for(j=0;j<i;j++)          {                  v[j]=aleatorio(max,  min);                  printf("%d,  ",  v[j]);          }            return  0;   }   int  aleatorio  (int  max,  int  min)   {          int  c;          c=rand()%(max-­‐min+1)+min;          return  c;  
2012   88   }   Ejercicio  4.5   Dado el siguiente programa, construir las funciones cuyos prototipos se indican y de modo que el programa genere la salida correspondiente. Todas las funciones cuyos prototipos figuran deben ser programadas y utilizadas sin  modificar  los tipos de los parametros ni el tipo de dato de retorno. #include <stdio.h> void  dibujar_fila(int);   void  dibujar_rectangulo(int,  int);   int main() { int alto, ancho; printf("Ingrese ancho:"); scanf("%d", &ancho); printf("Ingrese altura:"); scanf("%d", &alto); dibujar_rectangulo(ancho, alto); return 0; } Ejercicio  4.6   Dado el siguiente programa, construir las funciones cuyos prototipos se indican y de modo que el programa genere la salida correspondiente. Todas las funciones cuyos prototipos figuran deben ser programadas y utilizadas sin  modificar  los tipos de los parametros ni el tipo de dato de retorno. #include <stdio.h> int  ingresar_texto(void);   int  es_letra(unsigned  char);   int main() { int len; printf("Ingrese texto (punto para finalizar):"); len = ingresar_texto(); printf("nEl texto tiene %d letras.", len); return 0; }   #include  <stdio.h>  
2012   89   void  dibujar_fila(int);   void  dibujar_rectangulo(int,  int);   int  main()   {   int  alto,  ancho;   printf("Ingrese  ancho:");   scanf("%d",  &ancho);   printf("Ingrese  altura:");   scanf("%d",  &alto);   dibujar_rectangulo(ancho,  alto);   return  0;   }   void  dibujar_fila(int  anch)   {          int  c;          for(c=0;c<anch;c++)          {                  printf("*");          }   }   void  dibujar_rectangulo(int  anch,  int  alt)   {          int  f;          for(f=0;f<alt;f++)          {                  dibujar_fila  (anch);  
2012   90                  printf("n");          }   }   Ejercicio  4.7   Programar una funcion que tome como parametro un texto y que convierta sus letras mayusculas en minusculas y todo lo que no sean ni letras ni numeros, se conviertan en espacios. Utilizarla en un programa en el que se ingrese un texto de hasta 1000 caracteres y luego se imprima la version modificada del texto. El texto debe contener ‘0’ como caracter final a fin de que pueda imprimirse con printf(“%s”, texto); #include  <stdio.h>   #include  <conio.h>   #define  N  1000   int  es_letra_o_numero(char);   int  es_mayuscula(char);   void  trans_texto(char[],  int);   int  main()   {                  int  i=0,  l;                  char  texto[N];                  printf("Ingrese  el  texto:n");                  do                  {                          l=getche();                          if(l!='r')                          {  
2012   91                                  texto[i]=l;                                  i++;                          }                    }while(l!='r');                  texto[i]='0';                  trans_texto(texto,  i);                  printf("ntexto  modificado:  %s",  texto);                  return  0;   }   int  es_letra_o_numero(char  a)   {          return((a>='a'&&a<='z')||(a>='A'&&a<='Z')||(a>='0'&&a<='9'));   }   int  es_mayuscula  (char  l)   {          return(l>='A'&&l<='Z');   }   void  trans_texto(char  texto[],  int  i)   {          int  j;          for(j=0;j<i;j++)          {                  if(!es_letra_o_numero(texto[j]))                  texto[j]='  ';                  else  
2012   92                  {                          if(es_mayuscula(texto[j]))                          texto[j]=texto[j]+32;                  }          }   }   Ejercicio  4.8   Realizar una funcion que permita ingresar en un arreglo de caracteres (string) solamente caracteres numericos (ignorar y no mostrar en pantalla cuando se ingrese un caracter que no sea numero). Luego, programar otra funcion que tome ese arreglo de caracteres y lo convierta a un valor numerico entero. Utilizar ambas funciones en un programa en que se ingrese un numero y luego se convierta a entero para ser impreso mediante printf(“%d”, numero). #include  <stdio.h>   #include  <conio.h>   #define  N  1000   int  number(char[],  int);   int  main()   {                  int  i=0;                  char  numero[N]={0},  l;                  printf("Ingrese  los  numeros:n");                  do                  {                          l=getch();                          if(l>='0'&&l<='9')                          {                                  printf("%c",  l);  
2012   93                                  numero[i]=l;                                  i++;                          }                    }while(l!='r'&&i<N-­‐2);                  numero[i]='0';                  int  j=0;                  j=number(numero,i);                  printf("nnumero:  %sn",  numero);                  printf("nnumero:  %dn",  j);                  for(j=0;j<i;j++)                  printf("%d",  numero[j]);                  return  0;   }     int  number  (char  numero[],  int  i)   {          int  num=0,  j;          for(j=0;j<i;j++)          {                  num=num*10+(numero[j]-­‐48);          }          return  num;   }  
2012   94   Ejercicio  4.9   Elabore un programa que cargue un arreglo con 100 numeros al azar entre 1 y 100. Luego obtener el valor maximo y el valor minimo presentes en el arreglo. #include  <stdio.h>   #include  <stdlib.h>   #include  <time.h>   #define  N  100     int  main()   {                  int  numero[N]={0},i=0,  j,  max,  min;                  srand(time(NULL));                  do                  {                                  numero[i]=rand()%100+1;                                  i++;                  }while(i<N);                  max=numero[0];                  min=numero[0];                  for(j=0;j<i;j++)                  {                                  if(numero[j]>max)                                          max=numero[j];                                  else                                  {                                          if(numero[j]<min)  
2012   95                                          min=numero[j];                                  }                  }                  printf("nmaximo:  %dn",  max);                  printf("nminimo:  %dn",  min);   Ejercicio  4.10   Realizar un programa que solicite al usuario una cantidad de numeros al azar que se generara entre el 0 y el 36. Presentar luego un informe que indique que cantidad de veces salio cada valor y el porcentaje que representa. No mostrar aquellos numeros que no hayan salido. Ejemplo: Ingrese cantidad de valores: 10   Informe: El numero 8 salio 1 vez (10%). El numero 14 salio 2 veces (20%). El numero 20 salio 4 veces (40%). El numero 23 salio 1 veces (10%). El numero 30 salio 2 veces (20%). #include  <stdio.h>   #include  <stdlib.h>   #include  <time.h>   #define  N  99999     int  main()   {                  int  numero[N]={0},i,  j=0,  cont=0;                  srand(time(NULL));                  printf("ingrese  la  cantidad  de  valores:  ");                  scanf("%d",  &i);                  do                  {  
2012   96                                  j=rand()%37;                                  numero[j]++;                                  cont++;                    }while(cont<=i);                  int  k;                  for(j=0;j<37;j++)                  {                          if(numero[j]>0)                          printf("nEl  numero  %d  salio  %d  veces  (%%%d)n",  j,  numero[j],  (numero[j]*100)/i);                    }                    return  0;   }   Ejercicio  4.11   Realice una funcion que reciba como parametro un arreglo de hasta 10 enteros y luego calcule el desvio estandar de esos valores. Programar otra funcion que calcule el promedio de un arreglo. Aplicar ambas funciones en un programa en el que se carguen los valores del arreglo y luego imprima el desvio estandar de dicho arreglo. Ayuda: El desvio estandar (σ) es una medida estadistica de dispersion y la formula usual para su calculo es: N = Cantidad de valores Xi = Cada uno de los valores m = Es el promedio (ver imagen de la formulita en el apunte de lirweb) #include  <stdio.h>   #include  <stdlib.h>  
2012   97   #include  <math.h>   #define  N  10   double  promedio  (int[]);   double  desvio_estandard  (int[],double);   int  main()   {                  int  numero[N],i=0;                  double  de,  m;                  printf("ingrese  los  valores:  ");                    do                  {                          scanf("%d",  &numero[i]);                          i++;                  }while(i<N);                  m=promedio(numero);                  de=desvio_estandard(numero,  m);                  printf("La  desviacion  estandard  de  los  valores  ingresados  es:  %g",  de);                  return  0;   }   double  promedio  (int  numero[])   {          int  i;          double  m=0;          for(i=0;i<N;i++)          {  
2012   98                  m=m+numero[i];          }          m=m/N;          return  m;   }   double  desvio_estandard(int  numero[],double  m)   {          int  s=0,  i;          for(i=0;i<N;i++)                s=s+((numero[i]-­‐m)*(numero[i]-­‐m));            double  solucion;          solucion=sqrt((double)s/N);          return  solucion;   }   Ejercicio  4.12   Rehacer los ejercicios 3.3 y 3.4 de la practica de arreglos, utilizando funciones. Preste especial atencion al codigo que se repite; identifiquelo, transcribalo a una funcion y reescriba el main para utilizarla. 3.3:   #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  7   ingrese(char[]);   AND(char[],char[],  char[]);  
2012   99   OR(char[],char[],  char[]);   NOT(char[],char[],  char[]);   int  main()   {          int  i,  menu;          char  v[N],  b[N],  r[N],  l;          do{          printf("nMenun");          printf("1  -­‐  ANDn");          printf("2  -­‐  ORn");          printf("3  -­‐  NOTn");          printf("4  -­‐  SALIRn");          scanf("%d",  &menu);            switch(menu)          {                    case  1:                  printf("nIngrese  el  primer  arreglo:");                  ingrese  (v);                  printf("nIngrese  el  segundo  arreglo:");                  ingrese(b);                  AND(v,b,r);                  printf("nEl  arreglo  resultante  es:  %s",  r);                  break;    
2012   100                  case  2:                  printf("nIngrese  el  primer  arreglo:");                  ingrese(v);                  printf("nIngrese  el  segundo  arreglo:");                  ingrese(b);                  OR(v,b,r);                  printf("nEl  arreglo  resultante  es:  %s",  r);                    break;                                    case  3:                  i=0;                  printf("nIngrese  el  arreglo:");                  ingrese(v);                  NOT(v,b,r);                  printf("nEl  arreglo  resultante  es:  %s",  r);                  break;                                    case  4:                  printf("nTerminado.  Tenga  un  buen  dia!.");                  break;                                    default:                  printf("nOpcion  no  valida.  Por  favor  reintente:  ");                  break;          }  
2012   101          }while(menu!=4);          return  0;   }   ingrese(char  v[])   {                  int  i=0;                  char  l;                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  v[i]=l;                                  i++;                          }                  }while(i<6);                  v[i]='0';   }   AND(char  v[],char  b[],  char  r[])   {          int  i;          for(i=0;i<6;i++)          {          if(v[i]=='1'&&b[i]=='1')                  r[i]='1';  
2012   102          else                  r[i]='0';          }          r[i]='0';     }   OR(char[],char[],  char[])   {          int  i;          for(i=0;i<6;i++)          {                  if(v[i]=='1'||b[i]=='1')                          r[i]='1';                  else                          r[i]='0';          }          r[i]='0';   }   NOT(char[],char[],  char[])   {          int  i;          for(i=0;i<6;i++)          {                  if(v[i]=='1')                          r[i]='0';                  else  
2012   103                          r[i]='1';          }          r[i]='0';   }   3.4:   #include  <stdio.h>   #include  <stdlib.h>   #define  N  1000   int  repetido  (int[],  int,  int);   int  ingrese  (int[]);   imprimir_resultado(int[],  int);   int  main()   {          int    i,  j,  k,  m,  sen=0,  menu,  l,  v[N],  b[N],  r[N*2];          do{          printf("nMenun");          printf("1  -­‐  UNIONn");          printf("2  -­‐  INTERSECCIONn");          printf("3  -­‐  DIFERENCIAn");          printf("4  -­‐  SALIRn");          scanf("%d",  &menu);            switch(menu)          {                  case  1:    
2012   104                  printf("nIngrese  el  primer  arreglo:");                  i=ingrese(v);                  printf("nIngrese  el  segundo  arreglo:");                  k=ingrese(b);                  //pedaso  que  checkea  si  guardar  en  el  arreglo  solucion  o  no.                  for(m=0;m<i;m++)                  {                          r[m]=v[m];                  }                  for(j=0;j<k;j++)                  {                          sen=0;                          sen=repetido(r,m,b[j]);                          sen=repetido(v,m,b[j]);                          if(sen==0)                          {                                  r[m]=b[j];                                  m++;                          }                  }                  imprimir_resultado(r,m);                  break;                  case  2:                  printf("nIngrese  el  primer  arreglo:");                  i=ingrese(v);                  printf("nIngrese  el  segundo  arreglo:");  
2012   105                  k=ingrese(b);                  m=0;                  for(j=0;j<i;j++)                  {                          sen=0;                          sen=repetido(b,k,v[j]);                          if(sen==1)                          {                                  r[m]=v[j];                                  m++;                          }                  }                  imprimir_resultado(r,m);                    break;                  case  3:                  printf("nIngrese  el  primer  arreglo:");                  i=ingrese(v);                  printf("nIngrese  el  segundo  arreglo:");                  k=ingrese(b);                  for(j=0;j<i;j++)                  {                          sen=repetido(b,k,v[j]);                          if(sen==0)                          {                                  r[m]=v[j];  
2012   106                                  m++;                          }                  }                  imprimir_resultado(r,m);                  break;                  case  4:                  printf("nTerminado.  Tenga  un  buen  dia!.");                  break;                  default:                  printf("nOpcion  no  valida.  Por  favor  reintente:  ");                  break;          }          }while(menu!=4);          return  0;   }   int  ingrese(int  v[])   {          int  i=0,  sen,  l;          do          {                  scanf("%d",  &l);                  sen=repetido(v,i,l);                  if(sen==0)                  {                          v[i]=l;                          i++;  
2012   107                  }          }while(i<N-­‐1&&l!=0);          i-­‐-­‐;          return  i;   }   int  repetido  (int  v[],  int  i,  int  l)   {          int  j,  sen=0;                  for(j=0;j<i;j++)                  {                          if(v[j]==l)                          sen=1;                  }                  return  sen;   }   imprimir_resultado(int  r[],  int  m)   {          printf("El  arreglo  resultante  es:  ");          int  i;          for(i=0;i<m;i++)          {                  printf("%d-­‐",  r[i]);          }   }   Ejercicio  4.13   Realizar un programa que contenga las siguientes funciones:
2012   108   a. Una funcion que permita cargar un texto de hasta 1000 caracteres finalizando dicha carga con ENTER. El arreglo debe contener el caracter ‘0’ como marca de finalizacion de acuerdo con la convencion utilizada en el lenguaje C. b. Una funcion que reciba como parametro una frase y que retorne cuantas palabras tiene esa frase. c. Una funcion que reciba como parametro una frase y que retorne la longitud promedio de las palabras de esa frase. d. Una funcion que reciba como parametro una frase y que modifique el contenido de dicha frase de modo que la primera letra de cada palabra quede en mayuscula. En base a estas funciones, Realizar un programa en el que se ingrese una frase y a continuacion se muestren por pantalla los resultados obtenidos mediante las funciones creadas en los puntos b, c y d. Considere programar funciones adicionales. #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  1001   a  (char[]);   int  b(char[]);   double  c  (char[]);   d  (char[]);   int  es_separador(char);   int  es_minuscula(char);   int  main()   {          char  texto[N];          int  cantidad_palabras;          double  promedio;          a(texto);  
2012   109          printf("nTexto  original:%s",  texto);          cantidad_palabras=b(texto);          printf("nCantidad  de  palabras:  %d",  cantidad_palabras);          promedio=c(texto);          printf("nPromedio  de  longitud  de  las  palabras:  %.2lf",  promedio);          d(texto);          printf("nTexto  modificado:  %s",  texto);          return  0;   }   a(char  texto[])   {          int  i=0;          char  l;          printf("Ingrese  el  texto:  ");          do          {                  l=getche();                  if(l!='r')                  {                          texto[i]=l;                          i++;                  }          }while(i<N-­‐1&&l!='r');          texto[i]='0';   }   int  es_separador(char  l)  
2012   110   {          return(l=='  '||l==','||l==';'||l=='?'||l=='!');   }   int  b  (char  texto[])   {          int  cont=0,  sen=0,  i;          for(i=0;i<N-­‐1&&texto[i]!='0';)          {                  sen=0;                  while(es_separador(texto[i])&&texto[i]!='0')                  i++;                  while(!es_separador(texto[i])&&texto[i]!='0')                  {                          sen=1;                          i++;                  }                  if(sen==1)                  cont++;            }          return  cont;   }   double  c  (char  texto[])   {          /*c.  Una  funcion  que  reciba  como  parametro  una  frase  y  que  retorne  la  longitud  promedio  de   las  
2012   111   palabras  de  esa  frase.*/          int  cant_pal[N/2]={0},  i,  suma=0,  j=0,  sen;          for(i=0;(i<N-­‐1)&&(texto[i]!='0');)          {                  sen=0;                  while(es_separador(texto[i])&&texto[i]!='0')                  i++;                  while(!es_separador(texto[i])&&texto[i]!='0')                  {                          cant_pal[j]++;                          sen=1;                          i++;                  }                  if(sen==1)                  {                          suma=suma+cant_pal[j];                          j++;                  }            }          double  resultado;          resultado=suma/(double)j;            return  resultado;   }   d  (char  texto[])  
2012   112   {          int  sen=0,  i;          for(i=0;i<N-­‐1&&texto[i]!='0';)          {                  sen=0;                  while(es_separador(texto[i])&&texto[i]!='0')                  i++;                  while(!es_separador(texto[i])&&texto[i]!='0')                  {                          if(sen==0)                          {                                  if(es_minuscula(texto[i]))                                  texto[i]-­‐=32;                          }                          sen=1;                          i++;                  }          }   }   int  es_minuscula(char  l)   {          return(l>='a'||l<='z');   }     Ejercicio  4.  14   Realizar un programa que contenga las siguientes funciones:
2012   113   a. Una funcion que permita cargar un texto de hasta 1000 caracteres finalizando dicha carga con ENTER. El arreglo debe contener el caracter ‘0’ como marca de finalizacion de acuerdo con la convencion utilizada en el lenguaje C. b. Una funcion booleana que reciba como parametros dos palabras (en dos arreglos independientes) y que indique si ambas palabras son iguales (considerar mayusculas y minusculas como iguales). c. Una funcion que reciba como parametros una frase y una palabra (considerar mayusculas y minusculas como iguales) y que retorne cuantas veces aparece dicha palabra en la frase. d. Una funcion booleana que reciba como parametros dos frases (en dos arreglos independientes) y que determine si ambas frases son iguales. Es decir, cuando contengan las mismas palabras en el mismo orden. Por ejemplo: “Hola, como te va?” debe ser considerada igual a “hola… Como te va!” En base a estas funciones, Realizar un programa en el que se ingresen por teclado dos frases y una palabra. A continuacion, el programa debera mostrar por pantalla cuantas veces aparece la palabra ingresada en cada una de las frases ingresadas y si ambas frases son iguales. Considere programar funciones adicionales y utilizar la funcion del punto b en los puntos c y d. #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  1001   void  a  (char[]);   int  b(char[],  char[]);   int  c  (char[],  char[]);   int  d  (char[],  char[]);   int  es_separador(char);   int  es_minuscula(char);   int  es_letra(char);   int  main()  
2012   114   {          char  texto1[N],  texto2[N],  palabra[N],  sen;          int  cant_pal_rep1,cant_pal_rep2;          a(texto1);          printf("n");          a(texto2);          printf("n");          a(palabra);          cant_pal_rep1=c(texto1,  palabra);          printf("ncantidad  de  veces  que  se  repite  la  palabra  en  el  texto  1:  %d",  cant_pal_rep1);          cant_pal_rep2=c(texto2,  palabra);          printf("ncantidad  de  veces  que  se  repite  la  palabra  en  el  texto  2:  %d",  cant_pal_rep2);          sen=d(texto1,texto2);          if(sen==1)          printf("nlos  textos  son  iguales");          else          printf("nlos  textos  son  distintos");            return  0;   }   void  a(char  texto[])   {          int  i=0;          char  l;          printf("Ingrese  el  texto:  ");          do  
2012   115          {                  l=getche();                  if(l!='r')                  {                          texto[i]=l;                          i++;                  }          }while(i<N-­‐1&&l!='r');          texto[i]='0';   }   int  es_separador(char  l)   {          return(l=='  '||l==','||l==';'||l=='?'||l=='!');   }   int  b  (char  palabra1[],char  palabra2[])   {          /*b.  Una  funcion  booleana  que  reciba  como  parametros  dos  palabras  (en  dos  arreglos   independientes)  y  que  indique  si  ambas  palabras  son  iguales  (considerar  mayusculas  y   minusculas  como  iguales).*/          int  sen=1,  i;          for(i=0;palabra1[i]!='0'&&palabra2[i]!='0'&&sen==1;i++)          {                  if(palabra1[i]==palabra2[i])                  sen=1;                  else                  sen=0;  
2012   116          }          return  sen;   }   int  c  (char  texto[],  char  palabra[])   {          /*c.  Una  funcion  que  reciba  como  parametros  una  frase  y  una  palabra  (considerar  mayusculas  y   minusculas  como  iguales)  y  que  retorne  cuantas  veces  aparece  dicha  palabra  en  la  frase.*/          int  sen=1,  i,  cont=0,  j;          for(i=0;texto[i]!='0';i++)          {                  sen=1;                  j=0;                  if(es_minuscula(palabra[j]))                  palabra[j]-­‐=32;                  if(texto[i]==palabra[j]||texto[i]==palabra[j]+32)                  {                          i++;                          j++;                          while(palabra[j]!='0'&&sen==1)                          {                                  if(es_minuscula(palabra[j]))                                  palabra[j]-­‐=32;                                  if(texto[i]==palabra[j]||texto[i]==palabra[j]+32)                                  sen=1;                                  else                                  sen=0;  
2012   117                                  j++;                                  i++;                          }                          if(es_separador(texto[i])||texto[i]=='0')                          sen=1;                          else                          sen=0;                          if(sen==1)                          cont++;                  }            }          return  cont;   }   int  d  (char  texto1[],char  texto2[])   {          /*d.  Una  funcion  booleana  que  reciba  como  parametros  dos  frases  (en  dos  arreglos   independientes)  y  que  determine  si  ambas  frases  son  iguales.  Es  decir,  cuando  contengan  las   mismas  palabras  en  el  mismo  orden.  Por  ejemplo:  “Hola,  como  te  va?”  debe  ser  considerada   igual  a  “hola…  Como  te  va!”*/          int  i=0,  j=0,  sen=1;          while(texto1[i]!='0'&&texto2[i]!='0'&&sen==1)          {                  if(es_letra(texto1[i]))                  {                          if(es_minuscula(texto1[i]))  
2012   118                          texto1[i]-­‐=32;                          if(es_letra(texto2[j]))                          {                                  if(es_minuscula(texto2[j]))                                  texto2[j]-­‐=32;                                  if(texto1[i]!=texto2[j])                                  sen=0;                                  else                                  {                                          j++;                                          i++;                                  }                          }                          else                          j++;                  }                  else                  i++;            }          return  sen;   }   int  es_minuscula(char  l)   {          return  (l>='a'&&l<='z');   }  
2012   119   int  es_letra(char  l)   {          return  ((l>='A'&&l<='Z')||(l>='a'&&l<='z'));   }     En  este  programita  tengo  q  avisar  q  ni  use  una  función  asique  probablemente  no  sea  asi  como   tendría  que  estar  hecho,  pero  no  se  me  ocurrio  de  otra  manera..  

Más contenido relacionado

PPT
Agentes lógicos
MarcoUlisesArcosSanchez
 
PPTX
Ejercicios de algoritmos
1002pc4
 
DOCX
Tabla comparativa de los sistemas de informacion
BryanEstrada4512
 
PPTX
Mapa conceptual poo
saulalex2017
 
DOCX
Diferencia entre dato e informacion
warrior92
 
PPTX
EJERCICIOS DE ALGORITMOS
1002pc3
 
PPT
Redes Neuronales
Danny Valencia
 
PPTX
Ticm10p
Orel Hernandez
 
Agentes lógicos
MarcoUlisesArcosSanchez
 
Ejercicios de algoritmos
1002pc4
 
Tabla comparativa de los sistemas de informacion
BryanEstrada4512
 
Mapa conceptual poo
saulalex2017
 
Diferencia entre dato e informacion
warrior92
 
EJERCICIOS DE ALGORITMOS
1002pc3
 
Redes Neuronales
Danny Valencia
 
Ticm10p
Orel Hernandez
 

La actualidad más candente (20)

PDF
Sistemas formales e informales
Fernando Omar Arciniega Martinez
 
PPTX
Objetivos básicos del sistema de información...!
alejasebas
 
PPT
Estructuras condicionales
Andreina Trejo
 
PPTX
Sistemas de informacion
Ingeniería de Sistemas e Informática
 
PPTX
Caso Practico: Torrevision - SIG.
Landis Toro
 
PPSX
Sistemas ERP
Consultor Independiente
 
PDF
Ejercicio 2 diagrama de flujo
lisvancelis
 
PPTX
Sistemas tipicos en la etapa de inicio
Diana Fernanda Pedroza Escobar
 
DOCX
LENGUAJE DE PROGRAMACION. INVESTIGACION
KathGon1
 
PPTX
Tipos sistemas de información
brugman1985
 
PPTX
Inteligencia Artificial en videojuegos
Van Esab
 
PPT
Lenguaje natural pseudocodigo diagramacion y programacion
Claudia Poza
 
PPTX
Topicos Avanzados de Programacion - Unidad 2 GUI Interfaz Grafica de Usuario
José Antonio Sandoval Acosta
 
PPTX
Riesgos y amenazas de la informacion
Jean Carlos Leon Vega
 
PPTX
Sistema de Información Gerencial
Sheyla Ricaldi
 
PDF
Gramaticas y lic
Oscar Eduardo
 
PPTX
Sistemas de Proceso de Transacciones
Carlos Guilarte
 
PPTX
Simulación - Unidad 2 numeros pseudoaleatorios
José Antonio Sandoval Acosta
 
PPTX
Programación Orientada a Objetos vs Programación Estructurada
Michael de la Cruz
 
PDF
1.6 Activos Informáticos
Meztli Valeriano Orozco
 
Sistemas formales e informales
Fernando Omar Arciniega Martinez
 
Objetivos básicos del sistema de información...!
alejasebas
 
Estructuras condicionales
Andreina Trejo
 
Sistemas de informacion
Ingeniería de Sistemas e Informática
 
Caso Practico: Torrevision - SIG.
Landis Toro
 
Sistemas ERP
Consultor Independiente
 
Ejercicio 2 diagrama de flujo
lisvancelis
 
Sistemas tipicos en la etapa de inicio
Diana Fernanda Pedroza Escobar
 
LENGUAJE DE PROGRAMACION. INVESTIGACION
KathGon1
 
Tipos sistemas de información
brugman1985
 
Inteligencia Artificial en videojuegos
Van Esab
 
Lenguaje natural pseudocodigo diagramacion y programacion
Claudia Poza
 
Topicos Avanzados de Programacion - Unidad 2 GUI Interfaz Grafica de Usuario
José Antonio Sandoval Acosta
 
Riesgos y amenazas de la informacion
Jean Carlos Leon Vega
 
Sistema de Información Gerencial
Sheyla Ricaldi
 
Gramaticas y lic
Oscar Eduardo
 
Sistemas de Proceso de Transacciones
Carlos Guilarte
 
Simulación - Unidad 2 numeros pseudoaleatorios
José Antonio Sandoval Acosta
 
Programación Orientada a Objetos vs Programación Estructurada
Michael de la Cruz
 
1.6 Activos Informáticos
Meztli Valeriano Orozco
 
Publicidad

Destacado (20)

DOCX
Informática I: Ejercicios Resueltos
Alvin Jacobs
 
PDF
Ejercicios resueltos
fermodcor
 
PPTX
Encapsulamiento
Fernando Solis
 
PDF
02 Ejercicios Resueltos diagramas de flujo
Tete Alar
 
PPT
Javadoc
Fernando Solis
 
PPTX
Implementacion clases
Fernando Solis
 
PPT
Operadores y expresiones
Fernando Solis
 
PPTX
Funciones
Fernando Solis
 
PPTX
Constructores
Fernando Solis
 
PPTX
Agregacion composicion
Fernando Solis
 
PPTX
Arraylist
Fernando Solis
 
PPTX
Uml
Fernando Solis
 
PPTX
Poo
Fernando Solis
 
PPTX
Paso de parametros
Fernando Solis
 
PPTX
Tipos de datos
Fernando Solis
 
PPTX
String
Fernando Solis
 
PDF
21 problemas de algoritmo resueltos
Roldan El Gato
 
PPT
CARACTERES Y CADENAS LENGUAJE C
Gustavo Salazar Loor
 
DOC
Ejemplos de algoritmos en C básicos (aprendiendo a programar)
Kiim Kerrigan
 
PDF
introduccion al desarrollo de aplicaciones en c#
Eduardo Carrillo
 
Informática I: Ejercicios Resueltos
Alvin Jacobs
 
Ejercicios resueltos
fermodcor
 
Encapsulamiento
Fernando Solis
 
02 Ejercicios Resueltos diagramas de flujo
Tete Alar
 
Javadoc
Fernando Solis
 
Implementacion clases
Fernando Solis
 
Operadores y expresiones
Fernando Solis
 
Funciones
Fernando Solis
 
Constructores
Fernando Solis
 
Agregacion composicion
Fernando Solis
 
Arraylist
Fernando Solis
 
Uml
Fernando Solis
 
Poo
Fernando Solis
 
Paso de parametros
Fernando Solis
 
Tipos de datos
Fernando Solis
 
String
Fernando Solis
 
21 problemas de algoritmo resueltos
Roldan El Gato
 
CARACTERES Y CADENAS LENGUAJE C
Gustavo Salazar Loor
 
Ejemplos de algoritmos en C básicos (aprendiendo a programar)
Kiim Kerrigan
 
introduccion al desarrollo de aplicaciones en c#
Eduardo Carrillo
 
Publicidad

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

PDF
Ejercicios generales
Brivé Soluciones
 
PDF
Ejercicios generales C Programa
Brivé Soluciones
 
DOCX
Cuestionario Fundamentos de Programación
Anita Albán
 
PDF
Ejercicios resueltos en c
alan moreno
 
PPTX
Introducción a JavaScript 2
Lorenzo Alejo
 
PDF
Prueba1
Sergio Ramos Garcia
 
PDF
CLASE 05.pdf
NandoMartiHufer
 
DOCX
Tarea algoritmos
alejandrooocp
 
PPTX
4. ESTRUCTURA REPETITIVAS (1) python.pptx
kabelikas
 
PDF
Ejercicios_TeoriaOCW_zuz.pdf
MelidaCedeo1
 
DOCX
Cuaderno de trabajo de introduccion a la programacion (Revisado ver 2.0).docx
Laura Macias
 
PDF
Ejercicios de programacion resueltos
Karen Aguinaga Zambrana
 
DOCX
Ejercicios de repetición(JAVA)
IannWiichann
 
PDF
Introducción a la programación en c
victdiazm
 
PDF
Introducción a la programación en C
Andy Juan Sarango Veliz
 
PDF
Practica1 ejercio
esperanzabravotandazo77
 
PDF
Ejercicios reusltos en c++
IlviaGarcaRivera
 
PDF
Cuaderno de-ejercicios-y-practicas-php
william kozisck
 
PDF
Ejercicios y practicas en PHP
Robert Rodriguez
 
PDF
cuaderno-de-ejercicios-y-practicas-php.pdf
EdwinDelgado43
 
Ejercicios generales
Brivé Soluciones
 
Ejercicios generales C Programa
Brivé Soluciones
 
Cuestionario Fundamentos de Programación
Anita Albán
 
Ejercicios resueltos en c
alan moreno
 
Introducción a JavaScript 2
Lorenzo Alejo
 
Prueba1
Sergio Ramos Garcia
 
CLASE 05.pdf
NandoMartiHufer
 
Tarea algoritmos
alejandrooocp
 
4. ESTRUCTURA REPETITIVAS (1) python.pptx
kabelikas
 
Ejercicios_TeoriaOCW_zuz.pdf
MelidaCedeo1
 
Cuaderno de trabajo de introduccion a la programacion (Revisado ver 2.0).docx
Laura Macias
 
Ejercicios de programacion resueltos
Karen Aguinaga Zambrana
 
Ejercicios de repetición(JAVA)
IannWiichann
 
Introducción a la programación en c
victdiazm
 
Introducción a la programación en C
Andy Juan Sarango Veliz
 
Practica1 ejercio
esperanzabravotandazo77
 
Ejercicios reusltos en c++
IlviaGarcaRivera
 
Cuaderno de-ejercicios-y-practicas-php
william kozisck
 
Ejercicios y practicas en PHP
Robert Rodriguez
 
cuaderno-de-ejercicios-y-practicas-php.pdf
EdwinDelgado43
 

Más de Alvin Jacobs (14)

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

Último (20)

PPTX
MARITIMO Y LESGILACION DEL MACO TRANSPORTE
74965302
 
PDF
1132-2018 espectrofotometro uv visible.pdf
keyerlin1
 
PPTX
Presentación - Taller interpretación iso 9001-Solutions consulting learning.pptx
AndresJuarez52
 
PDF
Sustitucion_del_maiz_por_harina_integral_de_zapall.pdf
keyerlin1
 
PDF
SEC formula cargos al Consejo Directivo del Coordinador y a ocho eléctricas p...
Alexis Muñoz González
 
PDF
NORMATIVA Y DESCRIPCION ALCANTARILLADO PLUVIAL.pdf
eaririveros
 
PDF
Informe Comision Investigadora Final distribución electrica años 2024 y 2025
Alexis Muñoz González
 
PPTX
Contexto Normativo NSR10, presentacion 2025
Andres Galvis Sarmiento
 
PDF
SUBDIVISIÓN URBANA PUEDE ENFRENTAR SERVIDUMBRE DE PASO.pdf
JuanLuis188
 
PPTX
Gestion de seguridad y salud ocupacional.pptx
AlvaroMendietaZeball1
 
PPTX
Manual ISO9001_2015_IATF_16949_2016.pptx
AndresJuarez52
 
PPTX
MODULO 1.SEGURIDAD Y SALUD CONCEPTOS GENERALES.pptx
HectorCabezas15
 
PDF
prg2_t01_p01_Fundamentos POO - parte1.pdf
davidvargas666
 
PDF
Copia de Presentación Propuesta de Marketing Corporativo Blanco y Negro.pdf
jesusdcardonalvarez
 
PDF
Estrategias de apoyo de tecnología 2do periodo pdf
edepsantiagoguerrero
 
DOCX
Cumplimiento normativo y realidad laboral
espinocristhian
 
PDF
Electricidad-Estatica-Peligros-Prevencion.pdf
CristianPerez151938
 
DOCX
CONCEPTOS BASICOS DE LA PROGRAMACION STEP
juanmam210
 
PDF
Oficio SEC 293416 Comision Investigadora
Alexis Muñoz González
 
PPTX
MODULO 2. METODOLOGIAS PARA ANALISIS DE RIESGOS 2da Parte.pptx
HectorCabezas15
 
MARITIMO Y LESGILACION DEL MACO TRANSPORTE
74965302
 
1132-2018 espectrofotometro uv visible.pdf
keyerlin1
 
Presentación - Taller interpretación iso 9001-Solutions consulting learning.pptx
AndresJuarez52
 
Sustitucion_del_maiz_por_harina_integral_de_zapall.pdf
keyerlin1
 
SEC formula cargos al Consejo Directivo del Coordinador y a ocho eléctricas p...
Alexis Muñoz González
 
NORMATIVA Y DESCRIPCION ALCANTARILLADO PLUVIAL.pdf
eaririveros
 
Informe Comision Investigadora Final distribución electrica años 2024 y 2025
Alexis Muñoz González
 
Contexto Normativo NSR10, presentacion 2025
Andres Galvis Sarmiento
 
SUBDIVISIÓN URBANA PUEDE ENFRENTAR SERVIDUMBRE DE PASO.pdf
JuanLuis188
 
Gestion de seguridad y salud ocupacional.pptx
AlvaroMendietaZeball1
 
Manual ISO9001_2015_IATF_16949_2016.pptx
AndresJuarez52
 
MODULO 1.SEGURIDAD Y SALUD CONCEPTOS GENERALES.pptx
HectorCabezas15
 
prg2_t01_p01_Fundamentos POO - parte1.pdf
davidvargas666
 
Copia de Presentación Propuesta de Marketing Corporativo Blanco y Negro.pdf
jesusdcardonalvarez
 
Estrategias de apoyo de tecnología 2do periodo pdf
edepsantiagoguerrero
 
Cumplimiento normativo y realidad laboral
espinocristhian
 
Electricidad-Estatica-Peligros-Prevencion.pdf
CristianPerez151938
 
CONCEPTOS BASICOS DE LA PROGRAMACION STEP
juanmam210
 
Oficio SEC 293416 Comision Investigadora
Alexis Muñoz González
 
MODULO 2. METODOLOGIAS PARA ANALISIS DE RIESGOS 2da Parte.pptx
HectorCabezas15
 

Informática I: Ejercicios Resueltos

  • 1. 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  
  • 2. 2012   2   Ejercicio  2.16  ....................................................................................................................................  50   Ejercicio  2.17  ....................................................................................................................................  52   Ejercicio  2.18  ....................................................................................................................................  54   Ejercicio  2.19  ....................................................................................................................................  55   Ejercicio  2.20  ....................................................................................................................................  56   Ejercicio  2.21  ....................................................................................................................................  57   Practica  3  .....................................................................................................................................  59   Arreglos  ........................................................................................................................................  59   Ejercicio  3.1  ......................................................................................................................................  59   Ejercicio  3.2  ......................................................................................................................................  60   Ejercicio  3.3  ......................................................................................................................................  60   Ejercicio  3.4  ......................................................................................................................................  66   Ejercicio  3.5  ......................................................................................................................................  75   Ejercicio  3.6  ......................................................................................................................................  77   Ejercicio  3.7  ......................................................................................................................................  79   Practica  4  .....................................................................................................................................  81   Funciones  .....................................................................................................................................  81   Ejercicio  4.1  ......................................................................................................................................  81   Ejercicio  4.2  ......................................................................................................................................  82   Ejercicio  4.3  ......................................................................................................................................  84   Ejercicio  4.4  ......................................................................................................................................  86   Ejercicio  4.5  ......................................................................................................................................  88   Ejercicio  4.6  ......................................................................................................................................  88   Ejercicio  4.7  ......................................................................................................................................  90   Ejercicio  4.8  ......................................................................................................................................  92   Ejercicio  4.9  ......................................................................................................................................  94   Ejercicio  4.10  ....................................................................................................................................  95   Ejercicio  4.11  ....................................................................................................................................  96   Ejercicio  4.12  ....................................................................................................................................  98   Ejercicio  4.13  ..................................................................................................................................  107   Ejercicio  4.  14  ................................................................................................................................  112  
  • 3. 2012   3       Practica  1   Ejercicio  1.1   Elaborar  un  programa  en  el  que  se  ingrese  un  número  y  que  muestre  el  resto  de  dividirlo  por   2.  Lo   debe  mostrar  justificado  hacia  la  derecha  en  10  espacios.   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num;          printf("Por  favor,  ingrese  el  numero:n");          scanf("%d",  &num);          printf("                    %d/2=%dn                    resto:%d",  num,  num/2,  num%2);          return  0;   }   Ejercicio  1.2   Realizar  un  programa  en  el  que  se  ingrese  la  base  y  la  altura  de  un  triángulo  e  informe  su   superficie.  El  programa  debe  imprimir  una  leyenda  que  incluya  los  datos  de  entrada  y  el   resultado   con  una  precisión  de  2  dígitos  decimales.   Ejemplo:   Ingrese  la  base  del  triángulo:  8   Ingrese  la  altura  del  triángulo:  5   La  superficie  del  triangulo  de  base  7  y  altura  5  es  17.50   #include  <stdio.h>   #include  <stdlib.h>  
  • 4. 2012   4     int  main()   {          double  base,  alt,  sup;          printf("Ingrese  la  base  del  triangulo:");          scanf("%lf",  &base);          printf("Ingrese  la  altura  del  triangulo:");          scanf("%lf",  &alt);          sup=base*alt/2;          printf("La  superficie  del  triangulo  de  base  %.2lf  y  altura  %.2lf  es  %.2lf",  base,  alt,  sup);          return  0;   }   Ejercicio  1.3   Elaborar  un  programa  en  el  que  se  ingrese  por  teclado  un  número  real  y,  a  continuación,  se   muestre  la  parte  entera  de  dicho  número  y  la  parte  fraccionaria  (por  separado).   Ejemplo:   Ingrese  numero:  48.151   Parte  entera:  48   Parte  fraccionaria:  0.151   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          double  num,  Fnum,  Enum;          printf("Ingrese  numero:  ");          scanf("%lf",  &num);          Fnum=num-­‐(int)num;  
  • 5. 2012   5          Enum=num-­‐Fnum;          printf("Parte  entera:  %gn",  Enum);          printf("Parte  fraccionaria:  %gn",  Fnum);          return  0;   }   Ejercicio  1.4   Desarrollar  un  programa  en  el  que  se  ingrese  un  número  de  5  dígitos  y  que  luego  muestre   cada   dígito  separado  por  un  guión.   Ejemplo:   Ingrese  numero:  45212   Separacion  en  dígitos:  4-­‐5-­‐2-­‐1-­‐2.   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num,  num1,  num2,  num3,  num4,  num5;          printf("Ingrese  numero:  ");          scanf("%d",  &num);          num5=num%10;          num=num/10;          num4=num%10;          num=num/10;          num3=num%10;          num=num/10;          num2=num%10;          num=num/10;          num1=num%10;  
  • 6. 2012   6          //lo  hice  asi  choto  a  proposito  podria  haber  validado  y  usado  un  while.  includo  un  arreglo.          printf("Separacion  en  digitos:  %d-­‐%d-­‐%d-­‐%d-­‐%d.n",  num1,  num2,  num3,  num4,  num5);          return  0;   }   Ejercicio  1.5   Hacer  un  programa  en  el  que  se  ingrese  la  medida  de  los  catetos  de  un  triángulo  rectángulo  y   que   se  calcule  y  muestre  el  perímetro  de  dicho  triángulo.  Incluir  math.h  a  fin  de  utilizar  la  función   sqrt(expresión)  que  calcula  la  raíz  cuadrada  de  un  número.   #include  <stdio.h>   #include  <stdlib.h>   #include  <math.h>     int  main()   {          double  ct1,ct2,  perim;          printf("Ingrese  el  primer  cateto:  ");          scanf("%lf",  &ct1);          printf("Ingrese  el  segundo  cateto:  ");          scanf("%lf",  &ct2);          perim=ct1+ct2+sqrt(ct1*ct1+ct2*ct2);          printf("El  perimetro  del  triangulo  ingresado  mide  %.2lf",  perim);              return  0;   }   Ejercicio  1.6   Elaborar  un  programa  en  el  que  se  ingrese  una  cantidad  expresada  en  segundos  y  luego  la   exprese  en  días,  horas,  minutos  y  segundos.   Ejemplo:  
  • 7. 2012   7   Ingrese  tiempo  en  segundos:  93714   1  dia(s),  2  hora(s),  1  minuto(s),  54  segundo(s).   #include  <stdio.h>   #include  <stdlib.h>   #include  <math.h>     int  main()   {          int  num,  seg,  dias,  horas,  min;          printf("Ingrese  tiempo  en  segundos:  ");          scanf("%d",  &num);          seg=num%60;          num=num/60;          min=num%60;          num=num/60;          horas=num%24;          dias=num/24;          printf("%d  dia(s),  %d  hora(s),  %d  minuto(s),  %dsegundo(s)",  dias,  horas,  min,  seg);          return  0;   }   Ejercicio  1.7   Desarrollar  un  programa  en  el  que  se  ingresen  dos  números  enteros  positivos  y  que  genere  y   muestre  un  tercer  numero  que  esté  compuesto  por  las  unidades  del  primer  número  y  por  las   decenas  del  segundo.   Ejemplo:   Ingrese  el  primer  numero:  427   Ingrese  el  segundo  numero:  52   El  numero  resultante  es:  57   #include  <stdio.h>   #include  <stdlib.h>  
  • 8. 2012   8     int  main()   {          int  num1,  num2,  res;          printf("Ingrese  el  primer  numero:  ");          scanf("%d",  &num1);          printf("Ingrese  el  segundo  numero:  ");          scanf("%d",  &num2);          num2=num2/10;          num2=num2%10;          num1=num1%10;          res=num1+num2*10;          printf("El  numero  resultante  es:  %d",  res);          return  0;   }   Ejercicio  1.8   Hacer  un  programa  que  calcule  las  raíces  reales  de  una  ecuación  cuadrática.  El  usuario   ingresará   los  coeficientes  a,  b  y  c  tal  que  ax²  +  bx  +  c=0.  Cuando  las  raíces  no  sean  reales,  se  mostrará  un   mensaje  indicando  esta  situación.   Ejemplo:   Ingrese  coeficiente  a:  2   Ingrese  coeficiente  b:  3   Ingrese  coeficiente  c:  1   La  raíz  1  es:  0.50   La  raíz  2  es:  1.00   #include  <stdio.h>   #include  <stdlib.h>   #include  <math.h>     int  main()  
  • 9. 2012   9   {          double  a,  b,  c,  x1,  x2,  d;          printf("Ingrese  coeficiente  a:  ");          scanf("%lf",  &a);          printf("Ingrese  coeficiente  b:  ");          scanf("%lf",  &b);          printf("Ingrese  coeficiente  c:  ");          scanf("%lf",  &c);          d=b*b-­‐4*a*c;          if(d<0)          {                printf("Las  raices  no  son  reales.");          }          else          {                  d=sqrt(d);                  x1=(b+d)/(2*a);                  x2=(b-­‐d)/(2*a);                  printf("La  raíz  1  es:  %.2lf",  x1);                  printf("nLa  raíz  2  es:  %.2lf",  x2);          }            return  0;   }   Ejercicio  1.9   Escriba  un  programa  en  el  que  se  ingresen  2  números  y  un  carácter  (+,-­‐,*,/)  e  informe  el   resultado   de  la  operación.   Ejemplo:  
  • 10. 2012   10   Ingrese  el  primer  número:  8   Ingrese  el  segundo  número:  2   Ingrese  la  operación  (+,-­‐,   *,  /):  +   8  +  2  =10   #include  <stdio.h>   #include  <conio.h>       int  main()   {          int  num1,  num2;          char  sign;          printf("Ingrese  el  primer  numero:  ");          scanf("%d",  &num1);          printf("Ingrese  el  segundo  numero:  ");          scanf("%d",  &num2);          printf("Ingrese  la  operacion  (+,-­‐,*,  /):  ");          sign=getche();          printf("n");          switch  (sign)          {                  case  '+':                  printf("%d+%d=%d",num1,  num2,  num1+num2);                  break;                  case  '-­‐':                  printf("%d-­‐%d=%d",num1,  num2,  num1-­‐num2);                  break;  
  • 11. 2012   11                  case  '*':                  printf("%d*%d=%d",num1,  num2,  num1*num2);                  break;                  case  '/':                  if  (num2!=0)                  printf("%d/%d=%d",num1,  num2,  num1/num2);                  else                  printf("El  denominador  no  puede  ser  igual  a  0");                  break;                  default:                  printf("El  caracter  ingresado  es  incompatible");                  break;          }            return  0;   }   Ejercicio  1.10   Realizar  un  programa  en  el  que  se  ingresen  por  teclado  3  letras  que  pueden  ser  mayúsculas  o   minúsculas  (no  necesariamente  todas  del  mismo  tipo).  A  continuación  el  programa  deberá   indicar   cuál  se  encuentra  primero  en  el  alfabeto.   #include  <stdio.h>   #include  <conio.h>   //el  programa  verifica  el  dato  pero  muy  primitivamente...  necesitaria  un  while  para  hacerlo  en   serio.   int  main()   {          char  let1,  let2,  let3,l1,  l2,  l3;  
  • 12. 2012   12          printf("Ingrese  la  primer  letra:  ");          l1=getche();          if(l1>='a'&&l1<='z')                  let1=l1;          else          {                  if(l1>='A'&&l1<='Z')                          let1=l1+32;          }          printf("nIngrese  la  segunda  letra:  ");                  l2=getche();          if(l2>='a'&&l2<='z')                  let2=l2;          else          {                  if(l2>='A'&&l2<='Z')                          let2=l2+32;          }          printf("nIngrese  la  tercera  letra:  ");          l3=getche();          if(l3>='a'&&l3<='z')                  let3=l3;          else          {                  if(l3>='A'&&l3<='Z')                          let3=l3+32;  
  • 13. 2012   13          }          if(let1<let2&&let1<let3)                  printf("nLa  letra  que  aparece  primero  en  el  alfabeto  es  '%c'",  l1);          else          {                  if(let2<let1&&let2<let3)                          printf("nLa  letra  que  aparece  primero  en  el  alfabeto  es  '%c'",  l2);                  else                  {                          if(let3<let2&&let3<let1)                          printf("nLa  letra  que  aparece  primero  en  el  alfabeto  es  '%c'",  l3);                  }          }          return  0;   }   Ejercicio  1.11   Hacer  un  programa  en  el  que  se  ingrese  un  número  real  y  que  se  muestre  si  el  número  es   positivo,  negativo  o  cero.  Adicionalmente  deberá  indicar  si  es  natural,  entero  o  real.   Ejemplo:   Ingrese  un  número:  13.4   El  número  es  positivo  y  real.   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          double  num;          printf("Ingrese  numeron");  
  • 14. 2012   14          scanf("%lf",  &num);          if(num>0)          {                  if(num-­‐(int)num==0)                  printf("el  numero  es  positivo  y  natural");                  else                  printf("el  numero  es  positivo  y  real");          }          else          {                  if(num==0)                  printf("el  numero  es  0");                  else                  if(num-­‐(int)num==0)                  printf("el  numero  es  negativo  y  entero");                  else                  printf("el  numero  es  negativo  y  real");          }          return  0;   }   número  es  positivo  y  real.   Ejercicio  1.12   Realizar  un  programa  que  solicite  al  usuario  ingresar  una  letra.  Si  la  letra  es  mayúscula,  debe   convertirla  a  minúscula  y  viceversa.  Luego  deberá  informar  si  la  letra  ingresada  es  una  vocal  o   una   consonante.  Cualquier  otro  caracter  ingresado  debe  ser  impreso  sin  modificaciones  pero   indicando  que  no  se  trata  de  una  letra.   Ejemplo  1:   Ingrese  una  letra:  a  
  • 15. 2012   15   La  letra  ingresada  es  una  vocal.  Su  mayúscula  es  A.   Ejemplo  2:   Ingrese  una  letra:  $   No  se  ingresó  una  letra.   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          char  letr;          printf("Ingrese  una  letra:  ");          letr=getche();          printf("n");          if(letr>='a'&&letr<='z')          {                  if(letr=='a'||letr=='e'||letr=='i'||letr=='o'||letr=='u')                  printf("la  letra  ingresada  el  vocal.  Su  mayuscula  es  %c",  letr-­‐32);                  else                  printf("La  letra  ingresada  el  consonante.  Su  mayuscula  es  %c",  letr-­‐32);          }          else          {                  if(letr>='A'&&letr<='Z')                  {                          if(letr=='A'||letr=='E'||letr=='I'||letr=='O'||letr=='U')                          printf("la  letra  ingresada  el  vocal.  Su  minuscula  es  %c",  letr+32);                          else  
  • 16. 2012   16                          printf("La  letra  ingresada  el  consonante.  Su  minuscula  es  %c",  letr+32);                  }                  else                  printf("El  caracter  no  es  una  letra");          }          return  0;   }   Ejercicio  1.13   Realizar  un  programa  en  el  que  se  ingresen  dos  números  enteros  positivos.  Luego  deberá   restar   el  mayor  del  menor  e  indicar  si  dicha  diferencia  es  un  valor  que  está  entre  ambos  números  (es   decir,  es  mayor  que  el  más  chico  y  menor  que  el  más  grande  de  los  ingresados).   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num1,  num2,  res;          printf("Ingrese  un  numero:  ");          scanf("%d",  &num1);          printf("Ingrese  otro  numero:  ");          scanf("%d",  &num2);          if(num1>=num2)          {                  res=num1-­‐num2;                  if(res>=num2&&res<=num1)                  printf("nEl  numero  resultante  de  la  resta  esta  entre  los  dos  intresados");  
  • 17. 2012   17                  else                  printf("nEl  numero  resultante  de  la  resta  NO  esta  entre  los  dos  intresados");          }          else          {                  res=num2-­‐num1;                  if(res>=num1&&res<=num2)                  printf("nEl  numero  resultante  de  la  resta  esta  entre  los  dos  intresados");                  else                  printf("nEl  numero  resultante  de  la  resta  NO  esta  entre  los  dos  intresados");          }              return  0;   }   Ejercicio  1.14   Elaborar  un  programa  que  calcule  el  impuesto  que  se  aplica  a  una  cierta  compra  de  la   siguiente   forma:   •  Si  el  importe  de  una  compra  es  mayor  a  $500.-­‐  el  impuesto  será  del  16%.   •  En  caso  contrario,  el  impuesto  será  del  18%.   Sin  embargo,  ante  la  escasez  de  monedas  de  1  centavo,  el  importe  final  de  la  compra  debe  ser   redondeado,  en  favor  del  cliente,  hasta  un  múltiplo  de  5  centavos.  Es  decir,  si  el  importe  fuera   de   $5,17.-­‐  entonces  la  suma  a  abonar  sería  $5,15.-­‐.  El  programa  debe  solicitar  el  ingreso  de  la   compra  y  calcular  y  mostrar  el  subtotal  (compra  +  impuesto)  y  el  total  a  abonar  (subtotal   redondeado).   Ejemplo:   Valor  de  la  compra:  521   Subtotal:  604.36   Importe  a  abonar:  604.35   #include  <stdio.h>   #include  <stdlib.h>  
  • 18. 2012   18   //lo  hice  pensando  en  el  redondeo  clasico.  si  queres  redondeo  del  tipo  q  hacen  en  el   supermercado,  hasta  seria  mas  facil.  if(num>5){num=5;}else{num=0;}   int  main()   {          double  compra,  subtotal,  importe,  num;          printf("Valor  de  la  compra:  ");          scanf("%lf",  &compra);          if(compra>500)          {                  subtotal=compra+compra*0.16;          }          else          {                  subtotal=compra+compra*0.18;          }          num=subtotal*10;          importe=(int)num;          num=subtotal*100-­‐importe*10;          if(num>=2.5&&num<=7.5)          {                  num=5;          }          else          {                  if(num>7.5)                  num=10;  
  • 19. 2012   19                  else                  num=0;          }          importe=importe/10+num/100;          printf("nSubtotal:  %.2lf",  subtotal);          printf("nImporte  a  abonar:  %.2lf",  importe);            return  0;   }   Ejercicio  1.15   Realizar  un  programa  que  solicite  una  fecha.  El  usuario  ingresará  el  día,  el  mes  y  el  año  por   separado.  Luego  el  programa  mostrará  una  leyenda  que  indique  si  la  fecha  ingresada  es   válida.   Ejemplo:   Ingrese  el  día:  29   Ingrese  el  mes:  2   Ingrese  el  año:  2000   La  fecha  es  correcta.   Casos  de  prueba  para  (verificar  si  el  ejercicio  fue  hecho  correctamente)   29/2/2000  es  correcta   31/4/2008  es  incorrecta   28/2/2000  es  correcta   32/7/2005  es  incorrecta   29/2/2012  es  correcta   8/13/2007  es  incorrecta   5/12/1903  es  correcta   29/2/1900  es  incorrecta   Ayuda:  Para  saber  si  un  año  es  bisiesto:  Si  el  año  es  divisible  por  4,  es  bisiesto  siempre  y  cuando   no  sea  divisible  por  100.  Cuando  el  año  es  divisible  por  100  también  debe  ser  divisible  por  400.   Por  ejemplo:  el  año  2000  es  bisiesto  pero  el  1800  no  lo  es.   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  dia,  mes,  anio,  sen=0;  
  • 20. 2012   20          printf("Ingrese  el  dia:  ");          scanf("%d",  &dia);          printf("Ingrese  el  mes:  ");          scanf("%d",  &mes);          printf("Ingrese  el  anio:  ");          scanf("%d",  &anio);          if(anio%4==0)          {                  if(anio%100==0)                  {                          if(anio%400==0)                          sen=1;                  }                  else                  {                          sen=1;                  }          }          if(mes<=12)          {                  if(mes==1||mes==3||mes==5||mes==7||mes==8||mes==10||mes==12)                  {                          if(dia<=31)                          printf("%d/%d/%d  es  correcta",  dia,  mes,  anio);                          else                          printf("%d/%d/%d  es  incorrecta",  dia,  mes,  anio);  
  • 21. 2012   21                  }                  else                  {                        if(mes==2)                        {                                if(dia<=28)                                printf("%d/%d/%d  es  correcta",  dia,  mes,  anio);                                else                                {                                        if(sen==1&&dia<=29)                                          printf("%d/%d/%d  es  correcta",  dia,  mes,  anio);                                          else                                          printf("%d/%d/%d  es  incorrecta",  dia,  mes,  anio);                                }                          }                          else                          {                                  if(dia<=30)                                  printf("%d/%d/%d  es  correcta",  dia,  mes,  anio);                                  else                                  printf("%d/%d/%d  es  incorrecta",  dia,  mes,  anio);                          }                  }          }          return  0;  
  • 22. 2012   22   }     Ejercicio  1.16   Elaborar  un  programa  que  solicite  al  usuario  que  ingrese  un  número  real  y  luego  muestre  el   Redondeo  al  entero  más  próximo  de  dicho  número,  el  Piso  y  el  Techo.   Definiciones   Redondeo:  Si  la  parte  decimal  es  mayor  o  igual  a  0,5,  se  redondea  hacia  arriba.  Caso  contrario,   hacia  abajo.   Piso:  El  entero  más  próximo  hacia  abajo.   Techo:  El  entero  más  próximo  hacia  arriba.   Casos  de  prueba  para  (verificar  si  el  ejercicio  fue  hecho  correctamente):   Ejemplo  1:   Ingrese  un  numero  real:  5.3   Redondeo  =  5   Piso  =  5   Techo  =  6   Ejemplo  2:   Ingrese  un  numero  real:  8   Piso  =  8   Techo  =  8   Redondeo  =  8   Ejemplo  3:   Ingrese  un  numero  real:  8.92   Piso  =  8   Techo  =  9   Redondeo  =  9   Ejemplo  4:   Ingrese  un  numero  real:  8.6   Piso  =  9   Techo  =  8   Redondeo  =  9   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          double  num;          int  piso,  techo,  redondeo;          printf("Ingrese  el  numero:  ");  
  • 23. 2012   23          scanf("%lf",  &num);          if(num-­‐(int)num>=0.5)          redondeo=num+1;          else          redondeo=num;          piso=num;          techo=num+1;          printf("nRedondeo:  %d",  redondeo);          printf("nTecho:  %d",  techo);          printf("nPiso:  %d",  piso);          return  0;   }   Ejercicio  1.17   Realizar  un  programa  que  solicite  3  notas  de  parciales  obtenidas  por  un  alumno.  A   continuación   se  mostrará  por  pantalla  un  mensaje  que  indique  la  situación  del  alumno:   •  Si  el  alumno  aprobó  los  3  parciales  (nota  4  o  más)  y  su  promedio  es  mayor  a  7,   promociona  la  materia  con  la  nota  promedio.   •  Si  el  alumno  aprobó  los  3  parciales  pero  su  promedio  no  supera  los  7  puntos,  debe  rendir   examen  final.   •  Si  el  alumno  no  aprobó  uno  o  más  parciales,  se  solicitará  que  se  ingrese  la  nota  de  un   recuperatorio.  Si  éste  hubiera  sido  aprobado,  se  informará  el  promedio  general  (3  parciales   +  el  recuperatorio)  y  su  condición  de  aprobado  (aún  cuando  el  promedio  no  supere  los  4   puntos).  Si  no  hubiera  aprobado  el  recuperatorio  se  informará  que  el  alumno  fue  aplazado.   Ejemplo:   Ingrese  la  nota  del  primer  parcial:  2   Ingrese  la  nota  del  segundo  parcial:  6   Ingrese  la  nota  del  tercer  parcial:  2   Ingrese  la  nota  del  recuperatorio:  4   Promedio  general  =  3.5.  El  alumno  deberá  rendir  final.   #include  <stdio.h>   #include  <stdlib.h>    
  • 24. 2012   24   int  main()   {          int  nota1,  nota2,  nota3,  notar;          double  prom;          printf("Ingrese  la  nota  del  primer  parcial:  ");          scanf("%d",  &nota1);          printf("Ingrese  la  nota  del  segundo  parcial:  ");          scanf("%d",  &nota2);          printf("Ingrese  la  nota  del  tercer  parcial:  ");          scanf("%d",  &nota3);            if(nota1<4||nota2<4||nota3<4)          {                  printf("Ingrese  la  nota  del  recuperatorio:  ");                  scanf("%d",  &notar);                  prom=(nota1+nota2+nota3+notar)/4.0;          }          else          prom=(nota1+nota2+nota3)/3.0;          printf("Promedio  general:  %.2lf.",  prom);          if(prom<4)          printf("  El  alumno  debera  presentarse  a  final:");          else          printf("  El  alumno  ha  aprovado  y  no  debe  presentarse  a  final.");          return  0;   }  
  • 25. 2012   25   Ejercicio  1.18   Una  empresa  necesita  calcular  un  bono  que  dará  a  sus  empleados  a  fin  de  este  año.  Para  ello   se   sigue  el  siguiente  criterio:   •  Si  el  sueldo  supera  los  $2000,  el  bono  será  del  15%.  De  lo  contrario,  el  bono  será  del  20%.   •  Si  el  empleado  tiene  hijos  se  suma  un  plus  del  5%  del  sueldo.   •  Si  el  empleado  pertenece  a  la  categoría  1,  2  ó  3,  recibe  un  10%  del  sueldo.  Si  pertenece  a   la  categoría  4,  5  ó  6,  recibe  un  12%  del  sueldo.  Si  es  de  la  categoría  7,  8  ó  9,  recibe  un   20%  del  sueldo  pero  no  cobra  el  plus  por  tener  hijos.   Realizar  el  programa  que  solicite  la  información  necesaria  para  calcular  el  sueldo  final.   Finalmente   el  programa  mostrará  el  total  a  pagarle  al  empleado  (sueldo  +  bono).   Ejemplo:   Ingrese  el  sueldo:  1000   Tiene  hijos  (s/n)?:  s   Ingrese  categoría  (19):   2   El  sueldo  total  será  de  $1350.00   #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>     int  main()   {          int  sueldo,  categoria;          char  op;          double  bono;          printf("Ingrese  el  sueldo:  ");          scanf("%d",  &sueldo);          printf("Tiene  hijos  (s/n)?:  ");          op=getche();          printf("nIngrese  categoria  (1-­‐9):  ");          scanf("%d",  &categoria);          if(sueldo>2000)  
  • 26. 2012   26          bono=sueldo*0.15;          else          bono=sueldo*0.2;          if(op=='s'&&categoria!=7&&categoria!=8&&categoria!=9)          bono=bono+sueldo*0.05;          if(categoria==1||categoria==2||categoria==3)          bono=bono+sueldo*0.1;          else          {                  if(categoria==4||categoria==5||categoria==6)                  bono=bono+sueldo*0.12;                  else                  bono=bono+sueldo*0.2;          }          printf("El  sueldo  total  sera  de  %.2lf",  bono+sueldo);            return  0;   }   Ejercicio  1.19   Según  las  normas  de  tránsito,  un  automóvil  no  puede  superar  la  velocidad  máxima  ni  circular   a   menos  que  la  velocidad  mínima  (que  es  la  mitad  de  la  velocidad  máxima).  Por  una  cuestión  de   errores  de  medición  (tanto  en  el  automóvil  como  en  los  dispositivos  de  control)  hay  un  15%   de  tolerancia.  Sin  embargo,  se  permite  que  los  vehículos  en  emergencia  (ambulancias,   patrulleros,   etc.)  superen  la  velocidad  máxima  (no  así,  circular  a  menos  que  la  velocidad  mínima).  Hacer   un   programa  en  el  que  se  ingrese  la  velocidad  a  la  que  circula  un  vehículo,  la  velocidad  máxima   permitida  y  si  se  trata  o  no  de  un  vehículo  en  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:  
  • 27. 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  
  • 28. 2012   28                  {                          if(veiculo<=velmax+velmax*0.15&&veiculo>=velmax/2-­‐((velmax/2)*0.15))                          printf("Recive  advertencia");                          else                          {                                  if(veiculo>velmax+velmax*0.15)                                  printf("Recibe  multa  por  exceso  de  velocidad");                                  else                                  printf("Recibe  multa  por  entorpecer  el  tránsito");                          }                  }            }          else          {                  if(categoria=='s'||categoria=='S')                  {                          if(veiculo>=velmax/2)                          printf("No  recibe  multa");                          else                          {                                  if(veiculo>=velmax/2-­‐((velmax/2)*0.15))                                  printf("Recive  advertencia");                                  else                                  printf("Recibe  multa  por  entorpecer  el  tránsito");                          }  
  • 29. 2012   29                    }                  else                  printf("nCaracter  ingresado  incompatible");          }            return  0;   }   Ejercicio  1.20   Hacer  un  programa  que  ayude  a  decidir  a  un  alumno  si  debe  o  no  debe  atender  su  teléfono   celular   cuando  suena,  en  base  a  las  condiciones  que  se  enumeran  a  continuación.  El  programa  debe   preguntar  al  alumno  lo  siguiente:   ¿Es  de  mañana?   ¿El  llamado  es  de  tu  casa?   ¿Estás  en  clase  en  este  momento?   El  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;  
  • 30. 2012   30          printf("Por  favor,  responda  las  siguientes  preguntas  con  's'  o  'n'  segun  correspondan");          printf("nEs  de  maniana?:  ");          manana=getche();          printf("nEl  llamado  es  de  tu  casa?:  ");          casa=getche();          printf("nEstas  en  clase  en  este  momento?:  ");          clase=getche();          printf("n");          if(clase=='s'||clase=='S')          {                  printf("NO  DEBE  ATENDER");          }          else          {                  if(casa=='s'||casa=='S')                  {                          printf("DEBE  ATENDER");                  }                  else                  {                          if(manana=='s'||manana=='S')                          {                                  printf("NO  DEBE  ATENDER");                          }                          else                          {  
  • 31. 2012   31                                  printf("DEBE  ATENDER");                          }                  }          }          return  0;   }   Practica  2   Estructuras  de  repetición   Ejercicio  2.1   Elaborar un programa que solicite al usuario que ingrese un número entero y determine si el mismo es un número primo. #include <stdio.h> #include <stdlib.h> int main() { int num, cont=0, div; printf("Ingrese el numero:"); scanf("%d", &num); for(div=1; div<=num; div++) { if(num%div==0) cont++; } if(cont<=2) printf("Es primo"); else printf("No es primo"); return 0; } Ejercicio  2.2   Escribir un programa que encuentre los primeros 4 números perfectos. Un número perfecto es un
  • 32. 2012   32   entero positivo, que es igual a la suma de todos los enteros positivos (excluido él mismo) que son divisores del número. Por ejemplo, el primer número perfecto es 6, ya que los divisores de 6 son 1, 2, 3 y 1 + 2 + 3 = 6. #include <stdio.h> #include <stdlib.h> int main() { int num, cont=0, cont2=1, div; for(num=2; cont2<=4 ; num++) { for(div=1;div<num;div++) { if(num%div==0) cont=cont+div; } if(cont==num) { cont2++; printf("El %d es un numero perfecton", num); } cont=0; } return 0; }   Ejercicio  2.3   Hacer un programa que encuentre e imprima un listado con todos los números de 4 cifras que cumplan la condición de que la suma de las cifras de orden impar es igual a la suma de las cifras de orden par. Por ejemplo, el número 7821 cumple esta condición ya que 7 + 2 = 8 + 1. #include  <stdio.h>   #include  <stdlib.h>     int  main()  
  • 33. 2012   33   {          int  num,  s1,s2,s3,s4;          for(num=1000;  num<10000;  num++)          {                  s1=num%10;                  s2=(num%100-­‐s1)/10;                  s3=(num%1000-­‐s2*10-­‐s1)/100;                  s4=(num-­‐s1-­‐s2*10-­‐s3*100)/1000;                  if(s1+s2==s3+s4)                  printf("%dn",  num);          }          return  0;   }   Ejercicio  2.4   Realizar un programa en el que se ingresa una letra a buscar y luego un texto de tamaño indefinido (hasta ingresar punto). Luego, el programa debe informar cuántas apariciones de la letra hay en ese texto. Ejemplo: Ingrese la letra a contar: a   Ingrese el texto: La  bella  y  graciosa  moza,  marchose  a  lavar  la   ropa.   La letra “a” aparece 11 veces. #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>     int  main()   {  
  • 34. 2012   34          char  letra,  texto;          int  cont=0;          printf("Ingrese  la  letra  a  buscar:  ");          letra=getche();          printf("nIngrese  el  texto:  (punto  para  terminar)  n");          do          {                  texto=getche();                  if(texto==letra)                  cont++;          }while(texto!='.');          printf("nla  letra  '%c'  aparece  %d  veces  en  el  texto.",  letra,  cont);            return  0;   }   Ejercicio  2.5   Realizar un programa en el que se ingresa un texto de longitud indefinida (hasta ingresar asterisco). Luego debe informarse por pantalla cuántas de sus letras fueron mayúsculas y cuántas fueron minúsculas. Por ejemplo, para el texto “Hola Mundo” debe obtenerse 2 mayúsculas y 7 minúsculas #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>     int  main()   {  
  • 35. 2012   35          char  texto;          int  contmin=0,  contmay=0;          printf("nIngrese  el  texto:  ('*'  para  terminar)  n");          do          {                  texto=getche();                  if(texto>='a'&&texto<='z')                  contmin++;                  else                  {                          if(texto>='A'&&texto<='Z')                          contmay++;                  }          }while(texto!='*');          printf("nEn  el  texto  ingresado  hay  %d  minusculas  y  %d  mayusculas  ",  contmin,  contmay);            return  0;   }   Ejercicio  2.6   Realizar un programa en el que se ingresa un texto de longitud indefinida (hasta ingresar ENTER). Luego informar cuántas de las letras ingresadas fueron vocales (contar tanto mayúsculas como minúsculas) y cuántas fueron consonantes (contar tanto mayúsculas como minúsculas). Por ejemplo, para el texto “Kate Austen fue una de las 6 sobrevivientes del Oceanic 815” debe informarse que hay 22 vocales y 23 consonantes. #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>  
  • 36. 2012   36     int  main()   {          char  texto;          int  contvoc=0,  contcons=0;          printf("nIngrese  el  texto:  (ENTER  para  terminar)  n");          do          {                  texto=getche();                  if(texto>='a'&&texto<='z'||texto>='A'&&texto<='Z')                  {                           if(texto=='a'||texto=='A'||texto=='e'||texto=='E'||texto=='i'||texto=='I'||texto=='o'||texto=='O'| |texto=='u'||texto=='U')                          contvoc++;                          else                          contcons++;                  }          }while(texto!='r');          printf("nEn  el  texto  ingresado  hay  %d  vocales  y  %d  consonantes  ",  contvoc,  contcons);            return  0;   }   Ejercicio  2.7   Construir un programa en el que se ingresen números enteros hasta que se hayan ingresado 5 números pares e informar si alguno de ellos es también múltiplo de cuatro. #include  <stdio.h>  
  • 37. 2012   37   #include  <stdlib.h>   int  main()   {          int  num,  cont=0,  sen=0,  div;          do          {                  printf("Ingrese  numero:  ");                  scanf("%d",  &num);                  if  (num%2==0&&num!=0)                  cont++;                  if(num>=0)                  {                          div=0;                          do                          {                          div++;                          if(div*4==num)                          sen=1;                          }while(div*4<=num);                  }                  else                  {                          div=0;                          do                          {                          div-­‐-­‐;  
  • 38. 2012   38                          if(div*4==num)                          sen=1;                          }while(div*4>=num);                  }            }while(cont<=4);          if(sen==1)          printf("Hay  por  lo  menos  un  multiplo  de  4n");          else          printf("No  hay  multiplos  de  4");            return  0;   }   Ejercicio  2.8   Escribir un programa que reciba una cantidad indefinida de números enteros positivos hasta que se ingresa el 0. A continuación el programa debe indicar cuál fue el mayor y cuál el menor. #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num,  may,  men,  sen=0;          printf("Ingrese  numero:  ");                  scanf("%d",  &num);          if(num!=0)          {  
  • 39. 2012   39                  may=num;                  men=num;          }          else          {                  printf("No  se  ingresaron  valores  utiles.");                  sen=1;          }          while(num!=0)          {                  printf("Ingrese  numero:  ");                  scanf("%d",  &num);                  if(num>may)                  may=num;                  if(num<men&&num!=0)                  men=num;          }          if(sen==0)          printf("El  mayor  fue  %d  y  el  menor  fue  %d",  may,  men);          return  0;   }   Ejercicio  2.9   Armar un programa en el que se ingrese un número entero decimal (base diez) y convertirlo a binario. #include  <stdio.h>   #include  <stdlib.h>  
  • 40. 2012   40     int  main()   {          int  num,  pot=1,  bin=0,  guard_num;          printf("Ingrese  numero:  ");          scanf("%d",  &num);          guard_num=num;          while(num>0)          {                bin=bin+(num%2*pot);                pot=pot*10;                num=num/2;          }          printf("El  numero  %d(10)  es  igual  al  numero  %d(2)",  guard_num,  bin);          return  0;   }   Ejercicio  2.10   Para encontrar el máximo común divisor (MCD) de dos números se emplea el algoritmo de Euclides, que se puede describir así: Dados dos enteros a  y b  (siendo a  > b), se divide a  por b. Si el resto de la división es cero, el número b  es el máximo común divisor. Si la división no es exacta, el valor de a  pasa a ser b  y el nuevo valor de b  será el resto de la división anterior. Se repite el procedimiento hasta obtener un resto cero. El último divisor (b) es el mcd buscado. Escribir un programa que calcule el mcd de dos números enteros. Por ejemplo, si a  = 2366 y b=273, se divide a   por b  y el resto es 182; como no es cero, se divide el nuevo a  que será 273 por el nuevo b   que será 182 y da como resto 91; como no es cero se divide 182 por 91 y da como resto cero; se concluye entonces que 91 es el MCD entre 2366 y 273.
  • 41. 2012   41   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  a,  b,  aux,  resto,  guarda,  guardb;          printf("Ingrese  el  primer  numero:  ");          scanf("%d",  &a);          guarda=a;          printf("Ingrese  el  segundo  numero:  ");          scanf("%d",  &b);          guardb=b;          if(b>a)          {                  aux=b;                  b=a;                  a=aux;          }          while(a%b!=0)          {                  resto=a%b;                  a=b;                  b=resto;          }            printf("El  MCD  entre  %d  y  %d  es:  %d",guarda  ,  guardb,  b);  
  • 42. 2012   42          return  0;   }   Ejercicio  2.11   Escribir un programa que permita ingresar las notas de una cantidad indefinida de alumnos. A continuación el programa deberá mostrar la cantidad de alumnos aplazados (nota menor a 4), la cantidad de alumnos aprobados (nota entre 4 y 7 inclusive) y la cantidad de alumnos que promocionan la materia (nota superior a 7). En cada caso, se mostrará el porcentaje del total de notas cargadas que cada caso representa y el promedio general de todas las notas. Las notas pueden ser valores reales y la carga finaliza cuando la nota ingresada es 0. Ignorar las notas no válidas (fuera del rango de 1 a 10). Ejemplo: Ingrese nota: 5 Ingrese nota: 4 Ingrese nota: 2 Ingrese nota: 8 ... Ingrese nota: 0 Cantidad de aplazos: 5 (10%) Cantidad de aprobados: 15 (30%) Cantidad de promocionados: 30 (60%) Promedio general: 6.72 #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  nota,  aplazados=0,  aprovados=0,  promocionantes=0,  total,  pcapl,  pcapr,pcpro;          do          {                  printf("Ingrese  nota:  ");                  scanf("%d",  &nota);  
  • 43. 2012   43                  if(nota!=0)                  {                            if(nota<4&&nota>=1)                          aplazados++;                          else                          {                                  if(nota>=4&&nota<=7)                                  aprovados++;                                  else                                  {                                          if(nota>7&&nota<=10)                                          promocionantes++;                                          else                                          printf("nDato  incorrecto!  ingrese  notas  del  1  al  10  por  favor.n");                                  }                          }                  }          }while(nota!=0);          if(aplazados==0&&aprovados==0&&promocionantes==0)          printf("nNo  se  han  ingresado  datos  relevantes");          else          {                  total=aplazados+aprovados+promocionantes;                  pcpro=(promocionantes*100)/total;                  pcapr=(aprovados*100)/total;  
  • 44. 2012   44                  pcapl=(aplazados*100)/total;                  printf("nCantidad  de  aplazos:  %d  (%d%%)",aplazados,  pcapl);                  printf("nCantidad  de  aprobados:  %d  (%d%%)",aprovados,pcapr);                  printf("nCantidad  de  promocionados:  %d  (%d%%)",promocionantes,  pcpro);          }          return  0;   }   Ejercicio  2.12   Realizar un programa que permita el ingreso de letras en minúscula y que brinde al usuario tres operaciones posibles a través de un menú de opciones. La primera opción devolverá la mayúscula correspondiente. La segunda opción devolverá la letra siguiente en el alfabeto (si la letra ingresada fuera “z” se debe informar que es la última). La tercera opción devolverá la letra anterior en el alfabeto siempre que la letra ingresada no sea “a”. Validar que efectivamente el carácter ingresado sea una letra minúscula o *  (este último determina el final de la serie de opciones). Ejemplo: Ingrese letra: f   1 – Convertir a mayúscula 2 – Obtener la siguiente 3 – Obtener la anterior Escoja una operación (1 – 3): 1 La mayúscula es F. #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>     int  main()   {          char  letra;          int  menu;  
  • 45. 2012   45          do          {                  printf("Ingrese  la  letra:  ");                  letra=getche();                  printf("n");          }while(letra<'a'||letra>'z');          do          {                  printf("1  -­‐  Convertir  a  mayusculan");                  printf("2  -­‐  Obtener  la  siguienten");                  printf("3  -­‐  Obtener  la  anteriorn");                  printf("Escoja  una  operacion  (1  -­‐  3):  ");                  scanf("%d",  &menu);                  if(menu<1||menu>3)                  printf("Error!n");          }while(menu<1||menu>3);          switch(menu)          {                  case  1:                  letra=letra-­‐32;                  printf("La  mayuscula  es  %c",  letra);                  break;                  case  2:                  letra=letra+1;                  printf("La  siguiente  es:  %c",  letra);                  break;  
  • 46. 2012   46                  case  3:                  letra=letra-­‐1;                  printf("La  anterior  es:  %c",  letra);                  break;          }            return  0;   }   Ejercicio  2.13   Realizar un programa para calcular utilidades de inversión en plazos fijos. Para esto, se ingresarán las cantidades que serán los importes mensuales que el cliente desea invertir (cantidad = 0 para terminar). Luego se debe obtener el resultado de la colocación total en plazos fijos. Primero se debe solicitar la Tasa Nominal Anual (TNA) al principio de la serie de importes, a partir de la cual se obtiene la Tasa Efectiva Mensual (TEM = TNA /12). En cada mes, se calculan los intereses multiplicando la TEM por el total de montos acumulados hasta dicho mes. Al finalizar la carga, se imprimirá el monto final (suma de montos invertidos) más los intereses acumulados durante cada mes. Ejemplo: Se desea invertir tres sumas (durante tres meses seguidos) en plazos fijos. Ingrese porcentaje de TNA: 8   Ingrese monto del mes 1: 2000   Ingrese monto del mes 2: 3000   Ingrese monto del mes 3: 1000   Ingrese monto del mes 4: 0   El monto final es: 6086.67 Ayuda: • Ej.: TNA = 8% = 0.08. TEM = TNA /12 = 0.08/12 = 0.0067 • Intereses = 2000 * 0.0067 + (2000+3000) * 0.0067 + (2000+3000+1000) * 0.0067 • Monto total = Inversión + Intereses = 2000 + 3000 + 1000 + 86.67 = 6086.67 #include  <stdio.h>   #include  <stdlib.h>    
  • 47. 2012   47   int  main()   {          int    monto,  cont=1,  inversion=0;          double  tna,intereses=0;          printf("Ingrese  porcentaje  de  TNA:  ");          scanf("%lf",  &tna);          tna=tna/100;          do          {              printf("Ingrese  monto  del  mes  %d:  ",  cont);              scanf("%d",  &monto);              if(monto!=0)              {                  cont++;                  inversion=inversion+monto;                  intereses=intereses+inversion*(tna/12);              }          }while(monto!=0);            printf("Monto  total  =  Inversion  +  Intereses  =  %d  +  %.2lf  =  %.2lf",  inversion,  intereses,   inversion+intereses);          return  0;   }   Ejercicio  2.14   Efectuar un programa que solicite al usuario que ingrese un número entero impar (validar el valor ingresado). El programa tendrá que dibujar en la ventana un triángulo de asteriscos cuya base sea el
  • 48. 2012   48   valor ingresado. Ejemplo: Ingrese número: 8   Número no válido. Ingrese número: 11 * *** ***** ******* ********* *********** #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num,  f,  c,  ast=1,  blancos;            do          {              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);              if(num%2!=1)              printf("Error!");          }while(num%2!=1||num<3);          blancos=num/2;            for(f=1;  f<=num/2+1;  f++)          {                  for(c=1;  c<=blancos;  c++)                  {  
  • 49. 2012   49                          printf("  ");                  }                  blancos-­‐-­‐;                  for(c=1;c<=ast;c++)                  {                          printf("*");                    }                  ast+=2;                  printf("n");          }          return  0;   }   Ejercicio  2.15   Efectuar un programa que solicite al usuario que ingrese la base de un triángulo rectángulo. Luego dibujar en la ventana dicho triángulo como se muestra en el ejemplo. Ejemplo: Ingrese base: 5   * ** *** **** ***** #include  <stdio.h>   #include  <stdlib.h>     int  main()   {  
  • 50. 2012   50          int  num,  f,  c;   do{              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);   }while(num<2);          for(f=1;  f<=num;  f++)          {                  for(c=1;  c<=f;  c++)                  {                          printf("*");                  }                  printf("n");          }          return  0;   }   Ejercicio  2.16   Efectuar un programa que solicite al usuario que ingrese la base de un triángulo rectángulo. Luego dibujar en la ventana dicho triángulo como se muestra en el ejemplo. Ejemplo: Ingrese base: 5   * ** *** **** *****   #include  <stdio.h>   #include  <stdlib.h>     int  main()  
  • 51. 2012   51   {          int  num,  f,  c,  blancos,  ast=1;   do{              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);   }while(num<2);              blancos=num-­‐1;            for(f=1;  f<=num;  f++)          {                  for(c=1;  c<=blancos;  c++)                  {                          printf("  ");                  }                  blancos-­‐-­‐;                  for(c=1;  c<=ast;  c++)                  {                          printf("*");                  }                  ast++;                  printf("n");          }          return  0;   }  
  • 52. 2012   52   Ejercicio  2.17   Efectuar un programa que solicite al usuario que ingrese la diagonal de un rombo (validar que el valor ingresado sea impar). Luego deberá dibujar dicho rombo en la ventana. Ejemplo: Ingrese diagonal: 8   Valor incorrecto. Ingrese diagonal: 7   * *** ***** ******* ***** *** * #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num,  f,  c,  blancos,  ast=1;            do{              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);              blancos=num/2;          }while(num<3||num%2!=1);              for(f=1;  f<=num/2+1;  f++)          {                  for(c=1;  c<=blancos;  c++)  
  • 53. 2012   53                  {                          printf("  ");                  }                  blancos-­‐-­‐;                  for(c=1;  c<=ast;  c++)                  {                          printf("*");                  }                  ast+=2;                  printf("n");          }          blancos+=2;          ast-­‐=4;          for(f=1;  f<=num/2;  f++)          {                  for(c=1;  c<=blancos;  c++)                  {                          printf("  ");                  }                  blancos++;                  for(c=1;  c<=ast;  c++)                  {                          printf("*");                  }                  ast-­‐=2;                  printf("n");  
  • 54. 2012   54          }          return  0;   }   Ejercicio  2.18   Efectuar un programa que solicite al usuario que ingrese la base y la altura de un rectángulo. Luego deberá dibujar en la ventana el rectángulo hueco. Ejemplo: Ingrese base: 7   Ingrese altura: 4   ******* * * * * *******   #include <stdio.h> #include <stdlib.h> int main() { int num, f, c; do{ printf("Ingrese el numero: "); scanf("%d", &num); }while(num<3); for(f=1; f<=num; f++) { for(c=1; c<=num ; c++) { if(c==1||f==1||f==num||c==num) printf("*"); else printf(" "); } printf("n"); } return 0; }
  • 55. 2012   55   Ejercicio  2.19   Efectuar un programa que solicite al usuario que ingrese la base y la altura de un rectángulo. Luego deberá dibujar en la ventana dicho rectángulo. Ejemplo: Ingrese base: 8   Ingrese altura: 3   ******** ******** ********   #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  alt,  base,  f,  c;            do{              printf("Ingrese  la  base:  ");              scanf("%d",  &base);          }while(base<2);          do{              printf("Ingrese  la  altura:  ");              scanf("%d",  &alt);          }while(alt<2);              for(f=1;  f<=alt;  f++)          {  
  • 56. 2012   56                  for(c=1;  c<=base  ;  c++)                  {                          printf("*");                  }                  printf("n");          }          return  0;   }   Ejercicio  2.20   La operación factorial de un número entero positivo “n” (expresado como n!) es el producto que resulta de multiplicar “n” por todos los enteros inferiores a él hasta el uno. Por ejemplo: 5! = 5 * 4 * 3 * 2 * 1 10! = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 n! = n * (n-1) * (n-2) * … * 3 * 2 * 1 Como salvedad se define 0! = 1. Elaborar un programa que calcule el factorial de un número entero. El programa principal debe solicitar el ingreso de un número entero, verificar si se trata de un número mayor o igual a 0 y calcular su factorial. En caso de que el usuario ingresara un número negativo, imprimir una advertencia. Ejemplos: Ingrese un número entero: 5   El factorial de 5 es: 120 Ingrese un número entero: -­‐10   No se puede calcular el factorial de un número negativo. #include  <stdio.h>   #include  <stdlib.h>     int  main()   {          int  num,  cont,  res;    
  • 57. 2012   57          do{              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);              if(num<0)              printf("No  se  puede  calcular  el  factorial  de  un  numero  negativo.n");          }while(num<0);          if(num==0)          res=1;          else          {                  res=num;                  for(cont=1;  cont<num;  cont++)                          res=res*(num-­‐cont);          }          printf("El  factorial  de  %d  es:  %d",  num,  res);          return  0;   }   Ejercicio  2.21   Elaborar un programa en el que se ingrese un número entero positivo (de cualquier cantidad de cifras) y determine si es un número capicúa. Un número capicúa es aquel que leído de izquierda a derecha es igual que leído de derecha a izquierda. Por ejemplo: 82428. Considere invertir el número y luego compararlo con el número original. Si resultan iguales, será capicúa.     #include  <stdio.h>   #include  <stdlib.h>    
  • 58. 2012   58   int  main()   {          int  num,  aux,  res=0;            do{              printf("Ingrese  el  numero:  ");              scanf("%d",  &num);              if(num<=0)              printf("Error!n");          }while(num<=0);          aux=num;          while(aux>0)          {                  res=res*10+(aux%10);                  aux/=10;          }          if(num==res)          printf("El  numero  %d  es  capicua",  num);          else          printf("El  numero  %d  NO  es  capicua",  num);          return  0;   }  
  • 59. 2012   59   Practica  3   Arreglos   Ejercicio  3.1   Realice un programa que permita cargar números enteros positivos en un arreglo (de hasta 1000 elementos) hasta que el usuario ingrese 0 (este valor marca el final de los valores útiles). Luego, se deberá obtener otro arreglo que contenga los mismos valores pero en forma inversa y a continuación imprimir este último. Ejemplo: Ingrese número: 20   Ingrese número: 21   Ingrese número: 14   Ingrese número: 0   El arreglo revertido contiene: 14, 21, 20. #include  <stdio.h>   #include  <stdlib.h>   #define  N  1000     int  main()   {          int  v[N],  i=0,  b[N],  j=0;            do{              printf("Ingrese  numero:  ");              scanf("%d",  &v[i]);              i++;          }while(v[i-­‐1]!=0);          i-­‐=2;          while(i>=0)  
  • 60. 2012   60          {                  b[j]=v[i];                  j++;                  i-­‐-­‐;          }          j-­‐-­‐;          printf("El  arreglo  revertido  contiene:  ");          for(i=0;  i<=j;  i++)          printf("%d-­‐",  b[i]);            return  0;   }   Ejercicio  3.2   Realice un programa que permita cargar números enteros positivos en un arreglo (de hasta 1000 elementos) hasta que el usuario ingrese 0 (este valor marca el final de los valores utiles). No se permitirá al usuario cargar 2 veces el mismo valor, en dicho caso se mostrara un mensaje. Luego, imprima el arreglo resultante. Ejercicio  3.3   Elaborar un programa que presente un menú con las siguientes opciones: AND,  OR,   NOT,SALIR. Luego, para cada opción elegida el programa deberá permitir la carga de uno o dos (según corresponda) arreglos booleanos de 6 elementos cada uno. El 0 tendra un valor de verdad FALSO y el 1 VERDADERO. Se pide obtener el arreglo booleano resultante de la operacion logica sobre el/los arreglo/s correspondiente/s.. Ejemplo: 1 – AND 2 – OR 3 – NOT 4 – SALIR Seleccione una opción: 1  
  • 61. 2012   61   Ingrese los elementos del primer arreglo: 1  1  1  0  0  0   Ingrese los elementos del segundo arreglo: 1  1  0  0  0  1   El arreglo resultante es: 1 1 0 0 0 0 1 – AND 2 – OR 3 – NOT 4 – SALIR Seleccione una opción: 3   Ingrese los elementos del arreglo: 1  1  1  0  0  0   El arreglo resultante es: 0 0 0 1 1 1 #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  7     int  main()   {          int  i,  menu;          char  v[N],  b[N],  r[N],  l;          do{          printf("nMenun");          printf("1  -­‐  ANDn");          printf("2  -­‐  ORn");          printf("3  -­‐  NOTn");          printf("4  -­‐  SALIRn");          scanf("%d",  &menu);            switch(menu)          {    
  • 62. 2012   62                  case  1:                  i=0;                  printf("nIngrese  el  primer  arreglo:");                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  v[i]=l;                                  i++;                          }                  }while(i<6);                  v[i]='0';                  printf("nIngrese  el  segundo  arreglo:");                  i=0;                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  b[i]=l;                                  i++;                          }                  }while(i<6);  
  • 63. 2012   63                  b[i]='0';                  for(i=0;i<6;i++)                  {                          if(v[i]=='1'&&b[i]=='1')                                  r[i]='1';                          else                                  r[i]='0';                  }                  r[i]='0';                  printf("nEl  arreglo  resultante  es:  %s",  r);                  break;                  case  2:                  i=0;                  printf("nIngrese  el  primer  arreglo:");                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  v[i]=l;                                  i++;                          }                  }while(i<6);                  v[i]='0';                  printf("nIngrese  el  segundo  arreglo:");  
  • 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. 2012   65                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  v[i]=l;                                  i++;                          }                  }while(i<6);                  v[i]='0';                  for(i=0;i<6;i++)                  {                          if(v[i]=='1')                                  r[i]='0';                          else                                  r[i]='1';                  }                  r[i]='0';                  printf("nEl  arreglo  resultante  es:  %s",  r);                  break;                  case  4:                  printf("nTerminado.  Tenga  un  buen  dia!.");                  break;                  default:                  printf("nOpcion  no  valida.  Por  favor  reintente:  ");  
  • 66. 2012   66                  break;          }          }while(menu!=4);          return  0;   }   Ejercicio  3.4   Elaborar un programa que permita cargar dos arreglos numéricos de hasta 1000 elementos. Se efectuara la carga de cada uno (hasta que se ingrese 0 o se complete la capacidad del arreglo). Luego se presenta el siguiente menú con las siguientes opciones: UNION,  INTERSECCION,   DIFERENCIA,  SALIR. A continuación se efectuara la operación entre ambos arreglos como si fueran conjuntos (considerar que los conjuntos no pueden tener elementos repetidos). #include  <stdio.h>   #include  <stdlib.h>   #define  N  1000     int  main()   {          int    i,  j,  k,  m,  sen=0,  menu,  l,  v[N],  b[N],  r[N*2];          do{          printf("nMenun");          printf("1  -­‐  UNIONn");          printf("2  -­‐  INTERSECCIONn");          printf("3  -­‐  DIFERENCIAn");          printf("4  -­‐  SALIRn");          scanf("%d",  &menu);    
  • 67. 2012   67          switch(menu)          {                  case  1:                  i=0;                  printf("nIngrese  el  primer  arreglo:");                  do                  {                            sen=0;                          scanf("%d",  &l);                          for(j=0;j<i;j++)                          {                                  if(v[j]==l)                                  sen=1;                          }                          if(sen==0)                          {                                    v[i]=l;                                  i++;                          }                      }while(i<N-­‐1&&v[i-­‐1]!=0);                  i-­‐-­‐;                  printf("nIngrese  el  segundo  arreglo:");  
  • 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. 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. 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. 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. 2012   72                          }                          if(sen==1)                          {                                  r[p]=v[n];                                  p++;                          }                  }                  printf("El  arreglo  resultante  es:  ");                  for(i=0;i<p;i++)                  {                          printf("%d-­‐",  r[i]);                  }                    break;                  case  3:                  i=0;                  printf("nIngrese  el  primer  arreglo:");                  do                  {                            sen=0;                          scanf("%d",  &l);                          for(j=0;j<i;j++)                          {                                  if(v[j]==l)                                  sen=1;  
  • 73. 2012   73                          }                          if(sen==0)                          {                                    v[i]=l;                                  i++;                          }                      }while(i<N-­‐1&&v[i-­‐1]!=0);                  i-­‐-­‐;                  printf("nIngrese  el  segundo  arreglo:");                  k=0;                  do                  {                            sen=0;                          scanf("%d",  &l);                          for(j=0;j<k;j++)                          {                                  if(b[j]==l)                                  sen=1;                          }                            if(sen==0)                          {  
  • 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. 2012   75                  }                  break;                  case  4:                  printf("nTerminado.  Tenga  un  buen  dia!.");                  break;                  default:                  printf("nOpcion  no  valida.  Por  favor  reintente:  ");                  break;          }          }while(menu!=4);          return  0;   }   Ejercicio  3.5   Realizar un programa en el que se ingrese un texto de hasta 100 caracteres finalizando con ENTER (utilizar ‘r’ para detectar el ingreso de ENTER). Luego, el usuario deberá elegir un caracter al cual reemplazar y con que caracter reemplazarlo. Ejemplo: Ingrese texto: La  mar  estaba  serena   Ingrese carácter a reemplazar: a   Ingrese carácter de reemplazo: e   Resultado: Le mer estebe serene #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  101     int  main()   {  
  • 76. 2012   76          char  l,  lo='0',lc='0',texto[N];          int  i=0;          printf("nIngrese  la  letra  a  reemplazar:  ");          do          {                  l=getche();                  if(l>='a'&&l<='z'||l>='A'&&l<='Z')                  lo=l;                  else                  printf("nError!.  Reintente:  ");          }while(lo=='0');          printf("nIngrese  la  letra  a  ser  reemplazada:  ");          do          {                  l=getche();                  if(l>='a'&&l<='z'||l>='A'&&l<='Z')                  lc=l;                  else                  printf("nError!.  Reintente:  ");          }while(lc=='0');          printf("nIngrese  el  texto:  n");          do          {                  l=getche();                  if(l!='r')                  {  
  • 77. 2012   77                          texto[i]=l;                          i++;                  }            }while(l!='r'&&i<N-­‐1);          texto[i]='0';          int  j;          for(j=0;j<i;j++)          {                  if(texto[j]==lo)                  texto[j]=lc;          }          printf("ntexto  modificado:  %sn",  texto);          return  0;   }   Ejercicio  3.6   Realizar un programa en el que se ingrese un texto de hasta 75 caracteres finalizando con ENTER (utilizar el caracter ‘r’ para detectarlo). Luego imprimir dicho texto centrado y, en la siguiente linea, alineado hacia la derecha. Tener en cuenta que el ancho de la pantalla de texto es de 80 columnas. El texto debe contener ‘0’ como caracter final a fin de que pueda imprimirse con printf(“%s”, texto); Ejemplo: Ingrese texto: La  bella  y  graciosa  moza  marchose  a  lavar  la  ropa   La bella y graciosa moza marchose a lavar la ropa La bella y graciosa moza marchose a lavar la ropa #include  <stdio.h>   #include  <stdlib.h>  
  • 78. 2012   78   #include  <conio.h>   #define  N  76     int  main()   {          char  text[N],  l;          int  cont  ,i=0;          printf("Ingrese  texto:  n");          do          {                          l=getche();                          if(l!='r')                          {                                  text[i]=l;                                  i++;                          }          }while  (l!='r'&&i<N);          text[i]='0';          printf("n");          for(cont=0;cont<40-­‐i/2;cont++)          printf("  ");          printf("%sn",  text);          for(cont=0;cont<80-­‐i;cont++)          printf("  ");          printf("%sn",  text);          return  0;  
  • 79. 2012   79   }   Ejercicio  3.7   Programar una funcion que reciba como parametro un texto y que elimine todo lo que no sean letras que encuentre al principio y al final del texto. Utilizarla en un programa en el que se ingrese un texto de hasta 1000 caracteres y luego se imprima la version “limpia” del texto. El texto debe contener ‘0’ como caracter final a fin de que pueda imprimirse con printf(“%s”, texto); Ejemplo: Ingrese texto:... La  bella  y  graciosa  moza  marchose  a  lavar  la  ropa,  $@   La bella y graciosa moza marchose a lavar la ropa #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  1000   void  trans  (char[],  int);   int  main()   {          char  text[N],  l;          int  cont  ,i=0;          printf("Ingrese  texto:  n");          do          {                          l=getche();                          if(l!='r')                          {                                  text[i]=l;                                  i++;                          }  
  • 80. 2012   80          }while  (l!='r'&&i<N);          trans  (text,  i);          printf("n%sn",  text);          return  0;   }   void  trans  (char  text[],  int  i)   {          int  j=0,  k=0,  sen=0;          while(j<i)          {                  if(text[j]>='A'&&text[j]<='Z'||text[j]>='a'&&text[j]<='z'||text[j]=='  ')                  {                          sen=1;                          text[k]=text[j];                          k++;                  }                  else                  {                          if(sen==1)                          text[k]='0';                  }                  j++;          }   }  
  • 81. 2012   81   Practica  4 Funciones   Ejercicio  4.1   Escribir una funcion que reciba como parametros la longitud de los lados de un triangulo y que retorne  el area del mismo. Implementarla en un programa que reciba los parametros como datos e informe el area calculada. Ejemplo: Ingrese lado 1: 2   Ingrese lado 1: 6   Ingrese lado 1: 7   El area del triangulo es = 5.56 Ayuda: El area de un triangulo se puede calcular como √ p( p  - a)( p  - b)( p  - c) siendo p  =(a +b +c) ÷2 #include  <stdio.h>   #include  <stdlib.h>   #include  <math.h>     double  area  (int,  int,  int);   int  main()   {          int  a,b,c;          double  areatri;          printf("Ingrese  lado  1:  n");          do          {                  scanf("%d",  &a);          }while  (a<=0);          printf("Ingrese  lado  2:  n");  
  • 82. 2012   82          do          {                  scanf("%d",  &b);          }while  (b<=0);          printf("Ingrese  lado  3:  n");          do          {                  scanf("%d",  &c);          }while  (c<=0);          areatri=area(a,b,c);          printf("El  area  del  triangulo  es  =  %.2lf",  areatri);          return  0;   }   double  area  (int  a,  int  b,  int  c)   {          double  areatri,p;          p=(a+b+c)/2.0;          areatri=sqrt((double)p*(p-­‐a)*(p-­‐b)*(p-­‐c));          return  areatri;   }   Ejercicio  4.2   Programar una funcion que reciba como parametros un numero real ‘x’ y otro entero positivo ‘n’ mayor que 0. Esta funcion debera retornar  la raiz enesima de x. Utilizarla en un programa que solicite el numero real, la raiz y luego imprima el valor calculado. Ejemplo: Ingrese un numero real: 14   Ingrese la raiz a calcular: 3  
  • 83. 2012   83   La raiz 3 de 14 es = 2.410142 Ayuda: Utilizar la funcion pow de la libreria math.h cuyo prototipo es double  pow(double  base, double  exponente); #include  <stdio.h>   #include  <stdlib.h>   #include  <math.h>     double  raiz  (double,  int);   int  main()   {          double  x,  resultado;          int  n;          printf("Ingrese  el  numero  a  radicar:  n");          do          {                  scanf("%lf",  &x);                  if(x<0)                  printf("Error!  No  existe  la  raiz  de  un  numero  negativo  en  reales.  Reingrese:  ");            }while  (x<0);          printf("Ingrese  la  raiz  a  efectuar:  n");          do          {                  scanf("%d",  &n);                  if(n<=0)                  printf("Error!  Reingrese  un  numero  positivo:  ");          }while  (n<=0);  
  • 84. 2012   84          resultado=raiz(x,  n);          printf("La  raiz  %d  de  %g  es  =  %g",  n,  x,  resultado);          return  0;   }   double  raiz  (double  x,  int  n)   {          double  resultado;          resultado=pow(x,1.0/n);          return  resultado;   }   Ejercicio  4.3   Realizar una funcion que reciba como parametros un numero entero positivo (en sistema decimal) y otro entero positivo entre 2 y 9. Luego, la funcion debera retornar  el numero decimal convertido a la base solicitada. Aplicar dicha funcion a un programa que solicite el numero decimal, la base a convertir y luego imprima el valor calculado. Ejemplo: Ingrese el numero decimal: 527   Ingrese la base: 8   527 (10) = 1017 (8) #include  <stdio.h>   #include  <stdlib.h>     int  cambio_base  (int,  int);   int  main()   {          int  decimal,  base,  cambiado;          printf("Ingrese  el  numero  en  sistema  decimal:  n");          do  
  • 85. 2012   85          {                  scanf("%d",  &decimal);                  if(decimal<0)                  printf("Error!  Reingrese  un  numero  positivo:  ");            }while  (decimal<0);          printf("Ingrese  la  base  en  que  lo  quiere:  n");          do          {                  scanf("%d",  &base);                  if(base<2||base>9)                  printf("Error!  Reingrese  un  numero  positivo  (entre  2  y  9):  ");          }while  (base<2||base>9);          cambiado=cambio_base(decimal,  base);          printf("El  numero  %d(10)  es  igual  a  %d(%d)",  decimal,  cambiado,  base);          return  0;   }   int  cambio_base  (int  d,  int  b)   {          int  c=0,  pot=1;          do          {                  c=c+(d%b)*pot;                  d/=b;                  pot*=10;          }while(d>0);  
  • 86. 2012   86          return  c;   }   Ejercicio  4.4   Programar una funcion que reciba como parametros 2 numeros enteros y que retorne  un numero aleatorio entre estos 2 numeros (inclusive). Por ejemplo, si se invocara la funcion con parametros 1 y 6, debera devolver un numero aleatorio entre 1 y 6 inclusive. Validar que el valor maximo no sea superior al valor maximo que es capaz de generar la funcion rand. Implementarla en un programa que solicite al usuario que ingrese el rango de valores aleatorios y la cantidad deseada de valor. A continuacion imprimir la lista de numeros aleatorios segun el criterio solicitado. Ejemplo: Ingrese minimo: 1   Ingrese maximo: 20   Ingrese cantida de valores: 10   1, 8, 20, 14, 11, 17, 2, 1, 5, 6. #include  <stdio.h>   #include  <stdlib.h>   #include  <time.h>   #define  N  99999   int  aleatorio  (int,  int);   int  main()   {          int  max,  min,i,j  ,v[N];          srand(time(NULL));          printf("Ingrese  el  maximo:  n");          scanf("%d",  &max);          printf("Ingrese  el  minimo:  n");          do  
  • 87. 2012   87          {                  scanf("%d",  &min);                  if(min>max)                  printf("Error!  Reingrese  un  numero  menor  al  maximo:  ");          }while  (min>max);          printf("Ingrese  la  cantidad  de  valores:  n");          do          {                  scanf("%d",  &i);                  if(i<0)                  printf("no  se  puede  mostrar  una  cantidad  negativa  de  veces.  reingrese:  ");          }while  (i<0);          printf("n");          for(j=0;j<i;j++)          {                  v[j]=aleatorio(max,  min);                  printf("%d,  ",  v[j]);          }            return  0;   }   int  aleatorio  (int  max,  int  min)   {          int  c;          c=rand()%(max-­‐min+1)+min;          return  c;  
  • 88. 2012   88   }   Ejercicio  4.5   Dado el siguiente programa, construir las funciones cuyos prototipos se indican y de modo que el programa genere la salida correspondiente. Todas las funciones cuyos prototipos figuran deben ser programadas y utilizadas sin  modificar  los tipos de los parametros ni el tipo de dato de retorno. #include <stdio.h> void  dibujar_fila(int);   void  dibujar_rectangulo(int,  int);   int main() { int alto, ancho; printf("Ingrese ancho:"); scanf("%d", &ancho); printf("Ingrese altura:"); scanf("%d", &alto); dibujar_rectangulo(ancho, alto); return 0; } Ejercicio  4.6   Dado el siguiente programa, construir las funciones cuyos prototipos se indican y de modo que el programa genere la salida correspondiente. Todas las funciones cuyos prototipos figuran deben ser programadas y utilizadas sin  modificar  los tipos de los parametros ni el tipo de dato de retorno. #include <stdio.h> int  ingresar_texto(void);   int  es_letra(unsigned  char);   int main() { int len; printf("Ingrese texto (punto para finalizar):"); len = ingresar_texto(); printf("nEl texto tiene %d letras.", len); return 0; }   #include  <stdio.h>  
  • 89. 2012   89   void  dibujar_fila(int);   void  dibujar_rectangulo(int,  int);   int  main()   {   int  alto,  ancho;   printf("Ingrese  ancho:");   scanf("%d",  &ancho);   printf("Ingrese  altura:");   scanf("%d",  &alto);   dibujar_rectangulo(ancho,  alto);   return  0;   }   void  dibujar_fila(int  anch)   {          int  c;          for(c=0;c<anch;c++)          {                  printf("*");          }   }   void  dibujar_rectangulo(int  anch,  int  alt)   {          int  f;          for(f=0;f<alt;f++)          {                  dibujar_fila  (anch);  
  • 90. 2012   90                  printf("n");          }   }   Ejercicio  4.7   Programar una funcion que tome como parametro un texto y que convierta sus letras mayusculas en minusculas y todo lo que no sean ni letras ni numeros, se conviertan en espacios. Utilizarla en un programa en el que se ingrese un texto de hasta 1000 caracteres y luego se imprima la version modificada del texto. El texto debe contener ‘0’ como caracter final a fin de que pueda imprimirse con printf(“%s”, texto); #include  <stdio.h>   #include  <conio.h>   #define  N  1000   int  es_letra_o_numero(char);   int  es_mayuscula(char);   void  trans_texto(char[],  int);   int  main()   {                  int  i=0,  l;                  char  texto[N];                  printf("Ingrese  el  texto:n");                  do                  {                          l=getche();                          if(l!='r')                          {  
  • 91. 2012   91                                  texto[i]=l;                                  i++;                          }                    }while(l!='r');                  texto[i]='0';                  trans_texto(texto,  i);                  printf("ntexto  modificado:  %s",  texto);                  return  0;   }   int  es_letra_o_numero(char  a)   {          return((a>='a'&&a<='z')||(a>='A'&&a<='Z')||(a>='0'&&a<='9'));   }   int  es_mayuscula  (char  l)   {          return(l>='A'&&l<='Z');   }   void  trans_texto(char  texto[],  int  i)   {          int  j;          for(j=0;j<i;j++)          {                  if(!es_letra_o_numero(texto[j]))                  texto[j]='  ';                  else  
  • 92. 2012   92                  {                          if(es_mayuscula(texto[j]))                          texto[j]=texto[j]+32;                  }          }   }   Ejercicio  4.8   Realizar una funcion que permita ingresar en un arreglo de caracteres (string) solamente caracteres numericos (ignorar y no mostrar en pantalla cuando se ingrese un caracter que no sea numero). Luego, programar otra funcion que tome ese arreglo de caracteres y lo convierta a un valor numerico entero. Utilizar ambas funciones en un programa en que se ingrese un numero y luego se convierta a entero para ser impreso mediante printf(“%d”, numero). #include  <stdio.h>   #include  <conio.h>   #define  N  1000   int  number(char[],  int);   int  main()   {                  int  i=0;                  char  numero[N]={0},  l;                  printf("Ingrese  los  numeros:n");                  do                  {                          l=getch();                          if(l>='0'&&l<='9')                          {                                  printf("%c",  l);  
  • 93. 2012   93                                  numero[i]=l;                                  i++;                          }                    }while(l!='r'&&i<N-­‐2);                  numero[i]='0';                  int  j=0;                  j=number(numero,i);                  printf("nnumero:  %sn",  numero);                  printf("nnumero:  %dn",  j);                  for(j=0;j<i;j++)                  printf("%d",  numero[j]);                  return  0;   }     int  number  (char  numero[],  int  i)   {          int  num=0,  j;          for(j=0;j<i;j++)          {                  num=num*10+(numero[j]-­‐48);          }          return  num;   }  
  • 94. 2012   94   Ejercicio  4.9   Elabore un programa que cargue un arreglo con 100 numeros al azar entre 1 y 100. Luego obtener el valor maximo y el valor minimo presentes en el arreglo. #include  <stdio.h>   #include  <stdlib.h>   #include  <time.h>   #define  N  100     int  main()   {                  int  numero[N]={0},i=0,  j,  max,  min;                  srand(time(NULL));                  do                  {                                  numero[i]=rand()%100+1;                                  i++;                  }while(i<N);                  max=numero[0];                  min=numero[0];                  for(j=0;j<i;j++)                  {                                  if(numero[j]>max)                                          max=numero[j];                                  else                                  {                                          if(numero[j]<min)  
  • 95. 2012   95                                          min=numero[j];                                  }                  }                  printf("nmaximo:  %dn",  max);                  printf("nminimo:  %dn",  min);   Ejercicio  4.10   Realizar un programa que solicite al usuario una cantidad de numeros al azar que se generara entre el 0 y el 36. Presentar luego un informe que indique que cantidad de veces salio cada valor y el porcentaje que representa. No mostrar aquellos numeros que no hayan salido. Ejemplo: Ingrese cantidad de valores: 10   Informe: El numero 8 salio 1 vez (10%). El numero 14 salio 2 veces (20%). El numero 20 salio 4 veces (40%). El numero 23 salio 1 veces (10%). El numero 30 salio 2 veces (20%). #include  <stdio.h>   #include  <stdlib.h>   #include  <time.h>   #define  N  99999     int  main()   {                  int  numero[N]={0},i,  j=0,  cont=0;                  srand(time(NULL));                  printf("ingrese  la  cantidad  de  valores:  ");                  scanf("%d",  &i);                  do                  {  
  • 96. 2012   96                                  j=rand()%37;                                  numero[j]++;                                  cont++;                    }while(cont<=i);                  int  k;                  for(j=0;j<37;j++)                  {                          if(numero[j]>0)                          printf("nEl  numero  %d  salio  %d  veces  (%%%d)n",  j,  numero[j],  (numero[j]*100)/i);                    }                    return  0;   }   Ejercicio  4.11   Realice una funcion que reciba como parametro un arreglo de hasta 10 enteros y luego calcule el desvio estandar de esos valores. Programar otra funcion que calcule el promedio de un arreglo. Aplicar ambas funciones en un programa en el que se carguen los valores del arreglo y luego imprima el desvio estandar de dicho arreglo. Ayuda: El desvio estandar (σ) es una medida estadistica de dispersion y la formula usual para su calculo es: N = Cantidad de valores Xi = Cada uno de los valores m = Es el promedio (ver imagen de la formulita en el apunte de lirweb) #include  <stdio.h>   #include  <stdlib.h>  
  • 97. 2012   97   #include  <math.h>   #define  N  10   double  promedio  (int[]);   double  desvio_estandard  (int[],double);   int  main()   {                  int  numero[N],i=0;                  double  de,  m;                  printf("ingrese  los  valores:  ");                    do                  {                          scanf("%d",  &numero[i]);                          i++;                  }while(i<N);                  m=promedio(numero);                  de=desvio_estandard(numero,  m);                  printf("La  desviacion  estandard  de  los  valores  ingresados  es:  %g",  de);                  return  0;   }   double  promedio  (int  numero[])   {          int  i;          double  m=0;          for(i=0;i<N;i++)          {  
  • 98. 2012   98                  m=m+numero[i];          }          m=m/N;          return  m;   }   double  desvio_estandard(int  numero[],double  m)   {          int  s=0,  i;          for(i=0;i<N;i++)                s=s+((numero[i]-­‐m)*(numero[i]-­‐m));            double  solucion;          solucion=sqrt((double)s/N);          return  solucion;   }   Ejercicio  4.12   Rehacer los ejercicios 3.3 y 3.4 de la practica de arreglos, utilizando funciones. Preste especial atencion al codigo que se repite; identifiquelo, transcribalo a una funcion y reescriba el main para utilizarla. 3.3:   #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  7   ingrese(char[]);   AND(char[],char[],  char[]);  
  • 99. 2012   99   OR(char[],char[],  char[]);   NOT(char[],char[],  char[]);   int  main()   {          int  i,  menu;          char  v[N],  b[N],  r[N],  l;          do{          printf("nMenun");          printf("1  -­‐  ANDn");          printf("2  -­‐  ORn");          printf("3  -­‐  NOTn");          printf("4  -­‐  SALIRn");          scanf("%d",  &menu);            switch(menu)          {                    case  1:                  printf("nIngrese  el  primer  arreglo:");                  ingrese  (v);                  printf("nIngrese  el  segundo  arreglo:");                  ingrese(b);                  AND(v,b,r);                  printf("nEl  arreglo  resultante  es:  %s",  r);                  break;    
  • 100. 2012   100                  case  2:                  printf("nIngrese  el  primer  arreglo:");                  ingrese(v);                  printf("nIngrese  el  segundo  arreglo:");                  ingrese(b);                  OR(v,b,r);                  printf("nEl  arreglo  resultante  es:  %s",  r);                    break;                                    case  3:                  i=0;                  printf("nIngrese  el  arreglo:");                  ingrese(v);                  NOT(v,b,r);                  printf("nEl  arreglo  resultante  es:  %s",  r);                  break;                                    case  4:                  printf("nTerminado.  Tenga  un  buen  dia!.");                  break;                                    default:                  printf("nOpcion  no  valida.  Por  favor  reintente:  ");                  break;          }  
  • 101. 2012   101          }while(menu!=4);          return  0;   }   ingrese(char  v[])   {                  int  i=0;                  char  l;                  do                  {                          l=getche();                            if(l=='0'||l=='1')                          {                                  v[i]=l;                                  i++;                          }                  }while(i<6);                  v[i]='0';   }   AND(char  v[],char  b[],  char  r[])   {          int  i;          for(i=0;i<6;i++)          {          if(v[i]=='1'&&b[i]=='1')                  r[i]='1';  
  • 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. 2012   103                          r[i]='1';          }          r[i]='0';   }   3.4:   #include  <stdio.h>   #include  <stdlib.h>   #define  N  1000   int  repetido  (int[],  int,  int);   int  ingrese  (int[]);   imprimir_resultado(int[],  int);   int  main()   {          int    i,  j,  k,  m,  sen=0,  menu,  l,  v[N],  b[N],  r[N*2];          do{          printf("nMenun");          printf("1  -­‐  UNIONn");          printf("2  -­‐  INTERSECCIONn");          printf("3  -­‐  DIFERENCIAn");          printf("4  -­‐  SALIRn");          scanf("%d",  &menu);            switch(menu)          {                  case  1:    
  • 104. 2012   104                  printf("nIngrese  el  primer  arreglo:");                  i=ingrese(v);                  printf("nIngrese  el  segundo  arreglo:");                  k=ingrese(b);                  //pedaso  que  checkea  si  guardar  en  el  arreglo  solucion  o  no.                  for(m=0;m<i;m++)                  {                          r[m]=v[m];                  }                  for(j=0;j<k;j++)                  {                          sen=0;                          sen=repetido(r,m,b[j]);                          sen=repetido(v,m,b[j]);                          if(sen==0)                          {                                  r[m]=b[j];                                  m++;                          }                  }                  imprimir_resultado(r,m);                  break;                  case  2:                  printf("nIngrese  el  primer  arreglo:");                  i=ingrese(v);                  printf("nIngrese  el  segundo  arreglo:");  
  • 105. 2012   105                  k=ingrese(b);                  m=0;                  for(j=0;j<i;j++)                  {                          sen=0;                          sen=repetido(b,k,v[j]);                          if(sen==1)                          {                                  r[m]=v[j];                                  m++;                          }                  }                  imprimir_resultado(r,m);                    break;                  case  3:                  printf("nIngrese  el  primer  arreglo:");                  i=ingrese(v);                  printf("nIngrese  el  segundo  arreglo:");                  k=ingrese(b);                  for(j=0;j<i;j++)                  {                          sen=repetido(b,k,v[j]);                          if(sen==0)                          {                                  r[m]=v[j];  
  • 106. 2012   106                                  m++;                          }                  }                  imprimir_resultado(r,m);                  break;                  case  4:                  printf("nTerminado.  Tenga  un  buen  dia!.");                  break;                  default:                  printf("nOpcion  no  valida.  Por  favor  reintente:  ");                  break;          }          }while(menu!=4);          return  0;   }   int  ingrese(int  v[])   {          int  i=0,  sen,  l;          do          {                  scanf("%d",  &l);                  sen=repetido(v,i,l);                  if(sen==0)                  {                          v[i]=l;                          i++;  
  • 107. 2012   107                  }          }while(i<N-­‐1&&l!=0);          i-­‐-­‐;          return  i;   }   int  repetido  (int  v[],  int  i,  int  l)   {          int  j,  sen=0;                  for(j=0;j<i;j++)                  {                          if(v[j]==l)                          sen=1;                  }                  return  sen;   }   imprimir_resultado(int  r[],  int  m)   {          printf("El  arreglo  resultante  es:  ");          int  i;          for(i=0;i<m;i++)          {                  printf("%d-­‐",  r[i]);          }   }   Ejercicio  4.13   Realizar un programa que contenga las siguientes funciones:
  • 108. 2012   108   a. Una funcion que permita cargar un texto de hasta 1000 caracteres finalizando dicha carga con ENTER. El arreglo debe contener el caracter ‘0’ como marca de finalizacion de acuerdo con la convencion utilizada en el lenguaje C. b. Una funcion que reciba como parametro una frase y que retorne cuantas palabras tiene esa frase. c. Una funcion que reciba como parametro una frase y que retorne la longitud promedio de las palabras de esa frase. d. Una funcion que reciba como parametro una frase y que modifique el contenido de dicha frase de modo que la primera letra de cada palabra quede en mayuscula. En base a estas funciones, Realizar un programa en el que se ingrese una frase y a continuacion se muestren por pantalla los resultados obtenidos mediante las funciones creadas en los puntos b, c y d. Considere programar funciones adicionales. #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  1001   a  (char[]);   int  b(char[]);   double  c  (char[]);   d  (char[]);   int  es_separador(char);   int  es_minuscula(char);   int  main()   {          char  texto[N];          int  cantidad_palabras;          double  promedio;          a(texto);  
  • 109. 2012   109          printf("nTexto  original:%s",  texto);          cantidad_palabras=b(texto);          printf("nCantidad  de  palabras:  %d",  cantidad_palabras);          promedio=c(texto);          printf("nPromedio  de  longitud  de  las  palabras:  %.2lf",  promedio);          d(texto);          printf("nTexto  modificado:  %s",  texto);          return  0;   }   a(char  texto[])   {          int  i=0;          char  l;          printf("Ingrese  el  texto:  ");          do          {                  l=getche();                  if(l!='r')                  {                          texto[i]=l;                          i++;                  }          }while(i<N-­‐1&&l!='r');          texto[i]='0';   }   int  es_separador(char  l)  
  • 110. 2012   110   {          return(l=='  '||l==','||l==';'||l=='?'||l=='!');   }   int  b  (char  texto[])   {          int  cont=0,  sen=0,  i;          for(i=0;i<N-­‐1&&texto[i]!='0';)          {                  sen=0;                  while(es_separador(texto[i])&&texto[i]!='0')                  i++;                  while(!es_separador(texto[i])&&texto[i]!='0')                  {                          sen=1;                          i++;                  }                  if(sen==1)                  cont++;            }          return  cont;   }   double  c  (char  texto[])   {          /*c.  Una  funcion  que  reciba  como  parametro  una  frase  y  que  retorne  la  longitud  promedio  de   las  
  • 111. 2012   111   palabras  de  esa  frase.*/          int  cant_pal[N/2]={0},  i,  suma=0,  j=0,  sen;          for(i=0;(i<N-­‐1)&&(texto[i]!='0');)          {                  sen=0;                  while(es_separador(texto[i])&&texto[i]!='0')                  i++;                  while(!es_separador(texto[i])&&texto[i]!='0')                  {                          cant_pal[j]++;                          sen=1;                          i++;                  }                  if(sen==1)                  {                          suma=suma+cant_pal[j];                          j++;                  }            }          double  resultado;          resultado=suma/(double)j;            return  resultado;   }   d  (char  texto[])  
  • 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. 2012   113   a. Una funcion que permita cargar un texto de hasta 1000 caracteres finalizando dicha carga con ENTER. El arreglo debe contener el caracter ‘0’ como marca de finalizacion de acuerdo con la convencion utilizada en el lenguaje C. b. Una funcion booleana que reciba como parametros dos palabras (en dos arreglos independientes) y que indique si ambas palabras son iguales (considerar mayusculas y minusculas como iguales). c. Una funcion que reciba como parametros una frase y una palabra (considerar mayusculas y minusculas como iguales) y que retorne cuantas veces aparece dicha palabra en la frase. d. Una funcion booleana que reciba como parametros dos frases (en dos arreglos independientes) y que determine si ambas frases son iguales. Es decir, cuando contengan las mismas palabras en el mismo orden. Por ejemplo: “Hola, como te va?” debe ser considerada igual a “hola… Como te va!” En base a estas funciones, Realizar un programa en el que se ingresen por teclado dos frases y una palabra. A continuacion, el programa debera mostrar por pantalla cuantas veces aparece la palabra ingresada en cada una de las frases ingresadas y si ambas frases son iguales. Considere programar funciones adicionales y utilizar la funcion del punto b en los puntos c y d. #include  <stdio.h>   #include  <stdlib.h>   #include  <conio.h>   #define  N  1001   void  a  (char[]);   int  b(char[],  char[]);   int  c  (char[],  char[]);   int  d  (char[],  char[]);   int  es_separador(char);   int  es_minuscula(char);   int  es_letra(char);   int  main()  
  • 114. 2012   114   {          char  texto1[N],  texto2[N],  palabra[N],  sen;          int  cant_pal_rep1,cant_pal_rep2;          a(texto1);          printf("n");          a(texto2);          printf("n");          a(palabra);          cant_pal_rep1=c(texto1,  palabra);          printf("ncantidad  de  veces  que  se  repite  la  palabra  en  el  texto  1:  %d",  cant_pal_rep1);          cant_pal_rep2=c(texto2,  palabra);          printf("ncantidad  de  veces  que  se  repite  la  palabra  en  el  texto  2:  %d",  cant_pal_rep2);          sen=d(texto1,texto2);          if(sen==1)          printf("nlos  textos  son  iguales");          else          printf("nlos  textos  son  distintos");            return  0;   }   void  a(char  texto[])   {          int  i=0;          char  l;          printf("Ingrese  el  texto:  ");          do  
  • 115. 2012   115          {                  l=getche();                  if(l!='r')                  {                          texto[i]=l;                          i++;                  }          }while(i<N-­‐1&&l!='r');          texto[i]='0';   }   int  es_separador(char  l)   {          return(l=='  '||l==','||l==';'||l=='?'||l=='!');   }   int  b  (char  palabra1[],char  palabra2[])   {          /*b.  Una  funcion  booleana  que  reciba  como  parametros  dos  palabras  (en  dos  arreglos   independientes)  y  que  indique  si  ambas  palabras  son  iguales  (considerar  mayusculas  y   minusculas  como  iguales).*/          int  sen=1,  i;          for(i=0;palabra1[i]!='0'&&palabra2[i]!='0'&&sen==1;i++)          {                  if(palabra1[i]==palabra2[i])                  sen=1;                  else                  sen=0;  
  • 116. 2012   116          }          return  sen;   }   int  c  (char  texto[],  char  palabra[])   {          /*c.  Una  funcion  que  reciba  como  parametros  una  frase  y  una  palabra  (considerar  mayusculas  y   minusculas  como  iguales)  y  que  retorne  cuantas  veces  aparece  dicha  palabra  en  la  frase.*/          int  sen=1,  i,  cont=0,  j;          for(i=0;texto[i]!='0';i++)          {                  sen=1;                  j=0;                  if(es_minuscula(palabra[j]))                  palabra[j]-­‐=32;                  if(texto[i]==palabra[j]||texto[i]==palabra[j]+32)                  {                          i++;                          j++;                          while(palabra[j]!='0'&&sen==1)                          {                                  if(es_minuscula(palabra[j]))                                  palabra[j]-­‐=32;                                  if(texto[i]==palabra[j]||texto[i]==palabra[j]+32)                                  sen=1;                                  else                                  sen=0;  
  • 117. 2012   117                                  j++;                                  i++;                          }                          if(es_separador(texto[i])||texto[i]=='0')                          sen=1;                          else                          sen=0;                          if(sen==1)                          cont++;                  }            }          return  cont;   }   int  d  (char  texto1[],char  texto2[])   {          /*d.  Una  funcion  booleana  que  reciba  como  parametros  dos  frases  (en  dos  arreglos   independientes)  y  que  determine  si  ambas  frases  son  iguales.  Es  decir,  cuando  contengan  las   mismas  palabras  en  el  mismo  orden.  Por  ejemplo:  “Hola,  como  te  va?”  debe  ser  considerada   igual  a  “hola…  Como  te  va!”*/          int  i=0,  j=0,  sen=1;          while(texto1[i]!='0'&&texto2[i]!='0'&&sen==1)          {                  if(es_letra(texto1[i]))                  {                          if(es_minuscula(texto1[i]))  
  • 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. 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..