Estructuras Repetitivas Teoria y Ejercicios

Explicamos las distintas estructuras poniendo ejemplos
tanto en diagrama de flujo como en pseudocódigo.

Las estructuras condicionales comparan una variable contra otro(s)valor (es),
para que en base al resultado de esta comparación, se siga un curso de acción
dentro del programa. Cabe mencionar que la comparación se puede hacer
contra otra variable o contra una constante, según se necesite. Existen tres
tipos básicos, las simples, las dobles y las múltiples.
ESTRUCTURAS CONDICIONALES SIMPLES:
Las estructuras condicionales simples se les conoce como “Tomas de

decisión”. Estas tomas de decisión tienen la siguiente forma:
Pseudocódigo: Diagrama de flujo:

ESTRUCTURAS CONDICIONALES DOBLES:
Las estructuras condicionales dobles permiten elegir entre dos opciones o

alternativas posibles en función del cumplimiento o no de una determinada
condición. Se representa de la siguiente forma:
Donde:
Si:Indica el comando de comparación
Condición : Indica la condición a evaluar
Entonces : Precede a las acciones a realizar cuando se cumple la condición
Instrucción(es):Son las acciones a realizar cuando se cumple o no la condición
si no :Precede a las acciones a realizar cuando no se cumple la condición
Dependiendo de si la comparación es cierta o falsa, se pueden realizar una o
más acciones.
ESTRUCTURAS CONDICIONALES MULTIPLES:
Las estructuras de comparación múltiples, son tomas de decisión

especializadas que permiten comparar una variable contra distintos posibles
resultados, ejecutando para cada caso una serie de instrucciones especificas.
La forma común es la siguiente:

Múltiples (En caso de):
Las estructuras de comparación múltiples, es una toma de decisión

especializada que permiten evaluar una variable con distintos posibles
resultados, ejecutando para cada caso una serie de instrucciones especificas.
La forma es la siguiente:
Veamos algunos ejemplos donde se aplique todo lo anterior:
Realizar un algoritmo en donde se pide la edad del usuario; si es mayor de

edad debe aparecer un mensaje indicándolo. Expresarlo en Pseudocódigo y
Diagrama de flujos.

Se pide leer tres notas del alumno, calcular su definitiva en un rango de 0-5 y
enviar un mensaje donde diga si el alumno aprobó o reprobó el curso. Exprese
el algoritmo usando Pseudocódigo y diagrama de flujos.
Pseudocódigo:
INICIO
Not1, Not2, Not 3 :REAL
Def: REAL
LEA Nota1, Nota2, Nota3
Def ß (Not1 + Not2 + Not3) /3
Si Def < 3 entonces
Escriba “Reprobó el curso”
Sino
Escriba “Aprobó el curso”
Fin-Si
FIN
Diagrama de flujo:
Se desea escribir un algoritmo que pida la altura de una persona, si la altura es
menor o igual a 150 cm envíe el mensaje: “Persona de altura baja”; si la altura
está entre 151 y 170 escriba el mensaje: “Persona de altura media” y si la
altura es mayor al 171 escriba el mensaje: “Persona alta”. Exprese el algoritmo
usando Pseudocódigo y diagrama de flujos.
Pseudocódigo:
INICIO
Altura: ENTERO
ESCRIBA “Cuál es tu altura? ”
LEA Altura
Si Altura <=150 entonces
ESCRIBA “persona de altura baja”
Sino
Si Altura <=170 entonces
ESCRIBA “persona de altura media”
Sino
Si Altura>170 ENTONCES
ESCRIBA “persona alta”
Fin-Si
Fin-Si
Fin-Si
FIN
¡Es importante ser ordenado en el código que se escribe!
Diagrama de flujo:
Dado un numero entre 1 y 7 escriba su correspondiente día de la semana así:

1- Lunes 2- Martes 3- Miércoles 4- Jueves 5- Viernes 6- Sábado 7- Domingo
Exprese el algoritmo usando Pseudocódigo y diagrama de flujos.
Pseudocódigo: Pseudocódigo:
INICIO
Dia: ENTERO
ESCRIBA “Diga un número para escribir su día”
LEA Dia
En-caso-de Dia haga
Caso 1: ESCRIBA “Lunes”
Caso 2: ESCRIBA “Martes”
Caso 3: ESCRIBA “Miércoles”
Caso 4: ESCRIBA “Jueves”
Caso 5: ESCRIBA “Viernes”
Caso 6: ESCRIBA “Sábado”
Caso 7: ESCRIBA “Domingo”
SINO: ESCRIBA “Escribió un numero fuera del rango 1-7”
Fin-Caso
FIN
Diagrama de flujo:
Teoría y Ejemplos Estructura Condicional Simple

Las estructuras condicionales comparan una variable contra
otro(s) valor(es), paraque con base al resultado de esta
comparación, se siga un curso de acción dentrodel
programa. Cabe mencionar que la comparación se puede
hacer contra otravariable o contra una constante, según se
necesite. Existen dos tipos básicos, lassimples y las
múltiples.
Simples:
Las estructuras condicionales simples se les conoce como
“Tomasde decisión”. Estas tomas de decisión ti
enen la siguiente forma:
Si (la condición se cumple) entoncesRealizar Acción(es) o

Instrucción(es)Fin-si
Ejemplo 1
Algoritmo en donde se pide la edad del usuario; si es mayor
de edad debe aparecerun mensaje indicándolo.
Expresado en Pseudocódigo
Entero edad Inicio
Escriba “
¿Cuál es tu edad?
”
Lea edad
Si edad >= 18 entonces
Escriba “Eres mayor de edad”
Fin si
Fin
Expresado en Diagrama de flujos

.
Dobles o compuestas:
Las estructuras condicionales dobles permiten elegirentre
dos opciones o alternativas posibles en función del
cumplimiento o node una determinada condición. Se
representa de la siguiente forma:
Si (la condición se cumple) entoncesRealizar Acción(es) o

Instrucción(es)SinoRealizar otra instrucción(es)Fin-si
Ejemplo 2
:Construir un algoritmo tal, que dado como dato la
calificación de un alumno en unexamen, escriba "Aprobado"
en caso que esa calificación fuese mayor que 8.Un alumno
aprueba si la calificación es mayor que 8Salidas: mensaje
de aprobado si se cumple la condición.Entradas: calificación
Ejemplo en seudocódigo:
Variables:Cal = calificaciónAlgoritmo:InicioLeer (cal)Si cal >
8 entoncesEscribir ("aprobado")Fin siFin
Ejemplo en LPP:
Real calCadena [25] nombreInicio

Escriba “Ingresar el nombre”
Lea nombre
Escriba “Ingresar la
calificación
”
Lea cal
Si cal > 8 entonces
Escriba “Alumno aprobado ”, nombre
Sino
Escriba “No aprobado! ” ,nombre
Fin si
Fin
Ejemplo 3
Ingresar el nombre de un empleado, las horas trabajadas,
luego Calcular pagobruto (50 lps la hora) IHSS y total a
pagar, presentar los resultado del programa
Nota
el seguro social es 84 si el sueldo es mayor 2400 sino es el
3.5% del sueldodel empleado.
Entero horasReal Pbruto,ihss,tpCadena [25]

