UNIDAD V y VI

1. UNIDAD V y VI Sentencias de control e iteración

2. 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: 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.

3. V.1 Sentencia “IF” 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 }

4. ingresar datos de variables Resul parc= (pagoXhora+nivel)* horasTrabajadas Horastrabajas > =40 SI Resul parc+= (horasTrabajadas-40)*bono NO imprime resultado Resul parc V.1 Sentencia “IF” En un diagrama de flujo se tendrá una forma como la que hemos visto: 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); } }

5. 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. V.1 Sentencia “IF” 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: 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: "); 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); } } }

6. V.1 Sentencia “IF” Ahora deseamos realizar un programa que resuelva la ecuación cuadrática siguiente: 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 unai; que representa la unidad imaginaria.

7. ingresar datos de variables a, b, c Calcular b2-4ac y calcular parte real e imaginaria B2-4ac<0? SI raíces = xRe±xImgi NO raíces = xRe±xImg Fin V.1 Sentencia “IF” El diagrama de flujo de esta solución será: Por lo tanto el programa será: import javabook.*; public class cuad_fist { public static void main(String args[]) { double a,b,c,xRe,xImg,Di; SimpleInput entrada = new SimpleInput(); 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)); } } }

8. V.1 Sentencia “IF” 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. 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 …..]

9. V.1 Sentencia “IF” 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(" "); 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!!"); } }

10. V.1 Sentencia “IF” 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. 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)); } } 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;

11. V.1 Sentencia “IF” 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”.

12. 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 } }

13. V.2 Sentencia “Switch” 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.

14. Sí t=2 resulta ►►Ahora es el momento para ....... Sí t=0 resulta ►► Sí t=5 ó 6 resulta ►►hagan Sí t=1 resulta ►►Ahora Sí t=3 resulta ►►el momento para ....... Sí t=7, 8 ó 9 resulta ►►. El caso de t=4 es idéntico a t=0 V.2 Sentencia “Switch” 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 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 . . . Su ejecución será:

15. V.2 Sentencia “Switch” 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 Usando la sentencia “switch” podemos reescribir el programa de conversión octal, binario y hexadecimal como:

16. acción i Cond? si acciones no acción i+1 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: import javabook.*; public class ler_while { public static void main(String args[]) { SimpleInput entrada = new SimpleInput(); 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 }

17. 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 15 15 16 16 17 17 18 18 19 19 20 20 21 21 22 22 23 23 24 24 25 25 26 26 27 27 28 28 29 29 30 30 31 31 32 32 33 33 34 34 35 35 36 36 37 37 38 38 39 39 40 40 41 41 42 42 43 43 44 44 45 45 46 46 47 47 48 48 49 49 50 50 51 51 52 52 53 53 54 54 55 55 56 56 57 57 58 58 59 59 60 60 61 61 62 62 63 63 64 64 65 65 66 66 67 67 68 68 69 69 70 70 71 71 72 72 73 73 74 74 75 75 76 76 77 77 78 78 79 79 80 80 81 81 82 82 83 83 84 84 85 85 86 86 87 87 88 88 89 89 90 90 91 91 92 92 93 93 94 94 95 95 96 96 97 97 98 98 99 99 100 100 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.

18. 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 15 15 16 16 17 17 18 18 19 19 20 20 21 21 22 22 23 23 24 24 25 25 26 26 27 27 28 28 29 29 30 30 31 31 32 32 33 33 34 34 35 35 36 36 37 37 38 38 39 39 40 40 41 41 42 42 43 43 44 44 45 45 46 46 47 47 48 48 49 49 50 50 51 51 52 52 53 53 54 54 55 55 56 56 57 57 58 58 59 59 60 60 61 61 62 62 63 63 64 64 65 65 66 66 67 67 68 68 69 69 70 70 71 71 72 72 73 73 74 74 75 75 76 76 77 77 78 78 79 79 80 80 81 81 82 82 83 83 84 84 85 85 86 86 87 87 88 88 89 89 90 90 91 91 92 92 93 93 94 94 95 95 96 96 97 97 98 98 99 99 100 100 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: 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.

19. 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 []

20. Definir tabla cuenta<=100? Llena tabla[cuenta] Índice<50? tabla[índice]=0? busca siguiente Elige nuevo primo, incrementa índice Índice<=99 tabla mod primo=0? tabla =0 Incrementa índice cuenta<=100 Imprime tabla fin V.3 Sentencia “While” Consideremos ahora el algoritmo: Definamos 100 variables indexadas Llenemos estas con los 100 primeros números enteros. Definir 2 como el primer PRIMO Para 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 PRIMO Imprimir la tabla en los números diferentes de cero. Del presente algoritmo se desprende el programa de la hoja siguiente!!!

21. ----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” 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 j=0; while (j<=99) { if (tabla[j]!=0) System.out.print(tabla[j]+","); j++; }// último while System.out.println(" FIN!"); } // main }

22. 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?

23. n m p p n m m p n V.3 Sentencia “While” 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

24. V.3 Sentencia “While” 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 } A continuación se muestra el programa y algunos resultados: ----jGRASP exec: java acomodo_3x3 ------------------ | 1 | 1 | 7 | | 7 | | 1 | | 1 | 7 | 1 | ------------------ ------------------ | 1 | 2 | 6 | | 6 | | 2 | | 2 | 6 | 1 | ------------------

25. V.3 Sentencia “While” 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 ¿Cuántos números de tres cifras existen, tal que la suma de las 2 primeras cifras dé como resultado la tercera? 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!!

26. acción i acciones Cond? si no acción i+1 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. 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:

27. Inicio del ciclo do Final del ciclo y prueba de condición, de ser verdad se continuará con el ciclo!!! V.4 Sentencia “Do-While” 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

28. V.4 Sentencia “Do-While” 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. 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

29. V.4 Sentencia “Do-While” 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. 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. 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);} } } 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.

30. 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 y solicitar 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 V.4 Sentencia “Do-While” 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. 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) fr.close(); } catch(IOException e){System.out.println(e);} } } Proceso de identificación

31. 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. V.4 Sentencia “Do-While” 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.

32. 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. V.4 Sentencia “Do-While” 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): 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());

33. V.4 Sentencia “Do-While” 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); 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

34. acción i inicializa valor acciones for (cond. inicial; cond. final; incremento) {acciones;….} Cond final? si no resultado del programa acción i+1 ----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, 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;….} 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 }

35. V.4 Sentencia “For” import javabook.*; public class converterFOR { public static void main(String args[]) { SimpleInput disp=new SimpleInput(); intopcion=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 Consideremos el ejemplo del programa de conversión hexadecimal, octal y binario; ahora, usemos la sentencia “for” para resolver el problema: No requerimos de iniciar con un valor, y tampoco requerimos de incremento; solo de la condición de continuar ciclo.

36. V.4 Sentencia “For” ¿Cuántos números de tres cifras existen, tal que la suma de las 2 primeras cifras dé como resultado la tercera? 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 ----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: operation complete.

37. V.4 Sentencia “For” 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 . "); System.out.println("_______________________________________________"); 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 System.out.println("_______________________________________________"); } //main } //class 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.