UNIDAD V y VI

Sentencias de control e iteración

UNIDAD V y VI

V.1 Sentencia “IF”

Cuando se realizan operaciones en una computadora conlleva el obtener una diversidad de valores y resultados, que estos deberán de tomar la forma de programas lo más general posible.

Permitiendo que los valores tomen resultados que pueden ser limitados o bien seleccionados de algún rango o dominio posible.

Consideremos el siguiente problema.“En una empresa se le pagará un bono de 5% del sueldo a la persona que trabaje más de 40 horas (hasta un máximo de 2.5 por semana). Se deberá de realizar un programa para calcular el sueldo semanal conforme a la siguiente fórmula:

jadasHorasTrabanivelExtrasbonoXHorasjadasHorasTrabaPagoXhoraSueldo ** jadasHorasTrabanivelExtrasbonoXHorasjadasHorasTrabaPagoXhoraSueldo **

En este caso será necesario tomar alternativas de cálculo.

Por ejemplo, sí el trabajador tiene 41.5 horas habrá que sumar el bono x horas extras. Sí estas fueran 40 o menos, no se deberá sumar el bono.


El lenguaje de programación deberá de permitir determinar en términos de la variable horas_trabajadas, sí se agrega o no el bono con su cálculo.

JAVA posee un sentencia o instrucción que permite elegir una opción, en relación a una “condición lógica”, que establecerá sí esta es verdad o falsa (true or false).

La instrucción tiene la sintaxis siguiente:

if (condición lógica) { bloque de acciones sí condición es verdad } else { bloque de acciones sí condición es falso }

O bien la forma:

if (condición lógica) { bloque de acciones sí condición es verdad }


En un diagrama de flujo se tendrá una forma como la que hemos visto:

ingresar datosde variables

ingresar datosde variables

Resul parc=(pagoXhora+nivel)*

horasTrabajadas

Resul parc=(pagoXhora+nivel)*

horasTrabajadas

Horastrabajas> =40

Horastrabajas> =40

Resul parc+=(horasTrabajadas-40)*bono

Resul parc+=(horasTrabajadas-40)*bono

imprime resultado

Resul parc

imprime resultado

Resul parc

SI

NO

De esta forma el programa será:

import javabook.*;

public class pago01 {

public static void main(String args[]) {

SimpleInput entrada = new SimpleInput();

float pagoXhora=25.00f, bono=0.05f, resultado;

float horasTrabajadas, nivel;

horasTrabajadas=entrada.getFloat("Dé horas del trabajdor ");

nivel=entrada.getFloat("Dé el nivel del trabajdor ");

resultado=(pagoXhora+nivel)*horasTrabajadas;

if (horasTrabajadas>40)

resultado+=(horasTrabajadas-40)*bono;

System.out.println("El resultado es ="+resultado);

}

}

import javabook.*;

public class converter {


SimpleInput disp=new SimpleInput();

int opcion, valor; String res;

System.out.println(" CONVERTIDOR DE ENTERO A: ");

System.out.println(" -------------------------");

System.out.println(" 1) DECIMAL A HEXADECIMAL ");

System.out.println(" 2) DECIMAL A OCTAL ");

System.out.println(" 3) DECIMAL A BINARIO ");

System.out.println(" ------------------------ ");

opcion=disp.getInteger("Escriba su opción: ");

valor=disp.getInteger("Dé el valor a convertir: ");

if (opcion==1) { res=Integer.toHexString(valor);

System.out.println("Número "+valor+" a Hexadecimal "+res); }

if (opcion==2) { res=Integer.toOctalString(valor);

System.out.println("Número "+valor+" a Octal "+res); }

if (opcion==3) { res=Integer.toBinaryString(valor);

System.out.println("Número "+valor+" a Binario "+res); }

}

}

import javabook.*;

public class converter {


SimpleInput disp=new SimpleInput();

int opcion, valor; String res;

System.out.println(" CONVERTIDOR DE ENTERO A: ");

System.out.println(" -------------------------");

System.out.println(" 1) DECIMAL A HEXADECIMAL ");

System.out.println(" 2) DECIMAL A OCTAL ");

System.out.println(" 3) DECIMAL A BINARIO ");

System.out.println(" ------------------------ ");

opcion=disp.getInteger("Escriba su opción: ");

valor=disp.getInteger("Dé el valor a convertir: ");

if (opcion==1) { res=Integer.toHexString(valor);

System.out.println("Número "+valor+" a Hexadecimal "+res); }

if (opcion==2) { res=Integer.toOctalString(valor);

System.out.println("Número "+valor+" a Octal "+res); }

if (opcion==3) { res=Integer.toBinaryString(valor);

System.out.println("Número "+valor+" a Binario "+res); }

}

}


Supongamos que se desea realizar un programa que convierta un entero en su equivalente binario, octal o hexadecimal. Aquí tendríamos una triple opción para decidir que debemos convertir.

Veamos el siguiente programa:

Variables para almacenar opciones y valor a convertir.

Variable para conversión a “String”.

Menú de opciones (3)

Lectura de valor a convertir y su opción de valor final.

Elección de la opción y su presentación en pantalla, así como la conversión a cadena de texto.


Ahora deseamos realizar un programa que resuelva la ecuación cuadrática siguiente:

02 cbxax 02 cbxax

a

acbbx

2

42 a

acbbx

2

42

Que tiene la siguiente solución:

El programa básicamente realizará los cálculos pertinentes, solo que sí el discriminante b2-4ac, es menor de cero se tendrá que obtener la raíz positiva y agregarle una i; que representa la unidad imaginaria.


El diagrama de flujo de esta solución será:

ingresar datosde variables a, b, c

ingresar datosde variables a, b, c

B2-4ac<0?B2-4ac<0? raíces = xRe±xImgiraíces = xRe±xImgiSI