nombreInicio
Escriba “Ingresar el nombre”
Lea nombre
Escriba “Ingresar las horas trabajadas”
Lea horasPbruto
_
horas*50
Si pbruto > 2400 entoncesIhss
_
84SinoIhss
_
0.035*pbrutoFin si
Tp
_
pbruto-ihss
Escriba “Pago bruto ” , pbruto
Llamar Nueva_lineaEscrib
a “Seguro Social ” , ihss
Llamar Nueva_linea
Escriba “Total a pagar ” , tp
Llamar Nueva_lineaFin
En este algoritmo se usó en el cálculo del ihss una decisión

que tiene dos salidas,una cuando se cumple la condición
que es el entonces y la otra cuando no secumple la
condición que es el sino , ahora esto nos ayuda a
que nuestros
1. Que pida un número del 1 al 5 y diga si es primo o no.

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int i;
printf("Introduzca número del 1 al 5:");
scanf("%d",&i);
if (i!=4) {
printf("Es primo.");
}
else
{
printf("No es primo.");
}
system("PAUSE");
return 0;
}
2. Que pida un número y diga si es par o impar.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int i;
printf("Introduzca número:");
scanf("%d",&i);
if (i%2==0) {
printf("Es par.");
}
else
{
printf("Es impar.");
}
system("PAUSE");
return 0;
}
3. Que pida un número del 1 al 7 y diga el día de la semana

correspondiente.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int i;
scanf("%d",&i);
switch(i){
case 1:
printf ("Lunes\n");
break;
case 2:
printf ("Martes\n");
break;
case 3:
printf ("Miércoles\n");
break;
case 4:
printf ("Jueves\n");
break;
case 5:
printf ("Viernes\n");
break;
case 6:
printf ("Sábado\n");
break;
case 7:
printf ("Domingo\n");
break;
default:
printf ("Opción no válida\n");
break;
}
system("PAUSE");
return 0;
}
4. Que pida un número del 1 al 12 y diga el nombre del mes

correspondiente.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int i;
scanf("%d",&i);
switch(i){
case 1:
printf ("Enero\n");
break;
case 2:
printf ("Febrero\n");
break;
case 3:
printf ("Marzo\n");
break;
case 4:
printf ("Abril\n");
break;
case 5:
printf ("Mayo\n");
break;
case 6:
printf ("Junio\n");
break;
case 7:
printf ("Julio\n");
break;
case 8:
printf ("Agosto\n");
break;
case 9:
printf ("Septiembre\n");
break;
case 10:
printf ("Octubre\n");
break;
case 11:
printf ("Noviembre\n");
break;
case 12:
printf ("Diciembre\n");
break;
default:
printf ("Opción no válida\n");
break;
}
system("PAUSE");
return 0;
}
5. Que pida 3 números y los muestre en pantalla de menor a mayor.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1,num2,num3;
printf("Introduzca número 1:");

scanf("%d",&num1);

scanf("%d",&num2);

scanf("%d",&num3);
if (num1<num2 && num1<num3)

{
if (num2<num3)
{
printf("%d",num1);
printf("%d",num2);
printf("%d",num3);
}
else
{
printf("%d",num1);
printf("%d",num3);
printf("%d",num2);
}
}
else if (num2<num1 && num2<num3)
{
if (num1<num3)
{
printf("%d",num2);
printf("%d",num1);
printf("%d",num3);
}
else
{
printf("%d",num2);
printf("%d",num3);
printf("%d",num1);
}
}
else if (num3<num1 && num3<num2)
{
if (num1<num2)
{
printf("%d",num3);
printf("%d",num1);
printf("%d",num2);
}
else
{
printf("%d",num3);
printf("%d",num2);
printf("%d",num1);
}
}
system("PAUSE");
return 0;
}
6. Que pida 3 números y los muestre en pantalla de mayor a menor.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1,num2,num3;

scanf("%d",&num1);

scanf("%d",&num2);

scanf("%d",&num3);
if (num1>num2 && num1>num3)

{
if (num2>num3)
{
printf("%d",num1);
printf("%d",num2);
printf("%d",num3);
}
else
{
printf("%d",num1);
printf("%d",num3);
printf("%d",num2);
}
}
else if (num2>num1 && num2>num3)
{
if (num1>num3)
{
printf("%d",num2);
printf("%d",num1);
printf("%d",num3);
}
else
{
printf("%d",num2);
printf("%d",num3);
printf("%d",num1);
}
}
{
if (num1>num2)
{
printf("%d",num3);
printf("%d",num1);
printf("%d",num2);
}
else
{
printf("%d",num3);
printf("%d",num2);
printf("%d",num1);
}
}
system("PAUSE");
return 0;
}
7. Que pida 3 números y los muestre en pantalla de mayor a menor en

líneas distintas. En caso de haber números iguales se pintan en la misma
línea.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1,num2,num3;

scanf("%d",&num1);

scanf("%d",&num2);

scanf("%d",&num3);
if (num1>num2 && num1>num3)

{
if (num2>num3)
{
printf("%d\n",num1);
}
else if (num3>num2)
{
}
else
{
printf("%d",num3);
}
}
{
if (num1>num3)
{
}
else if (num3>num1)
{
}
else
{
printf("%d",num3);
}
}
{
if (num1>num2)
{
}
else if (num2>num1)
{
}
else
{
printf("%d",num2);
}
}
else
{
printf("%d",num1);
printf("%d",num2);
printf("%d",num3);
}
system("PAUSE");
return 0;
}
8. Que pida un número y diga si es positivo o negativo.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1;

scanf("%d",&num1);
if (num1>0){
printf("Es positivo\n");
}
else if (num1<0){
printf("Es negativo\n");
}
else
{
printf("Es cero\n");
}
system("PAUSE");
return 0;
}
9. Que sólo permita introducir los caracteres S y N.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char c;
printf("Introduzca un carácter:");
scanf("%c",&c);
if (c=='s' || c=='n' ){
printf("Es correcto\n");
}
else
{
printf("Es incorrecto\n");
}
system("PAUSE");
return 0;
}
10. Que pida un número y diga si es mayor de 100.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1;
printf("Introduzca un número:");
scanf("%d",&num1);
if (num1>100){
printf("Es mayor\n");
}
else
{
printf("Es menor\n");
}
system("PAUSE");
return 0;
}
11. Que pida una letra y detecte si es una vocal.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char c;
printf("Introduzca un carácter:");
scanf("%c",&c);
switch (c)
{
case 'a':
printf ("Es vocal\n");
break;
case 'e':
break;
case 'i':
break;
case 'o':
break;
case 'u':
break;
default:
printf ("No es vocal\n");
break;
}
system("PAUSE");
return 0;
}
12. Que pida tres números y detecte si se han introducido en orden

creciente.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1,num2,num3;

scanf("%d",&num1);

scanf("%d",&num2);

scanf("%d",&num3);
if (num1<num2)
{
if (num2<num3)
{
printf("Orden creciente");
}
else
{
printf("No están introducidos en orden creciente ");
}
}
else
{
printf("No están introducidos en orden creciente ");
}
system("PAUSE");
return 0;
}
13. Que pida tres números y detecte si se han introducido en orden

decreciente.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1,num2,num3;

scanf("%d",&num1);

scanf("%d",&num2);

scanf("%d",&num3);
if (num1>num2)
{
if (num2>num3)
{
printf("Orden decreciente");
}
else
{
printf("No están introducidos en orden decreciente ");
}
}
else
{
printf("No están introducidos en orden decreciente ");
}
system("PAUSE");
return 0;
}
14. Que pida 10 números y diga cuál es el mayor y cual el menor.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int
num1,num2,num3,num4,num5,num6,num7,num8,num9,num10,mayor,menor;
mayor=0;
menor=10;