NO

Calcular b2-4ac y calcular parte real e imaginaria

Calcular b2-4ac y calcular parte real e imaginaria

ab

x2

Re

a

acbgx

2

4Im

2

raíces = xRe±xImgraíces = xRe±xImg

FinFin

import javabook.*;

public class cuad_fist {


double a,b,c,xRe,xImg,Di;


a=entrada.getDouble("Número a= ");

b=entrada.getDouble("Número b= ");

c=entrada.getDouble("Número c= ");

Di=b*b-4*a*c;

xRe=-b/2/a;

xImg=Math.sqrt(Math.abs(Di))/2/a;

if (Di<0) {

System.out.println("Raíz 1="+xRe+"+"+xImg+"i");

System.out.println("Raíz 2="+xRe+"-"+xImg+"i");

}

else {

System.out.println("Raíz 1="+(xRe+xImg));

System.out.println("Raíz 2="+(xRe-xImg));

}

}

}

import javabook.*;

public class cuad_fist {


double a,b,c,xRe,xImg,Di;


a=entrada.getDouble("Número a= ");

b=entrada.getDouble("Número b= ");

c=entrada.getDouble("Número c= ");

Di=b*b-4*a*c;

xRe=-b/2/a;

xImg=Math.sqrt(Math.abs(Di))/2/a;

if (Di<0) {

System.out.println("Raíz 1="+xRe+"+"+xImg+"i");

System.out.println("Raíz 2="+xRe+"-"+xImg+"i");

}

else {

System.out.println("Raíz 1="+(xRe+xImg));

System.out.println("Raíz 2="+(xRe-xImg));

}

}

}

Por lo tanto el programa será:


En algunos casos, es necesario proponer diversas opciones o más de una alternativa. Aquí es dónde se pueden escribir de manera sucesiva varios “if’s” o decisiones. Este no es el caso de anidamiento que veremos después.

Un ejemplo simple pero ilustrativo es el elegir una respuesta en el examen de álgebra y decidir cual es la respuesta; una vez que respondimos el programa deberá de informar sobre la opción tomada y retroalimentar sobre el acierto o el error cometido!!.

Consideremos la pregunta sobre la siguiente fracción sucesiva y algunas de sus respuestas, una correcta y 3 equivocadas en sumar numeradores o error al invertir la fracción.

?

11

11

1

x

?

11

11

1

x

La forma general será plantear la pregunta y pedir que se escriba la opción de respuesta. Una vez que se da está, decidimos la opción en la forma general:

if (opción==dato) { hacer esto …..] if (opción==dato) { hacer esto otro con el error …..] if (opción==dato) { hacer esto otro con otro error …..]


El programa será:

public class fraccion { public static void main(String args[]) { char opt=' ';

System.out.println(" Solución de la fracción: "); System.out.println(" "); System.out.println(" 1 "); System.out.println(" -------------------------- = ? "); System.out.println(" 1 "); System.out.println(" 1 + ---------------- "); System.out.println(" 1 "); System.out.println(" 1 + ------- "); System.out.println(" 1 "); System.out.println(" 1 + - "); System.out.println(" x "); System.out.println(" "); System.out.println("Respuestas posibles: "); System.out.println(" x+1 1 2 "); System.out.println(" A) ------ B) -- C) ----- "); System.out.println(" 2x+1 x x+1 "); System.out.println(" "); System.out.println(" x+1 "); System.out.println(" D) -------- E) ninguno de ellos "); System.out.println(" x²+x+1 "); System.out.println(" "); opt=TextIO.getChar(); System.out.println(" ");

public class fraccion { public static void main(String args[]) { char opt=' ';

System.out.println(" Solución de la fracción: "); System.out.println(" "); System.out.println(" 1 "); System.out.println(" -------------------------- = ? "); System.out.println(" 1 "); System.out.println(" 1 + ---------------- "); System.out.println(" 1 "); System.out.println(" 1 + ------- "); System.out.println(" 1 "); System.out.println(" 1 + - "); System.out.println(" x "); System.out.println(" "); System.out.println("Respuestas posibles: "); System.out.println(" x+1 1 2 "); System.out.println(" A) ------ B) -- C) ----- "); System.out.println(" 2x+1 x x+1 "); System.out.println(" "); System.out.println(" x+1 "); System.out.println(" D) -------- E) ninguno de ellos "); System.out.println(" x²+x+1 "); System.out.println(" "); opt=TextIO.getChar(); System.out.println(" ");

if ((opt=='a')|(opt=='A')) System.out.println(" Solución correcta!!! felicidades --");if ((opt=='b')|(opt=='B')) { System.out.println(" Existe un error, el más probable es que ");

System.out.println(" Ud. sumo los numeradores!!!! "); System.out.println(" Se sumaron los numeradores en expresiones"); System.out.println(" como 1 2 "); System.out.println(" 1+ --- = - esto es incorrecto!!! "); System.out.println(" x x "); System.out.println(" Lo correcto será sumar como x + 1 "); System.out.println(" ----- "); System.out.println(" x "); }

if ((opt=='c')|(opt=='C')) { System.out.println(" Existe un error, el más probable es que "); System.out.println(" Ud. sumo los numeradores, de la fracción "); System.out.println(" más interna (más abajo), e invirtió mal "); System.out.println(" los términos de la fracción resultante "); System.out.println(" 1 1 "); System.out.println(" ---------- = ------- Esto es un error!!! "); System.out.println(" 1 x "); System.out.println(" 1 + ---- 1 + --- "); System.out.println(" x 2 "); }

if ((opt=='a')|(opt=='A')) System.out.println(" Solución correcta!!! felicidades --");if ((opt=='b')|(opt=='B')) { System.out.println(" Existe un error, el más probable es que ");

System.out.println(" Ud. sumo los numeradores!!!! "); System.out.println(" Se sumaron los numeradores en expresiones"); System.out.println(" como 1 2 "); System.out.println(" 1+ --- = - esto es incorrecto!!! "); System.out.println(" x x "); System.out.println(" Lo correcto será sumar como x + 1 "); System.out.println(" ----- "); System.out.println(" x "); }

if ((opt=='c')|(opt=='C')) { System.out.println(" Existe un error, el más probable es que "); System.out.println(" Ud. sumo los numeradores, de la fracción "); System.out.println(" más interna (más abajo), e invirtió mal "); System.out.println(" los términos de la fracción resultante "); System.out.println(" 1 1 "); System.out.println(" ---------- = ------- Esto es un error!!! "); System.out.println(" 1 x "); System.out.println(" 1 + ---- 1 + --- "); System.out.println(" x 2 "); }

if ((opt=='d')|(opt=='D')) { System.out.println(" Existe un error, el más probable es que "); System.out.println(" Ud. sumo correctamente la primer fracción"); System.out.println(" Pero resolvió mal el resultado de la otra"); System.out.println(" 1 1 "); System.out.println(" 1 + ----- = x + ----- "); System.out.println(" x+1 x+1 "); System.out.println(" --- "); System.out.println(" x Lo correcto sería "); System.out.println(" "); System.out.println(" 1 x 2x+1 "); System.out.println(" 1 + ----- = 1+ --- = ----- "); System.out.println(" x+1 x+1 x+1 "); System.out.println(" --- "); System.out.println(" x "); }

if ((opt=='e')|(opt=='E')) System.out.println("Existe un grave ERROR mejor estudie de nuevo el tema!!");

}}

if ((opt=='d')|(opt=='D')) { System.out.println(" Existe un error, el más probable es que "); System.out.println(" Ud. sumo correctamente la primer fracción"); System.out.println(" Pero resolvió mal el resultado de la otra"); System.out.println(" 1 1 "); System.out.println(" 1 + ----- = x + ----- "); System.out.println(" x+1 x+1 "); System.out.println(" --- "); System.out.println(" x Lo correcto sería "); System.out.println(" "); System.out.println(" 1 x 2x+1 "); System.out.println(" 1 + ----- = 1+ --- = ----- "); System.out.println(" x+1 x+1 x+1 "); System.out.println(" --- "); System.out.println(" x "); }

if ((opt=='e')|(opt=='E')) System.out.println("Existe un grave ERROR mejor estudie de nuevo el tema!!");

}}