scanf("%d",&num1);
if (num1>mayor)
{
mayor=num1;
}
else if (num1<menor)
{
menor=num1;
}

scanf("%d",&num2);
if (num2>mayor)
{
mayor=num2;
}
{
menor=num2;
}

scanf("%d",&num3);
if (num3>mayor)
{
mayor=num3;
}
{
menor=num3;
}

scanf("%d",&num4);
if (num4>mayor)
{
mayor=num4;
}
{
menor=num4;
}

scanf("%d",&num5);
if (num5>mayor)
{
mayor=num5;
}
{
menor=num5;
}

scanf("%d",&num6);
if (num6>mayor)
{
mayor=num6;
}
{
menor=num6;
}

scanf("%d",&num7);
if (num7>mayor)
{
mayor=num7;
}
{
menor=num7;
}

scanf("%d",&num8);
if (num8>mayor)
{
mayor=num8;
}
{
menor=num8;
}

scanf("%d",&num9);
if (num9>mayor)
{
mayor=num9;
}
{
menor=num9;
}

scanf("%d",&num10);
if (num10>mayor)
{
mayor=num10;
}
{
menor=num10;
}
printf("El mayor es:%d\n",mayor);
printf("El menor es:%d\n",menor);
system("PAUSE");
return 0;
}
15. Que pida tres números e indicar si el tercero es igual a la suma del
primero y el segundo.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1,num2,num3;

scanf("%d",&num1);

scanf("%d",&num2);

scanf("%d",&num3);
if (num1+num2==num3)
{
printf("El tercer número es la suma de los dos primeros.\n");
}
else
{
printf("El tercer número NO es la suma de los dos primeros.\n");
}
system("PAUSE");
return 0;
}
16. Que muestre un menú que contemple las opciones “Archivo”, “Buscar”
y “Salir”, en caso de que no se introduzca una opción correcta se
notificará por pantalla.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int opcion;
printf("Seleccione opción:\n");
printf("1 - Archivo\n");
printf("2 - Buscar\n");
printf("3 - Salir\n");
scanf("%d",&opcion);
if (opcion!=1 && opcion!=2 && opcion!=3)

{
printf("La opción NO es correcta.\n");
}
else
{
printf("La opción es correcta.\n");
}
system("PAUSE");
return 0;
}
17. Que tome dos números del 1 al 5 y diga si ambos son primos.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1,num2;
scanf("%d",&num1);

scanf("%d",&num2);
if (num1!=4 && num2!=4) {

printf("Ambos son primos.\n");
}
else
{
printf("Los números, o uno de ellos, no son primos.\n");
}
system("PAUSE");
return 0;
}
18. Que tome dos números y diga si ambos son pares o impares.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1,num2;
printf("Introduzca primer número:");
scanf("%d",&num1);
printf("Introduzca segundo número:");

scanf("%d",&num2);
if (num1%2==0 && num2%2==0) {

printf("Ambos son pares.\n");
}
else
{
printf("Los números, o uno de ellos, no son pares.\n");
}
system("PAUSE");
return 0;
}
19. Que tome tres números y diga si la multiplicación de los dos primeros es
igual al tercero.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1,num2,num3;

scanf("%d",&num1);

scanf("%d",&num2);

scanf("%d",&num3);
if (num1*num2==num3)
{
printf("El tercer número es la multiplicación de los dos primeros.\n");
}
else
{
printf("El tercer número NO es la multiplicación de los dos primeros.\
n");
}
system("PAUSE");
return 0;
}
20. Que tome tres números y diga si el tercero es el resto de la división de

los dos primeros.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num1,num2,num3;

scanf("%d",&num1);

scanf("%d",&num2);

scanf("%d",&num3);
if (num1%num2==num3)
{
printf("El tercer número es el resto de la división de los dos primeros.\n");
}
else
{
printf("El tercer número NO es el resto de la división de los dos primeros.\
n");
}
system("PAUSE");
return 0;
}
21. Que muestre un menú donde las opciones sean “Equilátero”, “Isósceles”
y “Escaleno”, pida una opción y calcule el perímetro del triángulo
seleccionado.
Sirva de aclaración que el perímetro de un triángulo es siempre la suma de sus

lados, pero he preferido hacerlo así para ver las tres formas diferentes de
calcularlo.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int lado, base, opcion;
printf("Introduzca lado del triángulo:");

scanf("%d",&lado);
printf("Introduzca base del triángulo:");
scanf("%d",&base);
printf("1 - Equilátero\n");
printf("2 - Isósceles\n");
printf("3 - Escaleno\n");
switch (opcion)
{
case 1:
printf("El perímetro es:%d\n",3*lado);
break;
case 2:
printf("El perímetro es:%d\n",(2*lado)+base);
break;
case 3:
printf("El perímetro es:%d\n",lado + lado + lado);
break;
default:
printf("Opción no válida.");
break;
}
system("PAUSE");
return 0;
}
22. Que pase de Kg a otra unidad de medida de masa, mostrar en pantalla un

menú con las opciones posibles.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int peso;
printf("Introduzca peso en kilogramos:");

scanf("%d",&peso);
printf("1 - Hectogramos\n");
printf("2 - Decagramos\n");
printf("3 - Gramos\n");
printf("4 - Decigramos\n");
printf("5 - Centigramos\n");
printf("6 - Miligramos\n");
switch (opcion)
{
case 1:
printf("El peso es:%d\n",peso/10);
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
default:
printf("Opción no válida.");
break;
}
system("PAUSE");
return 0;
}
23. Que lea un importe bruto y calcule su importe neto, si es mayor de

15.000 se le aplicará un 16% de impuestos, en caso contrario se le
aplicará un 10%.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
float importe, deduccion;
printf("Introduzca Importe:");
scanf("%f",&importe);
if (importe>15000)
{
deduccion=importe*0.16;
}
else
{
deduccion=importe*0.1;
}
printf("El importe neto es %f euros\n",importe-deduccion);
system("PAUSE");
return 0;
}
24. Que lea una hora en hora:minutos:segundos y diga la hora que es un

segundo después.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int horas, minutos, segundos;
printf("Introduzca Hora:");
scanf("%d",&horas);
printf("Introduzca Minutos:");
scanf("%d",&minutos);
printf("Introduzca Segundos:");
scanf("%d",&segundos);
segundos=segundos+1;
if (minutos>59)
{
minutos=0;
}
if (horas>23)
{
horas=0;
}
if (segundos>59)
{
segundos=0;
minutos=minutos+1;
if (minutos>59)
{
minutos=0;
horas=horas+1;
if (horas>23)
{
horas=0;
}
}
}
printf("La hora (un segundo después) es: %02d:%02d:%02d \n", horas,

minutos, segundos);
system("PAUSE");
return 0;
}
25. Que calcule el sueldo que le corresponde al trabajador de una empresa

que cobra 40.000 euros anuales, el programa debe realizar los cálculos en
función de los siguientes criterios:
a. Si lleva más de 10 años en la empresa se le aplica un aumento del 10%.

b. Si lleva menos de 10 años pero más que 5 se le aplica un aumento del 7%.
c. Si lleva menos de 5 años pero más que 3 se le aplica un aumento del 5%.
d. Si lleva menos de 3 años se le aplica un aumento del 3%.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
float importe, aumento;
int antiguedad;
importe=40000;
printf("Introduzca la antigüedad del trabajador:");