Consideremos ahora el problema de elegir varias opciones o tener que formular condiciones más complejas.

En este ejemplo es el pago del sueldo semanal de un empleado, de acuerdo a su salario normal de 40 horas y su nivel (1+%nivel). De tal forma que sí trabaja menos de 40 se calcula en 97% del total. Mientras que sí trabaja más de 40, pero menos de 45, se la calculan sobre el doble. Sí es mayor de 45 el sueldo es 50.00 mayor por hora. Al final se descuentan el porcentaje de impuesto.

import javabook.*;public class anidados { public static void main(String args[]){ double nvl_01=0.07, nvl_02=0.11, nvl_03=0.18; int nvl; double horas,monto,pag=150.0; SimpleInput disp = new SimpleInput(); System.out.println("Cálculo de pago semanal -----"); horas=disp.getDouble(" Escriba horas trabajadas x Semana= "); nvl=disp.getInteger(" Dé el nivel del trabajador= "); monto=0.0;

if (nvl==1) monto=horas*(1.0+nvl_01)*pag; if (nvl==2) monto=horas*(1.0+nvl_02)*pag; if (nvl==3) monto=horas*(1.0+nvl_03)*pag; TextIO.putln("Pago de "+((int)horas)+" = "+Format.rightAlign(10,2,monto)); if (horas>=40) { monto=monto+(horas-40)*300.0; TextIO.putln("Pago por "+((int) (horas-40))+" Extras (acumulado)"+Format.rightAlign(10,2,monto)); if (horas>45) { monto=(horas-45)*350.0+monto; TextIO.putln("Pago por "+(horas-45)+" por encima de 45 Extras (acumulado)" +Format.rightAlign(10,2,monto)); } } else { monto*=0.97;} monto*=0.83; System.out.println("El pago final con desc. es "+Format.rightAlign(10,2,monto)); }}


Nota sobre la “anidación” de sentencias “IF”.

Sí se tiene la siguiente secuencia de sentencias:

If (a>b) { acciones; acciones; If (c>b) { hacer tal y tal } }

Esto será igual a la siguiente combinación:

If (a>b) { acciones; acciones; }If ((a>b)&(c>b)) { hacer tal y tal }

Por lo que la anidación deberá de evitarse cuanto más se pueda o reemplazarla por opciones más claras.

A continuación veremos una variación de esta anidación en un sentencia que conjunta diversos valores para seleccionar y se denomina “switch”.

V.2 Sentencia “Switch”

Una forma de conseguir eficientar los “IF’s” consecutivos por las diversas opciones que presenta un problema, es una sentencia de ejecución denominada “switch” que permite dada una variable de un tipo entero o similar (char, byte, etc.) clasificar sus opciones y realizar una o más acciones dependiendo de los valores posibles.

La sintaxis es como sigue: switch (expresión) { case (expresión):

{ bloque para este expresión } case (expresión):

{ bloque para este expresión } case (expresión):

{ bloque para este expresión }

case (expresión):{ bloque para este expresión }

default:{ bloque para este expresión }

}


Un ejemplo sencillo sería:

Nuestro ejemplo, se escribirá (suponiendo una variable g de control, del tipo char), lo siguiente:

swicth (g){ case ‘a’: { pago = pago*.095; break;} case ‘b’: { pago = pago*1.005; break;} case ‘c’: { pago = pago*1.02; break;} case ‘d’: { pago = pago*1.035; break;} case ‘e’: { pago = pago*1.07; break;}}System.out.println(“Su pago “+pago);