scanf("%d",&antiguedad);
if (antiguedad>=10)
{
aumento=importe*0.1;
}
else if (antiguedad<10 && antiguedad>=5)
{
}
else if (antiguedad<5 && antiguedad>=3)
{
}
else
{
}
printf("El sueldo que le corresponde al trabajador es de %f euros\

n",importe+aumento);
system("PAUSE");
return 0;
}
* Las estructuras condicionales nos permiten ejecutar una serie

de instrucciones si cumple una determinada condición que nosotros le
indiquemos. Es importante recordar que la condición debe dar un
resultado booleano, por lo que lo mas normal es usar
operadores relacionales y condicionales.
Tenemos varios tipos de estructuras condicionales:
 if: le indicamos una condición si esta es verdadera se ejecuta, sino no

se ejecuta las instrucciones de dentro. Se suele traducir como “Si se
cumple esta condición haz esto”. Su sintaxis es:
1 if (condición){
2 instrucciones
3 }
Por ejemplo:
1
public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int precio=300;
6
7 if (precio>100){
8 System.out.println("El precio es mayor que 100");
}
9
}
10
11 }
12
Donde colocamos la condición, podemos colocar una variable booleana, ya
que su valor puede ser true o false.
if – else: es como el anterior solo que después de cerrarse la llave de if,
se añade else sin indicarle ninguna condición. Esto sirve para que si
la condicióndel if no es verdadera, ejecute otras instrucciones que
estarán dentro de else. Se suele traducir como “Si se cumple
esta condición haz esto y sino haz esto”.
Veamos un ejemplo:
1
2 public class PruebaApp {
3
5
6 int precio=50;
7
8 if (precio>100){
System.out.println("El precio es mayor que 100");
9 }else{
10 System.out.println("El precio es menor que 100");
11 }
12 }
13
}
14
En este caso, se ejecutara lo que hay en else ya que no cumple la condición.
if -elseif: esta estructura es como una mezcla de los anteriores, esto nos

permite, que si no se cumple la condición podamos indicar
otra condición para hacerlo aún mas especifico. Se suele traducir
como “Si se cumple esta condición haz esto y sino si cumple
esta condición haz esto”.
Veamos un ejemplo:
1
3
5
int precio=50;
6
7 if (precio>100){
9 }else if(precio>80){
}else{
11
System.out.println("El precio es menor que 80");
12 }
13 }
14 }
15
El ejemplo anterior es equivalente al siguiente, esto es lo que se conoce
como if anidados, podemos anidar tantos como queramos:

2
public static void main(String[] args) {
3
4
int precio=50;
5
6 if (precio>100){
8 }else {
9 if(precio>80){
10
12 }else{
System.out.println("El precio es menor que 80");
13 }
14 }
15 }
16 }
17
 Switch: esta estructura condicional de selección múltiple, le damos un
valor (puede ser una variable) y una lista de casos y si cumple alguno de
los casos ejecuta las instrucciones asociadas a ella, en caso de que
ninguna sea podemos indicarle que hace por defecto, normalmente se
usa para indicar de un error con un mensaje. Su sintaxis es:
1
2 switch (valor){
3 case caso1:
Instrucciones
4 break;
5 case caso2:
6 Instrucciones
7 break;
8 case caso N:
Instrucciones
9 break;
10 default:
11 Instrucciones
12 }
13
Veamos un ejemplo:

2
3
4
String dia="Lunes";
5
6 switch (dia){
7 case "Lunes":
8 System.out.println("Hoy es "+dia);
9 break;
case "Martes":
11 break;
12 case "Miercoles":
14 break;
case "Jueves":
16 break;
17 case "Viernes":
break;
19 case "Sabado":
21 break;
22 case "Domingo":
System.out.println("Hoy es "+dia);
23 break;
24 default:
25 System.out.println("No has introducido un dia correcto");
26 }
}
27
}
28
Como vemos en el caso anterior, como los valores son String debemos poner
dobles comillas a los casos. En caso de que sean números, se pondrán como
tal, también podríamos usar constantes.
Una cosa más, si haya varios casos que tienen ejecuta las mismas
instrucciones, podemos agruparlas. Veamos un ejemplo:
1
2
import javax.swing.JOptionPane;
4
6
7 String dia=JOptionPane.showInputDialog("Introduce un dia de la semana");
8
9 switch(dia){
10 case "lunes":
case "martes":
11 case "miercoles":
12 case "jueves":
13 case "viernes":
14 System.out.println("Es un dia laboral");
break;
15
case "sabado":
16 case "domingo":
17 System.out.println("Es un dia festivo");
18 default:
19 System.out.println("Introduce un dia de la semana");
}
20 }
21 }
22
23
CONDICIONALES EN JAVA
1. Ingrese un número entero y encuentre el dígito mayor y el dígito
menor.
SOLUCIÓN:
import java.util.Scanner;
public class MAYORMENOR {
Scanner b=new Scanner(System.in);
int n, mayor=0, menor=10, digito;

System.out.println("Ingrese el numero a evaluar: ");
n=b.nextInt();
while(n>0){
digito=n%10;
n=n/10;
if(digito>=mayor){
mayor=digito;
}
if(digito<menor){
menor=digito;
}
}
System.out.println("El digito mayor es: "+mayor);
System.out.println("El digito menor es: "+menor);
}
}
2. En una tienda se ha establecido la siguiente oferta: por compras menores

a 50 soles se hace un descuento de 8%, pero para compras a partir de 50
el descuento es de 10%. Se pide ingresar la cantidad y el precio del
producto que se compra y determinar cuanto se descontará y cuanto se
cobrará.
SOLUCIÓN:
public class EJERCICIO3 {
Scanner consola=new Scanner(System.in);
double cantidad, precio,pago, descuento;

System.out.println("ingresar cantidad: ");
cantidad=consola.nextInt();
System.out.println("ingrese el precio: ");
precio=consola.nextInt();
pago=cantidad*precio;
if(pago<50){
descuento=pago*0.08;
pago=pago-descuento;
System.out.println("el descuento es: "+descuento+" , el pago a realizar es:
"+pago);
}
else{
descuento=pago*0.1;
pago=pago-descuento;
System.out.println("el descuento es: "+descuento+" , el pago a realizar
es: "+pago);
}
}
}
Al gen que resuelva este ejercicio
Una compañía de seguros para autos ofrece dos tipos de póliza: cobertura
amplia (A) y daños a terceros (B). Para el plan A, la cuota
base es de S/. 1,200, y para el B, de S/. 950. A ambos planes se les carga
10% del costo si la persona que conduce tiene por hábito beber alcohol, 5% si
utiliza lentes, 5% si padece alguna enfermedad –como deficiencia cardiaca o
diabetes–, y si tiene más de 40 años, se le carga
20%, de lo contrario sólo 10%. Todos estos cargos se realizan sobre
el costo base. Realice diagrama de flujo que represente el algoritmo para
determinar cuánto le cuesta a una persona
contratar una póliza.
Responder
int n, mayor=0, menor=10, digito;

System.out.println("Ingrese el numero a evaluar: ");
n=b.nextInt();
while(n>0){
digito=n%10;
n=n/10;
if(digito>=mayor){
mayor=digito;
}
if(digito<menor){
menor=digito;
}
}
System.out.println("El digito mayor es: "+mayor);
System.out.println("El digito menor es: "+menor);
}
}
TUTORIAL DE T U TO R I A L E S 3 J AVA :
ESTRUCTURAS CONDICIONALES Y
EXCEPCIONES
¡Bienvenidos a un nuevo tutorial de Java! Como ya dije en el Tutorial 2 Java:
Estructuras secuenciales, hoy vamos a aprender cómo funcionan las
estructuras condicionales y las excepciones.
Una estructura condicional hace que el programa ejecute una acción u