El comando break ayudará a terminar la selección de cada concepto de cobro, en este caso.

A continuación veamos un caso del uso de la instrucción “break”, que de hecho deberá de acompañar a la instrucción “switch” para facilitar su comprensión y ejecución.


Veamos un ejemplo usando la sentencia “switch” y el complemento de “break” o su falta del mismo: Import javabook.*;

public class ejemswicth {

public static void main(String args[ ]){

int t;

SimpleInput teclado=new SimpleInput();

t=teclado.getInteger(“Escriba un número “);

switch (t){

case 1: System.out.println("Ahora "); break;

case 2: System.out.println(" es ");

case 3: System.out.println("el");

System.out.println(" momento para que todos los hombres\n");break;

case 5:

case 6: System.out.println("hagan ");break;

case 7:

case 8:

case 9: System.out.print(".");

} // switch

} // main

} // class

Su ejecución será:

Sí t=0 resulta ►►

Sí t=1 resulta ►►Ahora

Sí t=2 resulta ►►Ahora es el momento para .......

Sí t=2 resulta ►►Ahora es el momento para .......

Sí t=3 resulta ►►el momento para .......

Sí t=3 resulta ►►el momento para .......

Sí t=5 ó 6 resulta ►►hagan

Sí t=5 ó 6 resulta ►►hagan

Sí t=7, 8 ó 9 resulta ►►.

Sí t=7, 8 ó 9 resulta ►►.

El caso de t=4 es idéntico a t=0El caso de t=4 es idéntico a t=0

La ejecución tomando la serie de valores: 1,2,3,4,5,6,7,8,9 seráAhora es el momento para que todos los hombres

el momento para que todos los hombres

hagan hagan ...

La ejecución tomando la serie de valores: 1,2,3,4,5,6,7,8,9 seráAhora es el momento para que todos los hombres

el momento para que todos los hombres

hagan hagan ...


Usando la sentencia “switch” podemos reescribir el programa de conversión octal, binario y hexadecimal como:

import javabook.*; public class converter { public static void main(String args[]) { SimpleInput disp=new SimpleInput(); int opcion, valor; String res; System.out.println(" CONVERTIDOR DE ENTERO A: "); System.out.println(" -------------------------"); System.out.println(" 1) DECIMAL A HEXADECIMAL "); System.out.println(" 2) DECIMAL A OCTAL "); System.out.println(" 3) DECIMAL A BINARIO "); System.out.println(" ------------------------ "); opcion=disp.getInteger("Escriba su opción: "); valor=disp.getInteger("Dé el valor a convertir: "); swicth (opcion) { case 1: res=Integer.toHexString(valor); System.out.println("Número "+valor+" a Hexadecimal "+res); break; case 2: res=Integer.toOctalString(valor); System.out.println("Número "+valor+" a Octal "+res); break; case 3: res=Integer.toBinaryString(valor); System.out.println("Número "+valor+" a Binario "+res); break; } // switch } // main } //classs

import javabook.*; public class converter { public static void main(String args[]) { SimpleInput disp=new SimpleInput(); int opcion, valor; String res; System.out.println(" CONVERTIDOR DE ENTERO A: "); System.out.println(" -------------------------"); System.out.println(" 1) DECIMAL A HEXADECIMAL "); System.out.println(" 2) DECIMAL A OCTAL "); System.out.println(" 3) DECIMAL A BINARIO "); System.out.println(" ------------------------ "); opcion=disp.getInteger("Escriba su opción: "); valor=disp.getInteger("Dé el valor a convertir: "); swicth (opcion) { case 1: res=Integer.toHexString(valor); System.out.println("Número "+valor+" a Hexadecimal "+res); break; case 2: res=Integer.toOctalString(valor); System.out.println("Número "+valor+" a Octal "+res); break; case 3: res=Integer.toBinaryString(valor); System.out.println("Número "+valor+" a Binario "+res); break; } // switch } // main } //classs

V.3 Sentencia “While”Ahora vamos a revisar una sentencia que puede alterar el flujo de ejecución de instrucciones, esta se denomina “while” y es una sentencia que ejecuta un “bucle”, lazo o ciclo de sentencias mientras se cumple una condición.

La sintaxis de esta será: while (cond) { acción; acción; etc …. }

En diagrama de flujo se representa como:acción i

Cond?

acción i+1

acciones

si

no

import javabook.*;

public class ler_while {



int a,b;

String h="si";

while (h.charAt(0)!='n') {

a=entrada.getInteger("Dé el número a= ");

b=entrada.getInteger("Dé el número b= ");

System.out.println("Suma de a y b "+(a+b));

h=entrada.getString("Desea otra suma? ");

} //while

}//main

}

import javabook.*;

public class ler_while {



int a,b;

String h="si";

while (h.charAt(0)!='n') {

a=entrada.getInteger("Dé el número a= ");

b=entrada.getInteger("Dé el número b= ");

System.out.println("Suma de a y b "+(a+b));

h=entrada.getString("Desea otra suma? ");

} //while

}//main

}

V.3 Sentencia “While”Imaginemos que deseamos obtener los números primos de los primeros 100 enteros. Usando la “criba de Eratóstenes “ podemos obtenerlos.

El método se basa en tener una tabla de los primeros 100 números:

El número 1 es la unidad, así que el primer primo es 2!!. Con este número eliminamos todos los múltiplos de 2 hasta el final.

1 2 3 4 5 6 7 8 9 10

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

11 12 13 14 15 16 17 18 19 20

1 2 3 4 5 6 7 8 9 10

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

11 12 13 14 15 16 17 18 19 20

V.3 Sentencia “While”Una vez hecho esto, seleccionamos le siguiente número, en este caso 3 y lo nombramos primo.

Ahora eliminamos todos los múltiplos de 3 de la tabla:

1 2 3 4 5 6 7 8 9 10

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

11 12 13 14 15 16 17 18 19 201 2 3 4 5 6 7 8 9 10

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

11 12 13 14 15 16 17 18 19 20

El siguiente número, cuadro vacío, se salta y continuamos con el siguiente; 5 en este caso.

El proceso continuará hasta un cierto número que permita revisar todos los múltiplos, este número podría ser 50 ó menor.

V.3 Sentencia “While”Para elabora un programa requerimos de 2 cosas, un algoritmo más indicativo y 100 variables que se puedan referir de forma simple.

Nos adelantamos un poco a un tema de “arrays” o vectores y definiremos las 100 variables de forma vectorial o arreglo.

Un arreglo es una variable que refiere a N variables indexadas de forma tal que:

tabla representa el nombre de la zona de memoria y tabla[i] representa una variable del tipo especificado en la posición i

Podemos decir que la definición de “Integer tabla[100]”, representa a 100 variables del tipo entero y que se almacenan de forma consecutiva.

En JAVA la definición se hace de la forma siguiente: int tabla[]= new int[100];

Con esto obtenemos el equivalente a lo siguiente: int tabla01, tabla02, …., tabla100;Solo que la referencia será indexada con los paréntesis []

V.3 Sentencia “While”Consideremos ahora el algoritmo:

Definamos 100 variables indexadasLlenemos estas con los 100 primeros números enteros.Definir 2 como el primer PRIMOPara los primeros 50 enteros posibles: revisar sí no hay ceros en la posición nueva a checar verificar las posiciones del PRIMO actual +1

sí son divisibles llenar con cero incrementar la posición al siguiente PRIMOImprimir la tabla en los números diferentes de cero.

busca siguiente

Definir tabla

cuenta<=100? Llena tabla[cuenta]

Índice<50? tabla[índice]=0?

Elige nuevo primo, incrementa índice

Índice<=99

Incrementa índice

tabla mod primo=0? tabla =0

cuenta<=100 Imprime tabla

fin

Del presente algoritmo se desprende el programa de la hoja siguiente!!!

V.3 Sentencia “While”Usando la “criba de Eratóstenes “ podemos obtenerlos, con el programa:

public class primos100 { public static void main(String [ ] arg) { int tabla[]=new int [100]; int i,j,checar; // llenado de la tabla con los 100 primeros enteros i=0; while (i<100) tabla[i]=++i; i=1; while (i<50) { while (tabla[i]==0) i++; checar=tabla[i]; j=++i; while (j<=99) { if (tabla[j]%checar==0) tabla[j]=0; j++; } // while checa primo i++; } //2° while

public class primos100 { public static void main(String [ ] arg) { int tabla[]=new int [100]; int i,j,checar; // llenado de la tabla con los 100 primeros enteros i=0; while (i<100) tabla[i]=++i; i=1; while (i<50) { while (tabla[i]==0) i++; checar=tabla[i]; j=++i; while (j<=99) { if (tabla[j]%checar==0) tabla[j]=0; j++; } // while checa primo i++; } //2° while

j=0; while (j<=99) { if (tabla[j]!=0) System.out.print(tabla[j]+","); j++; }// último while System.out.println(" FIN!"); } // main}

j=0; while (j<=99) { if (tabla[j]!=0) System.out.print(tabla[j]+","); j++; }// último while System.out.println(" FIN!"); } // main}

----jGRASP exec: java primos100

1,2,3,5,7,9,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97, FIN!

----jGRASP: operation complete.

Salida del programa

V.3 Sentencia “While”Recordemos ahora un problema que realizamos en un capítulo anterior:

En medio de una enorme plantación se eleva la casa del propietario, de manera que puede ver cada punto de su propiedad desde los cuatro ventanales situados en las laterales de la mansión. Desde cada ventana puede observar exactamente 3 cuadrillas de trabajadores, que a su vez constan de 3 trabajadores cada una; es decir, puede ver de una sola mirada a 9 trabajadores.

Cierto día contrata 2 trabajadores más. El propietario desea continuar observando a todos los trabajadores desde la ventana; esto es, 9 trabajadores a la vez. Dispuestos en 3 cuadrillas de trabajo.

¿Podrá conseguirlo? ¿será única la solución?

V.3 Sentencia “While”

n m pp n mm p n

1 1 71 2 61 3 51 4 41 5 31 6 21 7 12 1 62 2 52 3 42 4 32 5 22 6 13 1 53 2 43 3 33 4 23 5 14 1 44 2 34 3 24 4 1

1 1 71 2 61 3 51 4 41 5 31 6 21 7 12 1 62 2 52 3 42 4 32 5 22 6 13 1 53 2 43 3 33 4 23 5 14 1 44 2 34 3 24 4 1

Consideremos el algoritmo que hicimos, consiste en encontrar una trena de números que se acomode como sigue:

Que la suma sea para n+m+p=9 y la suma total 2n+3m+3p=26,Haciendo las mismas opciones que la tabla de la derecha:

Podemos observar que solo requerimos de iniciar con un índice n=1 hasta 4 y de aquí calcular m desde 1 hasta que m+n=8.

Una vez hecho esto p deberá de cumplir que p=9-(m+n), por lo que definidos n y m, p es un cálculo directo.

Solo necesitamos checar que la suma total sea 2n+3m+3p=26


A continuación se muestra el programa y algunos resultados:

public class acomodo_3x3 {

public static void main(String[] arg){

int n,m,p;

n=1;

while (n<=4) {

m=1;

while ((m+n)<=8){

p=9-(m+n);

if ((2*n+3*m+3*p)==26){

System.out.println("-------------");

System.out.println("| "+n+" | "+m+" | "+p+" |");

System.out.println("| "+p+" | | "+m+" |");

System.out.println("| "+m+" | "+p+" | "+n+" |");

System.out.println("-------------");

} //if

m++;

} // 2° while

n++;

}//ler while

} // main

}

----jGRASP exec: java acomodo_3x3

------------------

| 1 | 1 | 7 |

| 7 | | 1 |

| 1 | 7 | 1 |

------------------

------------------

| 1 | 2 | 6 |

| 6 | | 2 |

| 2 | 6 | 1 |

------------------


¿Cuántos números de tres cifras existen, tal que la suma de las 2 primeras cifras dé como resultado la tercera?

public class trescifras {

public static void main(String args []){

int x,y,z, cuenta=0;

x=0;

while (x<=9) {

y=0;

while (y<=9) {

z=x+y;

if ((z<=9)&(x!=0)) {

System.out.print(x+""+y+""+z+", ");

cuenta++;

if (cuenta%10==0) System.out.println();

}

y++;

}

x++;

}// while x

System.out.println("\ncuántos "+cuenta);

} // main

} // class

Consideremos que el número se escribe como XYZ, donde Z=X+Y.

Pero X no puede ser cero, ya que tendríamos un número de 2 cifras.

Hagamos un programa que ponga los números del 0 al 9 en X e Y. con Z igual a la suma de estos. Solicitando que solo se impriman aquellos en los que Z es menor o igual a 9!!

Los contamos y listo!!

V.4 Sentencia “Do-While”

Ahora veamos la sentencia “do … while”, la cual es similar al ciclo anterior “while …”.

La diferencia más importante es que el “while” puede no realizar el conjunto de acciones, dependiendo de sí la condición es verdad o no. Y el ciclo “do …while” lo realiza al menos UNA VEZ.

acción i

Cond?

acción i+1

acciones

si

no

El diagrama de flujo visualiza la ejecución de este ciclo, y se puede observar que las acciones dentro de este ciclo; son ejecutadas al menos una vez. Independientemente de sí la condición será verdad o no.

Así los programas típicos de menús de opciones serán indicados con esta clase de ciclos, como es el caso de la conversión de decimal a hexadecimal, octal y binaria.

Programa que se muestra a continuación:


import javabook.*; public class converter { public static void main(String args[]) { SimpleInput disp=new SimpleInput(); int opcion=0, valor; String res; do { System.out.println(" CONVERTIDOR DE ENTERO A: "); System.out.println(" -------------------------"); System.out.println(" 1) DECIMAL A HEXADECIMAL "); System.out.println(" 2) DECIMAL A OCTAL "); System.out.println(" 3) DECIMAL A BINARIO "); System.out.println(" 4) SALIR "); System.out.println(" ------------------------ "); opcion=disp.getInteger("Escriba su opción: "); switch (opcion) { case 1: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toHexString(valor); System.out.println("Número "+valor+" a Hexadecimal "+res); break; case 2: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toOctalString(valor); System.out.println("Número "+valor+" a Octal "+res); break; case 3: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toBinaryString(valor); System.out.println("Número "+valor+" a Binario "+res); break; } // switch } while (opcion!=4); } // main } //class

import javabook.*; public class converter { public static void main(String args[]) { SimpleInput disp=new SimpleInput(); int opcion=0, valor; String res; do { System.out.println(" CONVERTIDOR DE ENTERO A: "); System.out.println(" -------------------------"); System.out.println(" 1) DECIMAL A HEXADECIMAL "); System.out.println(" 2) DECIMAL A OCTAL "); System.out.println(" 3) DECIMAL A BINARIO "); System.out.println(" 4) SALIR "); System.out.println(" ------------------------ "); opcion=disp.getInteger("Escriba su opción: "); switch (opcion) { case 1: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toHexString(valor); System.out.println("Número "+valor+" a Hexadecimal "+res); break; case 2: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toOctalString(valor); System.out.println("Número "+valor+" a Octal "+res); break; case 3: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toBinaryString(valor); System.out.println("Número "+valor+" a Binario "+res); break; } // switch } while (opcion!=4); } // main } //class

Inicio del ciclo do

Final del ciclo y prueba de condición, de ser verdad se continuará con el ciclo!!!


Propongamos ahora un problema en donde la computadora genera un número al azar de entre 1 y 1024. Nosotros debemos de adivinar en el menor número de intentos posible. La máquina nos informará de rango entre que valores estará nuestra adivinanza.

En una primera parte el programa informará del juego y definirá las variables a usar: límite inferior (lo), límite superior (hi), número a buscar (seek), número generado (num), una variable booleana para saber sí acertamos o no; y una variable que cuenta los intentos.

Por lo demás es un ciclo que se repetirá en tanto no acertemos, y las condiciones de nuestra adivinanzas y la retroinformación de la máquina.

En una primera parte el programa informará del juego y definirá las variables a usar: límite inferior (lo), límite superior (hi), número a buscar (seek), número generado (num), una variable booleana para saber sí acertamos o no; y una variable que cuenta los intentos.

Por lo demás es un ciclo que se repetirá en tanto no acertemos, y las condiciones de nuestra adivinanzas y la retroinformación de la máquina.

public class busqueda { public static void main(String args [ ]){ int lo=1,hi=1024,seek, veces=0; boolean found=false; int num; num=(int)(Math.random()*1024); System.out.println(num); System.out.println("La computadora generó un número al azar"); System.out.println("entre 1 y 1024, adivínelo!!!"); do { System.out.print("intente un número entre "+lo+" y "+hi+": "); seek=TextIO.getInt(); veces++; if (seek<num) lo=seek; if (seek>num) hi=seek; if (seek==num) found=true; } while (!found); System.out.println("lo encontró en "+veces+"!!"); }//main }//class


Pensemos en nuevo programa, digamos que se desea identificar una línea de texto en un archivo, de tal forma que podamos verificar desde la aparición de una frase o palabras código; hasta verificar mensajes.

Primero necesitamos una versión de un programa que leerá un archivo de texto y lo podrá enviar, a la pantalla o revisar por líneas (String) que a su vez revisemos su contenido.

import java.io.*;class LeeFichero { public static void main(String [] arg) {

File archivo = new File ("peter.txt");try {

String linea;FileReader fr = new FileReader (archivo);BufferedReader br = new BufferedReader(fr);while((linea=br.readLine())!=null)

System.out.println(linea);fr.close();

}catch(IOException e){System.out.println(e);}

}}




System.out.println(linea);fr.close();


}}

El programa define una variable de archivo (File archivo). Posteriormente define un String línea, variable que contendrá la lectura de cada línea de texto del archivo en disco.

En la línea FileReader fr abrimos el archivo para lectura (try) y de no existir (catch), se encarga de manejar el error.

La variable BufferedReader br leerá los bytes que componen la linea deseada, esto se hará hasta alcanzar el fin de archivo: “while ((linea=br.readLine())!=null”, esta línea SOLO se imprime en pantalla.


El programa que requerimos es ahora una parte del anterior, de hecho modificaremos este para agregar las sentencias necesarias.

En la parte del programa que lee la línea de texto del archivo, nos concentraremos a analizar cada carácter. Una vez que tenemos un primer carácter que coincida con el primero de la frase a buscar; entonces procederemos a identificar la frase completa. De no ser así regresaremos al carácter i+1 (uno delante de inicial encontrado). Y procedemos al mismo proceso.




fr.close();


}}




fr.close();


}}

Proceso de identificación

Declaración de nuevas variables

String archivo_a_leer, frase_buscar; int i,j; int contar=0;

Declaración de lectura de archivo a leer ysolicitar la frase a buscar

System.out.print("nombre del archivo ");archivo_a_leer=TextIO.getlnString();System.out.print("frase a buscar del texto ");frase_buscar=TextIO.getlnString();

Agregamos la variable checar, que es la que contendrá la frase a comparar con la buscada


import java.io.*;class LeeFichero { public static void main(String [] arg) { String archivo_a_leer, frase_buscar; int i,j; int contar=0; System.out.print("nombre del archivo "); archivo_a_leer=TextIO.getlnString(); System.out.print("frase a buscar del texto "); frase_buscar=TextIO.getlnString(); File archivo = new File ("peter.txt");

try { String linea,checar; FileReader fr = new FileReader (archivo); BufferedReader br = new BufferedReader(fr); while((linea=br.readLine())!=null) { System.out.println(linea);

i=0; if (linea.length()!=0) do { } while (i<linea.length()); } // while null

fr.close();}catch(IOException e){System.out.println(e);}

} // main}

import java.io.*;class LeeFichero { public static void main(String [] arg) { String archivo_a_leer, frase_buscar; int i,j; int contar=0; System.out.print("nombre del archivo "); archivo_a_leer=TextIO.getlnString(); System.out.print("frase a buscar del texto "); frase_buscar=TextIO.getlnString(); File archivo = new File ("peter.txt");

try { String linea,checar; FileReader fr = new FileReader (archivo); BufferedReader br = new BufferedReader(fr); while((linea=br.readLine())!=null) { System.out.println(linea);

i=0; if (linea.length()!=0) do { } while (i<linea.length()); } // while null

fr.close();}catch(IOException e){System.out.println(e);}

} // main}

Ahora agregamos algunos de las etapas necesarias para el análisis de la línea de texto leída.

Una es la impresión de la línea a analizar, y otra es la verificación de que sea una línea NO vacía.

A continuación realizaremos el análisis de la línea hasta antes de su valor de longitud total. Recordemos que los “strings” se inician en cero hasta la longitud-1.


do { j=0;checar=""; if (frase_buscar.charAt(j)==linea.charAt(i)) { while((i<linea.length())&(j<frase_buscar.length())){ checar=checar+linea.charAt(i); j++;i++; }//while checar if (frase_buscar.equals(checar)) contar++; else i=i-j+1; i--; } //if i++;}while (i<linea.length());

Dentro del “do{ … } while ();” iniciaremos la búsqueda de la frase que tenemos. Una vez que encontremos la primer letra agregaremos esta a la cadena checar, al terminar verificamos sí toda la frase es idéntica; de no ser así regresamos a la posición i+1 ( o la siguiente de la letra identificada como inicial).

El programa será (la porción que es la repetición):

Sí la primer letra es igual a frase buscada?

Checa hasta la longitud de línea y el tamaño de frase y extrae.

Confirmar sí son iguales, sí no regresar a i-j+1.


i=0; if (linea.length()!=0) do { j=0;checar=""; if (frase_buscar.charAt(j)==linea.charAt(i)) { while((i<linea.length())&(j<frase_buscar.length())){ checar=checar+linea.charAt(i); j++;i++; }//while checar if (frase_buscar.equals(checar)) contar++; else i=i-j+1; i--; }//if i++; }while (i<linea.length()); }//while línea null fr.close(); } catch(IOException e){System.out.println(e);} System.out.println("\n\n Encontré "+contar); }//main }//class

Juntando todo el programa y agregando la impresión de cuántos encontramos, al final del programa, resulta:

import java.io.*; public class otro_do { public static void main(String args [ ]){ String archivo_a_leer, frase_buscar; int i,j; int contar=0; System.out.print("nombre del archivo "); archivo_a_leer=TextIO.getlnString(); System.out.print("frase a buscar del texto "); frase_buscar=TextIO.getlnString(); File archivo = new File (archivo_a_leer); try { String linea,checar; FileReader fr = new FileReader (archivo); BufferedReader br = new BufferedReader(fr); while((linea=br.readLine())!=null) { System.out.println(linea);

V.4 Sentencia “For”

Existe una sentencia, que se puede usar tanto como “while” que como “do ... while” . Pero que se puede usar como un ciclo de repetición independiente y más versátil.

Este se denomina “for” y tiene la sintaxis siguiente: for (cond. inicial; cond. final; incremento) {acciones;….} acción i

Cond final?

inicializa valor

acción i+1

acciones

si

no

Ejemplo simple imprimir la serie 7,3,14,6,21,9,….

public class lerFor { public static void main(String args[]){ int x; for(x=1; x<100; x++){ System.out.print(x*7+","+x*3+","); if (x%8==0) System.out.println(); } //for } //main}

for (cond. inicial; cond. final; incremento) {acciones;….}

----jGRASP exec: java lerFor

7,3,14,6,21,9,28,12,35,15,42,18,49,21,56,24,

63,27,70,30,77,33,84,36,91,39,98,42,105,45,112,48,

119,51,126,54,133,57,140,60,147,63,154,66,161,69,168,72,

----jGRASP exec: java lerFor

7,3,14,6,21,9,28,12,35,15,42,18,49,21,56,24,

63,27,70,30,77,33,84,36,91,39,98,42,105,45,112,48,

119,51,126,54,133,57,140,60,147,63,154,66,161,69,168,72,

resultado del programa


Consideremos el ejemplo del programa de conversión hexadecimal, octal y binario; ahora, usemos la sentencia “for” para resolver el problema:

import javabook.*; public class converterFOR { public static void main(String args[]) { SimpleInput disp=new SimpleInput(); int opcion=0, valor; String res; for ( ;opcion!=4; ) { System.out.println(" CONVERTIDOR DE ENTERO A: "); System.out.println(" -------------------------"); System.out.println(" 1) DECIMAL A HEXADECIMAL "); System.out.println(" 2) DECIMAL A OCTAL "); System.out.println(" 3) DECIMAL A BINARIO "); System.out.println(" 4) SALIR "); System.out.println(" ------------------------ "); opcion=disp.getInteger("Escriba su opción: "); switch (opcion) { case 1: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toHexString(valor); System.out.println("Número "+valor+" a Hexadecimal "+res); break; case 2: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toOctalString(valor); System.out.println("Número "+valor+" a Octal "+res); break; case 3: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toBinaryString(valor); System.out.println("Número "+valor+" a Binario "+res); break; } // switch } // for } // main } //class

import javabook.*; public class converterFOR { public static void main(String args[]) { SimpleInput disp=new SimpleInput(); int opcion=0, valor; String res; for ( ;opcion!=4; ) { System.out.println(" CONVERTIDOR DE ENTERO A: "); System.out.println(" -------------------------"); System.out.println(" 1) DECIMAL A HEXADECIMAL "); System.out.println(" 2) DECIMAL A OCTAL "); System.out.println(" 3) DECIMAL A BINARIO "); System.out.println(" 4) SALIR "); System.out.println(" ------------------------ "); opcion=disp.getInteger("Escriba su opción: "); switch (opcion) { case 1: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toHexString(valor); System.out.println("Número "+valor+" a Hexadecimal "+res); break; case 2: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toOctalString(valor); System.out.println("Número "+valor+" a Octal "+res); break; case 3: valor=disp.getInteger("Dé el valor a convertir: "); res=Integer.toBinaryString(valor); System.out.println("Número "+valor+" a Binario "+res); break; } // switch } // for } // main } //class

No requerimos de iniciar con un valor, y tampoco requerimos de incremento; solo de la condición de continuar ciclo.


public class trescifrasFOR { public static void main(String args []){ int x,y,z, cuenta=0; for( x=0;x<=9;x++) { for(y=0;y<9; y++){ z=x+y; if ((z<=9)&(x!=0)) { System.out.print(x+""+y+""+z+", "); cuenta++; if (cuenta%10==0) System.out.println(); } } // for y } // for x System.out.println("\ncuántos "+cuenta); } // main} // class

¿Cuántos números de tres cifras existen, tal que la suma de las 2 primeras cifras dé como resultado la tercera?

----jGRASP exec: java trescifrasFOR

101, 112, 123, 134, 145, 156, 167, 178, 189, 202,

213, 224, 235, 246, 257, 268, 279, 303, 314, 325,

336, 347, 358, 369, 404, 415, 426, 437, 448, 459,

505, 516, 527, 538, 549, 606, 617, 628, 639, 707,

718, 729, 808, 819, 909,

cuántos 45


----jGRASP exec: java trescifrasFOR

101, 112, 123, 134, 145, 156, 167, 178, 189, 202,

213, 224, 235, 246, 257, 268, 279, 303, 314, 325,

336, 347, 358, 369, 404, 415, 426, 437, 448, 459,

505, 516, 527, 538, 549, 606, 617, 628, 639, 707,

718, 729, 808, 819, 909,

cuántos 45



Para los casos de construcciones de tablas de valores, la sentencia “for” resulta particularmente útil.

Supongamos que se desea la tabla de los valores de senos, cosenos y tangentes; de los ángulos de 0 a menos de 90, incrementando de 2 en 2.

import javabook.*;

public class trigonomet {

public static void main(String args []) {

int x; double pi=3.1415926535;

System.out.println("_______________________________________________");

System.out.println(" x° . Senx . Cosx . Tanx . ");


for (x=0;x<90;x+=2) {

System.out.println(Format.rightAlign(7,2,x)+"."+

Format.rightAlign(8,3,Math.sin(x*pi/180))+"."+

Format.rightAlign(8,3,Math.cos(x*pi/180))+"."+

Format.rightAlign(8,3,Math.tan(x*pi/180))+".");

} //for


} //main

} //class

UNIDAD V y VI

Documents

Transcript of UNIDAD V y VI