otra en función de ciertas variables, ciertas condiciones, que
programaremos nosotros. Por otro lado, una excepción es una situación
que puede provocar un fallo en el programa. Java lanza una excepción en
respuesta a una situación poco usual, aunque el programador puede lanzar
también sus propias excepciones. Ahora veremos cómo.
Para realizar el tutorial y que todo quede bien claro, voy a resolver un pequeño
problema, que tratará de hacer un programa que indique si un número
introducido por el usuario es par o impar. Esto lo sabremos calculando el
resto de una división entre dos. Si el resultado es cero, será par, si no, impar.
¡Vamos a comenzar!
Como siempre, lo primero que vamos a hacer es crear un nuevo proyecto,

al cual vamos a llamar Parimpar.
A continuación, vamos a empezar a programar. Como en el tutorial

anterior, primero crearemos un objeto de la clase Scanner, tras haber
importado previamente esta clase:
Scanner reader=new Scanner(System.in); int numero, resto; Lo siguiente

que haremos es pedirle al usuario que introduzca un número entero, para poder, así,
calcular su resto: System.out.print("Introduzca un número entero: ");
numero=reader.nextInt(); resto=numero%2;
Como podemos observar, calculamos el resto con '%', obteniendo así la

variable que condicionará si es par o impar. Si el resto es cero, será par. Si
es distinto de cero, impar. Esto lo vamos a programar con un if - else. Con el
if vemos si se cumple una condición y, si no se cumple, se ejecutará lo que hay
dentro del else. El código es el siguiente:
if(resto==0){ System.out.println("El número "+numero+" es

par."); } else { System.out.println("El número "+numero+" es
impar."); }
Se produce una excepción, la cual no nos deja ejecutar el programa. Para ello,
utilizaremos un try - catch, aunque también podríamos utilizar try - catch - finally. La
única diferencia entre ellos es que en el segundo, se ejecutará siempre el código que
se encuentre en el finally. Lo programaremos como mostraré a continuación. Es muy
sencillo. try{ numero=reader.nextInt(); resto=numero%2; if(resto==0)
{ System.out.println("El número "+numero+" es par."); } else
{ System.out.println("El número "+numero+" es impar."); } } catch
(Exception exception){ System.out.println("Por favor, introduzca un
número entero. Gracias."); } El código completo: package parimpar; import
java.util.Scanner; /** * * @author Mario * Tutorial 3: Estructuras
condicionales y excepciones * */ public class Parimpar { public static
void main(String[] args) { Scanner reader=new Scanner(System.in); int
numero, resto; System.out.print("Introduzca un número entero: "); try{
numero=reader.nextInt(); resto=numero%2; if(resto==0)
{ System.out.println("El número "+numero+" es par."); } else
{ System.out.println("El número "+numero+" es impar."); } } catch
(Exception exception){ System.out.println("Por favor, introduzca un
número entero. Gracias."); } } }
Estructuras repetitivas (while, do-
while, for)
3.2. Estructuras repetitivas
Hemos visto cómo comprobar condiciones, pero no cómo hacer que una
cierta parte de un programa se repita un cierto número de veces o
mientras se cumpla una condición (lo que llamaremos un “bucle”). En C
tenemos varias formas de conseguirlo.
3.2.1. while
Si queremos hacer que una sección de nuestro programa se repita
mientras se cumpla una cierta condición, usaremos la orden “while”. Esta
orden tiene dos formatos distintos, según comprobemos la condición al
principio o al final.
En el primer caso, su sintaxis es
while (condición)
sentencia;
Es decir, la sentencia se repetirá mientras la condición sea cierta. Si la

condición es falsa ya desde un principio, la sentencia no se ejecuta
nunca. Si queremos que se repita más de una sentencia, basta
agruparlas entre { y }. Como ocurria con "if", puede ser recomendable
incluir siempre las llaves, aunque sea una única sentencia, para evitar
errores posteriores difíciles de localizar.
Un ejemplo que nos diga si cada número que tecleemos es positivo o

negativo, y que pare cuando tecleemos el número 0, podría ser:
/*---------------------------*/
/* Ejemplo en C nº 26: */
/* C026.C */
/* */
/* La orden "while" */
/* */
/* Curso de C, */
/* Nacho Cabanes */
/*---------------------------*/
#include <stdio.h>
int main()
{
int numero;
printf("Teclea un número (0 para salir): ");

scanf("%d", &numero);
while (numero!=0)
{
if (numero > 0) printf("Es positivo\n");
else printf("Es negativo\n");
printf("Teclea otro número (0 para salir): ");
scanf("%d", &numero);
}
return 0;
}
En este ejemplo, si se introduce 0 la primera vez, la condición es falsa y

ni siquiera se entra al bloque del “while”, terminando el programa
inmediatamente.
Nota: si recordamos que una condición falsa se evalúa como el valor 0 y

una condición verdadera como una valor distinto de cero, veremos que
ese “while (numero != 0)” se podría abreviar como “while (numero)”.
Ejercicios propuestos:
 Crear un programa que pida al usuario su contraseña (numérica).

Deberá terminar cuando introduzca como contraseña el número
4567, pero volvérsela a pedir tantas veces como sea necesario.
 Crea un programa que escriba en pantalla los números del 1 al 10,
usando ?while?.
 Crea un programa que escriba en pantalla los números pares del
26 al 10 (descendiendo), usando ?while?.
 Crear un programa calcule cuantas cifras tiene un número entero
positivo (pista: se puede hacer dividiendo varias veces entre 10).
3.2.2. do ... while

Este es el otro formato que puede tener la orden “while”: la condición se
comprueba al final. El punto en que comienza a repetirse se indica con
la orden “do”, así:
do
sentencia;
while (condición);
Al igual que en el caso anterior, si queremos que se repitan varias

órdenes (es lo habitual), deberemos encerrarlas entre llaves.
Nuevamente, puede ser recomendable incluir siempre las llaves, como
costumbre.
Como ejemplo, vamos a ver cómo sería el típico programa que nos pide
una clave de acceso y nos nos deja entrar hasta que tecleemos la clave
correcta. Eso sí, como todavía no sabemos manejar cadenas de texto, la
clave será un número:
/*---------------------------*/
/* C027.C */
/* */
/* La orden "do..while" */
/* */
/* Curso de C, */
/* Nacho Cabanes */
/*---------------------------*/
#include <stdio.h>
int main()
{
int valida = 711;
int clave;
do
{
printf("Introduzca su clave numérica: ");
scanf("%d", &clave);
if (clave != valida) printf("No válida!\n");
}
while (clave != valida);
printf("Aceptada.\n");
return 0;
}
En este caso, se comprueba la condición al final, de modo que se nos

preguntará la clave al menos una vez. Mientras que la respuesta que
demos no sea la correcta, se nos vuelve a preguntar. Finalmente, cuando
tecleamos la clave correcta, el ordenador escribe “Aceptada” y termina el
programa.
 Crear un programa que pida números positivos al usuario, y vaya

calculando la suma de todos ellos (terminará cuando se teclea un
número negativo o cero).
 Crea un programa que escriba en pantalla los números del 1 al 10,
usando "do..while".
 Crea un programa que escriba en pantalla los números pares del
26 al 10 (descendiendo), usando "do..while".
 Crea un programa que pida al usuario su código de usuario (un
número entero) y su contraseña numérica (otro número entero), y
no le permita seguir hasta que introduzca como código 1024 y
como contraseña 4567.
3.2.3. for
Ésta es la orden que usaremos habitualmente para crear partes del
programa que se repitan un cierto número de veces. El formato de “for”
es
for (valorInicial; CondiciónRepetición; Incremento)

Sentencia;
Así, para contar del 1 al 10, tendríamos 1 como valor inicial, <=10 como
condición de repetición, y el incremento sería de 1 en 1. Por tanto, el
programa quedaría:
/*---------------------------*/
/* C028.C */
/* */
/* Uso básico de "for" */
/* */
/* Curso de C, */
/* Nacho Cabanes */
/*---------------------------*/
#include <stdio.h>
int main()
{
int contador;
for (contador=1; contador<=10; contador++)

printf("%d ", contador);
return 0;
}
Recordemos que “contador++” es una forma abreviada de escribir
“contador=contador+1”, de modo que en este ejemplo aumentamos la
variable de uno en uno.
 Crear un programa que muestre los números del 15 al 5,

descendiendo (pista: en cada pasada habrá que descontar 1, por
ejemplo haciendo i--).
 Crear un programa que muestre los primeros ocho números pares
(pista: en cada pasada habrá que aumentar de 2 en 2, o bien
mostrar el doble del valor que hace de contador).
En un “for”, realmente, la parte que hemos llamado “Incremento” no tiene

por qué incrementar la variable, aunque ése es su uso más habitual. Es
simplemente una orden que se ejecuta cuando se termine la “Sentencia”
y antes de volver a comprobar si todavía se cumple la condición de
repetición.
Por eso, si escribimos la siguiente línea:
for (contador=1; contador<=10; )
la variable “contador” no se incrementa nunca, por lo que nunca se

cumplirá la condición de salida: nos quedamos encerrados dando vueltas
dentro de la orden que siga al “for”.
Un caso todavía más exagerado de algo a lo que se entra y de lo que no

se sale sería la siguiente orden:
for ( ; ; )
Los bucles “for” se pueden anidar (incluir uno dentro de otro), de modo
que podríamos escribir las tablas de multiplicar del 1 al 5 con:
/*---------------------------*/
/* C029.C */
/* */
/* "for" anidados */
/* */
/* Curso de C, */
/* Nacho Cabanes */
/*---------------------------*/
#include <stdio.h>
int main()
{
int tabla, numero;
for (tabla=1; tabla<=5; tabla++)

for (numero=1; numero<=10; numero++)
printf("%d por %d es %d\n", tabla, numero, tabla*numero);
return 0;
}
En estos ejemplos que hemos visto, después de “for” había una única
sentencia. Si queremos que se hagan varias cosas, basta definirlas como
un bloque (una sentencia compuesta) encerrándolas entre llaves. Por
ejemplo, si queremos mejorar el ejemplo anterior haciendo que deje una
línea en blanco entre tabla y tabla, sería:
/*---------------------------*/
/* C030.C */
/* */
/* "for" anidados (2) */
/* */
/* Curso de C, */
/* Nacho Cabanes */
/*---------------------------*/
#include <stdio.h>
int main()
{
int tabla, numero;
for (tabla=1; tabla<=5; tabla++)

{
for (numero=1; numero<=10; numero++)
printf("%d por %d es %d\n", tabla, numero, tabla*numero);
printf("\n");
}
return 0;
}
Al igual que ocurría con "if" y con "while", suele ser buena
costumbre incluir siempre las llaves, aunque haya una única orden que
se repita en el "for", para evitar funcionamientos incorrectos si después
hay que añadir más sentencias que deban repetirse y se olvida incluir las
llaves en ese momento.
Para “contar” no necesariamente hay que usar números. Por ejemplo,

podemos contar con letras así:
/*---------------------------*/
/* C031.C */
/* */
/* "for" que usa "char" */
/* */
/* Curso de C, */
/* Nacho Cabanes */
/*---------------------------*/
#include <stdio.h>
int main()
{
char letra;
for (letra='a'; letra<='z'; letra++)

printf("%c", letra);
return 0;
}
En este caso, empezamos en la “a” y terminamos en la “z”, aumentando

de uno en uno.
Si queremos contar de forma decreciente, o de dos en dos, o como nos

interese, basta indicarlo en la condición de finalización del “for” y en la
parte que lo incrementa:
/*---------------------------*/
/* C032.C */
/* */
/* "for" que descuenta */
/* */
/* Curso de C, */
/* Nacho Cabanes */
/*---------------------------*/
#include <stdio.h>
int main()
{
char letra;
for (letra='z'; letra>='a'; letra-=2)

printf("%c", letra);
return 0;
}
ESTRUCTURAS DE CONTROL
REPETITIVAS EN JAVA: FOR, WHILE, DO
WHILE
ESTRUCTURAS DE CONTROL REPETITIVAS O ITERATIVAS

Esta vez vamos a ver cómo se utiliza las estructuras
de control repetitivas en Java (también conocidas
como ciclos o bucles). Como mencionaba en el
tutorial Estructuras de control condicionales vamos a
necesitar de estas estructuras al momento de
programar, y pues bueno este tipo de estructuras de
control se las utiliza cuando necesitamos recorrer un
conjunto de datos, por ejemplo al leer un archivo, al
leer registros de una base de datos, en fin, en todos
los problemas en los que se tenga que hacer
iteraciones, bucles, siempre vamos a necesitar de
estas estructuras.
1. LA ESTRUCTURA DE CONTROL FOR
El ciclo for permite ejecutar un conjunto de

sentencias un número fijo de veces y antes de
saber cómo funciona esta sentencia, primero que
nada vamos a ver la sintaxis.
Nota importante: Este ciclo se lo utiliza cuando
sabemos el número de veces que se debe
ejecutar
for(variable_inicializacion;condicion;incremento)
1
2{
3
//instrucciones
4
}
VAMOS A VER COMO FUNCIONA
Como podemos ver esta sentencia esta compuesta

de 3 partes separadas por ; (punto y coma) la
primera parte llamada inicialización permite controlar
el ciclo, suele ser la variable de tipo entero por lo
general la letra i, pero puede ser cualquier otra letra,
esta variable es declarada e inicializada dentro de la
estructura aunque se la puede hacer desde fuera, la
variable de inicialización indica desde que valor va
empezar el ciclo.
La segunda parte es la condición, la condición
indica cuantas veces se va ejecutar el ciclo y se
evalúa antes de cada iteración, si la condición es
verdadera el ciclo continua, tomar en cuenta que si
se omite esta parte, el ciclo se vuelve infinito.
La tercera parte es el incremento o decremento y le
indica en pasos de cuanto debe incrementarse o
decrementarse la variable de inicialización en cada
iteración, por lo general es de uno en uno, pero todo
dependerá del problema que se quiera resolver,
también puede omitirse esta parte, si se lo hace el
ciclo se vuelve infinito (no siempre).
AHORA UN EJEMPLO
1. Imprimir por consola los números enteros desde

el 2 hasta 20
Este es un problema sencillo que se lo puede
resolver utilizando el ciclo for:
1
package com.ecodeup.ciclos;
2
4 public class TestCiclos {

5
6
for (int i = 2; i < 21; i += 2) {
7
System.out.println("Número: " + i);
8 }
9 }
}
PROCESO
1. La variable i es declarada en inicializada en 2

(también se la puede declarar en inicializar fuera
y omitir esa parte).
2. Seguido de esto el compilador verifica si la
variable i es menor a 21, si es correcto continúa
el ciclo, ejecuta la (s) instrucciones y luego.
3. La variable i se incrementa en 2.
El compilador repite las mismas instrucciones desde
el paso 2 hasta que i toma el valor de 22, la
condición se verifica y como no se cumple, el ciclo
termina.
El ciclo for puede tomar varias sintaxis sin que esto
genere errores de compilación o cambie el resultado
del programa. A continuación se muestra algunas
sintaxis con las que nos podemos encontrar.
Ahora el mismo ejemplo anterior lo adaptamos a
esta sintaxis, como se puede ver la variable de
incremento se omite y se la pone dentro del ciclo,
luego de las instrucciones.
1 package com.ecodeup.ciclos;
2
5 for (int i = 2; i < 21;) {
6 System.out.println("Número: " + i);
7 i += 2;
8 }
9 }
10 }
Nota: En este caso la variable i es visible sólo dentro

del ciclo for, puesto que se la ha declarado e
inicializado dentro del ciclo, si la quisiéramos utilizar
fuera, nos va lanzar un error.
En algunos casos también se presenta con la
siguiente sintaxis, en este caso la variable de inicio
esta fuera del ciclo y la variable de incremento está
después de las instrucciones a ejecutar.
package com.ecodeup.ciclos;
1
2
public class TestCiclos {
3

5
int i = 2;
6
for (; i < 21;) {
7
8 System.out.println("Número: " + i);

9
i += 2;
10
}
11
}
}
En este caso la variable i es visible para todo el
programa puesto que la hemos declarado fuera del
ciclo.
LA ESTRUCTURA DE CONTROL WHILE
Esta estructura es parecida al ciclo for, la diferencia
está en su sintaxis:
1 while (condicion) {
2
//instrucciones
3
}
El ciclo while permite ejecutar n veces un

conjunto de instrucciones siempre y cuando la
condición se cumpla o sea verdadera.
Nota importante: Este ciclo se utiliza cuando no
sabemos el número de veces exacto que se
ejecutará el ciclo.
Si la condición siempre es verdadera o siempre se
cumple este ciclo puede crear un bucle que nunca
termine, por eso hay que tener en cuenta que en
algún momento del ciclo la condición no debe
cumplirse (debe volverse falsa) para que el ciclo
termine, caso contrario el ciclo se vuelve infinito.
VAMOS A VER UN EJEMPLO
1. Ingresar un número por teclado e imprimir por la

consola su decena superior: Ejemplo sin ingreso
el número 5, su decena superior es 10, si
ingreso el 25, su decena superior es 30.
ANÁLISIS DEL PROBLEMA PARA SABER QUE CICLO UTILIZAR
El ejemplo anterior lo podemos resolver también con

un ciclo for, pero como no sabemos cuantas
iteraciones o cuantas veces se repite el ciclo ya que
la decena superior cambiará de acuerdo al número
ingresado, es recomendable utilizar el ciclo while.
A continuación el código.
1 package com.ecodeup.ciclos;
2
3
4

8
int numero;
9
Scanner entrada = new Scanner(System.in);
10
11
System.out.println("Ingrese un número:");
12
13 try {
14
numero = entrada.nextInt();
15
while ((numero % 10) != 0) {
16
17
numero++;
18 }
19 System.out.println("La decena superior es: " +
20 numero);
21 } catch (Exception e) {
System.out.println("Número no válido");
}
}
}
Explicando un poco el ciclo, en la línea 12, se

obtiene el número desde teclado (si deseas un
ejemplo completo de cómo ingresar números desde
teclado puedes ingresar a esta entradaEntrada de
datos en Java utilizando la Clase Scanner), en la
línea 13 empieza el ciclo while, la condición para
que ingrese al ciclo, es que el módulo o resto de
dividir el número entre 10 sea diferente de cero.
El módulo de dividir cualquier número entre 10,
(excepto los múltiplos de 10 por ejemplo 10, 20, 30,
40, etc..) siempre nos dará un valor diferente de cero
y por ende ingresa al ciclo.
Entonces la idea es ir incrementando el número
ingresado hasta que sea múltiplo de 10 y con esto el
módulo de dividir el número entre 10 va ser cero y
por ende ya no va ingresar al bucle.
Con esto el número se habrá incrementado y
sabremos cual es la decena superior de cualquier
número ingresado.
LA ESTRUCTURA DE CONTROL DO WHILE
El ciclo do while también permite ejecutar n número
de veces un conjunto de instrucciones, es muy
parecida a las otras 2 estructuras de control que
hemos visto anteriormente, salvo que este
ciclo siempre se ejecuta por lo menos una
vez, recordemos que en el ciclo for debemos
conocer el número de veces que se va ejecutar las
instrucciones, el ciclo while hay una condición que se
debe cumplir para que se ejecuten las instrucciones,
en cambio en el ciclo do while primero se
ejecutan las instrucciones y luego verifica la
condición y si esta es verdadera el ciclo se repite
hasta verificar de nuevo la condición, para salir
del ciclo la condición se debe volver falsa.
La sintaxis del ciclo do while es la siguiente:
1
do {
2 //instrucciones
3
} while (condicion);
VAMOS A VER UN EJEMPLO
1. Obtener los dígitos de un número ingresado por

teclado, ejemplo 100, tiene 3 dígitos.
Una forma para obtener los dígitos que tiene un
número, realizamos divisiones sucesivas entre 10
hasta que el número se vuelve cero (del resultado de
la división sólo se debe tomar la parte entera), para
obtener el número de dígitos contamos las veces
que se ha dividido. Por ejemplo tenemos el número
345:
El resultado debe ser almacenado en una variable
de tipo entero.
345/10=34
34/10=3
3/10=0
En este caso se ha realizado 3 divisiones por lo que
el número de dígitos es 3.
1 package www.ecodeup.com;
2
public class TestCiclos {
3
4
5
6 int numero = 345;

7 int contador = 0;
8
do {
9
numero /= 10;
10
System.out.println(numero);
11
12 contador++;
13 } while (numero != 0);
14 System.out.println("El número tiene " + contador + "
15 dígitos");
}
}
EJERCICIOS RESUELTOS
1. Diseñe un algoritmo para un cajero automático. El cajero tiene la

particularidad de dar solamente billetes de 500, 200, 100, 50, y 20. Si
el usuario ingresa una cantidad menor a 1500 que desea retirar,
debe arrojarle la cantidad mínima de billetes de cada tipo.
NOTA: No debe dar billetes de 10 soles, POR EJEMPLO, si se le
ingresa un monto de 510, debe arrojarme:
Billetes de 200: 2
Billetes de 50: 1
Billetes de 20: 3
SOLUCIÓN:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class CAJERO2 {
public static void main(String[] args) throws IOException{
BufferedReader consola = new BufferedReader(new

InputStreamReader(System.in));
int monto, i, b1 = 0, b2=0, b3=0, b4=0, b5=0, b500, b200, b100, b50, b20;
do{
System.out.println("Ingrese un monto MENO O IGUAL a 1500: ");
monto=Integer.parseInt(consola.readLine());
}while((monto<=30||monto>1500)||monto%10!=0);
while(monto>=20){
if(monto>=500&&(monto!=510&&monto!=530)){
if(monto>1000){
b1+=(int)monto/500;
monto=monto-b1*500;
else{
if(monto%500!=30&&monto%500!=10){
b1+=(int)monto/500;
monto=monto-b1*500;
if(monto>=200&&(monto%200>=10||monto%200==0)){
if(monto>410){
b2+=(int)monto/200;
monto=monto-b2*200;
else{
if(monto%200!=30&&monto%200!=10){
b2+=(int)monto/200;
monto=monto-b2*200;
if(monto>110){
b3++;
monto=monto-100;
else{
if(monto%100!=30&&monto%100!=10){
b100=(int)monto/100;
b3=b3+b100;
monto=monto-b100*100;
}
if(monto>100){
b4++;
monto=monto-50;
else{
if(monto%50!=30&&monto%50!=10){
b50=(int)monto/50;
b4=b4+b50;
monto=monto-b50*50;
if(monto>=20){
b20=(int)monto/20;
b5=b5+b20;
monto=monto-b20*20;
if(b1>0){
System.out.println("Billetes de 500: "+b1);
if(b2>0){
if(b3>0){
if(b4>0){
if(b5>0){
2. Ingrese un número BINARIO (número compuesto por ceros y unos),

y muestre su equivalente. Pr ejemplo, si ingreso 101101, debe
mostrarme 45 como su equivalente.
SOLUCIÓN:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class EnteroBinario {
public static void main(String[] args) throws IOException{
BufferedReader consola=new BufferedReader(new

InputStreamReader(System.in));
int i, j, k=0, equivalente=0, numero, b=0;
boolean m = false;
String N;
do{
System.out.println("Ingrese el numero entero binario: ");
numero=Integer.parseInt(consola.readLine());
N=Integer.toString(numero);
for(i=0;i<N.length();i++){
if(N.charAt(i)=='0'||N.charAt(i)=='1'){
m=true;
b++;
}while(b<N.length());
j=numero;
while(numero>0){
numero=(int)numero/10;
k++;
for(i=0;i<k;i++){
equivalente+=(j%10)*Math.pow(2,i);
j=(int)j/10;
System.out.println("El equivalente del numero ingresado es: "+equivalente);
3. Un número se considera perfecto cuando la suma de sus divisores

es igual al número, por ejemplo 28, tiene como divisores a 1, 2, 4, 7
y 14. Luego 28 es número perfecto, pues 1+2+4+7+14=28. Hacer un
algoritmo para determinar si un número ingresado por teclado es
perfecto.
SOLUCIÓN:
public class perfecto {

int n, suma=1,i=2;
System.out.println("Ingrese el numero: ");
n=b.nextInt();
while(i<n){
if(n%i==0){
suma=suma+i;
i++;
if(suma==n){
System.out.println("El numero es perfecto");
else{
System.out.println("el numero no es perfecto");
4. La tribuna de un estadio esta numerada del 1 al 500 en la parte

superior horizontal que corresponde al número de asiento por
columna; y del 1 al 50 en la parte izquierda vertical que corresponde
al número de asiento por fila. Los boletos tienen una numeración
correlativa del 1 al 25000. Para cualquier número de boleto
determinar el número de fila y el número de columna que le
correspondería a la ubicación de su asiento.
SOLUCIÓN:
public class Asientoestadio {

Scanner teclado=new Scanner(System.in);
int asiento, fila=0, columna=0;
System.out.println("Ingrese el numero de asiento: ");
asiento=teclado.nextInt();
while(asiento>500){
fila++;
asiento=asiento-500;
fila++;
columna=asiento;
System.out.println("El asiento corresponde a la fila: "+fila+" y a la columna:

"+columna);
5. Diseñe un algoritmo que convierte un número en base 10, a otro

número en base menor que 10. El número en base 10 y la base a la
que se va a convertir se deben ingresar por teclado.
SOLUCIÓN:
public class ConvierteNumeroAbaseMenora10 {
Scanner teclado=new Scanner(System.in);
int base, numero,div=0,i=1;
System.out.println("Ingrese el numero en base 10: ");

numero=teclado.nextInt();
do{
System.out.println("Ingrese la base menor a 10 : ");
base=teclado.nextInt();
}while(base<=1||base>=10);
while(numero>=base){
div=div+(numero%base)*i;
numero=(int)(numero/base);
i=i*10;
div=div+(numero*i);
System.out.println("el numero en base "+base+" es: "+div);

Estructuras Repetitivas Teoria y Ejercicios

Cargado por

Copyright:

Formatos disponibles

Estructuras Repetitivas Teoria y Ejercicios

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Estructuras Repetitivas Teoria y Ejercicios

Cargado por

Copyright:

Formatos disponibles

Explicamos las distintas estructuras poniendo ejemplos

tanto en diagrama de flujo como en pseudocódigo.

ESTRUCTURAS CONDICIONALES SIMPLES:

Las estructuras condicionales simples se les conoce como “Tomas de

Pseudocódigo: Diagrama de flujo:

Las estructuras condicionales dobles permiten elegir entre dos opciones o

Pseudocódigo: Diagrama de flujo:

Las estructuras de comparación múltiples, son tomas de decisión

Pseudocódigo: Diagrama de flujo:

Las estructuras de comparación múltiples, es una toma de decisión

Pseudocódigo: Diagrama de flujo:

Veamos algunos ejemplos donde se aplique todo lo anterior:

Realizar un algoritmo en donde se pide la edad del usuario; si es mayor de

Pseudocódigo: Diagrama de flujo:

Dado un numero entre 1 y 7 escriba su correspondiente día de la semana así:

Teoría y Ejemplos Estructura Condicional Simple

Si (la condición se cumple) entoncesRealizar Acción(es) o

Expresado en Diagrama de flujos

Si (la condición se cumple) entoncesRealizar Acción(es) o

Real calCadena [25] nombreInicio

Entero horasReal Pbruto,ihss,tpCadena [25]

En este algoritmo se usó en el cálculo del ihss una decisión

1. Que pida un número del 1 al 5 y diga si es primo o no.

2. Que pida un número y diga si es par o impar.

3. Que pida un número del 1 al 7 y diga el día de la semana

4. Que pida un número del 1 al 12 y diga el nombre del mes

5. Que pida 3 números y los muestre en pantalla de menor a mayor.

printf("Introduzca número 1:");

printf("Introduzca número 2:");

printf("Introduzca número 3:");

if (num1<num2 && num1<num3)

6. Que pida 3 números y los muestre en pantalla de mayor a menor.

printf("Introduzca número 1:");

printf("Introduzca número 2:");

printf("Introduzca número 3:");

if (num1>num2 && num1>num3)

7. Que pida 3 números y los muestre en pantalla de mayor a menor en

printf("Introduzca número 1:");

printf("Introduzca número 2:");

printf("Introduzca número 3:");

if (num1>num2 && num1>num3)

8. Que pida un número y diga si es positivo o negativo.

printf("Introduzca número 1:");

9. Que sólo permita introducir los caracteres S y N.

10. Que pida un número y diga si es mayor de 100.

12. Que pida tres números y detecte si se han introducido en orden

printf("Introduzca número 1:");

printf("Introduzca número 2:");

printf("Introduzca número 3:");

13. Que pida tres números y detecte si se han introducido en orden

printf("Introduzca número 1:");

printf("Introduzca número 2:");

printf("Introduzca número 3:");

14. Que pida 10 números y diga cuál es el mayor y cual el menor.

printf("Introduzca número 1:");

printf("Introduzca número 2:");

printf("Introduzca número 3:");

printf("Introduzca número 4:");

printf("Introduzca número 5:");