JAVA 1.3 Volumen I: Fundamentos
por Carlos Eduardo G´ omez Montoya Juli´ an Esteban Guti´ errez Posada
ii
JAVA 1.3 Volumen I: Fundamentos No est´a permitida la reproducci´on total o parcial de esta obra, ni su tratamiento o transmisi´on por cualquier m´etodo sin autorizaci´on escrita del editor. Car´atula: Luis Eduardo Sep´ ulveda Rodr´ıguez Derechos reservados c Noviembre 2001 ° ISBN: 958 - 33 - 2592 - 9 Este libro fue editado usando LATEX 2ε Impresi´on: POL Editores Calle 32 # 27-56 Armenia, Q. Tel´efono: (6) 740 22 21 Nit: 7.538.895 - 0 E-Mail: pol@telesat.com.co Editor: Juli´an Esteban Guti´errez Posada Apartado A´ereo: 632 Armenia Tel´efono Celular: 491 74 32 E-Mail: jugutier@quimbaya.uniquindio.edu.co Armenia, Quind´ıo - Colombia
Presentaci´ on Java 1.3 Volumen I: Fundamentos es el primer libro de una serie de textos gu´ıa escritos con el fin de facilitar el aprendizaje y la ense˜ nanza de diferentes lenguajes de programaci´on, entre los que se encuentran C++, Php y JavaScript. Volumen I significa que una persona que no tenga conocimiento alguno sobre programaci´on de computadoras puede iniciar con este libro, aunque puede servir a aquellas personas que tienen conocimientos de programaci´on en otros lenguajes. El libro cuenta con m´as de 50 ejemplos programados de una forma muy sencilla de entender lo que permitir´a que el usuario aprenda en forma paulatina. Adem´as, contamos con un poco m´as de 100 problemas para poner a prueba los conocimientos adquiridos. Este libro es diferente a la mayor´ıa de los libros existentes sobre Java, debido a que no supone que el lector tiene avanzados conocimientos sobre programaci´on. Simplemente, con este libro se da tiempo para analizar los diferentes conceptos al igual que las estructuras de control de uso com´ un en cualquier lenguaje de programaci´on. El conjunto de programas de muestra y propuestos como ejercicios est´an organizados en forma progresiva, aumentando el nivel de dificultad para lograr los resultados al final del curso. Por otra parte, se espera que los usuarios aprendan a utilizar una metodolog´ıa de programaci´on basada en m´etodos y reutilizaci´on de c´odigo que facilitar´a la comprensi´on de los programas y ser´a fundamental en la elaboraci´on de programas orientados a objetos, el principal de los temas que ser´an tratados en el Volumen II. iii
iv
´ PRESENTACION
´Indice general Presentaci´ on
I
III
Algoritmos
1
1. Introducci´ on
3
1.1. Algoritmos de la vida diaria . . . . . . . . . . . . . . . . . . . Ama de casa.
3
. . . . . . . . . . . . . . . . . . . . . .
4
. . . . . . . . . . . . . . . . . .
5
. . . . . . . . . . . . . . . . .
5
. . . . . . . . . . . . . . . . . . .
6
1.2. Agrupaci´on de actividades . . . . . . . . . . . . . . . . . . . .
7
1.3. Decisiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
1.4. Repeticiones . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
Empleado de oficina. Profesor Universitario. Cajero autom´atico.
2. Conceptos b´ asicos
9
2.1. Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.2. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . 10 2.3. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.4. Funciones - M´etodos . . . . . . . . . . . . . . . . . . . . . . . 14 2.5. Expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.5.1. Expresiones aritm´eticas . . . . . . . . . . . . . . . . . . 15 v
´INDICE GENERAL
vi
2.5.2. Expresiones l´ogicas . . . . . . . . . . . . . . . . . . . . 15 2.5.3. Expresiones de asignaci´on . . . . . . . . . . . . . . . . 17 2.6. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Prueba de escritorio 1.
. . . . . . . . . . . . . . . . . 23
Prueba de escritorio 2.
. . . . . . . . . . . . . . . . . 23
3. Programaci´ on en seudoc´ odigo
25
Estructura de un programa.
. . . . . . . . . . . . . . 26
3.1. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 1: Radianes.
. . . . . . . . . . . . . . . . . . . . . . . 27
2: Pendiente de recta.
. . . . . . . . . . . . . . . . . . 28
3: Hallar el mayor de tres enteros. 4: Operaci´on aritm´etica. 5: Producto con sumas. 6: M´ınimo Com´ un M´ ultiplo. 7: Potencia con sumas.
II
Java
4. Conceptos b´ asicos
. . . . . . . . . . . 29
. . . . . . . . . . . . . . . . 31 . . . . . . . . . . . . . . . . . 32 . . . . . . . . . . . . . . 33 . . . . . . . . . . . . . . . . . 34
35 37
4.1. Historia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 4.2. Qu´e es Java? . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 4.3. Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 4.3.1. Identificadores v´alidos . . . . . . . . . . . . . . . . . . 38 4.3.2. Identificadores no v´alidos . . . . . . . . . . . . . . . . . 39 4.4. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . 40 4.4.1. Caracteres . . . . . . . . . . . . . . . . . . . . . . . . . 40 4.4.2. N´ umeros enteros . . . . . . . . . . . . . . . . . . . . . 41 4.4.3. N´ umeros de punto flotante . . . . . . . . . . . . . . . . 42
´INDICE GENERAL
vii
4.5. Aritm´etica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 Prueba de escritorio 3.
. . . . . . . . . . . . . . . . . 43
5. Estructura secuencial
45
5.1. Compilar y ejecutar un programa . . . . . . . . . . . . . . . . 45 5.2. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 46 1: Suma de dos enteros.
. . . . . . . . . . . . . . . . . 47
2: Calcular el ´area de un c´ırculo.
. . . . . . . . . . . . 51
3: Conversi´on de temperaturas.
. . . . . . . . . . . . 53
4: Conversi´on de ´angulos.
. . . . . . . . . . . . . . . . 54
´ 5: Area de un tri´angulo.
. . . . . . . . . . . . . . . . 56
5.3. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 57 6. M´ etodos
61
6.1. Estructura de un m´etodo . . . . . . . . . . . . . . . . . . . . . 61 Estructura de un m´etodo.
. . . . . . . . . . . . . . . 62
M´etodo que suma dos enteros.
. . . . . . . . . . . . . 62
M´etodo que llama a otro.
. . . . . . . . . . . . . . . . 63
6.2. Recomendaciones y generalidades . . . . . . . . . . . . . . . . 63 6.3. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 64 6: Suma de dos enteros.
. . . . . . . . . . . . . . . . . 65
7: Calcular el ´area de un c´ırculo.
. . . . . . . . . . . . 68
8: Conversi´on de temperaturas.
. . . . . . . . . . . . 70
9: Conversi´on de ´angulos.
. . . . . . . . . . . . . . . . 72
´ 10: Area de un tri´angulo.
. . . . . . . . . . . . . . . . 74
6.4. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 75
´INDICE GENERAL
viii 7. Decisiones simples
77
Estructura general del if - 1.
. . . . . . . . . . . . . . 78
Estructura general del if - 2.
. . . . . . . . . . . . . . 78
7.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 79 11: Divisi´on por cero.
. . . . . . . . . . . . . . . . . . 79
12: An´alisis del presupuesto mensual.
. . . . . . . . . 81
13: Verificaci´on del rango de un entero corto.
. . . . . 83
14: Pago de horas extras a un trabajador. 15: Rendimiento de un CDT.
. . . . . . . 85
. . . . . . . . . . . . . . 87
7.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 90 8. Decisiones anidadas
93
8.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 94 16: Comisi´on a pagar a un vendedor.
. . . . . . . . . 95
17: Valor de la matr´ıcula por categor´ıas.
. . . . . . . 99
18: Encontrar el mayor de tres enteros.
. . . . . . . . 101
19: Aviso para cambio de aceite.
. . . . . . . . . . . . 103
20: Clasificaci´on de tres enteros.
. . . . . . . . . . . . 105
8.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 108 9. Decisiones m´ ultiples Estructura general del switch.
113 . . . . . . . . . . . . . 114
9.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 115 21: C´alculos de Geometr´ıa Anal´ıtica.
. . . . . . . . . 115
22: Valor de la cuota fija de un pr´estamo. 23: Identificaci´on de caracteres.
. . . . . . . 120
. . . . . . . . . . . . 123
24: Resultado de la operaci´on de dos n´ umeros. 25: C´alculo del valor de la pensi´on.
. . . . 126
. . . . . . . . . . 128
9.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 132
´INDICE GENERAL
ix
10.Ciclo do - while
139
Lista secuencial de 1000 enteros.
. . . . . . . . . . . . 140
Estructura general del ciclo do - while.
. . . . . . . . 140
10.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 141 26: Lista de mil enteros positivos.
. . . . . . . . . . . 142
27: Impresi´on de un rango de n´ umeros.
. . . . . . . . 143
28: Impresi´on de un rango de n´ umeros con validaci´on.
144
29: Tabla de multiplicar de un valor ingresado.
. . . . 145
30: Multiplicaci´on a partir de sumas sucesivas.
. . . . 147
10.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 148 11.Ciclo while
151
Estructura general del while.
. . . . . . . . . . . . . . 151
11.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 152 31: Encontrar el mayor.
. . . . . . . . . . . . . . . . . 152
32: N´ umero de pares e impares. 33: Estad´ıstica sobre notas.
. . . . . . . . . . . . . . . 156
34: M´aximo Com´ un Divisor. Figura de longitud 6. 35: Figura.
. . . . . . . . . . . . 154 . . . . . . . . . . . . . . 158
. . . . . . . . . . . . . . . . . . 160
. . . . . . . . . . . . . . . . . . . . . . . . 160
11.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 162 12.Ciclo for Estructura general del for.
165 . . . . . . . . . . . . . . . 165
12.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 167 36: Divisi´on a partir de restas.
. . . . . . . . . . . . . 167
37: M´ınimo Com´ un M´ ultiplo.
. . . . . . . . . . . . . 169
38: Tabla trigonom´etrica.
. . . . . . . . . . . . . . . . 171
39: Plan de amortizaci´on.
. . . . . . . . . . . . . . . . 173
´INDICE GENERAL
x Figuras de 1 y 4 flechas, de longitud 5. 40: Figura.
. . . . . . . . 177
. . . . . . . . . . . . . . . . . . . . . . . . 177
12.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 180 13.Arreglos unidimensionales
183
Elementos de un arreglo.
. . . . . . . . . . . . . . . . 184
Acceso directo a las posiciones de un arreglo.
. . . . . 185
Acceso indirecto a las posiciones de un arreglo.
. . . . 185
Acceso a un arreglo usando ciclos do - while y for.
. . 186
13.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 186 41: Sumar los elementos de un arreglo. 42: Orden inverso.
. . . . . . . . 186
. . . . . . . . . . . . . . . . . . . . 190
43: Dividir en pares e impares. 44: Eliminar un dato. 45: Insertar y desplazar.
. . . . . . . . . . . . . 191
. . . . . . . . . . . . . . . . . . 195 . . . . . . . . . . . . . . . . 197
13.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 199 14.Matrices
203
Acceso directo a las posiciones de una matriz.
. . . . 205
Acceso indirecto a las posiciones de una matriz. Acceso a un arreglo usando el ciclo for.
. . . 205
. . . . . . . . 206
14.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 207 46: Inicializar la Matriz Identidad.
. . . . . . . . . . . 207
47: Suma de los elementos de la diagonal. 48: Imprimir la transpuesta de una matriz. 49: Intercambiar dos filas.
. . . . . . . 210 . . . . . . 212
. . . . . . . . . . . . . . . 215
50: Cuadrados m´agicos de orden impar.
. . . . . . . . 217
14.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 220
´INDICE GENERAL
xi
15.Para el Volumen II
223
15.1. Manejo de Excepciones . . . . . . . . . . . . . . . . . . . . . . 223 51: Excepciones 1.
. . . . . . . . . . . . . . . . . . . . 224
52: Excepciones 2.
. . . . . . . . . . . . . . . . . . . . 225
53: Excepciones 3.
. . . . . . . . . . . . . . . . . . . . 227
15.2. Cadenas de caracteres . . . . . . . . . . . . . . . . . . . . . . 229 54: Cadenas 1.
. . . . . . . . . . . . . . . . . . . . . . 229
55: Cadenas 2.
. . . . . . . . . . . . . . . . . . . . . . 231
56: Cadenas 3.
. . . . . . . . . . . . . . . . . . . . . . 232
15.3. Argumentos del m´etodo main . . . . . . . . . . . . . . . . . . 233 57: Argumentos 1.
. . . . . . . . . . . . . . . . . . . . 233
Resultado Argumentos 1. 58: Argumentos 2.
. . . . . . . . . . . . . . . . 234 . . . . . . . . . . . . . . . . . . . . 235
15.4. Archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 59: Archivos de acceso secuencial. 60: Archivos de acceso directo.
.
Bibliograf´ıa
. . . . . . . . . . . 237 . . . . . . . . . . . . . 241
245
xii
´INDICE GENERAL
Parte I Algoritmos
1
Cap´ıtulo 1 Introducci´ on Antes de entrar en detalles con respecto a los conceptos fundamentales de los lenguajes de programaci´on, es importante tener claridad sobre el contexto en el que se pueden apoyar. Un lenguaje de programaci´on es una definici´on formal de instrucciones que a primera vista parecen de una complejidad muy alta. Con dichas instrucciones es posible resolver problemas planteados de forma algor´ıtmica. Un algoritmo es un conjunto de instrucciones que permiten resolver un problema determinado. Se caracteriza por tener un n´ umero finito de instrucciones y no dar lugar a ning´ un tipo de ambig¨ uedad. Muchas veces, en la vida diaria estamos en contacto con situaciones que se pueden comportar de forma similar a las que usualmente se resuelven utilizando este tipo de lenguajes. Una receta de cocina donde no se especifican tiempos y cantidades exactas, no se considera un algoritmo. Pero los pasos que aprendimos en la escuela para calcular la suma, resta, multiplicaci´on o divisi´on s´ı se pueden llamar algoritmos.
1.1.
Algoritmos de la vida diaria
Generalmente las personas tenemos la costumbre de “programar”las diferentes actividades del d´ıa, a pesar de que la mayor´ıa no lo hace de forma 3
´ CAP´ITULO 1. INTRODUCCION
4
consciente. Es decir, algunas personas usan una agenda para registrar sus compromisos m´as importantes y otras solo conf´ıan en su memoria. Unas personas prefieren programar sus actividades a corto plazo (el d´ıa o parte de ´el, el d´ıa siguiente o la semana), mediano plazo (la quincena o el mes) y largo plazo. Ejemplos: 1. Ama de casa Un ama de casa, a grandes rasgos, divide su tiempo de tal manera que le alcance para: Ver “Ama de casa”. Ama de casa Servir el desayuno Organizar la casa Preparar el almuerzo Servir la cena
No se especifican detalles por ejemplo a qu´e hora realiza cada actividad, ni otros pormenores como por ejemplo su aseo personal o si descansa leyendo u observando la televisi´on. 2. Empleado de oficina Un empleado de una empresa cualquiera, a diferencia del ejemplo anterior puede tener ciertas diferencias de acuerdo al cargo que desempe˜ na. Podr´ıa organizar su d´ıa m´as o menos as´ı: Ver “Empleado de oficina”. En este caso, no se puede detallar el conjunto de actividades espec´ıficas de su trabajo o si almuerza en la oficina, cerca de ella o en su casa. De igual manera quedan muchas actividades complementarias que no son mencionadas.
1.1. ALGORITMOS DE LA VIDA DIARIA
5
Empleado de oficina Organizacion personal Desayunar Desplazarse al lugar de trabajo Realizar las actividades propias de su trabajo Desplazarse a su casa Cenar
3. Profesor universitario El caso de un profesor en la universidad es diferente a los anteriores. La siguiente puede ser la distribuci´on de su tiempo en horas de la ma˜ nana. Ver “Profesor Universitario”. Profesor Universitario 5:45 6:15 6:30 7:00 9:00 10:00 12:00
a.m. a.m. a.m. a.m. a.m. a.m. a.m.
Organizacion personal Desayunar Desplazarse a la universidad Clase de Calculo I Asesoria a Estudiantes Clase de Geometria Analitica Desplazarse a su casa
Se puede observar que podr´ıa ser un caso particular del ejemplo 2, por tratarse de una persona que va a su trabajo. En este ejemplo, es importante el d´ıa y la hora, porque no todos los d´ıas ni en los mismos horarios atiende las mismas asignaturas o asesor´ıas.
´ CAP´ITULO 1. INTRODUCCION
6 4. Retiro por cajero autom´atico
Una persona necesita seguir ciertos pasos para retirar su dinero del cajero autom´atico. Ver “Cajero autom´atico”. Cajero autom´ atico Introducir la tarjeta Retirar la tarjeta Digitar la clave SI la clave no es valida, ENTONCES Termina la transaccion SINO Leer un menu con las opciones Elegir Retiro en efectivo Elegir o digitar la cantidad SI la cantidad es <= al saldo disponible Y la cantidad es <= al monto maximo permitido Y el cajero dispone de esa cantidad ENTONCES Recoger el dinero Recoger el recibo SINO Termina la transaccion
Es natural hoy en d´ıa ir a un cajero electr´onico con el prop´osito de retirar dinero en efectivo. El cajero tiene un monto m´aximo permitido de entrega, al igual que el cliente tiene un saldo sobre el cual puede hacer el retiro. En casos extremos hay que contar con que el dinero que tiene almacenado el cajero puede escasear. No todas las personas hacen exactamente lo mismo aunque tengan afinidad en su actividad principal, ni establecen lo que deben hacer de la misma manera o con el mismo grado de detalle.
´ DE ACTIVIDADES 1.2. AGRUPACION
1.2.
7
Agrupaci´ on de actividades
Tal como est´an escritos los tres ejemplos anteriores, se puede apreciar que el d´ıa est´a dividido en actividades que a su vez pueden dividirse en pasos m´as detallados. Por ejemplo, preparar el almuerzo en el ejemplo 1, se puede realizar paso a paso siguiendo una receta de cocina particular. Desplazarse a su lugar de trabajo en los ejemplos 2 y 3, puede ser la suma de diferentes actividades parciales como salir de la casa, ir al paradero de bus, esperar la ruta correspondiente, montarse al bus, esperar el recorrido, bajarse en el paradero adecuado y caminar a la oficina.
1.3.
Decisiones
Los ejemplos mencionados corresponden a programaci´on secuencial. Es decir, funcionan perfectamente mientras no se presenten eventualidades, como por ejemplo amanecer enfermo y tener urgencia de ir al m´edico. Por m´as programado que se tenga el d´ıa, esa eventualidad obliga a tomar decisiones que afectar´an el normal desarrollo de las actividades siguientes. Por ejemplo, si el desplazamiento a la oficina se realiza en bus, pero se est´a haciendo tarde, es muy probable que el empleado tome la decisi´on de irse en taxi. El ama de casa puede tener planeado hacer de almuerzo cierto plato, pero justo en el momento en que va a iniciar su preparaci´on se entera de que algunos ingredientes hacen falta. En ese momento debe tomar una decisi´on antes de que sea tarde. Su decisi´on ser´a ir a comprar lo que hace falta o cambiar el men´ u que va a ofrecer, de tal manera que pueda prepararse con los ingredientes que hayan en el momento. En el caso del retiro de dinero en un cajero autom´atico, es importante considerar decisiones porque el cajero debe verificar la identidad del cliente mediante la tarjeta e intentar comprobar si se trata efectivamente del due˜ no de la tarjeta, solicitando la clave. Adem´as, existen posibles solicitudes que no pueden ser realizadas debido a condiciones que se deben cumplir para efectuar el retiro. Finalmente se puede decir que para la entrega del recibo
´ CAP´ITULO 1. INTRODUCCION
8
es indispensable que el cajero tenga suministro de papel. Esta condici´on no fue considerada.
1.4.
Repeticiones
Es importante tener en cuenta que en la mayor´ıa de los casos, las personas deben seguir una rutina de lunes a viernes, y el fin de semana lo utilizan para disfrutar con su familia el tiempo libre. Todas las semanas tienen m´as o menos el mismo comportamiento. El caso del profesor universitario, todas las semanas tiene las mismas clases los d´ıas lunes, otras los martes, y as´ı ocurre con los dem´as d´ıas de la semana. Para el empleado de oficina, si debe subir escaleras para llegar a su oficina, lo har´a hasta que se terminen las escaleras que debe subir. El ama de casa si debe quitar la c´ascara de las papas para preparar el almuerzo, con seguridad que lo har´a mientras no haya terminado de pelar las que haya escogido. En conclusi´on, podemos esperar que algunas actividades se repitan, pero con diferente frecuencia lo que quiere decir que dentro de una actividad puede estar incluida una cantidad de veces que se debe realizar otra.
Cap´ıtulo 2 Conceptos b´ asicos En este cap´ıtulo usaremos un m´etodo no muy formal que facilite la escritura de los primeros programas. Este m´etodo ser´a llamado seudoc´odigo. Se llama seudoc´odigo porque no es un lenguaje estandarizado y cada persona puede utilizarlo haciendo ligeras modificaciones. No es un lenguaje propio para ser operado en una computadora. Es m´as utilizado para especificar lo que un programa debe hacer para resolver un problema. Los programas se alimentan con datos, que al ser procesados generan datos con significado (informaci´on). Dichos datos deben almacenarse en alg´ un lugar de la memoria de la computadora para su posterior utilizaci´on en el procesamiento. Para tener acceso a estos datos en la memoria, el programa normalmente utiliza nombres que permitan identificarlos f´acilmente. Estos nombres se conocen como identificadores.
2.1.
Identificadores
Un identificador es una secuencia de caracteres que permite localizar datos almacenados en la memoria. Si los datos que se encuentran en la memoria se pueden modificar dentro de un programa, se llaman variables. De lo contrario, el se conocen como constantes. Estos nombres deben ser significativos, es decir, deben ayudar a reconocer perfectamente la variable o constante que est´a siendo representada. No es 9
´ CAP´ITULO 2. CONCEPTOS BASICOS
10
recomendable usar abreviaturas a menos que sean muy dicientes, lo mismo que secuencias demasiado largas porque se dificulta su utilizaci´on. Un identificador debe comenzar por una letra, puede incluir n´ umeros y el caracter subrayado. No se recomienda el uso de caracteres especiales diferentes ni espacios en blanco, porque en la mayor´ıa de los lenguajes de programaci´on no son permitidos. Existen lenguajes que diferencian las letras may´ usculas y min´ usculas, por lo tanto, es importante tener especial cuidado al utilizarlas. Identificadores v´ alidos A continuaci´on se pueden apreciar algunos ejemplos de identificadores v´alidos: Area, Suma, promedio, sueldo, nota1, Nota2, Nota_final Identificadores no v´ alidos No se permiten identificadores como primera nota, por el espacio en blanco; 1_pago, por comenzar con n´ umero y no con letra; ni %final por iniciar con un s´ımbolo no permitido. Tampoco se pueden utilizar como identificadores las palabras reservadas propias del lenguaje que se est´e utilizando. Por otra parte, es de anotar que algunos lenguajes de programaci´on requieren que antes de ubicar un dato en la memoria se especifique el tipo de dato que se desea almacenar, con el objeto de verificar su utilizaci´on para la detecci´on de errores, y para determinar su tama˜ no en bytes.
2.2.
Tipos de datos
Los datos pueden ser de diferentes tipos. Su correcta representaci´on incide en la elaboraci´on del programa, puesto que de una buena interpretaci´on de los datos depende el ´exito en los resultados obtenidos. Los datos se clasifican en: datos num´ericos, utilizados en operaciones aritm´eticas; y datos alfanum´ericos, los cuales se agrupan en series o cadenas de
2.3. OPERADORES
11
caracteres alfab´eticos, num´ericos o especiales; y se utilizan generalmente para referencia, es decir, no se utilizan para realizar operaciones matem´aticas. Dependiendo del lenguaje de programaci´on, pueden existir otros tipos de datos, o incluso el usuario (programador) puede especificar sus propios tipos de datos. Los datos num´ericos son utilizados para diferentes c´alculos aritm´eticos. Se dividen en enteros y de punto flotante. A pesar de que las matem´aticas define como infinito cualquier conjunto num´erico, las computadoras no pueden hacerlo. Dependiendo del tipo de dato, se puede almacenar un n´ umero que deber´a estar dentro de un rango determinado. Los diferentes lenguajes de programaci´on especifican estos l´ımites.
2.3.
Operadores
Un operador es un s´ımbolo utilizado para la manipulaci´on de datos. Se clasifican en: Aritm´ eticos: Utilizados para representar operaciones matem´aticas como suma (+), resta o diferencia (-), multiplicaci´on o producto (*), divisi´on (/), m´odulo o residuo de la divisi´on (%). Relacionales: Los operadores relacionales se utilizan para la comparaci´on de datos, mayor que (>), menor que (<), mayor o igual que (>=), menor o igual que (<=), igual que (==) o diferente de (!=). El resultado de una comparaci´on es un valor l´ogico (Verdadero o Falso). L´ ogicos: Son utilizados para agrupar dos o m´as comparaciones o para invertir o negar un valor l´ogico. Estos operadores son: conjunci´on (&&), disyunci´on (||) y negaci´on (!). La conjunci´on es normalmente llamada (Y). Dos o m´as comparaciones agrupadas con (&&) dar´an como resultado Verdadero siempre y cuando todas las comparaciones sean Verdaderas. En otro caso el resultado ser´a Falso. De forma similar, la disyunci´on es llamada (O). Si se tienen varias comparaciones agrupadas con el operador (||), el resultado ser´a Falso, s´ı y
´ CAP´ITULO 2. CONCEPTOS BASICOS
12
solo si todas las comparaciones son Falsas. En otro caso, el resultado ser´a Verdadero. De asignaci´ on: Es el operador utilizado para llevar datos a la memoria, a trav´es de identificadores. El operador de asignaci´on es (=). De signo: Es el operador utilizado para darle sentido positivo (+) o negativo (-) a un n´ umero. De agrupaci´ on: Son los s´ımbolos que se utilizan para modificar el orden en que se deben utilizar los diferentes operadores. Este orden se conoce como jerarqu´ıa, precedencia o prioridad de operadores. El operador de agrupaci´on es ( ). Ver tabla 2.1. ( ) + - (signo) * / % + < > <= >= == != ! && || = Cuadro 2.1: Jerarqu´ıa, precedencia o prioridad de operadores La uni´on de constantes y variables con operadores forman expresiones. Para evitar confusiones tenga en cuenta: Si entre dos o m´as operadores la prioridad es equivalente, se resuelve el que aparezca primero de izquierda a derecha. Esto incluye los par´entesis.
2.3. OPERADORES
13
De haber par´entesis anidados, se resuelven primero los m´as internos.
Ejemplo: ( 2 * ( 3 + 4 ) * 8 ) * 5 + 2 * ( 8 + 4 + ( 3 * 2 ) + 1 ) Realice los siguientes pasos para determinar el resultado. Observe que hay dos par´entesis principales. Primero se debe resolver el que est´a m´as a la izquierda, es decir, ( 2 * ( 3 + 4 ) * 8 ). Internamente, hay un producto, una suma entre par´entesis y otro producto. Debe resolverse entonces el par´entesis ( 3 + 4 ) cuyo resultado es 7. ( 2 * ( 3 + 4 ) * 8 ) * 5 + 2 * ( 8 + 4 + ( 3 * 2 ) + 1 ) ( 2 * 7 * 8 ) * 5 + 2 * ( 8 + 4 + ( 3 * 2 ) + 1 ) Dentro del primer par´entesis se encuentran dos multiplicaciones. Primero se resuelve 2 * 7, quedando as´ı: ( 14 * 8 ) * 5 + 2 * ( 8 + 4 + ( 3 * 2 ) + 1 ) Ahora, se multiplica 14 * 8 112 * 5 + 2 * ( 8 + 4 + ( 3 * 2 ) + 1 ) A continuaci´on escogemos el par´entesis que estaba pendiente y dentro de ´el la multiplicaci´on de 3 * 2. 112 * 5 + 2 * ( 8 + 4 + 6 + 1 ) El proceso de soluci´on de las sumas es en orden de aparici´on, de izquierda a derecha. 112 * 5 + 2 * ( 12 + 6 + 1 ) 112 * 5 + 2 * ( 18 + 1 ) 112 * 5 + 2 * 19
´ CAP´ITULO 2. CONCEPTOS BASICOS
14
En este momento han desaparecido los par´entesis. Ahora, seguimos con las multiplicaciones y luego la suma. 560 + 2 * 19 560 + 38 598 En la figura 2.1 se puede apreciar la transformaci´on desde la expresi´on inicial hasta el resultado.
Figura 2.1: Prioridad en los operadores aritm´eticos
2.4.
Funciones - M´ etodos
El nombre formal que recibe la agrupaci´on de instrucciones es Funci´on o M´etodo1 . Los lenguajes de programaci´on tienen funciones predefinidas, muchas de las cuales conducen a resultados de operaciones matem´aticas. Entre otras se encuentran:
1
Utilizados en los lenguajes orientados a objetos como Java y C++
2.5. EXPRESIONES
15
Seno( X ) Coseno( X ) Raiz_Cuadrada( X ) Potencia( X, Y ) Exponencial ( X )
2.5.
Expresiones
Una expresi´on es una combinaci´on de n´ umeros, variables, constantes, funciones y operadores. Debe tenerse en cuenta que no se pueden combinar de cualquier manera, es decir, se deben agrupar de forma coherente.
2.5.1.
Expresiones aritm´ eticas
Son operaciones donde intervienen los operadores aritm´eticos. Analice cuidadosamente la forma como se agrupan ciertos elementos utilizando par´entesis de tal manera que no se presente ninguna ambig¨ uedad. Ver tabla 2.2. Observe que si en el numerador va un signo de suma o resta, debe ir entre par´entesis. En el caso del denominador, el par´entesis debe ir si existe cualquier operador. Si hay dudas, es mejor escribir los par´entesis.
2.5.2.
Expresiones l´ ogicas
La expresiones l´ogicas son las que conducen a un resultado de Falso o Verdadero. Cuando una expresi´on es una sola comparaci´on, se llama expresi´on l´ogica simple. Esta expresi´on puede tener en uno o los dos extremos una expresi´on aritm´etica. Ver tabla 2.3. Las expresiones que resultan de unir expresiones l´ogicas simples con operadores l´ogicos dan lugar a las operaciones l´ogicas m´ ultiples. Ver tabla 2.4.
´ CAP´ITULO 2. CONCEPTOS BASICOS
16 Algebra
Seudocodigo
3 5
3/5
3+4 5
(3 + 4)/5
3+4 5−2
(3 + 4)/(5 − 2)
3∗4 5∗8
3 ∗ 4/(5 ∗ 8)
3 2+6 4
3/((2 + 6)/4)
Cuadro 2.2: Conversi´on de expresiones algebr´aicas
Nota < 3.0 3 * a + 5 * b / c == 0 X1 != X2 A + B >= C + D 2 * D != Z Cuadro 2.3: Expresiones l´ogicas simples
2.5. EXPRESIONES
17 a > b && X != 0
Horas >= 40 || Sueldo < 500000 (X == 1) || ( X == -1 ) && ( Min < 1 ) Ret <= Saldo && Ret <= Monto_Max && Ret <= Caja Cuadro 2.4: Expresiones l´ogicas m´ ultiples
2.5.3.
Expresiones de asignaci´ on
Generalmente son valores constantes o el resultado de una expresi´on aritm´etica la cual es asignada a una variable o el valor inicial de una constante. Pueden existir conflictos entre tipos de datos, por lo que se recomienda especial atenci´on al momento de usarlos para evitar interpretaciones equivocadas. Sucede lo mismo con los rangos que maneja cada tipo de dato en particular. Ver tabla 2.5. a = 5 Definitiva = ( Nota1 + Nota2 + Nota3 ) / 3.0 I = I + 1 Suma = Suma + X Promedio = Suma / N Peso = Peso * 0.03 Cuadro 2.5: Expresiones de asignaci´on
´ CAP´ITULO 2. CONCEPTOS BASICOS
18
2.6.
Ejercicios
1. Indique cu´ales de los siguientes valores son de tipo ENTERO, REAL, CARACTER, CADENA, o NINGUNO. Complete la tabla 2.6. Valor
Tipo de dato
Valor
’A’
48
23.58
7
-8.43
TRES
5
31
2.1
’e’
"TRES"
19
5.25
’y’
-6
A
"17.98"
"perro"
-8
215
’C’
2001
-1230
0.00
962
-12.0356
"Eusebio"
2000.0
Tipo de dato
Cuadro 2.6: Ejercicios sobre tipos de datos
2.6. EJERCICIOS
19
2. Indique si los siguientes indentificadores se pueden utilizar o no, completando la siguiente tabla 2.7. Responda Si o No y Porqu´e No. Identificador
Si o No
Porque
Arm nota 3 sueldo_basico dato1 area base Radio 5nota Aaa Pagototal Interes X %int Y 2 Entrada Dist Cuadro 2.7: Ejercicios sobre identificadores
´ CAP´ITULO 2. CONCEPTOS BASICOS
20
3. Escriba qu´e tipo de expresiones son las siguientes. Pueden ser de asignaci´on, l´ogicas o aritm´eticas. Ver tabla 2.8 Expresion
Tipo de expresion
a = b a = 5 && b > 3 3 + 5 * 8 - 9 * 3 area = 3.14 * r * r area > 1 c + 5 * 7 < b * b a = b * 3 b > c + a a > b && c < d a = a + a b = a + 1 c == d * 54 - f S % 2 == 1 a = Potencia( 2 , c ) Raiz_Cuadrada( X ) > 4.0 Cuadro 2.8: Ejercicios sobre expresiones
2.6. EJERCICIOS
21
4. Pasar a seudoc´odigo las expresiones aritm´eticas de la tabla 2.9. q c21 + c22 q
√ 1+3 2−4 2+3X 2 −X 4 +X
l 2 − c3 b A2 + B 2 + C 2 D2 + E 2 + F 2 A + BCD − EF 3 G √ √ G3 + 2 3X (4X 3 − b2 + Z)3 + 2X 3 Y (X 4 − 2Y 3 )1/2 + X + 4Y 3X + 4 − (−3X 2 + 4XY )3 2X 3 Y + 3XY X 5 + 2X 4 + 3X 3 − 2X 2 +X 2X 3 − X 2 + X 4X
√ 3X 2 +1
−
2X 3 X4 + Y
A2 + 3X X
2 −X
4X 3 − X 2 + X X + Y + Z 2X−3 + X 2 Cuadro 2.9: Ejercicios sobre expresiones aritm´eticas
´ CAP´ITULO 2. CONCEPTOS BASICOS
22
5. Eval´ ue paso a paso cada una de las siguientes expresiones de asignaci´on y determine el valor asignado a la variable. a = ( 20 + ( 10 + 5 * 2 ) * 4 ) / ( Potencia ( 2, 3 ) - 6 ) * Raiz_Cuadrada ( ( 40 - 8 ) / 8 ) b = 6 * 3 + 2 - 5 * Potencia ( 3 , 2 ) c = 3 / (5 -2 ) + 1 d = 4 * 3 + ( 17 - 2 ) / 5 e = 12 * 5 + ( 17 + 3 ) / 5 f = Potencia ( 4 , 2 ) * 8 - 55 g = ( ( Potencia ( 2, 8 ) - 15 * 4 - 4 ) / Raiz_Cuadrada ( 4 ) ) + ( 4 * Potencia ( 5, 2 ) -7 * 2 * 20 )| 6. Escriba las expresiones aritm´eticas que corresponden a cada una de las siguientes expresiones de asignaci´on en seudoc´odigo.
a = ( bmy + bmn ) * h / 2 b = Raiz_Cuadrada ( Potencia ( x2 - x1, 2 ) + Potencia ( y2 - y1 , 2 ) ) c = Raiz_Cuadrada ( s * ( s - a ) * ( s - b ) * ( s - c ) ) d = ( a + b
+ c ) / ( b + e ) +
f
e = ( Potencia ( a, b ) + 3 ) / ( Raiz_Cuadrada ( 16 * x * x ) - y * y )
2.6. EJERCICIOS
23
7. Encuentre los valores finales de a, b, c y d, enteras, teniendo en cuenta que los valores de las variables van cambiando a medida que se eval´ ua cada expresi´on. Ver Prueba de escritorio 1. Prueba de escritorio 1 a = 5 b = 2 c= a + b d = 15 % 20 + c * b / 2 a = a + b + c + d b = ( ( Potencia(b, ( Potencia( c - 4 , b ) + 1 ) / b - 1 ) + b * b ) * Raiz_Cuadrada( ( b + c + 1 ) - 4 ) + ( d - b ) ) * b - a + 20 c = b - 165 d = b + 2 * Raiz_Cuadrada ( 64 )
8. Encuentre los valores finales de a, b, c y d, enteras. Ver Prueba de escritorio 2. Prueba de escritorio 2 a b c d a b
= = = = = =
15 20 a - b a % ( 2 * b ) + b * c / 2 b + b + c + d Potencia ( ( ( 4 + Potencia ( 2 + a, 5 ) ) / ( b / 2 ) ) * ( ( 10 + a ) - Potencia ( 2, 3 ) ) - 4, 2 ) + 15 c = b - 250 + 13 d = a + 2 * Raiz_Cuadrada ( 100 + 28 * 2 - 12 )
24
´ CAP´ITULO 2. CONCEPTOS BASICOS
Cap´ıtulo 3 Programaci´ on en seudoc´ odigo Un programa en seudoc´odigo o en cualquier lenguaje de programaci´on, es una manera m´as formal de construir un algoritmo. Un programa debe tener claramente especificados los pasos que solucionar´an el problema. Generalmente tiene entradas, procesos y salidas. Por ejemplo, si se desea realizar un c´alculo matem´atico como determinar el ´area de un tri´angulo rect´angulo, es necesario conocer: La f´ormula matem´atica que permite obtener el ´area Area =
Cat1 ∗ Cat2 2
Las longitudes de los dos catetos Un programa puede ser gen´erico, es decir, estar en condiciones de resolver diferentes problemas similares. En el caso del ejemplo mencionado, puede calcular el ´area de diferentes tri´angulos rect´angulos, aplicando la f´ormula a varios conjuntos de entradas. Por ejemplo, puede obtener el ´area cuando los catetos miden respectivamente 3.00 y 4.00; o si sus longitudes son 12.0 y 5.0. Los datos conocidos se llaman datos de entrada. Lo que se desconoce, generalmente la informaci´on que se quiere calcular se genera a partir de la f´ormula o f´ormulas, donde todo lo que se encuentre a la derecha del signo = (operador de asignaci´on) debe ser conocido o calculado previamente. 25
26
´ EN SEUDOCODIGO ´ CAP´ITULO 3. PROGRAMACION
Al finalizar un programa, debe tratar de informar los resultados obtenidos, los cuales deben coincidir con el problema planteado inicialmente. Es decir, asegurarse que el problema cumpla con el objetivo propuesto. Para los dos conjuntos de entradas anteriores obtienen como resultados 6.00 y 30.0 respectivamente.
Estructura de un programa en Seudoc´ odigo Un programa en seudoc´odigo tiene la siguiente estructura. Ver “Estructura de un programa”. Estructura de un programa INICIO Declaracion de constantes Declaracion de variables Lectura de datos conocidos Calculos o procesos Impresion de resultados FINAL
Las declaraciones de constantes o variables deben incluir el tipo y los identificadores (nombres de constantes o variables) que ser´an utilizados en el programa. La lectura de los datos conocidos, generalmente se realiza en forma independiente, acompa˜ nando con un mensaje cada una de las entradas. Los c´alculos o procesos, relacionan los datos conocidos con lo que se quiere calcular para obtener los resultados. La impresi´on de resultados es finalmente el objetivo general de cualquier programa.
3.1. EJEMPLOS
3.1.
27
Ejemplos
1. Programaci´on secuencial: Dado un ´angulo medido en grados, minutos y segundos, convertirlo a radianes. Ver Algoritmo 1 “Radianes”. Algoritmo 1 - Radianes INICIO CONSTANTE CONSTANTE CONSTANTE CONSTANTE
REAL REAL REAL REAL
PI GRAD_MIN GRAD_SEG MEDIO_CIRCULO
= 3.1415926 = 60.0 = 3600.0 = 180.0
REAL Grados, Minutos, Segundos, Radianes IMPRIMIR "Ingrese Grados : " LEER Grados IMPRIMIR "Ingrese Minutos : " LEER Minutos IMPRIMIR "Ingrese Segundos: " LEER Segundos Grados = Grados + Minutos / GRAD_MIN + Segundos / GRAD_SEG Radianes = Grados * PI / MEDIO_CIRCULO IMPRIMIR "El angulo en radianes es:", Radianes FINAL
Este programa recibe tres datos: Grados, Minutos y Segundos. Para poder convertir a Radianes es indispensable igualar las unidades porque Minutos es una parte de Grados y Segundos es una parte de Minutos, de tal manera que todo sea expresado en Grados. Es muy importante tener en cuenta el orden en el que se escriben los diferentes pasos que solucionan un problema. Cambiar el orden de los
´ EN SEUDOCODIGO ´ CAP´ITULO 3. PROGRAMACION
28
pasos puede alterar el resultado del programa. Por ejemplo, si se invierten las dos f´ormulas, es decir, primero se calcula el resultado de Radianes y luego el de Grados, ser´ıa inexacto el valor a imprimir, pues no tendr´ıa en cuenta la parte decimal correspondiente a Minutos y Segundos. Por otra parte, si se cambia el orden en las operaciones de lectura, primero LEER y luego se imprime el mensaje, tendr´ıamos al usuario sin informaci´on sobre el dato que el programa est´a intentando leer. Pero si se intercambia la lectura con su respectivo mensaje, es decir, se leen los datos en otro orden, puede que no se altere el resultado sino que se dificulte la entrada de datos. ¿Qu´e pasar´ıa si el mensaje que acompa˜ na la entrada de Minutos es "Grados"? 2. Decisiones simples: Dadas las coordenadas de dos puntos del plano cartesiano, hallar la pendiente de recta. Ver Algoritmo 2 “Pendiente de recta”. Algoritmo 2 - Pendiente de recta INICIO REAL X1, Y1, X2, Y2, M IMPRIMIR LEER X1 IMPRIMIR LEER Y1 IMPRIMIR LEER X2 IMPRIMIR LEER Y2
"Ingrese X1: " "Ingrese Y1: " "Ingrese X2: " "Ingrese Y2: "
En este programa solicita los valores correspondientes a las coordenadas de dos puntos del plano cartesiano. Antes de aplicar la f´ormula de la pendiente, verifica que no se presente “Divisi´on por cero”porque genera un error que interrumpe la normal ejecuci´on de un programa. En este
3.1. EJEMPLOS
29 Continuaci´ on algoritmo 2
SI ( X1 == ENTONCES IMPRIMIR SINO M = ( Y2 IMPRIMIR FIN-SI FINAL
X2 ) "La pendiente no existe" - Y1 ) / ( X2 - X1 ) "La pendiente es: ", M
caso si la l´ınea recta es vertical, X1 es igual a X2 y la pendiente no existe. 3. Decisiones anidadas: Hallar el mayor de tres enteros sin usar conectores l´ogicos. Ver Algoritmo 3 “Hallar el mayor de tres enteros”. Algoritmo 3 - Hallar el mayor de tres enteros INICIO ENTERO a, b, c, m IMPRIMIR "Ingrese el primer numero: " LEER a IMPRIMIR "Ingrese el segundo numero: " LEER b IMPRIMIR "Ingrese el tercer numero: " LEER c
Este programa permite determinar el mayor de tres enteros diferentes. No utiliza operadores l´ogicos por lo que siempre las comparaciones se realizan entre dos n´ umeros. Al finalizar, independientemente del valor de a, b y c, la variable m tendr´a el mayor de los tres.
30
´ EN SEUDOCODIGO ´ CAP´ITULO 3. PROGRAMACION
Continuaci´ on algoritmo 3 SI ( a > b ) ENTONCES SI ( a > c ) ENTONCES m = a SINO m = c FIN-SI SINO SI ( b > c ) ENTONCES m = b SINO m = c FIN-SI FIN-SI IMPRIMIR "El mayor es: ", m FINAL
3.1. EJEMPLOS
31
4. Decisiones m´ ultiples: Realizar una operaci´on entre dos enteros seg´ un el operador ingresado. Ver Algoritmo 4 “Operaci´ on aritm´etica”. Algoritmo 4 - Operaci´ on aritm´ etica INICIO ENTERO Num1, Num2, Resultado CARACTER Operador IMPRIMIR "Primer numero LEER Num1 IMPRIMIR "Segundo numero LEER Num2 IMPRIMIR "Operador LEER Operador SELECCION ( Operador ) CASO ’+’ : Resultado FIN-CASO CASO ’-’ : Resultado FIN-CASO CASO ’*’ : CASO ’.’ : CASO ’x’ : CASO ’X’ : Resultado FIN-CASO CASO ’/’ : Resultado FIN-CASO FIN-SELECCION
: " : " : "
= Num1 + Num2; = Num1 - Num2;
= Num1 * Num2; = Num1 / Num2;
IMPRIMIR "El resultado es : ", Resultado FINAL
Este programa calcula el resultado de la operaci´on aritm´etica indicada mediante la variable Operador. La multiplicaci´on recibe cuatro operadores diferentes (*, ., x y X). Una vez seleccionado el caso de la
´ EN SEUDOCODIGO ´ CAP´ITULO 3. PROGRAMACION
32
variable Operador, se realiza el c´alculo y se sale de la selecci´on cuando llega FIN-CASO. Es decir, la palabra CASO correspondiente al valor de Operador indica el lugar desde donde se ejecutan las instrucciones. FIN-CASO determina el final. 5. Ciclo condicionado al final: Calcular el resultado de la multiplicaci´on de dos enteros positivos a partir de sumas sucesivas. Ver Algoritmo 5 “Producto con sumas”. Algoritmo 5 - Producto con sumas INICIO ENTERO i, a, b, Prod IMPRIMIR "Ingrese el primer numero: " LEER a IMPRIMIR "Ingrese el segundo numero: " LEER b i = 0 prod = 0 REPITA Prod = Prod + a i = i + 1 MIENTRAS ( i < b ) IMPRIMIR "El producto es: ", Prod FINAL
Este programa utiliza la defici´on de la multiplicaci´on a partir de sumas sucesivas, es decir, a×b = a | + a + a{z+ · · · + a}. El ejercicio es una simple b veces
sumatoria que se realiza un n´ umero determinado de veces.
3.1. EJEMPLOS
33
6. Ciclo condicionado al comienzo: Hallar el m´ınimo com´ un m´ ultiplo de dos enteros positivos. Ver Algoritmo 6 “M´ınimo Com´ un M´ ultiplo”. Algoritmo 6 - M´ınimo Com´ un M´ ultiplo INICIO ENTERO a, b, my, mn, MCM IMPRIMIR "Ingrese el primer numero: " LEER a IMPRIMIR "Ingrese el segundo numero: " LEER b SI ( a > b ) ENTONCES my = a mn = b SINO my = b my = a FIN-SI MCM = my MIENTRAS ( MCM % mn != 0 ) MCM = MCM + my FIN-MIENTRAS IMPRIMIR "El mcm es: ", MCM FINAL
El M´ınimo Com´ un M´ ultiplo es el m´as peque˜ no de los infinitos m´ ultiplos comunes a dos n´ umeros. Este programa inicia asignando a la variable MCM el mayor de los n´ umeros ingresados. El ciclo buscar´a entre los m´ ultiplos de my alguno que sea m´ ultiplo de mn. Ese es el M´ınimo Com´ un M´ ultiplo.
34
´ EN SEUDOCODIGO ´ CAP´ITULO 3. PROGRAMACION
7. Ciclos anidados: Hallar la potencia de xy usando unicamente sumas. Ver Algoritmo 7 “Potencia con sumas”. Algoritmo 7 - Potencia con sumas INICIO ENTERO i, j, base, exponente, potencia, aux IMPRIMIR "Ingrese la base: " LEER base IMPRIMIR "Ingrese el exponente: " LEER exponente i = 0 potencia = 1 MIENTRAS ( i < exponente ) j = 0 aux = 0 MIENTRAS ( j < base ) aux = aux + potencia j = j + 1 FIN-MIENTRAS potencia = aux i = i + 1 FIN-MIENTRAS IMPRIMIR "El resultado es: ", potencia FINAL
El programa anterior es una aplicaci´on de ciclos anidados, donde el ciclo exterior se encarga de aplicar xy = x x × · · · x}. El ciclo interior | × x ×{z y veces
se encarga de realizar cada uno de los productos internos.
Parte II Java
35
Cap´ıtulo 4 Conceptos b´ asicos 4.1.
Historia
Sun Microsystems, en 1991, en medio de un proyecto de investigaci´on sobre dispositivos inteligentes, llamado C´odigo Green, cre´o un lenguaje de programaci´on basado en C++ para interactuar con estos dispositivos. Inicialmente se conoci´o con el nombre de Oak. Desafortunadamente exist´ıa otro lenguaje con ese nombre, lo cual oblig´o a cambiarlo. Un d´ıa, en una cafeter´ıa cercana, un empleado de la compa˜ n´ıa sugiri´o Java, nombre con el cual tambi´en se conoce en ingl´es al caf´e. El nombre gust´o y fue adoptado. El proyecto inicial no tuvo el ´exito esperado, pero la creciente popularidad de Internet y la World Wide Web fue aprovechada por Sun para impulsar este lenguaje como herramienta para la creaci´on de p´aginas Web din´amicas. Java fue lanzado en 1995.
4.2.
Qu´ e es Java?
Java, a diferencia de otros lenguajes de programaci´on genera c´odigo binario para una m´aquina que no existe realmente, llamada Java Virtual Machine o JVM. 37
´ CAP´ITULO 4. CONCEPTOS BASICOS
38
Sun ha implementado dicha m´aquina virtual para los diferentes sistemas operativos e incluso distintas arquitecturas para que estas m´aquinas puedan interpretar el c´odigo binario generado por un compilador de Java. Esta caracter´ıstica propia de Java permite una portabilidad del 100% a nivel de c´odigo binario entre las diferentes arquitecturas. La implementaci´on de la JVM en un sistema particular se llama Java Runtime Environment o JRE. Todas las aplicaciones escritas en Java requieren del JRE para su ejecuci´on. Sin embargo, si se desea hacer desarrollo en Java, es necesario instalar el Java Development Kit o JDK, el cual incluye el JRE. En Java es posible hacer dos tipos de desarrollo, los que dependen de un navegador de Internet (browser), como Internet Explorer o Netscape Navigator, o los que pueden trabajar de forma independiente. Son llamados applets y aplicaciones respectivamente.
4.3.
Identificadores
Un identificador en Java es una unidad significativa de un programa que puede representar variablesconstantes, atributos, tipos de datos, y m´etodos, entre otros. No olvide que el nombre que le asigne a un identificador debe ayudar a relacionarlo con su contenido. Adem´as, debe ser pr´actico en su utilizaci´on, porque nombres muy largos pueden complicar la escritura del c´odigo. Muy cortos pueden confundir al usuario. Un identificador debe comenzar por una letra, puede incluir n´ umeros, el subrayado y no puede incluir espacios en blanco ni caracteres especiales. Java es sensible a las may´ usculas, por lo tanto, es distinto escribir AREA, area y Area.
4.3.1.
Identificadores v´ alidos
Los siguientes son algunos ejemplos de identificadores v´alidos en Java. area, suma, producto, promedio, sueldo, nota1, nota2, nota3, nota_final
4.3. IDENTIFICADORES
4.3.2.
39
Identificadores no v´ alidos
Algunos identificadores no v´alidos en Java pueden ser: primera nota y nota 2, por la aparici´on del espacio en blanco; 1_pago y %final por no comenzar con letra. Tampoco se pueden utilizar como identificadores palabras reservadas de Lenguaje Java, tales como: abstract
boolean
break
byte
byvalue
case
cast
catch
char
class
const
continue
default
do
double
else
extends
false
final
finally
float
for
future
generic
goto
if
implements
import
instanceof
inner
int
interface
long
native
new
null
outer
package
private
protected
public
rest
return
short
static
super
switch
synchronized
this
throw
throws
transient
true
try
var
void
volatile
while
Cuadro 4.1: Palabras reservadas
´ CAP´ITULO 4. CONCEPTOS BASICOS
40
4.4.
Tipos de datos
La tabla 4.2 contiene los tipos de datos primitivos en Java. Tipo de dato
Tama˜ no en bits
Rango
boolean
1
false o true
char
16
0000 a FFFF
byte
8
-128 a +127
short
16
-32768 a +32767
int
32
−231 a +(231 − 1)
long
64
−263 a +(263 − 1)
32
-3.40292347E+38 a +3.40292347E+38
64
-1.79769313486231570E+308 a +1.79769313486231570E+308
float
double
Cuadro 4.2: Tipos de Datos Los tipos de datos correspondientes a la tabla 4.2 difieren de otros lenguajes gracias a la necesidad de portabilidad, lo que oblig´o a utilizar tipos de datos estandarizados, especialmente char, float y double.
4.4.1.
Caracteres
El tipo de datos char es utilizado para representar un car´acter encerrado entre comitas simples, como por ejemplo ’a’, ’G’, ’8’, etc. El valor de un
4.4. TIPOS DE DATOS
41
dato de tipo char corresponde al equivalente en el conjunto de caracteres ISO Unicode, compuesta por 65535 caracteres. Debe tenerse especial cuidado al utilizar datos de este tipo en operaciones aritm´eticas con datos de otros tipos, ya que char no tiene signo. Los primeros 255 caracteres del Unicode corresponden a los 255 elementos del C´odigo ASCII1 . Existen unos caracteres especiales, com´ unmente llamados secuencias de escape, los cuales ser´an usados m´as adelante. Ver tabla 4.3. Secuencia de escape
Descripci´ on
\n
Salto al comienzo de la siguiente l´ınea
\t
Salto al siguiente tope de tabulaci´on
\r
Salto al comienzo de la l´ınea actual
\\
Sirve para imprimir el caracter \
\’
Sirve para imprimir el caracter ’
\"
Sirve para imprimir el caracter " Cuadro 4.3: Secuencias de escape
4.4.2.
N´ umeros enteros
Los n´ umeros enteros se dividen en los siguientes tipos de datos, de acuerdo a su longitud en bits, lo cual determina su rango de operaci´on. Los tipos de datos primitivos son: byte, short, int, long. 1
American Standard Code for Information Interchange
´ CAP´ITULO 4. CONCEPTOS BASICOS
42
4.4.3.
N´ umeros de punto flotante
Java tiene los datos correspondientes a los n´ umeros reales de precisi´on sencilla (float) y doble precisi´on (double). Es decir, representan aquellos n´ umeros que poseen punto decimal. Pueden ser reales decimales, como por ejemplo 120.5, 253482.6, 0.687, o reales exponenciales, los cuales se expresan en potencias de 10. Tambi´en se conocen como n´ umeros expresados en notaci´on cient´ıfica. Por ejemplo: 0.98E1 es igual a 9.8 -3.5E3 equivale a -3500.0 4.5E-4 es 0.00045 Los datos demasiado grandes, pierden precisi´on al ser escritos en notaci´on cient´ıfica, debido a las aproximaciones. Los n´ umeros de punto flotante en Java utilizan el est´andar ANSI2 / IEEE3 754-1985 (Standard for binary floating - point arithmetic) de 32 y 64 bits.
4.5.
Aritm´ etica
El la primera parte de este libro (Algoritmos), se ilustra detalladamente el uso de operadores, precedencias y expresiones. Java utiliza todo lo antes mencionado, excepto las funciones predeterminadas como Potencia y Raiz_Cuadrada, entre otras. A medida que se utilicen, ser´an explicadas. Adicionalmente, se deben tener en cuenta los operadores de la tabla 4.4
2 3
American National Standard Institute Institute of Electrical and Electronics Engineers
´ 4.5. ARITMETICA
43
Operador
Ejemplo
Significado
++
I++, ++I
I = I + 1
--
I--, --I
I = I - 1
+=
X += 3
X = X + 3
-=
X -= 2
X = X - 2
*=
X *= 7
X = X * 7
/=
X /= 2
X = X / 2
Cuadro 4.4: Otros operadores en Java
Ejemplo Ver Prueba de escritorio 3. Prueba de escritorio 3 a = 2; b = 3; b += a; c = a++; ++b; b *= 2; c--; c = ++a;
´ CAP´ITULO 4. CONCEPTOS BASICOS
44
An´ alisis En la tabla 4.5 se analiza la prueba de escritorio 3. Instrucciones a = 2; b = 3;
a
b
2
3
b += a; c = a++;
5 3
++b;
2 6
b *= 2;
12
c--; c = ++a;
c
1 4
4
Cuadro 4.5: An´alisis Prueba de Escritorio 3 Observe detalladamente la diferencia entre ++a y a++. El primero se conoce como preincremento. El segundo se llama posincremento. En el caso del preincremento, primero se realiza el incremento y luego se usa la variable con su nuevo valor. En el caso del posincremento, primero se usa la variable con el valor actual y luego se incrementa. Sucede lo mismo con el predecremento y posdecremento.
Cap´ıtulo 5 Estructura secuencial La programaci´on secuencial es una serie de comandos o instrucciones una tras otra, con el fin de resolver un problema determinado. Una instrucci´on es ejecutada a continuaci´on de otra y todas son ejecutadas en el orden indicado. Instrucci´ on 1 Instrucci´ on 2 Instrucci´ on 3 .. . Instrucci´ on n
Las instrucciones b´asicas normalmente se pueden clasificar en: instrucciones para solicitar datos al usuario, c´alculos o procesamiento de datos para producir informaci´on y por supuesto entrega o impresi´on de resultados.
5.1.
Compilar y ejecutar un programa
Todo programa que se escriba en Java deber´a ser compilado para que las instrucciones que el programador ha escrito sean entendidas por el procesador. Compilar es el proceso de conversi´on del lenguaje Java a lenguaje de la M´aquina Virtual de Java para que ella lo interprete. 45
CAP´ITULO 5. ESTRUCTURA SECUENCIAL
46
Para compilar un archivo en Java, use la instrucci´on javac nombre.java. Este proceso, en caso de no tener ning´ un error, permite obtener un archivo .class, el cual ser´a utilizado para la ejecuci´on del programa con el comando java nombre. Tanto el programa java como javac vienen en el paquete JDK del sistema operativo en uso. A continuaci´on se presentan una serie de ejemplos o problemas resueltos, en los cuales se utilizan diferentes comandos. En la medida que vayan apareciendo, ser´an explicados.
5.2.
Problemas resueltos
1. Dados dos n´ umeros enteros que ingresan por teclado, sumarlos e imprimir el resultado. Suma = A + B Ver programa 1 “Suma de dos enteros”. A continuaci´on se explicar´an cada una de las instrucciones que componen el programa 1. Los componentes predefinidos de Java, llamados clases, est´an agrupados por categor´ıas en un ´arbol de directorios. Cada directorio se conoce con el nombre de paquete o Java API1 . La l´ınea import java.io.*; indica a Java que debe incluir todos las clases relacionadas con entrada y salida, previamente construidas y al servicio del usuario (* representa todo el conjunto) del paquete io. La tabla 5.1 muestra los paquetes m´as representativos de java. Todo programa en Java debe tener al menos una definici´on de clase. En este caso, la instrucci´on public class P_Sec_01 indica que se est´a definiendo una clase p´ ublica llamada P_Sec_01, la cual debe coincidir con P_Sec_01.java,el nombre del archivo que almacena el programa fuente. Es obligatorio definirla public para que pueda ser ejecutada por el usuario. 1
Applications Programming Interface
5.2. PROBLEMAS RESUELTOS
47
Programa 1 - Suma de dos enteros import java.io.*; public class P_Sec_01 { public static void main ( String args[ ] ) throws IOException { //---------------------------------------------BufferedReader Teclado; Teclado = new BufferedReader ( new InputStreamReader ( System.in ) ); //---------------------------------------------int A, B, Suma; System.out.println
( "SUMA DE DOS ENTEROS!!"
);
System.out.print ( "Primer Numero : " A = Integer.parseInt ( Teclado.readLine()
); );
System.out.print ( "Segundo Numero : " B = Integer.parseInt ( Teclado.readLine()
); );
Suma = A + B; System.out.println } }
( "Suma
: " + Suma );
CAP´ITULO 5. ESTRUCTURA SECUENCIAL
48 Paquete java.io
java.lang
java.util
java.applet java.awt
Descripci´ on Java Input/Output package. Es el paquete que contiene las clases necesarias para introducir y producir datos. Java Languaje package. Es el paquete que se carga autom´aticamente, el cual contiene las clases necesarias para la ejecuci´on de la mayor´ıa de los programas. Java Utilities package. Es el paquete que contiene las clases necesarias para la manipulaci´on de fechas, n´ umeros aleatorios, entre otras. Java Applets package. Es el paquete que contiene las clases necesarias para crear applets. Java Abstract Windowing Toolkit package. Es el paquete que contiene las clases necesarias para crear y manipular interfaces gr´aficas.
Cuadro 5.1: Principales paquetes de la Java API
As´ı como todo programa en Java debe tener al menos una clase, tambi´en es necesario que tenga por lo menos un m´etodo llamado main. Su definici´on general es public static void main ( String args[ ] ) throws IOException donde public para que pueda ser accedida en el momento de su ejecuci´on por parte del usuario. Debe ser static para indicarle a Java que esta clase no es solo una definici´on, sino que ya est´a lista para ser utilizada. Es importante tener en cuenta que no es obligatorio partir en dos renglones la instrucci´on anterior. Se divide as´ı para facilitar la interpretaci´on. Ocurre lo mismo con otras instrucciones. El nombre del m´etodo principal de un programa se llama main. Su definici´on es: void main ( String args[ ] ), donde se indica que no retorna valor alguno al terminar su ejecuci´on void. Adem´as, este programa podr´ıa recibir valores al momento de ordenar su ejecuci´on. String indica que los argumentos son cadenas de caracteres y args[ ] indica el identificador con el cual se pueden manejar los argumentos, aunque no son utilizados en este programa. En caso de tener alg´ un
5.2. PROBLEMAS RESUELTOS
49
inconveniente en la entrada de datos, Java genera una excepci´on de entrada/salida, la cual le dice al programa que algo no est´a bien. La orden throws IOException indica claramente al programa que no tenga en cuenta ninguna excepci´on generada en el proceso de entrada/salida. Estas excepciones ser´an omitidas con el objeto de analizar f´acilmente la ejecuci´on de los programas en Java. El conjunto de instrucciones que forman la funci´on main se agrupa utilizando los s´ımbolos { y } los cuales indican el comienzo y el final de un bloque de c´odigo. Es importante anotar que si una variable es declarada dentro de un bloque, tiene alcance u ´nicamente al interior del bloque en que se encuentra, es decir, no se puede utilizar por fuera del bloque. Como ya se ha mencionado, existen algunos tipos de datos b´asicos en Java. BufferedReader es una clase (tipo especial de dato). Al utilizar un identificador para una clase se llama objeto. En este caso, con la instrucci´on BufferedReader Teclado; estamos declarando un identificador llamado Teclado para un objeto de tipo BufferedReader. A diferencia de una variable de un tipo de dato b´asico, la cual contiene u ´nicamente informaci´on, un objeto puede tener en su interior m´etodos y atributos (variables internas). Esta l´ınea debe terminar con el s´ımbolo ; el cual indica fin de una instrucci´on. La instrucci´on Teclado = new BufferedReader ( new InputStreamReader ( System.in ) ); permiten crear el objeto que ser´a accedido a trav´es del identificador Teclado, el cual tendr´a la informaci´on obtenida desde el dispositivo est´andar de entrada System.in, normalmente el teclado. Observe que una cosa es el teclado como dispositivo f´ısico y otra Teclado como identificador. Para evitar confusiones, el usuario podr´ıa cambiar el identificador. Las instrucciones que se han explicado hasta ahora hacen parte de la mayor´ıa de programas que componen este libro. Los atributos (variables) de este programa son de tipo entero. La declaraci´on es int A, B, Suma;.
50
CAP´ITULO 5. ESTRUCTURA SECUENCIAL System.out.println( "SUMA DE DOS ENTEROS!!" ); permite imprimir en el dispositivo est´andar de salida, normalmente la pantalla, el mensaje encerrado entre comillas. Le sufijo ln indica que al terminar de imprimir el mensaje, deber´a saltar al comienzo de la l´ınea siguiente. A = Integer.parseInt ( Teclado.readLine() ); es utilizada para la entrada del atributo A, donde (Integer.parseInt) indica que el tipo de dato es entero y Teclado.readLine() que la entrada es desde el teclado. Las entradas de los otros datos, en este caso u ´nicamente el atributo B, se realiza de la misma forma. Generalmente, los programas hacen c´alculos o procesos con los datos de entrada. En este caso, la f´ormula Suma = A + B; permite obtener el resultado que se persigue con este programa. Finalmente, es necesario informar el resultado obtenido. Es la misma instrucci´on de imprimir en la pantalla mencionada anteriormente, asociada con el valor de un atributo. System.out.println ( "Suma: " + Suma ); indica que se imprimir´a en pantalla el mensaje Suma: y a continuaci´on el valor del atributo Suma. Observe el uso del operador +, utilizado para concatenar el mensaje con el valor de Suma. De ser necesario, podr´ıa utilizarse m´as de una vez este operador si se requiere concatenar otros mensajes o valores de atributos.
2. Calcular el ´area de un c´ırculo dada la longitud del radio. Area = π × r2 Ver programa 2 “Calcular el ´area de un c´ırculo”. En el programa 2 se puede apreciar que algunos componentes son muy similares al primero. Tenga en cuenta que debe conservar la estructura inicial, cargando el paquete java.io. En la definici´on de la clase, observe que el nombre es el correspondiente al archivo P_Sec_02.java. La definici´on del m´etodo principal se compone de instrucciones equivalentes al programa P_Sec_01.java, con su manejo de excepciones, al igual que el objeto Teclado. Recuerde que este u ´ltimo es solo un identificador y su nombre puede ser asignado por el programador.
5.2. PROBLEMAS RESUELTOS
51
Programa 2 - Calcular el ´ area de un c´ırculo import java.io.*; public class P_Sec_02 { public static void main ( String args[ ] ) throws IOException { //---------------------------------------------BufferedReader Teclado; Teclado = new BufferedReader ( new InputStreamReader ( System.in ) ); //---------------------------------------------double Area, Radio; System.out.println
( "AREA DEL CIRCULO!!" );
System.out.print ( "Radio: " Radio = Double.parseDouble ( Teclado.readLine()
); );
Area = Math.PI * Radio * Radio; System.out.println } }
( "Area : " + Area
);
52
CAP´ITULO 5. ESTRUCTURA SECUENCIAL Dentro de las instrucciones propias del programa, encontramos los atributos |Area|y Radio son de tipo double. Luego, es natural que la entrada Radio, al ser de este tipo corresponda a la instrucci´on Radio = Double.parseDouble ( Teclado.readLine() ); Finalmente, se aplica la f´ormula adecuada y se imprime el resultado. Observe el uso de Math.PI, la cual permite utilizar el valor de PI = 3.1415926... dentro de un programa.
3. Convertir una temperatura dada en grados Fahrenheit a grados cent´ıgrados. Cent =
´ 5 ³ × F ahr − 32 9
Ver programa 3 “Conversi´on de temperaturas”. En el programa 3 se puede notar que a diferencia de los anteriores, hay dos elementos nuevos llamados constantes. La definici´on de ellas se realiza con la siguiente sintaxis: final static double CONSFAHR1 = 5.0/9.0; donde final indica que el atributo no puede ser modificado (es constante); static permite que el atributo sea com´ un a todos los objetos de esa clase. A continuaci´on se especifica el tipo de dato, el identificador y el valor a tomar. Observe que se utiliza el cero a continuaci´on del punto separador decimal. El prop´osito de hacerlo de esta forma es para que Java se entere de que no puede hacer divisi´on entre dos enteros. Es importante anotar que no es obligatorio utilizar constantes. Sin embargo, se recomienda su uso para facilitar la realizaci´on de modificaciones, la interpretaci´on y la lectura del c´odigo fuente de un programa. Otra recomendaci´on es mantener los nombres de los identificadores que corresponden a constantes en letras may´ usculas, para que se puedan diferenciar r´apidamente. Con respecto a la l´ogica del programa, la entrada de datos, el c´alculo y la salida correponde al enunciado del problema.
5.2. PROBLEMAS RESUELTOS
53
Programa 3 - Conversi´ on de temperaturas import java.io.*; public class P_Sec_03 { final static double CONSFAHR1 = 5.0/9.0; final static double CONSFAHR2 = 32.0; public static void main ( String args[ ] ) throws IOException { //---------------------------------------------BufferedReader Teclado; Teclado = new BufferedReader ( new InputStreamReader ( System.in ) ); //---------------------------------------------double Fahr, Cent; System.out.println
( "TEMPERATURA!!"
System.out.print ( "Fahrenheit : " Fahr = Double.parseDouble ( Teclado.readLine()
); ); );
Cent = CONSFAHR1 * ( Fahr - CONSFAHR2 ); System.out.println } }
( "Centigrados: " + Cent );
CAP´ITULO 5. ESTRUCTURA SECUENCIAL
54
4. Convertir la medida de un ´angulo expresado en grados, minutos y segundos, a radianes. Grados = Grados + M/60 + S/3600
Radianes =
Grados × π 180
Ver programa 4 “Conversi´on de ´angulos”. Programa 4 - Conversi´ on de ´ angulos import java.io.*; public class P_Sec_04 { final static double GRAD_MIN = 60.0; final static double GRAD_SEG = 3600.0; final static double MEDIO_CIRCULO = 180.0; public static void main ( String args[ ] ) throws IOException { //---------------------------------------------BufferedReader Teclado; Teclado = new BufferedReader ( new InputStreamReader ( System.in ) ); //---------------------------------------------double Grados, Minutos, Segundos, Radianes; System.out.println
( "CONVERSION DE ANGULOS!!" );
El programa 4, como novedad incluye dos f´ormulas, donde el resultado de la primera es incorporado en la segunda, por medio del identificador Grados.
5.2. PROBLEMAS RESUELTOS
55
Continuaci´ on programa 4 System.out.print ( "Grados : " ); Grados = Double.parseDouble ( Teclado.readLine() ); System.out.print ( "Minutos : " ); Minutos = Double.parseDouble ( Teclado.readLine() ); System.out.print ( "Segundos: " ); Segundos = Double.parseDouble ( Teclado.readLine() ); Grados
+= Minutos / GRAD_MIN + Segundos / GRAD_SEG;
Radianes = Grados * Math.PI / MEDIO_CIRCULO; System.out.println } }
("Radianes: " + Radianes );
CAP´ITULO 5. ESTRUCTURA SECUENCIAL
56
5. Calcular el ´area de un tri´angulo conociendo las longitudes de los tres lados. s= ´ Area =
a+b+c 2
p
s × (s − a) × (s − b) × (s − c)
´ Ver programa 5 “Area de un tri´angulo”. ´ Programa 5 - Area de un tri´ angulo import java.io.*; public class P_Sec_05 { public static void main ( String args[ ] ) throws IOException { //---------------------------------------------BufferedReader Teclado; Teclado = new BufferedReader ( new InputStreamReader ( System.in ) ); //---------------------------------------------final double SEMI = 2.0; double L1, L2, L3, S, Area;
En el programa 5 se utiliza la constante local al m´etodo main. A diferencia de las constantes declaradas en los programas anteriores es que SEMI solo es reconocida dentro del m´etodo main, mientras las otras son reconocidas en toda la clase. Adem´as, el m´etodo Math.sqrt corresponde a la operaci´on ra´ız cuadrada.
5.3. PROBLEMAS PROPUESTOS
57
Continuaci´ on programa 5 System.out.println
( "AREA DEL TRIANGULO!!" );
System.out.print ( "Lado 1 : " L1 = Double.parseDouble ( Teclado.readLine()
); );
System.out.print ( "Lado 2 : " L2 = Double.parseDouble ( Teclado.readLine()
); );
System.out.print ( "Lado 3 : " L3 = Double.parseDouble ( Teclado.readLine()
); );
S = ( L1 + L2 + L3 ) / SEMI; Area = Math.sqrt ( S * (S-L1) * (S-L2) * (S-L3)
);
System.out.println
);
( "El area es: " + Area
} }
5.3.
Problemas propuestos
Antes de resolver cualquier ejercicio, lea detenidamente el enunciado, identifique los datos que necesita, cu´ales son conocidos y cu´ales no. Los datos desconocidos generalmente est´an asociados a f´ormulas matem´aticas que debe tener a la mano. No olvide que la respuesta del programa debe estar de acuerdo con los requerimientos del enunciado. Documente y use identificadores representativos para que se puedan entender m´as f´acilmente sus programas. 1. Dado un n´ umero natural n, calcular la suma de los primeros n n´ umeros naturales. n × (n + 1) Suma = 2
58
CAP´ITULO 5. ESTRUCTURA SECUENCIAL
2. Calcular el valor de una compra de unos d´olares, conociendo el valor de la tasa representativa del mercado (TRM) en pesos. P esos = D´ olares × T RM 3. De un estudiante conocemos la nota 1 (N1 ), la nota 2 (N2 ), la nota de trabajos (NT ) y el Examen final (EF ). Calcular la nota definitiva (ND ) aplicando los porcentajes 20%, 20%, 30% y 30%, respectivamente. Tenga en cuenta que 20% equivale a 0.2 y 30% es igual a 0.3. ND = N1 × 20 % + N2 × 20 % + NT × 30 % + EF × 30 % 4. Dados dos puntos del plano cartesiano P (X1 , Y1 ) y Q(X2 , Y2 ), hallar las coordenadas del punto medio. Xm =
X1 + X2 2
Ym =
Y1 + Y2 2
5. En una competencia cicl´ıstica se hace un recorrido de una distancia medida en Km, en un tiempo total medido en horas (H), minutos (M ), segundos (S) y cent´esimas de segundo (CS ). Calcular la velocidad en Km por hora. Tenga en cuenta que una hora equivale a 60 minutos, un minuto a 60 segundos y un segundo a 100 cent´esimas de segundo. T iempo = H + M/60 + S/3600 + CS /360000 V elocidad =
Distancia T iempo
6. Dada la longitud del lado (L) de un cubo, calcular el ´area de la base (AB ), el ´area lateral (AL ), y el volumen (V ). AB = L2
AL = 4 × AB
V = L3
7. Hallar el deteminante de una matriz 2 x 2, de la forma: µ ¶ a b c d Determinante = a × d − b × c
5.3. PROBLEMAS PROPUESTOS
59
8. Calcular el rendimiento de un CDT en una entidad financiera, conociendo el monto, el plazo en d´ıas y la tasa de inter´es anual. Observe que por tener el plazo en dias, la tasa de inter´es anual se divide entre 360. M onto × Inter´ es × P lazo Rendimiento = 360 9. Dado el monto de un cr´edito (M ), el plazo (P ) y tasa de interes anual (I), calcular la cuota fija mensual (C) que se debe cancelar a una entidad financiera. M × I × (I + 1)P C= (I + 1)P − 1 10. Dados tres puntos del plano cartesiano P (X1 , Y1 ); Q(X2 , Y2 ) y R(X3 , Y3 ), correspondientes a los v´ertices de un tri´angulo, hallar su ´area y su per´ımetro. p DistanciaP −Q = a = (X2 − X1 )2 + (Y2 − Y1 )2 s= ´ Area =
p
a+b+c 2
s × (s − a) × (s − b) × (s − c) P erimetro = 2 × s
60
CAP´ITULO 5. ESTRUCTURA SECUENCIAL
Cap´ıtulo 6 M´ etodos Si un programa tuviera u ´nicamente el m´etodo main, el c´odigo ser´ıa demasiado largo y complejo, dif´ıcil de leer, modificar, actualizar y depurar. Para facilitar estas tareas, es recomendable utilizar m´etodos. Los m´etodos adem´as permiten modularizar programas (dividir un programa extenso en partes m´as f´aciles de manejar), reutilizar el c´odigo (aprovechar m´etodos ya escritos y probados en otros programas en programas nuevos) y evitar la repetici´on de c´odigo en un programa (fragmentos que se utilicen varias veces en un mismo programa).
6.1.
Estructura de un m´ etodo
Los m´etodos tienen una estructura general como la siguiente: Ver “Estructura de un m´etodo”.
Ejemplo Ver “M´etodo que suma dos enteros”. Para utilizar un m´etodo (hacer el llamado), es importante tener en cuenta el tipo de dato que devuelve, su identificador y los argumentos que se deben proporcionar, a fin de evitar errores. 61
´ CAP´ITULO 6. METODOS
62
Estructura de un m´ etodo tipo_de_valor_devuelto Nombre_metodo ( lista_de_parametros ) { declaracion_variables_locales lista_de_instrucciones }
M´ etodo que suma dos enteros static int Suma ( int Numero1, int Numero2 ) { int Resultado; Resultado = Numero1 + Numero2; return Resultado; }
6.2. RECOMENDACIONES Y GENERALIDADES
63
Los m´etodos se definen en este libro como static, de forma similar a las clases, para que no sean una simple definici´on y puedan ser utilizados inmediatamente. Ver p´agina 46. Ver “M´etodo que llama a otro”. M´ etodo que llama a otro static int Calculo_Prueba ( void ) { int A, B, S; A = 10; B = 50; S = Suma ( A, B ); return S; }
Tenga en cuenta la diferencia entre los t´erminos par´ametros y argumentos. En el m´etodo Suma, Numero1 y Numero2 son par´ametros y Resultado es una variable local de tipo entero. En Calculo_Prueba, no hay par´ametros (void) mientras que los argumentos con los cuales se pasa informaci´on al m´etodo Suma son A y B. Sus variables locales son A, B y S, enteras.
6.2.
Recomendaciones y generalidades
Cualquier programa escrito en Java se compone de al menos un m´etodo llamado main (principal). Este m´etodo tiene especificadas todas las instrucciones que se van a ejecutar en el programa, escritas en el orden que determine el programador. El nombre de un m´etodo es un identificador v´alido. Es importante utilizar nombres muy claros y significativos para aumentar la claridad de un programa.
´ CAP´ITULO 6. METODOS
64
Despu´es de creado un m´etodo, pasar´a a ser una instrucci´on m´as del lenguaje, dentro del programa en que se encuentre. Asi, se ampl´ıan las posibilidades del usuario. Las variables declaradas dentro de un m´etodo, tendr´an alcance local, es decir, solo tendr´an sentido dentro del m´etodo. Al terminar la ejecuci´on de dicho m´etodo, estas variables desaparecen. Cuando un m´etodo necesita de otro, generalmente le proporciona informaci´on al hacer el llamado (usando su identificador), a trav´es de argumentos, los cuales se llamar´an par´ametros dentro del m´etodo que recibe dicha informaci´on. Los par´ametros se consideran variables locales. Aunque no es obligatorio, los nombres de los par´ametros no deben ser los iguales a los nombres de los argumentos para evitar ambig¨ uedades. Un m´etodo debe estar escrito de tal manera que sea muy clara la tarea que desempe˜ na (una y solo una). En otras palabras, un m´etodo debe ser f´acil de describir mediante una frase que no tenga conectores l´ogicos. En caso de tener necesidad de realizar varias tareas en un m´etodo, deber´an hacerse los llamados a m´etodos que realicen tareas individuales. Con respecto a la longitud, en lo posible, un m´etodo no debe ocupar m´as de una p´agina. Ser´ıa ideal que no ocupara m´as de media. Al construir programas como una colecci´on de m´etodos peque˜ nos se facilita su escritura, depuraci´on, mantenimiento y modificaci´on.
6.3.
Problemas resueltos
En esta secci´on se mostrar´an los mismos ejemplos del cap´ıtulo anterior, aprovechando los beneficios que ofrecen los m´etodos. Cuando se utilicen m´etodos que hacen parte de otros programas, simplemente se har´a la referencia a la p´agina en la que se utiliz´o por primera vez y se encuentra su explicaci´on. A diferencia de los programas que se explicaban al finalizar cada uno, ahora se har´an los comentarios pertinentes al finalizar cada m´etodo.
6.3. PROBLEMAS RESUELTOS
65
1. Dados dos n´ umeros enteros que ingresan por teclado, sumarlos e imprimir el resultado. Suma = A + B Ver programa 6 “Suma de dos enteros”. Programa 6 - Suma de dos enteros import java.io.*; public class P_Met_01 { public static void main ( String args[ ] ) throws IOException { int A, B, Suma; System.out.println ( "SUMA DE DOS ENTEROS!!"
);
A = Entrada_Int B = Entrada_Int Suma = Calculo Salida_Int
); ); ); );
( ( ( (
"Primer Numero: " "Segundo Numero: " A, B "Suma : ", Suma
}
En el programa 6, el m´etodo principal tiene como objetivo llamar los m´etodos necesarios para entregar la suma de dos enteros dados por el usuario. Usa tres variables locales, A, B y Suma. Imprime en pantalla un t´ıtulo con el objetivo del programa. Realiza dos veces el llamado al m´etodo Entrada_Int, retornando en las variables A y B. Al hacer el llamado al m´etodo se le pasa como argumento una cadena de caracteres (mensaje entre comillas), que ayuda a identificar el dato que el usuario va a ingresar.
´ CAP´ITULO 6. METODOS
66
La variable Suma recibe el valor que retorna el m´etodo Calculo, al cual se le pasan como argumentos los valores de A y B. Finaliza el programa con el llamado al m´etodo Salida_Int, al cual se le pasan dos argumentos, una cadena de caracteres que acompa˜ na la salida y un valor entero que se desea imprimir, en este caso, el valor de Suma. Tenga presente que aunque no es necesario alinear los operadores de asignaci´on, ni los par´entesis, un programa es mucho m´as f´acil de leer si el programador se toma unos minutos adicionales para mejorar la apariencia del c´odigo que est´a escribiendo. Continuaci´ on programa 6 static int Entrada_Int ( String Msj ) throws IOException { //---------------------------------------------BufferedReader Teclado; Teclado = new BufferedReader ( new InputStreamReader ( System.in ) ); //---------------------------------------------int Numero; System.out.print ( Msj ); Numero = Integer.parseInt ( Teclado.readLine()
);
return Numero; }
En el m´etodo Entrada_Int, es necesario evitar el manejo de excepciones de entrada y salida, igual a como ocurre en el m´etodo principal de cualquier programa del cap´ıtulo anterior. Tambi´en, de la misma forma como se ha venido trabajando, el uso del objeto Teclado es el mismo, practicamente a lo largo de todo el libro. Simplemente, tenga presente de no olvidar ning´ un detalle al memento de hacer alguna entrada por el teclado.
6.3. PROBLEMAS RESUELTOS
67
Este m´etodo tiene como objetivo retornar un dato de tipo entero, ingresado por el usuario. El par´ametro Msj contiene el mensaje que se quiere imprimir (argumento dado en el llamado al m´etodo) para ayudar al usuario a identificar el dato a leer. El valor contenido en la variable local Numero es retornado al m´etodo que lo ha llamado, generalmente para asignarlo a una variable. Este m´etodo ser´a utilizado en este libro cada vez que se necesite ingresar un n´ umero entero. En virtud de la reutilizaci´on de c´odigo, no se volver´a a explicar. Simplemente se har´a una referencia a esta p´agina. Continuaci´ on programa 6 static int Calculo ( int Numero1, int Numero2 ) { return Numero1 + Numero2; }
El m´etodo Calculo tiene dos par´ametros Numero1 y Numero2. Estos dos par´ametros toman los valores que el m´etodo llamante ha entregado como argumentos. El objetivo es retornar la suma de ellos. Continuaci´ on programa 6 static void Salida_Int ( String Msj, int Numero ) { System.out.println ( Msj + Numero ); } }
El m´etodo Salida_Int imprime en la pantalla un mensaje y un n´ umero entero que el m´etodo llamante pasa como argumentos en los par´ametros Msj y Numero.
´ CAP´ITULO 6. METODOS
68
Al igual que en el m´etodo Entrada_Int, este m´etodo ser´a utilizado cada vez que se necesite imprimir un entero, caso en el cual se har´a la referencia respectiva. Observe que el u ´ltimo s´ımbolo } no corresponde al m´etodo Salida_Int. Es el indicador de que la clase P_Met_01 ha terminado. Tenga especial cuidado al reutilizar este m´etodo. 2. Calcular el ´area de un c´ırculo dada la longitud del radio. Area = π × r2 Ver programa 7 “Calcular el ´area de un c´ırculo”. Programa 7 - Calcular el ´ area de un c´ırculo import java.io.*; public class P_Met_02 { public static void main ( String args[ ] ) throws IOException { double Area, Radio; System.out.println
( "AREA DEL CIRCULO!!" );
Radio = Entrada_Double ( "Radio: " Area = Calculo ( Radio Salida_Double ( "Area : ", Area
); ); );
}
El objetivo de este programa es llamar los m´etodos necesarios para entregar el ´area de un c´ırculo cuando el usuario ha proporcionado la longitud del radio. La diferencia fundamental con el programa anterior radica en el uso de variables de tipo double, lo que obliga a utilizar Entrada_Double y Salida_Double.
6.3. PROBLEMAS RESUELTOS
69
Continuaci´ on programa 7 static double Entrada_Double ( String Msj ) throws IOException { //---------------------------------------------BufferedReader Teclado; Teclado = new BufferedReader ( new InputStreamReader ( System.in ) ); //---------------------------------------------double Numero; System.out.print ( Msj ); Numero = Double.parseDouble ( Teclado.readLine() ); return Numero; }
El m´etodo Entrada_Double, es similar a Entrada_Int, de la p´agina 66, pero retornando un valor de tipo double. Continuaci´ on programa 7 static double Calculo ( double Numero ) { return Math.PI * Numero * Numero; }
Este m´etodo Calculo, encuentra el ´area de un c´ırculo donde el radio est´a representado por el par´ametro Numero. Retorna un valor de tipo double. Salida_Double es similar a Salida_Int (p´agina 67), pero el n´ umero que imprime es de tipo double. Ser´a referenciada en cualquier utilizaci´on posterior.
´ CAP´ITULO 6. METODOS Continuaci´ on programa 7
70
static void Salida_Double ( String Msj, double Numero ) { System.out.println ( Msj + Numero ); } }
3. Convertir una temperatura dada en grados Fahrenheit a grados cent´ıgrados. Cent =
´ 5 ³ × F ahr − 32 9
Ver programa 8 “Conversi´on de temperaturas”. Programa 8 - Conversi´ on de temperaturas import java.io.*; public class P_Met_03 { final static double CONSFAHR1 = 5.0/9.0; final static double CONSFAHR2 = 32.0;
Este programa hace el llamado de los m´etodos necesarios para imprimir el resultado de convertir una temperatura dada por el usuario en grados Fahrenheit a grados Cent´ıgrados. Usa variables locales de tipo double, al igual que dos constantes. La entrada de la temperatura se hace mediante el llamado al m´etodo Entrada_Double, visto en la p´agina 69. El m´etodo Calculo recibe la temperatura en grados Fahrenheit y retorna su equivalente en grados cent´ıgrados. Para ello, recibe en el
6.3. PROBLEMAS RESUELTOS
71
Continuaci´ on programa 8 public static void main ( String args[ ] ) throws IOException { double Fahr, Cent; System.out.println
( "TEMPERATURA!!"
);
Fahr = Entrada_Double ( "Fahrenheit : " ); Cent = Calculo ( Fahr ); Salida_Double ( "Centigrados: ", Cent ); }
Continuaci´ on programa 8 static double Calculo ( double Numero ) { return CONSFAHR1 * ( Numero - CONSFAHR2 ); }
´ CAP´ITULO 6. METODOS
72
par´ametro Numero la temperatura y hace uso de las constantes definidas al inicio del programa. Para la salida del resultado, utilizamos el m´etodo Salida_Double de la p´agina 70. 4. Convertir la medida de un ´angulo expresado en grados, minutos y segundos, a radianes. Grados = Grados + M/60 + S/3600 Radianes =
Grados × π 180
Ver programa 9 “Conversi´on de ´angulos”. Programa 9 - Conversi´ on de ´ angulos import java.io.*; public class P_Met_04 { final static double GRAD_MIN = 60.0; final static double GRAD_SEG = 3600.0; final static double MEDIO_CIRCULO = 180.0; public static void main ( String args[ ] ) throws IOException { double Grados, Minutos, Segundos, Radianes; System.out.println
( "CONVERSION DE ANGULOS!!" );
Este programa imprime el equivalente de un ´angulo suministrado en Grados, Minutos y Segundos, a Radianes, utilizando los m´etodos Entrada_Double visto en la p´agina 69, Calc_Rad y Salida_Double de la p´agina 70. El m´etodo Calc_Rad realiza un c´alculo temporal en la variable Gr y luego la conversi´on aplicando las respectivas f´ormulas.
6.3. PROBLEMAS RESUELTOS
73
Continuaci´ on programa 9 Grados = Entrada_Double Minutos = Entrada_Double Segundos = Entrada_Double Radianes = Calc_Rad Salida_Double
( ( ( ( (
"Grados : " "Minutos : " "Segundos: " Grados, Minutos, Segundos "Radianes: ", Radianes
); ); ); ); );
}
Continuaci´ on programa 9 static double Calc_Rad ( double Gr, double Mn, double Sg ) { Gr += Mn / GRAD_MIN + Sg / GRAD_SEG; return Gr * Math.PI / MEDIO_CIRCULO; }
´ CAP´ITULO 6. METODOS
74
Es de tener en cuenta que al pasar valores de datos primitivos a un m´etodo, lo que se est´a pasando es una copia del valor respectivo. Por lo tanto, si dentro de un m´etodo se realiza alguna modificaci´ on al par´ametro recibido, no se modifica la variable original, como en caso de Calc_Rad con el valor del par´ ametro Gr. 5. Calcular el ´area de un tri´angulo conociendo las longitudes de los tres lados. s= ´ Area =
a+b+c 2
p
s × (s − a) × (s − b) × (s − c)
´ Ver programa 10 “Area de un tri´angulo”. ´ Programa 10 - Area de un tri´ angulo import java.io.*; public class P_Met_05 { final static double SEMI = 2.0; public static void main ( String args[ ] ) throws IOException { double L1, L2, L3, S, Area; System.out.println
( "AREA DEL TRIANGULO!!" );
El programa 10 imprime el ´area de un tri´angulo cuando el usuario ha proporcionado las longitudes de los tres lados. Usamos los m´etodos Entrada_Double, (p´agina 69) y Salida_Double (p´agina 70).
6.4. PROBLEMAS PROPUESTOS
75
Continuaci´ on programa 10 L1 = Entrada_Double L2 = Entrada_Double L3 = Entrada_Double Area = Calculo Salida_Double
( ( ( ( (
"Lado 1 : "Lado 2 : "Lado 3 : L1, L2, L3 "El area es:
" " " ", Area
); ); ); ); );
}
Continuaci´ on programa 10 static double Calculo ( double N1, double N2, double N3 ) { double S; S = ( N1 + N2 + N3 ) / SEMI; return Math.sqrt ( S * (S-N1) * (S-N2) * (S-N3) ); }
El m´etodo Calculo usa la informaci´on que recibe en sus tres par´ametros para calcular el ´area del tri´angulo. Usa un c´alculo temporal (Semiper´ımetro).
6.4.
Problemas propuestos
As´ı como los ejemplos de este cap´ıtulo fueron los mismos del cap´ıtulo anterior, convertidos de tal manera que usaran m´etodos, sugerimos que los problemas a resolver en este cap´ıtulo sean los mismos de la p´agina 57, usando m´etodos.
76
´ CAP´ITULO 6. METODOS
Cap´ıtulo 7 Decisiones simples En vista de que no todos los problemas se pueden resolver de forma secuencial, Java permite el uso de las decisiones simples mediante el uso de la estructura if. El if (estructura de decisi´on simple) permite definir dos conjuntos de instrucciones que se deben ejecutar de acuerdo al resultado de una expresi´on l´ogica. En todos los casos, se puede escoger un solo bloque de instrucciones de tal manera que el otro es ignorado. Puede ocurrir que el segundo bloque est´e vac´ıo, caso en el cual simplemente la ejecuci´on de las instrucciones del primer bloque dependen exclusivamente del resultado de la expresi´on l´ogica, tambi´en llamada condici´on. Ver “Estructura general del if - 1”. En cualquier caso, la condici´on tendr´a que tomar un valor de verdad, el cual puede ser verdadero o falso. No es posible evitarlos o escogerlos a los dos, al mismo tiempo. Por lo tanto, se dice que la decisi´on es excluyente. A pesar de que siempre se intenta escribir programas lo m´as f´aciles de leer y entender, a veces se requiere del criterio de FALSO es igual a cero y VERDADERO es diferente de cero, por lo cual es posible encontrar programas con decisiones como por ejemplo: Ver “Estructura general del if - 2”. Muchas personas intentan resumir el c´odigo de un programa eliminando los s´ımbolos de agrupaci´on { } cuando el bloque se compone de una sola instrucci´on. Aunque es muy respetable y no genera errores al momento de compi77
78
CAP´ITULO 7. DECISIONES SIMPLES Estructura general del if - 1 Instrucciones antes de la decision if ( condicion ) { Instrucciones en caso de que condicion sea verdadero } else { Instrucciones en caso de que condicion sea falso } Instrucciones despues de la decision
Estructura general del if - 2 Instrucciones antes de la decision if ( valor ) { Instrucciones en caso de que valor sea diferente de cero } else { Instrucciones en caso de que valor sea cero } Instrucciones despues de la decision
7.1. PROBLEMAS RESUELTOS
79
lar, no es recomendable porque dificulta la legibilidad y sobre todo el proceso de actualizaci´on de los programas.
7.1.
Problemas resueltos
1. Elabore un programa que realice la divisi´on entre dos enteros, evitando la divisi´on por cero. Cociente =
Dividendo Divisor
Ver programa 11 “Divisi´ on por cero”. Programa 11 - Divisi´ on por cero import java.io.*; public class P_Dec_01 { public static void main ( String args[ ] ) throws IOException { int Dividendo, Divisor, Cociente; System.out.println
( "DIVISION POR CERO!!" );
El manejo de la decisi´on en el programa 11 es con respecto a cero. Es decir, si el Divisor es diferente de cero, se ejecuta el bloque de instrucciones que se escribieron a continuaci´on de la condici´on. En caso de que sea falsa la condici´on, se ejecuta el bloque de instrucciones que est´a a continuaci´on de la palabra else. Para la entrada de los datos correspondientes al Dividendo y Divisor, se utiliza el m´etodo Entrada_Int de la p´agina 66.
CAP´ITULO 7. DECISIONES SIMPLES
80
Continuaci´ on programa 11 Dividendo = Entrada_Int ( "Dividendo: " Divisor = Entrada_Int ( "Divisor : "
); );
if ( Divisor != 0 ) { Cociente = Calc_Cociente( Dividendo, Divisor ); Salida_Int ( "Resultado: ", Cociente ); } else { System.out.println ( "ERROR!! Division por cero." ); } }
Continuaci´ on programa 11 static int Calc_Cociente ( int Numero1, int Numero2 ) { return Numero1 / Numero2; }
7.1. PROBLEMAS RESUELTOS
81
El m´etodo Calc_Cociente realiza la divisi´on entre dos enteros llamados (Dividendo y Divisor) que dentro de este m´etodo est´an representados por los par´ametros Numero1 y Numero2, respectivamente. Para la entrega de los resultados se utiliza el m´etodo Salida_Int de la p´agina 67. 2. De un trabajador se tienen el n´ umero de horas trabajadas, el valor de la hora y su presupuesto mensual de gastos. Mediante un programa que solicite estos datos desde el teclado, calcule el salario y determine si su ingreso es suficiente para cubrir los gastos o no. Ingreso = N u´mero de horas × V alor de la hora Ver programa 12 “An´ alisis del presupuesto mensual”. Programa 12 - An´ alisis del presupuesto mensual import java.io.*; public class P_Dec_02 { public static void main ( String args[ ] ) throws IOException { int N_Horas; double V_Hora, Ingreso, Presup; System.out.println
( "PRESUPUESTO!!
" );
N_Horas = Entrada_Int ( "Numero de horas : " ); V_Hora = Entrada_Double ( "Valor hora : " ); Presup = Entrada_Double ( "Presupuesto mensual: " ); Ingreso = Calculo_Ingreso( N_Horas, V_Hora Verificar ( Ingreso, Presup }
); );
CAP´ITULO 7. DECISIONES SIMPLES
82
Los m´etodos Entrada_Int de la p´agina 66 y Entrada_Double de la p´agina 69, permiten leer los datos desde el teclado. Estos datos son los argumentos al llamar el m´etodo Calculo_Ingreso para el c´alculo del salario del empleado. Finalmente las variables Ingreso y Presup se pasan como argumentos al m´etodo Verificar. Continuaci´ on programa 12 static double Calculo_Ingreso ( int NH, double VH ) { return NH * VH; }
El m´etodo Calculo_Ingreso recibe como par´ametros los argumentos con los cuales ha sido llamado, con el prop´osito de retornar el ingreso del empleado. Continuaci´ on programa 12 static void Verificar ( double Ing, double Pre ) { if ( Ing >= Pre ) { System.out.println ( "El ingreso alcanza!!" ); } else { System.out.println ( "No es suficiente!! " ); } } }
El m´etodo Verificar es un ejemplo de c´omo tomar una decisi´on para seleccionar el mensaje adecuado de acuerdo al comportamiento de la condici´on.
7.1. PROBLEMAS RESUELTOS
83
3. Verificar si un n´ umero est´a dentro del rango de los enteros cortos (short). Ver programa 13 “Verificaci´ on del rango de un entero corto”. Programa 13 - Verificaci´ on del rango de un entero corto import java.io.*; public class P_Dec_03 { final static long LIMITE_INF = -32768; final static long LIMITE_SUP = 32767; public static void main ( String args[ ] ) throws IOException { long Entero; System.out.println
( "RANGO DE ENTEROS!!" );
Entero = Entrada_Long ( "Numero : " Verificar ( Entero
); );
}
El programa 13 usa dos constantes de tipo long para establecer los l´ımites inferior y superior. Adem´as, mediante m´etodos se lee el n´ umero que se desea verificar y al pasarlo como argumento al m´etodo Verificar se imprime un resultado en la pantalla. El m´etodo Entrada_Long es similar a Entrada_Int especificado en la p´agina 66. El m´etodo Verificar imprime un mensaje de acuerdo a la condici´on. En este caso, la condici´on utiliza el conector l´ogico ||, para indicar que si el n´ umero al cual est´a representando el par´ametro Num est´a o no por fuera del rango especificado por las constantes LIMITE_INF y LIMITE_SUP.
CAP´ITULO 7. DECISIONES SIMPLES
84
Continuaci´ on programa 13 static long Entrada_Long ( String Msj ) throws IOException { //---------------------------------------------BufferedReader Teclado; Teclado = new BufferedReader ( new InputStreamReader ( System.in ) ); //---------------------------------------------long Numero; System.out.print ( Msj ); Numero = Long.parseLong ( Teclado.readLine()
);
return Numero; }
Continuaci´ on programa 13 static void Verificar ( long Num ) { if ( Num < LIMITE_INF || Num > LIMITE_SUP ) { System.out.println ( "Esta por fuera del rango!!" ); } else { System.out.println ( "Puede ser un Entero!! " ); } } }
7.1. PROBLEMAS RESUELTOS
85
4. Elabore un programa que solicite la entrada del n´ umero de horas y el valor de cada hora trabajada por un empleado. El pago se calcular´a teniendo en cuenta que debe trabajar 160 horas en el mes. En caso de tener horas extras tendr´a una bonificaci´on del 20%. P ago Horas N ormales = NHoras × VHora
P ago Horas Extras = NH.Extras × VHora × 120 %
P ago = P ago Horas N ormales + P ago Horas Extras Ver programa 14 “Pago de horas extras a un trabajador”. Programa 14 - Pago de horas extras a un trabajador import java.io.*; public class P_Dec_04 { final static int HORAS_BASE = 160; final static int MIN_H_EXTR = 0; final static double PORC_INC = 120.0 / 100.0; public static void main ( String args[ ] ) throws IOException { int N_Horas; double V_Hora, Pago; System.out.println
( "HORAS EXTRAS!!"
);
El programa 14 utiliza los m´etodos Entrada_Int de la p´agina 66 y Entrada_Double de la p´agina 69. Utiliza el m´etodo Calculo_Pago y el resultado que retorna lo almacena en la variable Pago.
CAP´ITULO 7. DECISIONES SIMPLES
86
Continuaci´ on programa 14 N_Horas = Entrada_Int V_Hora = Entrada_Double Pago = Calculo_Pago Salida_Double
( ( ( (
"Numero de horas : " "Valor hora : " N_Horas, V_Hora "Valor a pagar : ", Pago
}
Continuaci´ on programa 14 static double Calculo_Pago ( int NH, double VH ) { int H_Extras, H_Normal; if ( NH > HORAS_BASE ) { H_Extras = NH - HORAS_BASE; H_Normal = HORAS_BASE; } else { H_Extras = MIN_H_EXTR; H_Normal = NH; } return H_Normal * VH + H_Extras * VH * PORC_INC; }
); ); ); );
7.1. PROBLEMAS RESUELTOS
87
En el m´etodo Calculo_Pago es importante tener en cuenta el manejo de las operaciones que se deben realizar cuando se quiere calcular un porcentaje. Para la entrega de los resultados se utiliza el m´etodo Salida_Double de la p´agina 70. 5. Calcular el rendimiento de un CDT en una entidad financiera conociendo el monto, el plazo en d´ıas y la tasa de inter´es anual. Si el rendimiento supera el monto m´aximo permitido diario (especificado por el usuario) se debe pagar un impuesto a una tasa de inter´es, tambi´en ingresada por el usuario. Rendimiento = ½ Descuento =
M onto × P lazo × T asa 360
Rendimiento × T asa impuesto 0
Si el rendimiento supera la tasa diaria permitida se debe calcular el impuesto. En otro caso, no hay impuesto y se asigna como 0. P ago = Rendimiento − Descuento Ver programa 15 “Rendimiento de un CDT”. Programa 15 - Rendimiento de un CDT import java.io.*; public class P_Dec_05 { final static double DIAS = 360.0; final static double CONST_PORC = 100.0; final static double MINIMO_DESC = 0.0;
CAP´ITULO 7. DECISIONES SIMPLES Continuaci´ on programa 15
88
public static void main ( String args[ ] ) throws IOException { int Plazo; double Monto, Tasa, Maximo, Impuesto; double Rendto, Descuento, Pago; System.out.println ( "RENDIMIENTO CDT CON RETENCION!!" System.out.println ( "( 9% = 9 ) "
); );
Monto Plazo Tasa Maximo Impuesto
); ); ); ); );
= = = = =
Entrada_Double Entrada_Int Entrada_Double Entrada_Double Entrada_Double
( ( ( ( (
"Monto del CDT "Plazo en dias "Interes anual "Maximo valor diario "Tasa Impuesto
: : : : :
" " " " "
Rendto = Calc_Rend ( Monto, Plazo, Tasa ); Descuento = Calc_Desc ( Rendto, Maximo, Plazo, Impuesto ); Pago = Calc_Pago ( Rendto, Descuento ); Salida_Double Salida_Double Salida_Double
( "Rendimiento ( "Descuento ( "Valor a pagar
: ", Rendto ); : ", Descuento ); : ", Pago );
}
El programa 15 utiliza los m´etodos Entrada_Int de la p´agina 66 y Entrada_Double de la p´agina 69. Utiliza los m´etodos Calc_Rend, Calc_Desc, y Calc_Pago para determinar el rendimiento, el descuento y el pago de un CDT. En el m´etodo Calc_Rend se calcula el rendimiento del CDT, usando la f´ormula especificada. El m´etodo Calc_Desc se encarga de calcular el descuento, aplicando la f´ormula correspondiente. En caso de no superar la cantidad diaria, el descuento es el menor descuento especificado en la constante MINIMO_DESC.
7.1. PROBLEMAS RESUELTOS Continuaci´ on programa 15 static double Calc_Rend ( double Mon, int Pla, double Tas ) { return Mon * Pla * Tas / CONST_PORC / DIAS; }
Continuaci´ on programa 15 static double Calc_Desc ( double Ren, double Max, int Pla, double Imp ) { double Desc; if ( Ren > Max * Pla ) { Desc = Ren * Imp / CONST_PORC; } else { Desc = MINIMO_DESC; } return Desc; }
Continuaci´ on programa 15 static double Calc_Pago ( double Ren, double Des ) { return Ren - Des; }
89
CAP´ITULO 7. DECISIONES SIMPLES
90
Para el m´etodo Calc_Pago se utiliza la f´ormula indicada, con los datos que se le suministren al momento de hacer el llamado en el m´etodo principal. Para la entrega de los resultados se utiliza el m´etodo Salida_Double de la p´agina 70.
7.2.
Problemas propuestos
1. Dado un n´ umero real cualquiera, imprimir su valor absoluto. ½ |x| =
x, si x ≥ 0 −x, si x < 0
2. De un empleado se conoce su sueldo actual. Si ´este es mayor o igual a $500.000, se le aumenta un 8%. En caso contrario, se le aumenta el 10%. SueldoN uevo = SueldoActual × 1,08 SueldoN uevo = SueldoActual × 1,1 3. Dadas tres notas de un estudiante, calcular la definitiva por promedio y un mensaje que indique si gan´o o perdi´o el curso. La nota m´ınima necesaria para aprobar es 3.0. P romedio =
N1 + N2 + N3 3
4. Dado un n´ umero r y los coeficientes de una ecuaci´on cuadr´atica, imprima un mensaje que indique si r es ra´ız de la ecuaci´on, utilizando el m´etodo de sustituci´on. a × r2 + b × r + c = 0
7.2. PROBLEMAS PROPUESTOS
91
5. Dado el precio de un art´ıculo, la cantidad de art´ıculos a comprar y el valor entregado por el cliente, calcular la devuelta (si le alcanza) o imprimir un mensaje que le indique que le hace falta dinero para pagar la cuenta. Cuenta = Cantidad × P recio Devuelta = V alorP agado − Cuenta 6. Dados dos puntos del plano cartesiano P (X1 , Y1 ) y Q(X2 , Y2 ), hallar la pendiente de la recta que pasa por ellos. Si x1 = x2, la pendiente no existe. P endiente =
Y2 − Y1 X2 − X1
7. Dados dos n´ umeros racionales en la forma ab y dc , realice la suma teniendo en cuenta que los denominadores no pueden ser ceros. a c a×d+b×c + = b d b×d 8. Dada una ecuaci´on de segundo grado, encontrar las soluciones. Si el discirminate es cero o positivo, hay soluciones reales. Si es negativo, las soluciones son imaginarias. x=
−b ±
√
b2 − 4 × a × c 2×a
9. Hallar la inversa de una matriz de 2 x 2 de la forma: µ ¶ a b A= c d La inversa es: 1 det(A)
µ
d −b −c a
Verifique que el determinante no sea cero.
¶
CAP´ITULO 7. DECISIONES SIMPLES
92
10. Hallar la soluci´on u ´nica de un sistema de ecuaciones de 2 x 2 dados los coeficientes de las variables y los t´erminos independientes por la regla de Cramer. Si el determinante de la matriz de coeficientes es cero, el sistema no tiene soluci´on u ´nica.
aX + bY = c dX + eY = f ¯ ¯ ¯ a b ¯ ¯ ¯ Det = ¯ d e ¯ ¯ ¯ ¯ c b ¯ ¯ ¯ DetX = ¯ f e ¯
¯ ¯ a c DetY = ¯¯ d f DetX Det DetY Y = Det
X=
¯ ¯ ¯ ¯
Cap´ıtulo 8 Decisiones anidadas Existen problemas algor´ıtmicos que no se pueden realizar con una sola decisi´on, sino que requiere de una serie de decisiones, a veces una tras otra y otras veces unas dentro (dependientes) de otras. Cuando se tiene una decisi´on dentro del bloque de instrucciones a ejecutar dentro de otra decisi´on se dice que son decisiones anidadas. Por ejemplo, se pide calcular la comisi´on a pagar a un vendedor de acuerdo a su categor´ıa y al valor de las ventas realizadas seg´ un la tabla 8.1. Categor´ıa 1
2
Ventas 0 - 1.999.999 2.000.000 - 5.000.000 5.000.001 en adelante 0 1.000.000 2.000.001 3.000.001
Comisi´ on ( %) 0 3 5
999.999 - 2.000.000 - 3.000.000 en adelante
3
0 2 4 6 5
Cuadro 8.1: Ejercicio Ventas
93
CAP´ITULO 8. DECISIONES ANIDADAS
94
Se debe realizar primero un an´alisis para saber la forma de resolver el problema. Una forma acostumbrada por muchos programadores es realizar un ´arbol de decisiones similar al de la figura 8.1. Observe detalladamente esta gr´afica especialmente las diferentes condiciones y las f´ormulas respectivas.
´ Figura 8.1: Arbol de decisiones Note que en este tipo de tablas 1.999.999 quiere decir ventas menores, pero no iguales a 2.000.000. Sucede lo mismo con 999.999, es decir, ventas inferiores a 1.000.000.
8.1.
Problemas resueltos
1. Calcular la comisi´on a un vendedor de acuerdo a la tabla 8.1. Ver programa 16 “Comisi´ on a pagar a un vendedor”. En el programa 16 se puede notar que las decisiones se han dejado para que sean resueltas dentro del m´etodo Calculo_Com. El manejo de constantes en este programa es muy importante porque si se desean modificar los rangos o los porcentajes, se puede resolver cambiando estos valores. El manejo de las entradas se hace con los m´etodos Entrada_Int de la p´agina 66 y Entrada_Double de la p´agina 69.
8.1. PROBLEMAS RESUELTOS
95
Programa 16 - Comisi´ on a pagar a un vendedor import java.io.*; public class P_Ani_01 { final static double CAT1_TOPE1 = 2000000.0; final static double CAT1_TOPE2 = 5000000.0; final static double CAT2_TOPE1 = 1000000.0; final static double CAT2_TOPE2 = 2000000.0; final static double CAT2_TOPE3 = 3000000.0; final static double PORC_R1_C1 = 0.0/100.0; final static double PORC_R2_C1 = 3.0/100.0; final static double PORC_R3_C1 = 5.0/100.0; final final final final
static static static static
double double double double
PORC_R1_C2 PORC_R2_C2 PORC_R3_C2 PORC_R4_C2
final static double PORC_C3
= = = =
0.0/100.0; 2.0/100.0; 4.0/100.0; 6.0/100.0;
= 5.0/100.0;
public static void main ( String args[ ] ) throws IOException { int Categoria; double Ventas, Comision; System.out.println
Categoria = Entrada_Int ( "Categoria : " Ventas = Entrada_Double ( "Ventas : "
); );
Comision
);
= Calculo_Com
Salida_Double }
( "COMISIONES DE VENTAS!!" );
( Categoria, Ventas ( "Comision
: ", Comision );
96
CAP´ITULO 8. DECISIONES ANIDADAS Continuaci´ on programa 16 static double Calculo_Com ( int Cat, double Ven ) { double Porc_Com; if ( Cat == 1 ) { if ( Ven <= CAT1_TOPE1 ) { Porc_Com = PORC_R1_C1; } else { if ( Ven <= CAT1_TOPE2 ) { Porc_Com = PORC_R2_C1; } else { Porc_Com = PORC_R3_C1; } } }
El m´etodo Calculo_Com es un poco extenso a pesar de que una de las recomendaciones iniciales sugiere que la longitud no debe pasar de una p´agina y en lo posible no debe ser mayor a media (ver 63). Esta parte es la relacionada con la categor´ıa 1, en la cual se analizan los tres rangos posibles para la variable Ventas, que al pasar como argumento a este m´etodo es representada por el par´ametro Ven.
8.1. PROBLEMAS RESUELTOS
97
Continuaci´ on programa 16 else { if ( Cat == 2 ) { if ( Ven <= CAT2_TOPE1 ) { Porc_Com = PORC_R1_C2; } else { if ( Ven <= CAT2_TOPE2 ) { Porc_Com = PORC_R2_C2; } else { if ( Ven <= CAT2_TOPE3 ) { Porc_Com = PORC_R3_C2; } else { Porc_Com = PORC_R4_C2; } } } }
La segunda continuaci´on el programa 16 corresponde a los posibles rangos de la categor´ıa 2.
CAP´ITULO 8. DECISIONES ANIDADAS Continuaci´ on programa 16
98
else { Porc_Com = PORC_C3; } } return Ven * Porc_Com; }
La parte final del programa 16 permite calcular la comisi´on en caso de que la categor´ıa no sea ni 1 ni 2. Se supone, por descarte que la categor´ıa debe ser 3 para realizar un c´alculo correcto. Si por equivocaci´on o a prop´osito el usuario ingresa la categor´ıa como 4, el programa realiza los c´alculos como si fuera categor´ıa 3. Finalmente, la salida se realiza usando el m´etodo Salida_Double de la p´agina 70. 2. Calcular el valor a pagar por concepto de matr´ıcula de acuerdo a la categor´ıa y al n´ umero de materias registradas, de acuerdo a la tabla 8.2. Categoria 1 2 3 4
Valor Matricula 100.000 + nmat * 50.000 200.000 + nmat * 30.000 nmat * 70.000 350.000
Cuadro 8.2: Datos Ejemplo Matr´ıcula
Ver programa 17 “Valor de la matr´ıcula por categor´ıas”.
8.1. PROBLEMAS RESUELTOS
99
Programa 17 - Valor de la matr織覺cula por categor織覺as import java.io.*; public class P_Ani_02 { final static double C_FIJO_1 = 100000.0; final static double C_FIJO_2 = 200000.0; final final final final
static static static static
double double double double
V_MAT_1 V_MAT_2 V_MAT_3 MATRIC
= 50000.0; = 30000.0; = 70000.0; = 350000.0;
public static void main ( String args[ ] ) throws IOException { int Cat, N_Mat; double V_Materia, Pago; System.out.println
( "VALOR DE LA MATRICULA"
);
Cat = Entrada_Int N_Mat = Entrada_Int
( "Categoria : " ( "Numero de materias : "
); );
Pago
= Calc_Matricula ( Cat, N_Mat
Salida_Double }
( "Valor a pagar
); : ", Pago );
CAP´ITULO 8. DECISIONES ANIDADAS
100
El programa 17 calcula la matr´ıcula de acuerdo a las condiciones fijadas en la tabla 8.2. Si cambian las condiciones, puede facilitarse la correcci´on del programa gracias a la utilizaci´on de constantes. El manejo de las entradas se hace con el m´etodo Entrada_Int de la p´agina 66. Continuaci´ on programa 17 static double Calc_Matricula ( int Cat, int Mat ) { double Numero; if ( Cat == 1 ) { Numero = C_FIJO_1 + Mat * V_MAT_1; } else { if ( Cat == 2 ) { Numero = C_FIJO_2 + Mat * V_MAT_2; } else { if ( Cat == 3 ) { Numero = Mat * V_MAT_3; } else { Numero = MATRIC; } } } return Numero; }
8.1. PROBLEMAS RESUELTOS
101
Para el c´alculo de la matr´ıcula se requiere de dos datos que el m´etodo llamante pasa como argumentos. En la variable Numero se almacena el resultado que se retorna. La salida se realiza usando el m´etodo Salida_Double de la p´agina 70. 3. Encontrar el mayor de tres enteros diferentes que ingresan por teclado. Ver programa 18 “Encontrar el mayor de tres enteros”. Programa 18 - Encontrar el mayor de tres enteros import java.io.*; public class P_Ani_03 { public static void main ( String args[ ] ) throws IOException { int N_1, N_2, N_3, May; System.out.println ( "EL MAYOR DE TRES NUMEROS!!" ); N_1 = Entrada_Int N_2 = Entrada_Int N_3 = Entrada_Int
( "Primer numero : " ( "Segundo numero : " ( "Tercer numero : "
); ); );
May = Mayor
( N_1, N_2, N_3
);
Salida_Int
( "El mayor es
: ", May
);
}
El manejo de las entradas se hace con el m´etodo Entrada_Int de la p´agina 66. El m´etodo Mayor se encarga de determinar cu´al de los tres valores dados como argumentos es el mayor. En la p´agina 29 se resolvi´o el mismo ejercicio en lenguaje algor´ıtmico. Recomendamos realizar la comparaci´on para obtener algunas conclusiones.
CAP´ITULO 8. DECISIONES ANIDADAS
102
Continuaci´ on programa 18 static int Mayor ( int A, int B, int C ) { int Numero; if ( A > B ) { if ( A > C ) { Numero = A; } else { Numero = C; } } else { if ( B > C ) { Numero = B; } else { Numero = C; } } return Numero; }
8.1. PROBLEMAS RESUELTOS
103
En el m´etodo Mayor se busca el n´ umero m´as grande sin utilizar conectores l´ogicos. Se recomienda la construcci´on de un ´arbol de decisiones para facilitar su comprensi´on. La salida se hace con Salida_Int. Ver p´agina 67. 4. Conociendo el kilometraje actual de un autom´ovil y el kilometraje en el cual se le realiz´o el u ´ltimo cambio de aceite. De acuerdo a la diferencia, indique si es oportuno el cambio de aceite (Diferencia <= 6000 Km y Diferencia >= 4500 Km); si es urgente (diferencia > 6000) o cu´antos kil´ometros hacen falta (diferencia < 4500 Km). Se debe cambiar el aceite a los cada 6000 Km. Ver programa 19 “Aviso para cambio de aceite”. Programa 19 - Aviso para cambio de aceite import java.io.*; public class P_Ani_04 { final static double ALERTA = 4500.0; final static double TOPE = 6000.0; public static void main ( String args[ ] ) throws IOException { double Km_Ant, Km_Act, Km; System.out.println
( "CAMBIO DE ACEITE!!"
);
Km_Act = Entrada_Double ( "Km actual : " ); Km_Ant = Entrada_Double ( "Km ultimo cambio : " ); Km
= Diferencia
Verificar }
( Km_Act, Km_Ant
);
( Km
);
CAP´ITULO 8. DECISIONES ANIDADAS
104
El programa 19 utiliza el m´etodo Entrada_Double para el ingreso de los datos correspondientes a kilometraje actual y anterior. Este m´etodo se encuentra en la p´agina 69. El m´etodo Diferencia se encarga de realizar el c´alculo, mientras que Verificar se realiza la toma de decisiones para escoger el mensaje adecuado. Continuaci´ on programa 19 static double Diferencia ( double Act, double Ant ) { return Act - Ant; }
El m´etodo Diferencia es un c´alculo sencillo. Retorna la diferencia entre los dos datos que le han entregado como argumentos en el m´etodo principal. Continuaci´ on programa 19 static void Verificar ( double K ) { double Falta; Falta = TOPE - K; if ( K < ALERTA ) { System.out.println ( "Faltan " + Falta + " Km para el proximo cambio" }
);
Verificar se encarga de calcular los kil´ometros que hacen falta para realizar al pr´oximo cambio de aceite. Este c´alculo hace parte de la informaci´on que debe imprimir.
8.1. PROBLEMAS RESUELTOS
105
Continuaci´ on programa 19 else { if ( K < TOPE ) { System.out.println ( "Cambio debe hacerlo pronto!!" + "\nFaltan " + Falta + " Km." ); } else { System.out.println ( "URGENTE Cambio de Aceite" ); } } } }
5. Dados tres enteros diferentes, encuentre el mayor, el del medio y el menor, sin utilizar conectores l´ogicos. Ver programa 20 “Clasificaci´ on de tres enteros”. Programa 20 - Clasificaci´ on de tres enteros import java.io.*; public class P_Ani_05 { public static void main ( String args[ ] ) throws IOException { int N_1, N_2, N_3; System.out.println ( "CLASIFICACION DE TRES ENTEROS!!" );
CAP´ITULO 8. DECISIONES ANIDADAS Continuaci´ on programa 20
106
N_1 = Entrada_Int N_2 = Entrada_Int N_3 = Entrada_Int
( "Primer numero : " ( "Segundo numero : " ( "Tercer numero : "
); ); );
Ordenar_Tres
( N_1, N_2, N_3
);
}
Los n´ umeros enteros ingresan gracias al m´etodo Entrada_Int (ver p´agina 66. El programa 20 se encarga de llamar el m´etodos Ordenar_Tres para que determine el mayor. Continuaci´ on programa 20 static void Ordenar_Tres ( int A, int B, int C ) { int May, Med, Men; if ( A > B ) { if ( A > C ) { if ( B > C ) { May = A; Med = B; Men = C; }
El m´etodo Ordenar_Tres es un poco extenso. Desafortunadamente no siempre se pueden seguir todas las recomendaciones de la p´agina 63. La primera parte realiza las comparaciones entre cada posible par de n´ umeros cuando el primero es mayor que el segundo.
8.1. PROBLEMAS RESUELTOS
Continuaci´ on programa 20 else { May = A; Med = C; Men = B; } } else { May = C; Med = A; Men = B; } } else { if ( B > C ) { if ( A > C ) { May = B; Med = A; Men = C; } else { May = B; Med = C; Men = A; } }
107
CAP´ITULO 8. DECISIONES ANIDADAS Continuaci´ on programa 20
108
else { May = C; Med = B; Men = A; } } Salida_Int ( "El mayor Salida_Int ( "El medio Salida_Int ( "El menor
: ", May ); : ", Med ); : ", Men );
}
La segunda parte del m´etodo Ordenar_Tres se encarga de las comparaciones cuando el primero n´ umero no es mayor que el segundo. Al finalizar se encarga de imprimir los tres n´ umeros. Debe imprimirlos en el mismo m´etodo debido a que no es posible retornar tres valores enteros. Usa el m´etodo Salida_Int visto en la p´agina 67.
8.2.
Problemas propuestos
1. Muestre en pantalla el siguiente men´ u: 1. 2. 3. 4.
Convertir Convertir Convertir Convertir
de de de de
pulgadas a cent´ımetros cent´ımetros a pulgadas kil´ometros a metros metros a kil´ometros.
En cada opci´on haga la conversi´on e imprima el resultado correspondiente. 1 pulgada = 2.54 cm 1 Km = 1000 m.
8.2. PROBLEMAS PROPUESTOS
109
2. Solicite la entrada de la categor´ıa de un vendedor y las ventas del u ´ltimo mes. Calcule el pago teniendo en cuenta la tabla 8.3. No olvide que los porcentajes se deben escribir correctamente (3 % = 0,03). Categor´ıa 1 2 3 4
Ventas
Hasta 1.000.000 1.000.001 - 2.000.000 2.000.001 en adelante
5
B´ asico 100.000 200.000 300.000 1.000.000 0 100.000 200.000
Comisi´ on 3% 2% 1% 0% 3% 5% 10%
Cuadro 8.3: Datos problema propuesto 2 P ago = B´ asico + V entas × P orcentajeComisi´on
3. Dado el salario asignado a un empleado, calcular el impuesto sobre el salario recibido y el valor a pagar, de acuerdo a las siguientes consideraciones. Los primeros $250.000 no tienen impuesto; los segundos $250.000 tienen impuesto del 2%, los terceros $250.000 tienen un descuento del 4% adicional y el resto, 5% adicional. Tenga presente que un porcentaje del 4 % se escribe 0,04.
0, (Sal − 250,000) × 2 %, Imp = (Sal − 500,000) × 4 % + 5,000, (Sal − 750,000) × 5 % + 15,000,
si si si si
Sal Sal Sal Sal
≤ 250,000 ∈ (250,000, 500,000] ∈ (500,000, 750,000] > 750,000
CAP´ITULO 8. DECISIONES ANIDADAS
110
4. Leer el precio de un art´ıculo e imprimir el valor a pagar, teniendo en cuenta la tabla 8.4. No olvide que 5 % = 0,05. Precio Descuento 1 - 10.000 0% 10.001 - 20.000 5% 20.001 - 30.000 8% 30.001 en adelante 10% Cuadro 8.4: Datos problema propuesto 4 P ago = P recio − P recio × Descuento
5. Dado el valor de x, calcule el valor de y como resultado de la siguiente funci´on compuesta.
−x, x2 + 3, y= x, 10,
si si si si
x < −5 x ∈ [−5, 2] x ∈ (2, 5) x≥5
6. Dados tres valores enteros, correspondientes a las longitudes de un tri´angulo, determine el tipo de tri´angulo, is´osceles, escaleno, equil´atero; o si estas longitudes no corresponden a los lados de un tri´angulo. Si las longitudes de los lados son L1 , L2 y L3 , un tri´angulo se puede formar siempre y cuando s × (s − L1 ) × (s − L2 ) × (s − L3 ) > 0 s=
L1 + L2 + L3 2
7. Dadas tres notas parciales de un curso que se aprueba con 3.0, calcular la nota m´ınima con la cual se aprueba el curso, teniendo en cuenta que todas las notas tienen igual porcentaje. Imprimir un mensaje de acuerdo a la nota m´ınima que debe obtener el estudiante, as´ı:
8.2. PROBLEMAS PROPUESTOS “P erdi´ o el curso”, “T odavia se puede”, “N ecesita una buena nota”, “Es f a ´cil ganarla”, M ensaje : “La tiene casi ganada”, “P r´ acticamente ya gan´ o”, “M uy dif icil de perder”, “F elicitaciones Y a gan´ o”,
111
si si si si si si si si
N otaM in N otaM in N otaM in N otaM in N otaM in N otaM in N otaM in N otaM in
> 5,0 ∈ [4,0, 5,0] ∈ [3,5, 4,0) ∈ [3,0, 3,5) ∈ [2,0, 3,0) ∈ [1,0, 2,0) ∈ [0,1, 1,0) ≤ 0,0
N otaM in = 4 × 3,0 − (N1 + N2 + N3 ) 8. Halle los coeficientes de una ecuaci´on cuadr´atica, teniendo en cuenta todas las posibilidades, que no tenga ra´ıces reales, que no sea ecuaci´on cuadr´atica, etc. a × x2 + b × x + c es cuadr´ atica, si a 6= 0,0 √ 2−4×a×c x = −b ± b2 × , si b2 − 4 × a × c ≥ 0,0 a x∈ / R, si b2 − 4 × a × c < 0,0 9. De un estudiante se tienen 3 notas parciales. Se desea obtener la nota definitiva aplicando los porcentajes 30%, 30% y 40% respectivamente. De acuerdo a la definitiva en este curso, recibira un descuento para el proximo curso (si lo gana) o una multa (si lo pierde), de acuerdo a la siguiente tabla. Debe solicitar el valor del curso. Ver tabla 8.5.
112
CAP´ITULO 8. DECISIONES ANIDADAS Definitiva Descuento 0.0 - 0.9 1.0 - 1.9 2.0 - 2.9 3.0 - 3.4 10% 3.5 - 3.9 20% 4.0 - 4.4 30% 4.5 - 5.0 40%
Multa 40% 20% 10%
Cuadro 8.5: Datos problema propuesto 9 Def = N1 × 0,3 + N2 × 0,3 + N3 × 0,4 P recio = P recio + P recio × M ulta P recio = P recio − P recio × Descuento 10. Solicitar la fecha de nacimiento de una persona y la fecha actual en forma de aa mm dd. Si la fecha se ingresa correctamente, imprimir un mensaje si es mayor de edad o no.
A˜ nos = A˜ noActual − A˜ noN aci´o M eses = M esActual − M esN aci´o D´ıas = D´ıaActual − D´ıaN aci´o nos > 18 si A˜ si A˜ nos = 18 y M eses > 0 M ayor de edad : si A˜ nos = 18 y M eses = 0 y D´ıas ≥ 0
Cap´ıtulo 9 Decisiones m´ ultiples Algunos problemas resueltos utilizando decisiones anidadas, por ejemplo, aquellos que examinan un dato de tipo entero o caracter, pueden resolverse m´as f´acilmente con decisiones m´ ultiples, porque se aumenta la claridad y facilidad para leer un c´odigo fuente, lo mismo que detectar errores y aumentar las opciones sin complicar la programaci´on. En el caso de la vida diaria, cuando se tiene un men´ u con opciones, por ejemplo un restaurante, los canales en el televisor o en un cajero electr´onico, nos encontramos con la posibilidad de elegir entre m´ ultiples (dos o m´as) alternativas. El switch (estructura de decisi´on m´ ultiple) permite definir cualquier n´ umero de bloques de instrucciones que se deben ejecutar de acuerdo al valor de una variable de tipo entero o caracter. En todos los casos, se puede escoger un solo bloque de instrucciones que se ejecutan hasta encontrar la instrucci´on break, de tal manera que los dem´as bloques de instrucciones son ignorados. Por ejemplo, si se desea hacer un programa que pueda realizar una operaci´on aritm´etica de acuerdo al valor de la variable Op, la cual generalmente ha sido le´ıda previamente, lo mismo que las variables a y b. Ver “Estructura general del switch”.
113
114
´ CAP´ITULO 9. DECISIONES MULTIPLES Estructura general del switch switch ( Op ) { case 1 : Numero break; case 2 : Numero break; case 3 : Numero break; default: Numero break; }
= a + b; = a - b; = a * b; = a / b;
Es importante tener en cuenta: El tipo de dato de la variable que se utiliza para controlar el switch, en este caso Op puede ser entero o caracter, es decir, no se aceptan datos de tipo flotante. No se aceptan rangos. En esos casos es indispensable mencionar cada caso posible en forma individual o utilizar decisiones anidadas. No es necesario que los casos posibles tengan un orden especial. Generalmente se escriben en orden por facilidad de lectura y claridad. Cada opci´on posible a considerar va precedida de la palabra case. La etiqueta default es utilizada en el caso de que ninguno de los dem´as casos coincidan con la variable de control del switch. Adem´as, su uso es opcional. Es decir, muchas veces no se escribe, y cuando aparece, a pesar de ser posible su ubicaci´on en cualquier lugar entre los casos posibles, se recomienda escribirla al final. Si no se utiliza default, y ninguno de los casos es igual a la variable de control no se ejecuta ninguno de los bloques de instrucciones. La instrucci´on break es opcional al final de cada caso. Es decir, si es omitida, el control del programa contin´ ua con la siguiente opci´on
9.1. PROBLEMAS RESUELTOS
115
hasta encontrar esta instrucci´on o el final de la estructura de decisi´on m´ ultiple. Ver p´agina 127.
9.1.
Problemas resueltos
1. Programa de Geometr´ıa Anal´ıtica. Ver programa 21 “C´ alculos de Geometr´ıa Anal´ıtica”. Programa 21 - C´ alculos de Geometr´ıa Anal´ıtica import java.io.*; public class P_Mul_01 { public static void main ( String args[ ] ) throws IOException { int Opcion; System.out.println ( "GEOMETRIA ANALITICA!!" ); Opcion = Ver_Menu Menu
( ); ( Opcion );
}
Este programa ejecuta el m´etodo Ver_Menu el cual devuelve un valor de tipo entero que se almacenar´a en la variable Opcion, la cual alimenta el m´etodo Menu. El m´etodo Ver_Menu se encarga de capturar el valor que el usuario ingresa por teclado. Para poder ingresar este valor, el usuario debe conocer las diferentes opciones. Utiliza el m´etodo Entrada_Int de la p´agina 66. El m´etodo Menu recibe un valor que dentro de este m´etodo ser´a llamado Op y se encargar´a de controlar el switch. De acuerdo al valor obtenido har´a el llamado al m´etodo que corresponda.
´ CAP´ITULO 9. DECISIONES MULTIPLES
116
Continuaci´ on programa 21 static int Ver_Menu ( ) throws IOException { int Num; System.out.println ( "1. Pendiente de recta " ); System.out.println ( "2. Distancia entre dos puntos " ); System.out.println ( "3. Coordenadas del punto medio " ); System.out.println ( ); Num = Entrada_Int
( "Elija una opcion: " );
System.out.println ( ); return Num; }
Continuaci´ on programa 21 static void Menu ( int Op ) throws IOException { switch ( Op ) { case 1: Pendiente ( ); break; case 2: Distancia ( ); break; case 3: Punto_Medio ( ); break; } }
9.1. PROBLEMAS RESUELTOS
117
Continuaci´ on programa 21 static void Pendiente ( ) throws IOException { double X1, Y1, X2, Y2, M; X1 Y1 X2 Y2
= = = =
Entrada_Double Entrada_Double Entrada_Double Entrada_Double
System.out.println
( ( ( (
"X1: "Y1: "X2: "Y2:
" " " "
); ); ); );
( );
if ( X1 != X2 ) { M = ( Y2 - Y1 ) / ( X2 - X1 ); Salida_Double ( "La pendiente es: ", M ); } else { System.out.println ( "La pendiente NO EXISTE!!" ); } }
El m´etodo Pendiente se encarga de calcular la pendiente de la recta que pasa por los puntos (X1 ,Y1 ) y (X2 ,Y2 ), si existe. En caso de ser una l´ınea vertical, donde la pendiente no existe, imprime en pantalla un mensaje que lo indica. Utiliza los m´etodos Entrada_Double y Salida_Double de las p´aginas 69 y 70, respectivamente. P endiente =
Y2 − Y1 , si X1 6= X2 X2 − X1 N o existe, si X1 = X2
´ CAP´ITULO 9. DECISIONES MULTIPLES Continuaci´ on programa 21
118
static void Distancia ( ) throws IOException { double X1, Y1, X2, Y2, Dist; X1 Y1 X2 Y2
= = = =
Entrada_Double Entrada_Double Entrada_Double Entrada_Double
( ( ( (
"X1: "Y1: "X2: "Y2:
" " " "
); ); ); );
Dist = Math.sqrt ( Math.pow ( X2 - X1, 2.0 ) + Math.pow ( Y2 - Y1, 2.0 ) ); System.out.println Salida_Double
( );
( "La distancia es: ", Dist );
}
El m´etodo Distancia calcula la distancia entre los dos puntos despu´es de leer las coordenadas. p Distancia = (X2 − X1 )2 + (Y2 − Y1 )2 El m´etodo Punto_Medio calcula las coordenadas del punto medio entre los dos puntos especificados. XM =
X1 + X2 2
YM =
Y1 + Y2 2
9.1. PROBLEMAS RESUELTOS
119
Continuaci´ on programa 21 static void Punto_Medio ( ) throws IOException { double X1, Y1, X2, Y2, X_M, Y_M; X1 Y1 X2 Y2
= = = =
Entrada_Double Entrada_Double Entrada_Double Entrada_Double
( ( ( (
"X1: "Y1: "X2: "Y2:
" " " "
); ); ); );
X_M = ( X1 + X2 ) / 2.0; Y_M = ( Y1 + Y2 ) / 2.0; System.out.println
( );
System.out.println ( "Coordenadas del punto medio: " + X_M + " , " + Y_M); }
´ CAP´ITULO 9. DECISIONES MULTIPLES
120
2. Valor de la cuota fija de un pr´estamo en una entidad financiera, conociendo el monto (M), el plazo en meses (P) y la tasa de inter´es anual. C=
M × I × (I + 1)P (I + 1)P − 1
Tenga en cuenta que I corresponde a la tasa de inter´es mensual. Ver programa 22 “Valor de la cuota fija de un pr´estamo”. Programa 22 - Valor de la cuota fija de un pr´ estamo import java.io.*; public class P_Mul_02 { public static void main ( String args[ ] ) throws IOException { double Monto, Int_Anual, Int_Mensual, Cuota; int Plazo, Opcion; System.out.println
( "CUOTA DE UN CREDITO!!"
);
Monto
= Entrada_Double ( "Monto del credito: "
);
Opcion
= Ver_Menu
);
(
Int_Anual = Entrada_Double ( "Int anual (20% = 20): " ); Plazo Cuota
= Elegir_Plazo = Calc_Cuota
Salida_Double
( Opcion ( Monto, Plazo, Int_Anual
); );
( "Cuota mensual: ", Cuota );
}
Este programa permite calcular el valor de la cuota mensual de un cr´edito en una entidad financiera conociendo el monto, el inter´es anual
9.1. PROBLEMAS RESUELTOS
121
y el plazo. Para la entrada de los datos Monto e Int_Anual se utiliza el m´etodo Entrada_Double de la p´agina 69. Plazo es seleccionado de un men´ u usando el m´etodo Elegir_Plazo, el cual devuelve un valor que es almacenado en la variable Plazo. El m´etodo Calc_Cuota recibe los datos necesarios y retorna el resultado en la variable Cuota. Finalmente se utiliza el m´etodo Salida_Double de la p´agina 70. Continuaci´ on programa 22 static int Ver_Menu ( ) throws IOException { int Num; System.out.println ( ); System.out.println System.out.println System.out.println System.out.println System.out.println
( ( ( ( (
"1. "2. "3. "4. "5.
12 24 36 48 60
meses meses meses meses meses
" " " " "
); ); ); ); );
System.out.println ( ); Num = Entrada_Int
( "Elija una opcion: " );
System.out.println ( ); return Num; }
El m´etodo Ver_Menu se encarga de mostrar las opciones en la pantalla y leer el n´ umero digitado por el usuario. Este n´ umero le´ıdo se regresa al m´etodo que llam´o a Ver_Menu. El m´etodo Elegir_Plazo recibe como par´ametro la opci´on elegida por el usuario en el m´etodo Ver_Menu. Su objetivo es asignar el valor correspondiente a la variable Numero, valor que es retornado.
´ CAP´ITULO 9. DECISIONES MULTIPLES
122
Continuaci´ on programa 22 static int Elegir_Plazo ( int Op ) { int Numero; switch ( Op ) { case 1 : Numero break; case 2 : Numero break; case 3 : Numero break; case 4 : Numero break; default: Numero }
= 12; = 24; = 36; = 48; = 60;
return Numero; }
Continuaci´ on programa 22 static double Calc_Cuota ( double Mnt, int Pla, double I_Anl ) { double Numero, Int_Mes, Aux; Int_Mes = I_Anl /100.0 / 12.0; Aux = Math.pow ( Int_Mes + 1.0 , Pla ); Numero = Mnt * Int_Mes * Aux / ( Aux - 1.0 ); return Numero; }
9.1. PROBLEMAS RESUELTOS
123
Calc_Cuota recibe los datos correspondientes al monto, plazo y tasa de inter´es anual, para calcular y retornar el valor de la cuota mensual del cr´edito. 3. Identificaci´on de caracteres Ver programa 23 “Identificaci´ on de caracteres”. Programa 23 - Identificaci´ on de caracteres import java.io.*; public class P_Mul_03 { public static void main ( String args[ ] ) throws IOException { char Car; System.out.println ( "IDENTIFICAR CARACTERES!!"
);
System.out.print ( "Digite un caracter Car = (char) System.in.read ();
);
System.out.println System.out.println System.out.print Verificar
( ( ( (
: "
); "Caracter a procesar : " + Car ); "El caracter es : " ); Car );
}
Este programa lee un caracter usando el m´etodo System.in.read () y utilizando el molde (char) permite que sea convertida la entrada a un valor de tipo char, que ser´a almacenado en la variable Car.
124
´ CAP´ITULO 9. DECISIONES MULTIPLES Continuaci´ on programa 23 static void Verificar ( char Car ) { if ( Car >= ’0’ && Car <= ’9’ ) { Casos ( Car ); } else { if ( Car >= ’A’ && Car >= ’Z’ || Car >= ’a’ && Car >= ’z’ ) { System.out.println ( "Es una letra" ); } else { System.out.println ( "Es un simbolo" ); } } }
El m´etodo Verificar recibe como par´ametro el caracter ingresado por el usuario y determina si corresponde a un d´ıgito, una letra o un s´ımbolo. En caso se que el caracter sea un d´ıgito, llamar´a al m´etodo Casos. Continuaci´ on programa 23 static void Casos ( char Op ) { switch ( Op ) { case ’0’ : System.out.println ( "Cero break;
" );
9.1. PROBLEMAS RESUELTOS
125
Continuaci´ on programa 23 case ’1’ : System.out.println break; case ’2’ : System.out.println break; case ’3’ : System.out.println break; case ’4’ : System.out.println break; case ’5’ : System.out.println break; case ’6’ : System.out.println break; case ’7’ : System.out.println break; case ’8’ : System.out.println break; default : System.out.println
( "Uno
" );
( "Dos
" );
( "Tres
" );
( "Cuatro" ); ( "Cinco " ); ( "Seis
" );
( "Siete " ); ( "Ocho
" );
( "Nueve " );
} } }
El m´etodo Casos imprime en la pantalla el texto correspondiente al n´ umero que se recibe como par´ametro. 4. Resultado de la operaci´on de dos n´ umeros Ver programa 24 “Resultado de la operaci´ on de dos n´ umeros”. Este programa lee desde el teclado dos enteros y un caracter que especifica la operaci´on aritm´etica que debe realizar. Efect´ ua el c´alculo y muestra los resultados. Utiliza los m´etodos Entrada_Int explicada en la p´agina 66 y Entrada_Char. El m´etodo Entrada_Char, muy similar a los m´etodos de entrada de datos usados a lo largo del libro, con la diferencia que utiliza el m´etodo System.in.read () para leer datos desde el teclado, el cual hace parte del programa de la p´agina 123.
126
´ CAP´ITULO 9. DECISIONES MULTIPLES Programa 24 - Resultado de la operaci´ on de dos n´ umeros
import java.io.*; public class P_Mul_04 { public static void main ( String args[ ] ) throws IOException { int Num1, Num2, Resultado; char Operador; System.out.println
( "MENU DE OPERACIONES!!" );
Num1 Num2
= Entrada_Int = Entrada_Int
( "Primer numero ( "Segundo numero
Operador
= Entrada_Char ( "Operador
Resultado
= Operacion
: " : "
); );
: "
);
( Num1, Operador, Num2
);
Salida_Int ( "El resultado es : ", Resultado }
Continuaci´ on programa 24 static char Entrada_Char ( String Msj ) throws IOException { char Caracter; System.out.print ( Msj ); Caracter = (char) System.in.read ( ); return Caracter; }
);
9.1. PROBLEMAS RESUELTOS
127
Continuaci´ on programa 24 static int Operacion { int Numero;
( int Numero1, char Op, int Numero2 )
switch ( Op ) { case ’+’ : Numero = Numero1 + break; case ’-’ : Numero = Numero1 break; case ’*’ : case ’.’ : case ’x’ : case ’X’ : Numero = Numero1 * break; case ’/’ : Numero = Numero1 / break; default : System.out.println Numero = 0; }
Numero2; Numero2;
Numero2; Numero2; ( "ERROR!!" );
return Numero; }
El m´etodo Operacion recibe como par´ametros el primer n´ umero, el caracter que identifica la operaci´on aritm´etica a realizar y el segundo entero. Realiza el c´alculo y retorna el resultado en la variable Numero. Es de anotar que algunas opciones de la estructura switch no llevan la instrucci´on break. En otras palabras, el control del programa contin´ ua con las siguientes instrucciones hasta encontrar un breako el final del switch. Ver p´agina 115. Finalmente se utiliza el m´etodo Salida_Int de la p´agina 67.
´ CAP´ITULO 9. DECISIONES MULTIPLES
128
5. C´alculo del valor de la pensi´on Ver programa 25 “C´ alculo del valor de la pensi´ on”. Programa 25 - C´ alculo del valor de la pensi´ on import java.io.*; public class P_Mul_05 { public static void main ( String args[ ] ) throws IOException { int Estrato, Grado; char Transp; double Cargo_Fijo, Costo_Grado, Transporte, Pago; System.out.println Grado Estrato Transp Cargo_Fijo Costo_Grado Transporte Pago
= = = = = = =
( "COSTO MATRICULA!!" );
Entrada_Int Entrada_Int Entrada_Char Seleccion1 Seleccion2 Seleccion3 Calculo
( ( ( ( ( ( (
"Grado : " "Estrato : " "Transporte? (S/N) : " Estrato Grado Transp Cargo_Fijo, Costo_Grado, Transporte Salida_Double ( "El costo de la matricula es: ", Pago
); ); ); ); ); ); ); );
}
Este programa calcula el costo de la pensi´on en un colegio, conociendo el grado, el estrato social y si tiene o no sobrecosto por el transporte. Utiliza los m´etodos Entrada_Int y Entrada_Char ya explicados. El m´etodo Seleccion1 se encarga de retornar el valor del cargo fijo conociendo el estrato social, utilizando una estructura de decisi´on m´ ultiple.
9.1. PROBLEMAS RESUELTOS
Continuaci´ on programa 25 static double Seleccion1 ( int Op ) { double Numero; switch ( Op ) { case 1 : Numero = 6000; break; case 2 : Numero = 8000; break; case 3 : Numero = 10000; break; case 4 : Numero = 12000; break; case 5 : Numero = 14000; break; case 6 : Numero = 16000; break; default: System.out.println ( "ERROR!!" ); Numero = 0; } return Numero; }
129
´ CAP´ITULO 9. DECISIONES MULTIPLES Continuaci´ on programa 25
130
static double Seleccion2 ( int Gr ) { double Numero; if ( Gr < 5 ) { Numero = 20000; } else { if ( Gr < 10 ) { Numero = 30000; } else { Numero = 40000; } } return Numero; }
El m´etodo Seleccion2 se encarga de retornar el costo seg´ un el grado recibido como par´ametro, utilizando una estructura de decisi´on anidada.
9.1. PROBLEMAS RESUELTOS
131
Continuaci´ on programa 25 static double Seleccion3 ( char Op ) { double Numero; if ( Op == ’S’ || Op == ’s’ ) { Numero = 35000; } else { Numero = 0; } return Numero; }
El m´etodo Seleccion3 se encarga de retornar el costo del transporte de acuerdo a la opci´on digitada por el usuario. Utiliza una estructura de decisi´on simple. Continuaci´ on programa 25 static double Calculo ( double Cargo, double Costo, double Transp ) { double Numero; Numero = Cargo + Costo + Transp; return Numero; }
´ CAP´ITULO 9. DECISIONES MULTIPLES
132
El m´etodo Calculo se encarga de realizar la sumatoria de los valores que componen el valor de la pensi´on. Los resultados se pueden ver en la pantalla gracias al llamado al m´etodo Salida_Double.
9.2.
Problemas propuestos
1. Dados el sueldo actual y la categor´ıa de un empleado, calcular el aumento correspondiente de acuerdo a la tabla 9.1. Categor´ıa 1 2 3 4
Porcentaje de Aumento 12% 10% 8% 6%
Cuadro 9.1: Datos problema propuesto 1 SueldoN uevo = SueldoActual + SueldoActual × P orcentajeAumento
2. En una empresa se le hace descuento a los empleados por concepto de ahorro, de acuerdo al estrato social en que vive, con base en la tabla 9.2. Caclcule e imprima el valor a descontar. Estrato 1 2 3 4 5 6
Porcentaje de Descuento 2% 2% 4% 6% 8% 10%
Cuadro 9.2: Datos problema propuesto 2 Descuento = SueldoActual × P orcentajeDescuento
9.2. PROBLEMAS PROPUESTOS
133
3. Se ingresa el n´ umero de ejes de un veh´ıculo. Hallar el valor que debe pagar por peaje, de acuerdo a la tabla 9.3: No. Ejes 2 3 4 5 6
Peaje 4.000 5.000 7.000 11.000 15.000
Cuadro 9.3: Datos problema propuesto 3
4. De un empleado se conoce la categor´ıa 1, 2, 3 ´o 4 y el sueldo b´asico. El empleado posee una bonificaci´on y un descuento de acuerdo a la tabla 9.4. Categor´ıa 1 2 3 4
Bonificaci´ on 15% 10% 8% 0%
Descuento 2.0% 1.5% 1.0% 0.0%
Cuadro 9.4: Datos problema propuesto 4 P ago = SActual + SActual × Bonif icaci´ on − SActual × Descuento
5. Calcular el pago de la comisi´on sobre las ventas a un vendedor de acuerdo al tipo de vendedor como est´a en la tabla 9.5.
134
´ CAP´ITULO 9. DECISIONES MULTIPLES Tipo de vendedor A B C D
Comision 8% 6% 4% 2%
Cuadro 9.5: Datos problema propuesto 5 Comisi´ on = V entas × P orcentajeComisi´on
6. En un lavautos se cobra el servicio de la lavada de acuerdo al tipo de veh´ıculo. En caso de que el carro tenga 8 a˜ nos o m´as de antig¨edad, el costo se incrementa un 20%. Solicitar el a˜ no actual, el modelo y el tipo de veh´ıculo. Tenga en cuenta la tabla 9.6. Tipo de veh´ıculo peque˜ no Automovil mediano de lujo sencillo Campero de lujo cabina sencilla Camioneta doble cabina
Valor lavada 4.000 5.000 6.000 5.000 8.000 6.000 8.000
Cuadro 9.6: Datos problema propuesto 6
7. Se realiz´o un estudio para determinar el costo diario promedio de hospitalizaci´on de un paciente, en d´olares, de acuerdo al tipo de enfermedad que sufre el paciente. Adem´as, se pudo establecer que si el paciente tiene una edad entre 10 y 25 a˜ nos de edad, el costo promedio diario se incrementa en un 15%. Con base en la siguiente tabla, calcule e imprima el costo total que se le cobrar´ıa a un paciente, conociendo el n´ umero de d´ıas que permanecer´a hospitalizado. Exprese el resultado en pesos, con una tasa de cambio de $2.500. Ver tabla 9.7.
9.2. PROBLEMAS PROPUESTOS Tipo de Enfermedad 1 2 3 4
135
Costo promedio diario en d´ olares 28 26 18 34
Cuadro 9.7: Datos problema propuesto 7 CostoHospital = N o.Dias × CostoDiario ½ CostoHospital × 1,15, si Edad ∈ [10, 25] IncrementoEdad = 0, si Edad ∈ / [10, 25] Costopesos = (CostoHospital + IncrementoEdad ) ∗ 2,500 8. Un agricultor desea saber el costo de producci´on de un cultivo de acuerdo a la semilla seleccionada, conociendo el n´ umero de semillas que utilizar´a y el costo de cada semilla. El valor de cada semilla se encuentra en la tabla 9.8. Verdura Tomate
Tipo Chonto Ensalada
Repollo Papa Cebolla
Criolla Pastusa Salentuna Larga De huevo
Valor cada semilla 15 20 10 8 9 11 15 13
Cuadro 9.8: Datos problema propuesto 8 CostoSemillas = N o.Semillas × V alorSemilla
´ CAP´ITULO 9. DECISIONES MULTIPLES
136
9. Calcular el valor de la matr´ıcula en la Universidad, de acuerdo al estrato social, al estado civil, y al n´ umero de materias, de acuerdo a la tabla 9.9. Estrato 1
2
3
4 m´ as
Estado civil Casado Separado Viudo Divorciado Casado Separado Viudo Divorciado Casado Separado Viudo Divorciado Casado Separado Viudo Divorciado
Cargo fijo 15.000 30.000 20.000 25.000 25.000 40.000 30.000 35.000 35.000 50.000 40.000 45.000 50.000 80.000 65.000 70.000
Valor por materia 10.000 15.000 12.000 12.000 15.000 20.000 18.000 18.000 20.000 25.000 22.000 22.000 30.000 40.000 35.000 35.000
Cuadro 9.9: Datos problema propuesto 9 V alorM atricula = CargoF ijo + N o.M aterias × V alorM ateria
10. Se va a cobrar la matricula de la universidad a los estudiantes de acuerdo al estrato social, al ingreso promedio mensual de la familia y al n´ umero de materias registradas, de acuerdo a las siguientes tablas, en donde aparece el valor por materia. el cargo fijo esta indicado al terminar cada una de las tablas 9.10, 9.11, 9.12, 9.13 y 9.14.
9.2. PROBLEMAS PROPUESTOS Estratos 1 y 2 No. de columnas hasta 2 de 3 a 5 m´ as de 5 0 - 400.000 18.000 15.000 12.000 400.001 - 750.000 22.000 20.000 18.000 750.001 en adelante 25.000 22.000 20.000 Ingreso promedio
Cargo fijo $ 20.000 Cuadro 9.10: Datos problema propuesto 10 (a)
Estrato 3 No. de columnas Ingreso promedio hasta 2 de 3 a 5 m´ as de 5 0 - 500.000 22.000 20.000 18.000 500.001 - 800.000 28.000 24.000 20.000 800.001 - 1.000.000 35.000 30.000 25.000 1.000.001 en adelante 40.000 35.000 30.000 Cargo fijo $ 30.000 Cuadro 9.11: Datos problema propuesto 10 (b)
Estrato 4 No. de columnas Ingreso promedio hasta 2 de 3 a 5 m´ as de 5 0 - 600.000 35.000 30.000 25.000 600.001 - 1.000.000 45.000 40.000 35.000 1.000.001 - 2.000.000 55.000 50.000 45.000 2.000.001 en adelante 65.000 60.000 55.000 Cargo fijo $ 80.000 Cuadro 9.12: Datos problema propuesto 10 (c)
137
138
´ CAP´ITULO 9. DECISIONES MULTIPLES Estratos 5 y 6 Ingreso promedio 0 - 1.000.000 1.000.001 - 2.000.000 2.000.001 - 3.000.000 3.000.001 en adelante
No. de columnas hasta 2 de 3 a 5 m´ as de 5 45.000 40.000 35.000 55.000 50.000 45.000 65.000 60.000 55.000 75.000 70.000 65.000
Cargo fijo Estratos 5 $ 100.000 Cargo fijo Estratos 6 $ 120.000 Cuadro 9.13: Datos problema propuesto 10 (d)
En todos los casos, si el valor del semestre cuesta m´as del 30% del ingreso familiar promedio, se tendra derecho a un descuento de acuerdo a la siguiente tabla: Estrato 1 2 3 4 5 6
Descuento 30% 25% 20% 15% 12% 10%
Cuadro 9.14: Datos problema propuesto 10 (e) V alorM atricula = CargoF ijo + N o.M aterias × V alorM ateria Descuento = V alorM atricula × P orcentajeDescuento P ago = V alorM atricula − Descuento Imprimir el valor de la matr´ıcula sin descuento. Si tiene descuento, imprimir el valor a pagar.
Cap´ıtulo 10 Ciclo do - while En muchas ocasiones, existen problemas que no se pueden solucionar con las estructuras de control estudiadas hasta ahora. Por ejemplo, si se desea imprimir los primeros n enteros positivos, donde n puede cambiar entre una ejecuci´on y otra. En vista de que el valor de n no es conocido, no se puede construir un programa secuencial que resuelva todos los casos posibles. Para lograrlo se necesitan las estructuras de repetici´on. Un ciclo es una estructura de control que permite repetir la ejecuci´on de algunas instrucciones. Con el fin de controlar el n´ umero apropiado de veces que se ejecutan las instrucciones que hacen parte de ciclo, se usa una condici´on de tal manera que se repitan mientras sea verdadera. Imagine que el programa que quiere imprimir los primeros n enteros positivos se quiere ejecutar para un valor de n = 1000. Si se quiere hacer este programa en forma secuencial, ser´ıa necesario escribir 1000 veces la instrucci´on que imprime. Ver “Lista secuencial de 1000 enteros”. Utilizando ciclos, el programa ser´ıa notablemente m´as corto y eficiente (Ver el programa de la p´agina 142). Por otra parte, existen dos clases de ciclos, de acuerdo a la posici´on donde se escriba la condici´on. Estos pueden ser condicionados al comienzo o al final. Los ciclos condicionados al comienzo se pueden encontrar de dos formas, el while y el for, mientras que para el ciclo condicionado al final solo existe una forma llamada do - while. 139
140
CAP´ITULO 10. CICLO DO - WHILE Lista secuencial de 1000 enteros
System.out.println System.out.println System.out.println . . . System.out.println System.out.println System.out.println
( " ( " ( "
1" ); 2" ); 3" );
( " 998" ); ( " 999" ); ( "1000" );
Ver “Estructura general del ciclo do - while”. Estructura general del ciclo do - while Instrucciones antes del ciclo do { Instrucciones dentro del ciclo } while ( Condicion ); Instrucciones despues del ciclo
De la estructura general del ciclo do - while se debe tener en cuenta: Dentro de las instrucciones que se ejecutan antes del ciclo, puede encontrarse una que asigne un valor inicial a una variable que sirva para controlar el ciclo, es decir, esta variable ser´a utilizada en la condici´on que permite finalizar el ciclo. El grupo de instrucciones que se encuentran dentro del ciclo es el objetivo de esta estructura de repetici´on. Una de estas instrucciones, generalmente es el incremento o decremento de la variable de control. Esta
10.1. PROBLEMAS RESUELTOS
141
alteraci´on del valor de la variable de control se utiliza para que en alg´ un momento la condici´on deje de ser verdadera y se finalice el ciclo. La condici´on es una expresi´on l´ogica que tiene un valor de verdad que puede ser Falso o Verdadero. Igualmente, puede ser una expresi´on aritm´etica con valor de cero (Falso) o diferente de cero (Verdadero). Todas las instrucciones que hacen parte del ciclo se ejecutan al menos la primera vez. Las posibles repeticiones depender´an del resultado de evaluar la condici´on. De forma similar a las decisiones, los ciclos pueden anidarse de tal manera que un ciclo est´e completamente dentro de otro. Una aplicaci´on del ciclo condicionado al final es validar datos de entrada, es decir, impedir la entrada de informaci´on no v´alida, con el fin de minimizar los errores en la entrada de datos. En este caso, este tipo de ciclos no tiene inicializaci´on, ni incremento, y su condici´on depende u ´nicamente de un dato que se ingresa dentro de las instrucciones del ciclo. Una pasada por el grupo de instrucciones que componen el ciclo se conoce con el nombre de iteraci´on.
10.1.
Problemas resueltos
1. Imprimir un listado con los primeros 1.000 enteros positivos. Ver programa 26 “Lista de mil enteros positivos”. Este programa imprime 1.000 n´ umeros enteros (desde 1 hasta 1000), donde la variable de control (I) se incrementa en una unidad cada vez que pasa por la instrucci´on I++;. Observe que el valor inicial de I es cero, pero el incremento se realiza antes de utilizar al m´etodo Salida_Int, lo que permite que inicie la impresi´on a partir de 1. Si el incremento se hiciera despu´es del llamado al m´etodo Salida_Int, se imprimir´ıan desde 0 hasta 999. La condici´on (I < MAX) permite que el ciclo finalice cuando el valor de I sea igual o mayor que la constante MAX, la cual tiene predeterminado un
CAP´ITULO 10. CICLO DO - WHILE
142
Programa 26 - Lista de mil enteros positivos import java.io.*; public class P_DoW_01 { final static int MAX = 1000; public static void main ( String args[ ] ) throws IOException { int I; System.out.println ( "NUMEROS ENTEROS!!" ); I = 0; do { I++; Salida_Int ( "Numero : ", I ); } while ( I < MAX ); }
10.1. PROBLEMAS RESUELTOS
143
valor de 1000. Este valor no cambiar´a durante la ejecuci´on del programa por tratarse de una constante. 2. Imprimir los n´ umeros enteros que pertenecen a un rango determinado, incluyendo los l´ımites. Ver programa 27 “Impresi´on de un rango de n´ umeros”. Programa 27 - Impresi´ on de un rango de n´ umeros import java.io.*; public class P_DoW_02 { public static void main ( String args[ ] ) throws IOException { int I, Lim_Inf, Lim_Sup; System.out.println
( "INTERVALO!!" );
Lim_Inf = Entrada_Int ( "Limite inferior : " ); Lim_Sup = Entrada_Int ( "Limite superior : " ); I = Lim_Inf; do { Salida_Int ( "Numero I++; } while ( I <= Lim_Sup );
: ", I );
}
En este programa la variable de control (I) se inicia con el valor correspondiente al l´ımite inferior. Es de anotar que la condici´on requiere el uso del operador <=, debido a la necesidad de incluir el l´ımite superior.
CAP´ITULO 10. CICLO DO - WHILE
144
3. Imprimir los n´ umeros enteros que pertenecen a un rango determinado, incluyendo los l´ımites, validando que el l´ımite Superior sea mayor que el l´ımite inferior. Ver programa 28 “Impresi´ on de un rango de n´ umeros con validaci´on”. Programa 28 - Impresi´ on de un rango de n´ umeros con validaci´ on import java.io.*; public class P_DoW_03 { public static void main ( String args[ ] ) throws IOException { int I, Lim_Inf, Lim_Sup; System.out.println
( "INTERVALO VALIDADO!!" );
Lim_Inf = Entrada_Int ( "Limite inferior : " ); do { Lim_Sup = Entrada_Int ( "Limite superior : " ); } while ( Lim_Sup <= Lim_Inf ); I = Lim_Inf; do { Salida_Int ( "Numero I++; } while ( I <= Lim_Sup ); }
: ", I );
10.1. PROBLEMAS RESUELTOS
145
Este programa permite utilizar un ciclo do - while para validar una entrada. En el caso de la entrada del l´ımite superior, deber´a repetir la entrada mientras sea menor o igual que el l´ımite inferior. Es decir, cuando la entrada es correcta, la entrada no se vuelve a ejecutar. Despu´es de validar la entrada del l´ımite superior, se ejecuta otro ciclo do - while donde se imprimen los elementos pertenecientes al rango especificado. 4. Imprimir la tabla de multiplicar de un entero especificado con quince renglones. Ver programa 29 “Tabla de multiplicar de un valor ingresado”. Programa 29 - Tabla de multiplicar de un valor ingresado import java.io.*; public class P_DoW_04 { final static int MAX = 15; public static void main ( String args[ ] ) throws IOException { int Numero; System.out.println
( "TABLA DE MULTIPLICAR!!" );
Numero = Entrada_Int ( "Ingrese el numero : " ); Tabla ( Numero ); }
Este programa solicita la entrada del n´ umero sobre el cual se desea obtener la tabla de multiplicar. Este n´ umero se pasa como argumento al m´etodo Tabla.
CAP´ITULO 10. CICLO DO - WHILE Continuaci´ on programa 29
146
static void Tabla ( int Num ) { int I, Resultado; I = 1; do { Resultado = Num * I; Salida ( Num, I, Resultado ); I++; } while ( I <= MAX ); }
El m´etodo Tabla genera el resultado del producto entre el n´ umero que se recibe como par´ametro (Num) y el valor de la variable de control del ciclo (I). El llamado al m´etodo Salida se hace para que la salida en pantalla sea en forma de tabla. Continuaci´ on programa 29 static void Salida ( int N, int Con, int Res ) { System.out.println ( N + " * " + Con + "\t = " + Res ); } }
El m´etodo Salida recibe tres par´ametros, el n´ umero al que se le imprime la tabla (N), el n´ umero que cambia en cada iteraci´on (Con) y el resultado del producto de los dos anteriores (Res).
10.1. PROBLEMAS RESUELTOS
147
5. Realizar una multiplicaci´on de dos n´ umeros enteros positivos, utilizando sumas u ´nicamente. Tenga en cuenta que: a×b=a | + a + a{z+ · · · + a} b veces
Ver programa 30 “Multiplicaci´ on a partir de sumas sucesivas”. Programa 30 - Multiplicaci´ on a partir de sumas sucesivas import java.io.*; public class P_DoW_05 { public static void main ( String args[ ] ) throws IOException { int I, Numero1, Numero2, Resultado; System.out.println
( "PRODUCTO CON SUMAS!!" );
Numero1 = Entrada_Int ( "Primer numero : " Numero2 = Entrada_Int ( "Segundo numero : " I = 0; Resultado = 0; do { Resultado += Numero1; I++; } while ( I < Numero2 ); Salida_Int ( "Producto }
: ", Resultado);
); );
CAP´ITULO 10. CICLO DO - WHILE
148
Este programa solicita por teclado los dos enteros positivos que se van a multiplicar. En este caso, se tiene una variable (I) la cual se encarga de controlar que el ciclo sea ejecutado Numero2 veces. Por otra parte, la variable Resultado se encarga de llevar un registro de la suma parcial de Numero1 I veces. Al llegar I a Numero2, Resultado tendr´a el producto de N umero1 × N umero2. Es importante resaltar que las variables de control, generalmente se incrementan o decrementan en una unidad constante, muchas veces 1. Este tipo de variables reciben el nombre de contador. Las variables que se incrementan o decrementan en el interior de un ciclo en forma no constante, reciben el nombre de acumulador.
10.2.
Problemas propuestos
1. Una empresa dispone de una serie de empleados, a los cuales les paga teniendo en cuenta el n´ umero de horas trabajadas. Elabore un programa que lea los datos e imprima total de horas trabajadas, valor total a pagar y promedio de horas trabajadas. P agoi = Horasi × V alori T otalHoras =
n X
Horasi
i=1
T otalP ago =
n X
P agoi
i=1
P romedio =
T otalP ago n
2. Imprimir la serie 0, 0, 1, 0, 0, 1, 0, 0, 1, con 30 elementos. 3. Imprimir en pantalla una figura similar a la que se encuentra a continuaci´on, la cual se realiza recibiendo como par´ametro la longitud. Valide las entradas de forma tal que no se salga de la pantalla.
10.2. PROBLEMAS PROPUESTOS
149
******* ** * * * * * * * * * * 4. Calcular la suma de 1 + 4 + 9 + 16 + 25 + · · · + n2 Suma =
n X
i2
i=1
5. Elabore una funci´on que imprima la potencia usando productos. Valide que el exponente sea positivos. P otencia = base × base{z× · · · × base} | n veces
P otencia =
n Y
base
i=1
6. Dado un tiempo en HH:MM:SS sumarle otro tiempo, repitiendo este proceso hasta que el usuario lo indique. La respueta se debe mostrar en DD, HH, MM y SS. 14h 3m 50s 12h 58m 40s Ejemplo : 1d 2h 2m 30s 7. Calcular la suma de todos los enteros que pertenezcan al intervalo [a,b].
Suma =
b X i=a
i
CAP´ITULO 10. CICLO DO - WHILE
150
8. Elabore un programa que imprima una tabla con los valores correspondientes a las funciones SENO, COSENO, TANGENTE, COTANGENTE, para angulos cuadrantales, medidos en grados. Ver tabla 10.1. Rad =
´ Angulo 0 90 180 270 360
Seno
Angulo × π 180
Coseno
Sen(Rad) Cos(Rad) .. .. . .
Tangente
Cotangente
T an(Rad) .. .
1 T an(Rad) .. .
Cuadro 10.1: Datos problema propuesto 8
9. Programa que genere los n´ umeros primos menores que 100. Un n´ umero n es primo s´ı y solo si sus dos u ´nicos divisores son 1 y n. P = 1, 2, 3, 5, 7, 11, 13, 17, · · · 97 10. Se ingresa el numerador y denominador de un n´ umero racional. Simplificarlo (hacer el proceso hasta que uno de los valores sea primo). 20 = 10 6 3 60 = 15 Ejemplos : 8 2 20 20 7 = 7
Cap´ıtulo 11 Ciclo while Despu´es de conocer los detalles del ciclo do - while, es importante analizar el ciclo condicionado al comienzo llamado while, el cual se diferencia del anterior en que la condici´on se ubica al comienzo del ciclo, lo que permite la posibilidad de que las instrucciones que se encuentran dentro del ciclo no se ejecuten nunca, si en la primera evaluaci´on de la condici´on ´esta resulta falsa. Ver “Estructura general del while”. Estructura general del while Instrucciones antes del ciclo while ( Condicion ) { Instrucciones dentro del ciclo } Instrucciones despues del ciclo
De la estructura general del ciclo while se debe tener especial cuidado en no escribir el caracter ; (punto y coma) a continuaci´on del par´entesis de la condici´on porque aunque no se detecta un error de sintaxis, el programa 151
CAP´ITULO 11. CICLO WHILE
152
en su ejecuci´on puede hacer cosas diferentes a las que el programador ha planeado. Por ejemplo, si la condici´on es verdadera, puede terminar en un ciclo infinito. Si la condici´on es falsa, pasa al siguiente rengl´on y ejecuta el bloque de instrucciones una sola vez.
11.1.
Problemas resueltos
1. Leer por teclado N n´ umeros enteros y encontrar el mayor. Ver programa 31 “Encontrar el mayor”. Programa 31 - Encontrar el mayor import java.io.*; public class P_Whi_01 { public static void main ( String args[ ] ) throws IOException { int I, N, Numero, Mayor; System.out.println
( "ENCONTRAR EL MAYOR!!"
);
I = 1; N = Entrada_Int ( "Cantidad ? : " Numero = Entrada_Int ( "Numero " + I + " Mayor
); : " );
= Numero;
Este programa solicita un valor para la variable N de tal manera que sea especificado el n´ umero de enteros a leer por el teclado. A continuaci´on se lee un n´ umero (el primero de ellos). Este se asume como el mayor de todos. Luego, mediante un ciclo while se leen los restantes. En caso de que un n´ umero ingresado en la variable Numero sea mayor que el
11.1. PROBLEMAS RESUELTOS
153
Continuaci´ on programa 31 while ( I < N ) { I++; Numero = Entrada_Int ( "Numero " + I + " if ( Numero > Mayor ) { Mayor = Numero; } };
: " );
Salida_Int ( "El mayor es : ", Mayor); }
valor de la variable Mayor, entonces, ser´a asignado a Mayor el valor de Numero. 2. Determinar el n´ umero de pares e impares de un conjunto de N n´ umeros enteros aleatorios dentro de un intervalo determinado. Ver programa 32 “N´ umero de pares e impares”. Este programa lee por el teclado los l´ımites inferior y superior del intervalo, y la cantidad de n´ umeros aleatorios a generar. La instrucci´on Random Aleatorio; indica que Aleatorio ser´a un objeto de tipo Random el cual se utilizar´a para generar n´ umeros al azar. Aleatorio = new Random ( ); crea el objeto Aleatorio para que sea posible su utilizaci´on posterior. Dentro del ciclo se asignan n´ umeros enteros al azar en la variable Numero, mediante el llamado al m´etodo Azar_Int al cual se pasan como argumentos una referencia al objeto Aleatorio y los l´ımites del rango. Para determinar si el n´ umero es par o impar es necesario calcular el m´odulo 2 (residuo de la divisi´on entera por 2). Si este resultado es cero, entonces se puede concluir que el n´ umero es par. En caso contrario, es impar.
CAP´ITULO 11. CICLO WHILE
154
Programa 32 - N´ umero de pares e impares import java.io.*; import java.util.Random; public class P_Whi_02 { public static void main ( String args[ ] ) throws IOException { Random Aleatorio; int I, Lim_Inf, Lim_Sup, N, N_Par, N_Impar, Numero; System.out.println
( "NUMEROS AL AZAR!!"
);
Aleatorio = new Random ( ); N_Par = 0; N_Impar = 0; Lim_Inf = Entrada_Int Lim_Sup = Entrada_Int N = Entrada_Int
( "Limite inferior : " ); ( "Limite superior : " ); ( "Cantidad ? : " );
I = 1; while ( I <= N ) { Numero = Azar_Int ( Aleatorio, Lim_Inf, Lim_Sup ); if ( Numero % 2 == 0 ) { N_Par++; } else { N_Impar++; }
11.1. PROBLEMAS RESUELTOS
155
Continuaci´ on programa 32 Salida_Int ( "Azar " + I + " I++;
: ", Numero );
}; Salida_Int ( "Pares Salida_Int ( "Impares
: ", N_Par ); : ", N_Impar );
}
Continuaci´ on programa 32 static int Azar_Int { int Aux;
( Random Num, int Inf, int Sup )
if ( Inf > Sup ) { Aux = Inf; Inf = Sup; Sup = Aux; } return Num.nextInt ( Sup - Inf + 1 ) + Inf; }
CAP´ITULO 11. CICLO WHILE
156
El m´etodo Azar_Int se encarga de generar el siguiente n´ umero aleatorio entre 1 y el rango solicitado por los l´ımites, posteriormente a dicho n´ umero se le adiciona el l´ımite inferior para que dicho n´ umero est´e dentro del intervalo solicitado. El m´etodo invierte los l´ımites si por accidente el usuario no los ingres´o correctamente. 3. Dadas tres notas parciales de N estudiantes y determinar cuantos ganaron, cuantos perdieron el curso y el promedio general. Ver programa 33 “Estad´ıstica sobre notas”. Programa 33 - Estad´ıstica sobre notas import java.io.*; public class P_Whi_03 { final static double NUM_NOTAS = 3.0; public static void main ( String args[ ] ) throws IOException { int I, N, N_Gan, N_Per; double Nota_1, Nota_2, Nota_3, N_Def, Prom_Gen; System.out.println ( "ESTADISTICA ESTUDIANTES!!" ); N_Gan = 0; N_Per = 0; Prom_Gen = 0; N = Entrada_Int ( "Numero de estudiantes
: " );
Este programa lee tres notas parciales a N estudiantes. Con ellas, calcula la definitiva (N_Def) y la acumula en la variable Prom_Gen. A continuaci´on, aumenta el contador correspondiente de acuerdo a la decisi´on N_Def >= 3.0. Al terminar el ciclo, calcula el promedio general como
11.1. PROBLEMAS RESUELTOS
157
Continuaci´ on programa 33 I = 1; while ( I { Nota_1 Nota_2 Nota_3
<= N ) = Entrada_Double ( "Nota 1 Est. " + I + ": " ); = Entrada_Double ( "Nota 2 Est. " + I + ": " ); = Entrada_Double ( "Nota 3 Est. " + I + ": " );
N_Def = ( Nota_1 + Nota_2 + Nota_3 ) / NUM_NOTAS; Prom_Gen += N_Def; if ( N_Def >= 3.0 ) { N_Gan++; } else { N_Per++; } Salida_Double ( "Def. Est. " + I + ": I++;
", N_Def
);
}; Prom_Gen /= N; Salida_Int ( "Ganaron Salida_Int ( "Perdieron Salida_Double ( "Promedio General }
: ", N_Gan ); : ", N_Per ); : ", Prom_Gen );
CAP´ITULO 11. CICLO WHILE
158
la suma de las notas dividido entre el n´ umero de ellas y entrega los resultados. 4. Calcular el m´aximo com´ un divisor de dos enteros positivos. Ver programa 34 “M´ aximo Com´ un Divisor”. Programa 34 - M´ aximo Com´ un Divisor import java.io.*; public class P_Whi_04 { public static void main ( String args[ ] ) throws IOException { int Numero1, Numero2, MCD; System.out.println
( "MAXIMO COMUN DIVISOR!!"
Numero1 = Entrada_Int ( "Primer Numero Numero2 = Entrada_Int ( "Segundo Numero MCD
= Calculo
Salida_Int
( Numero1, Numero2
: " : "
); ); ); );
( "Maximo Comun Divisor : ", MCD );
}
Este programa recibe del usuario dos enteros, los cuales pasa como argumento al m´etodo Calculo en el cual se obtiene el m´aximo com´ un divisor. El m´etodo Calculo recibe com par´ametros los dos enteros. La variable de control del ciclo (I) se inicializa con el menor. Para ello se utiliza el m´etodo min de la clase Math, propio de Java. El MCD es el primer divisor com´ un que se encuentre al utilizar un ciclo descendente. En el caso de encontrar un divisor com´ un (Num1 % I == 0 && Num2 % I == 0), se sale del ciclo. Si no hay un divisor com´ un, llegar´a a 1. El MCD encontrado es el valor a retornar.
11.1. PROBLEMAS RESUELTOS
Continuaci´ on programa 34 static int Calculo ( int Num1, int Num2 ) { int I, Aux; Aux = 1; I = Math.min ( Num1, Num2 ); while ( I >= 1 ) { if ( Num1 % I == 0 && Num2 % I == 0 ) { Aux = I; break; } I--; }; return Aux; }
159
CAP´ITULO 11. CICLO WHILE
160
5. Realizar programa que genere con asteriscos una figura similar a la siguiente, de longitud variable, donde la longitud es el ancho mayor. Ver “Figura de longitud 6”. Figura de longitud 6 * ** *** **** ***** ****** ***** **** *** ** *
Ver programa 35 “Figura”. Programa 35 - Figura import java.io.*; public class P_Whi_05 { public static void main ( String args[ ] ) throws IOException { int I, J, N; System.out.println
( "DIBUJO!!" );
N = Entrada_Int ( "Longitud: " );
11.1. PROBLEMAS RESUELTOS
Continuaci´ on programa 35 I = 1; while ( I <= N ) { J = 1; while ( J <= I ) { System.out.print ( "*" ); J++; } System.out.println ( ); I++; } I = 1; while ( I <= N ) { J = N - I; while ( J >= 1 ) { System.out.print ( "*" ); J--; } System.out.println ( ); I++; } }
161
CAP´ITULO 11. CICLO WHILE
162
Este programa tiene dos partes, la primera es la que dibuja la mitad superior (el n´ umero de asteriscos en aumento). La segunda parte es la que dibuja la otra mitad. En las dos partes se utilizan ciclos anidados, es decir, un ciclo est´a en el interior de otro. Es decir, por cada iteraci´on del ciclo exterior, el interno deber´a ejecutarse completamente.
11.2.
Problemas propuestos
1. Halle la suma de 2 + 4 + 6 + 8 + · · · + 2 × n, para n, entero positivo. Suma =
n X
2×i
i=1
2. Lea un conjunto de datos de tipo char. Debe imprimir la cantidad de letras, d´ıgitos y otros caracteres. La entrada termina cuando es presionada <Esc>. El c´odigo ASCII asociado a la tecla <Esc> es el 27. 3. Crear un cuadrado en la pantalla con el caracter *, indicando las el ancho y el alto. Tenga en cuenta el tama˜ no de la pantalla. *********** * * * * * * * * * * ***********
11.2. PROBLEMAS PROPUESTOS
163
4. Imprimir en pantalla una figura similar a la que se encuentra a continuaci´on de manera que pueda recibir el ancho y el alto. Valide las entradas de forma que no se vaya a salir de la pantalla. Utilice una variable llamada tipo, la cual, si es 1, hace que se dibujen u ´nicamente los bordes, pero si es 0, el tri´angulo debe ser relleno. * ** * * * * * * ****** Tipo 1
* ** *** **** ***** ****** Tipo 0
5. Dibuje en pantalla la siguiente figura, dada la longitud a lo ancho (incluye los extremos). Valide las entradas de forma que no se vaya a salir de la pantalla. Si el ancho es impar, debe terminar en un solo caracter. ****** * * **
******* * * * * * Impar
Par
6. Dibujar una l´ınea de tama˜ no n con el caracter -. En los extremos debe escribir el caracter *, lo mismo que al completar las medidas n1 y n2 , contando desde el extremo izquierdo. Todas las medidas incluyen los extremos. ∗ − − − − ∗} − − − − ∗ − − − − − ∗ | − − − {z n1 | {z } n2 {z } | n
CAP´ITULO 11. CICLO WHILE
164
7. Determinar el coseno de x, a partir de la siguiente serie (en radianes), para 10 iteraciones: cos(x) ≈ 1 −
x2 x4 x6 + − + ··· 2! 4! 6!
9 X x2×i cos(x) ≈ (−1)i × (2 × i)! i=0
8. Halle el elemento de la serie Fibonacci para n t´erminos. La serie Fibonacci es: 1, 1, 2, 3, 5, 8, 13, 21.... Recuerde que Elementon = Elementon−1 + Elementon−2 9. Halle 10 t´erminos de la secuencia: 2, 3, 8, 30, 144, 840, · · ·, donde Elementon = n! + (n − 1)! 10. Imprima el tri´angulo de Pascal para un n menor o igual a 7. 1 1 1 1 1 1
1 2 1 3 3 1 4 6 4 5 10 10 ...
1 5
1
Cap´ıtulo 12 Ciclo for Otra forma muy com´ un de utilizar los ciclos es la estructura for, la cual hace parte de los ciclos condicionados al comienzo. Este ciclo agrupa en una sola l´ınea los tres elementos b´asicos de cualquier estructura de repetici´on (inicializaci´on, condici´on e incremento), facilitando la programaci´on. Ver “Estructura general del for”. Estructura general del for Instrucciones antes del ciclo for ( Inicializacion ; Condicion ; Incremento ) { Instrucciones dentro del ciclo } Instrucciones despues del ciclo
165
CAP´ITULO 12. CICLO FOR
166
De la estructura general del ciclo for se debe tener en cuenta: El orden de ejecuci´on es el siguiente: 1. Instrucciones antes del ciclo 2. Inicializaci´on 3. Condici´on 4. Instrucciones dentro del ciclo 5. Incremento 6. Paso 3 mientras sea verdadera la condici´on 7. Instrucciones despu´es del ciclo Como se trata de un ciclo condicionado al comienzo, es posible que el grupo de instrucciones dentro del ciclo no se ejecute. Generalmente los tres elementos b´asicos se escriben en cualquier utilizaci´on del ciclo for. Sin embargo, estos elementos son opcionales. En caso de omitirse alguno de estos elementos, se debe reservar el espacio que ocupar´ıa en condiciones normales. Por ejemplo: for ( ; Condicion ; Incremento ) for ( Inicializacion ; Condicion ; ) for ( ; Condicion ; ), entre otras. Si la instrucci´on que se omite es la inicializaci´on, quiere decir que dentro de las instrucciones que se ejecutan antes del ciclo se encuentra el valor inicial de la variable de control. Por otra parte, si lo que se omite es el incremento, se asume que ´este deber´a estar en el grupo de instrucciones dentro del ciclo. Si se omite la condici´on, el ciclo ser´a infinito o tiene un llamado a la instrucci´on break;, normalmente asociada a una decisi´on. Esta instrucci´on break; finaliza el ciclo y es aplicable a los otros tipos de estructuras repetitivas. De manera similar a la instrucci´on break;, se puede utilizar continue; para que ignore las instrucciones siguientes dentro del ciclo. El uso de esta instrucci´on obliga a ejecutar el incremento y a continuaci´on verificar la condici´on. De igual manera, se puede utilizar en los
12.1. PROBLEMAS RESUELTOS
167
ciclos do - while y while, el paso es directo a la verificaci´on de la condici´on, dejando a responsabilidad del usuario el incremento. Al igual que en el ciclo while, se debe tener cuidado de no escribir el s´ımbolo ; (punto y coma) al terminar la l´ınea correspondiente al ciclo for porque tiene las mismas implicaciones. Ver p´agina 151
12.1.
Problemas resueltos
1. Calcular el cociente y el residuo utilizando u ´nicamente restas. Ver programa 36 “Divisi´ on a partir de restas”. Programa 36 - Divisi´ on a partir de restas import java.io.*; public class P_For_01 { public static void main ( String args[ ] ) throws IOException { int Numero1, Numero2, Cociente, Residuo; System.out.println Numero1 Numero2
}
( "DIVISION ENTERA CON RESTAS!!" );
= Entrada_Int ( "Primer Numero = Entrada_Int ( "Segundo Numero
: " : "
); );
Cociente = Calculo_Coc ( Numero1, Numero2 Residuo = Calculo_Res ( Numero1, Numero2, Cociente
); );
Salida_Int Salida_Int
); );
( "Cociente : ", Cociente ( "Residuo : ", Residuo
CAP´ITULO 12. CICLO FOR
168
Este programa lee el dividendo y el divisor en las variables Numero1 y Numero2 respectivamente. A continuaci´on calcula el cociente y el residuo llamando los respectivos m´etodos, a los cuales se les pasan los argumentos correspondientes, para finalmente imprimir los resultados. Continuaci´ on programa 36 static int Calculo_Coc ( int Dividendo, int Divisor ) { int I, R; R = Dividendo; for ( I = 0 ; R >= Divisor ; R -= Divisor ) { I++; } return I; }
El m´etodo Calculo_Coc retorna el cociente de dividir el Dividendo entre el Divisor. En este caso, el cociente es el n´ umero de veces que es posible restar del Dividendo, el Divisor, sin encontrar n´ umeros negativos. El m´etodo Calculo_Res devuelve el resultado correspondiente al residuo luego de pasar el Dividendo, el Divisor y el Cociente.
12.1. PROBLEMAS RESUELTOS
169
Continuaci´ on programa 36 static int Calculo_Res ( int Dividendo, int Divisor, int Coc ) { int R; R = Dividendo - Coc * Divisor; return R; } )
2. Calcular el m´ınimo com´ un m´ ultiplo de dos enteros positivos. Ver programa 37 “M´ınimo Com´ un M´ ultiplo”. Programa 37 - M´ınimo Com´ un M´ ultiplo import java.io.*; public class P_For_02 { public static void main ( String args[ ] ) throws IOException { int Numero1, Numero2, MCM; System.out.println
( "MINIMO COMUN MULTIPLO!!"
);
Este programa lee los dos n´ umeros a los que se les va a calcular el M´ınimo Com´ un M´ ultiplo. Este resultado se obtiene al llamar al m´etodo Calculo, valor que al final se imprime en la pantalla.
CAP´ITULO 12. CICLO FOR
170
Continuaci´ on programa 37 Numero1 = Entrada_Int ( "Primer Numero Numero2 = Entrada_Int ( "Segundo Numero MCM
= Calculo
Salida_Int
( Numero1, Numero2
Continuaci´ on programa 37 static int Calculo ( int Num1, int Num2 ) { int I, Aux1, Aux2; Aux1 = Math.max ( Num1, Num2 ); Aux2 = 1; for ( I = Aux1 ; ; I += Aux1 ) { if ( I % Num1 == 0 && I % Num2 == 0 ) { Aux2 = I; break; } } return Aux2;
); ); );
( "Minimo Comun Multiplo : ", MCM );
}
}
: " : "
12.1. PROBLEMAS RESUELTOS
171
El m´etodo Calculo inicia encontrando el mayor entre los dos n´ umros que se reciben como par´ametros. Para este fin utiliza el m´etodo propio de Java llamado max, perteneciente a la clase Math. El valor inicial de la variable de control (I) es el mayor de los dos n´ umeros que ingresan (Aux1). Luego, se busca el primer m´ ultiplo com´ un a los dos n´ umeros, incrementando la variable de control en cada iteraci´on con el valor correspondiente a Aux1. Al encontrar el primer m´ ultiplo com´ un, este es el MCM y se sale del ciclo. 3. Imprimir una tabla trigonom´etrica para ´angulos desde 0.0 Grados hasta 90.0 Grados, cada 5.0 Grados, con su equivalente en Radianes, para las funciones trigonom´etricas Seno, Coseno y Tangente. Ver programa 38 “Tabla trigonom´etrica”. Programa 38 - Tabla trigonom´ etrica import java.io.*; public class P_For_03 { final static double MEDIO_CIRCULO = final static double APROXIMACION =
180.0; 100.0;
public static void main ( String args[ ] ) throws IOException { double Grados, Rad; System.out.println
( "TABLA TRIGONOMETRICA!!" );
System.out.println ( "Grados" + "\t" + "Rad" + "\t" + "Seno" + "\t" + "Coseno" + "\t" + "Tangente");
CAP´ITULO 12. CICLO FOR Continuaci´ on programa 38
172
for ( Grados = 0.0 ; Grados <= 90.0; Grados += 5.0 ) { Rad = Grados * Math.PI / MEDIO_CIRCULO; System.out.print ( Grados + "\t" + Formatear( Rad ) + "\t" + Formatear( Math.sin (Rad) ) + "\t" + Formatear( Math.cos (Rad) ) + "\t" ); if ( Grados != 90.0 ) { System.out.println ( Formatear( Math.tan (Rad) ) ); } else { System.out.println ( "No existe" ); } } }
Este programa genera ´angulos desde 0.0 Grados hasta 90.0 Grados, donde el incremento en cada iteraci´on es de 5.0 Grados. Se calcula el equivalente a Radianes y con este valor se calculan el seno y el coseno. Para el c´alculo de la tangente se comprueba que el ´angulo medido en grados sea diferente de 90 Grados, porque la tangente de ´este ´angulo no existe. Para el c´alculo de las funciones trigonom´etricas se utilizan los m´etodos de la clase Math y es importante tener en cuenta que operan sobre ´angulos medidos en radianes. El m´etodo Formatear se utiliza para fijar dos cifras decimales. Para lograrlo, se utiliza el m´etodo floor de la clase Math, el cual elimina los decimales. Las dos cifras se establecen multiplicando el numero recibido como par´ametro (Num) por 100, valor asignado a la constante APROXIMACION. El significado de este n´ umero es que 102 = 100.
12.1. PROBLEMAS RESUELTOS
173
Continuaci´ on programa 38 static double Formatear ( double Num ) { return Math.floor( Num * APROXIMACION ) / APROXIMACION; } }
4. Escribir el plan de amortizaci´on de un cr´edito en una entidad financiera conociendo el monto, el plazo en meses y el inter´es anual. El plan de amortizaci´on deber´a mostrar en un listado el comportamiento del cr´edito cada mes, incluyendo el abono al capital, el inter´es en cada mes y el saldo. Ver programa 39 “Plan de amortizaci´on”. Programa 39 - Plan de amortizaci´ on import java.io.*; public class P_For_04 { final static double APROXIMACION
=
100.0;
public static void main ( String args[ ] ) throws IOException { double Monto, Int_Anual, Int_Mensual, Cuota; double Abono, Interes, Saldo; int Plazo, I; System.out.println Abono Interes
= 0.0; = 0.0;
( "PLAN DE AMORTIZACION!!" );
CAP´ITULO 12. CICLO FOR
174
Continuaci´ on programa 39 Monto Plazo Int_Anual
= Entrada_Double ( "Monto del credito : " ); = Entrada_Int ( "Plazo en meses : " ); = Entrada_Double ( "Int anual (20% = 20): " );
Cuota
= Calc_Cuota
( Monto, Plazo, Int_Anual
);
Saldo = Monto; System.out.println ( "\n" + "Mes No." + "\t" + "Abono Capital" + "\t" + "Interes" + "\t\t" + "Cuota" + "\t\t" + "Saldo" + "\n" ); for ( I = 0 ; I <= Plazo ; I++ ) { if ( I == 0 ) { System.out.println ( I + "\t" + "\t" + " \t\t" + "\t\t\t" + Saldo ); } else { System.out.println ( I + "\t" + Formatear ( Abono ) + "\t" + Formatear ( Interes ) + " \t" + Formatear ( Cuota ) + "\t" + Formatear ( Saldo )); } Interes = Calc_Interes ( Int_Anual, Saldo ); Abono = Calc_Abono ( Cuota, Interes ); Saldo = Calc_Saldo ( Saldo, Abono ); } }
12.1. PROBLEMAS RESUELTOS
175
Este programa calcula el valor de una cuota mensual de un cr´edito en una entidad financiera conociendo el monto del cr´edito, el inter´es anual y el plazo en meses. Adem´as, permite visualizar el comportamiento de cada una de las mensualidades con el fin de conocer detalles sobre el inter´es y abono al capital en cada cuota, lo mismo que el saldo actualizado. En la presentaci´on de cada valor se hace el llamado al m´etodo Formatear, explicado en la ejemplo anterior. Continuaci´ on programa 39 static double Calc_Interes ( double I_Anl, double Sal ) { return I_Anl / 100.0 / 12.0 * Sal; }
El m´etodo Calc_Interes permite obtener el valor del inter´es para cada una de las cuotas mensuales. El c´alculo del inter´es que se paga en cada cuota corresponde al producto del saldo por la tasa de inter´es mensual que a su vez es la doceava parte de la tasa de inter´es anual. Se debe hacer divisi´on entre 100 debido a la forma como se interpret´o la entrada de la tasa anual. Continuaci´ on programa 39 static double Calc_Abono ( double Cuo, double V_Int ) { return Cuo - V_Int; }
El m´etodo Calc_Abono recibe como par´ametros el valor de la cuota y el valor del inter´es asociado a esa cuota. Con estos dos valores se calcula la diferencia, correspondiente al abono a capital.
CAP´ITULO 12. CICLO FOR Continuaci´ on programa 39
176
static double Calc_Saldo ( double Sal, double Abo ) { return Sal - Abo; }
El m´etodo Calc_Saldo calcula el nuevo saldo el cual corresponde al saldo anterior menos el abono que se realiz´o en la respectiva cuota. Continuaci´ on programa 39 static double Calc_Cuota ( double Mnt, int Pla, double I_Anl ) { double Numero, Int_Mes, Aux; Int_Mes = I_Anl /100.0 / 12.0; Aux = Math.pow ( Int_Mes + 1.0 , Pla ); Numero = Mnt * Int_Mes * Aux / ( Aux - 1.0 ); return Numero; }
El m´etodo Calc_Cuota utiliza los tres valores conocidos y una ecuaci´on cl´asica de ingenier´ıa econ´omica que no es pertinente explicar a fondo. C=
M × I × (I + 1)P (I + 1)P − 1
5. Realizar programa que genere con asteriscos una figura similara a la siguiente de tal manera que permita cambiar la longitud y el n´ umero de flechas. La longitud es el ancho mayor de un segmento de asteriscos. El n´ umero de flechas no tiene en cuenta el tri´angulo inicial.
12.1. PROBLEMAS RESUELTOS
177
Figuras de 1 y 4 flechas, de longitud 5 * * ** ** *** *** **** **** ***** ***** **** **** *** *** ** ** * *
* * * * * ** ** ** ** ** *** *** *** *** *** **** **** **** **** **** ***** ***** ***** ***** ***** **** **** **** **** **** *** *** *** *** *** ** ** ** ** ** * * * * *
Ver “Figuras de 1 y 4 flechas, de longitud 5”. Ver programa 40 “Figura”. Programa 40 - Figura import java.io.*; public class P_For_05 { final static int SEPARACION = -2; public static void main ( String args[ ] ) throws IOException { int I, J, K, N, N_Flechas, Tope; System.out.println
( "DIBUJO!!" );
Este programa genera una figura la cual consta de un tri´angulo y un n´ umero especificado de flechas que se forman con el caracter *. La constante SEPARACION puede ser modificada con el fin de variar la apariencia de la figura.
CAP´ITULO 12. CICLO FOR
178
Continuaci´ on programa 40 Tope = 0; N = Entrada_Int ( "Longitud: " ); N_Flechas = Entrada_Int ( "Flechas : " ); for ( I = 1 ; I <= N ; I++ ) { for ( J = 1 ; J <= I ; J++ ) { System.out.print ( "*" ); } for ( K = 1 ; K <= N_Flechas ; K++ ) { if ( K == 1 ) { Tope = N - 1 + SEPARACION; } else { Tope = 2 * N - I + SEPARACION; } for ( J = 1 ; J <= Tope ; J++ ) { System.out.print ( " " ); } for ( J = 1 ; J <= I ; J++ ) { System.out.print ( "*" ); } } System.out.println ( ); }
12.1. PROBLEMAS RESUELTOS
Continuaci´ on programa 40 for ( I = 1 ; I <= N ; I++ ) { for ( J = N - I ; J >= 1 ; J-- ) { System.out.print ( "*" ); } for ( K = 1 ; K <= N_Flechas ; K++ ) { if ( K == 1 ) { Tope = N - 1 + SEPARACION; } else { Tope = N + I + SEPARACION; } for ( J = 1 ; J <= Tope ; J++ ) { System.out.print ( " " ); } for ( J = N - I ; J >= 1 ; J-- ) { System.out.print ( "*" ); } } System.out.println ( ); } }
179
CAP´ITULO 12. CICLO FOR
180
Con este ejemplo ser´ıa ideal practicar el seguimiento de las variables en forma manual para fortalecer la habilidad en el manejo de las estructuras de repetici´on anidadas.
12.2.
Problemas propuestos
1. Con * dibuje una letra L en la pantalla. Solicite la altura y el ancho. Valide las entradas de acuerdo al tama˜ no de la pantalla. * * * * * * ****** 2. Dibujar en la pantalla la siguiente figura. El ancho es igual al alto y su valor es especificado por teclado. ****** ***** **** *** ** * 3. Hallar los divisores de un entero positivo dado. 4. Hallar el m´aximo com´ un divisor de dos enteros positivos. 5. Dados a y b, enteros positivos, calcular a×b usando u ´nicamente sumas. 6. Hallar la primera potencia de 3 mayor de 1000, usando productos.
12.2. PROBLEMAS PROPUESTOS
181
7. Elabore un programa que imprima en pantalla la figura siguiente con caracteres *. La altura y el ancho se ingresan por teclado. La altura debe ser impar. Valide las entradas. ****** * * * * * * ** * * ** *** **** ***** ****** 8. Genere e imprima los n elementos de la serie de fibonacci, a partir del elemento k ´esimo. Tanto n como k deben ser solicitados al usuario. Recuerde que la serie de fibonacci es: 1, 1, 2, 3, 5, 8, 13, 21.... Elementon = Elementon−1 + Elementon−2 9. Calcular el factorial de un n´ umero entero positivo menor de 7, utilizando u ´nicamente sumas. n! = n × (n − 1) × (n − 2) × · · · × 3 × 2 × 1 a×b=a | + a + a{z+ · · · + a} b veces
10. Teniendo 100 n´ umeros al azar entre 1 y 5, determine la frecuencia de cada n´ umero.
182
CAP´ITULO 12. CICLO FOR
Cap´ıtulo 13 Arreglos unidimensionales Las variablee simples almacenan valores individuales. Java permite la utilizaci´on de arreglos para almacenar uno o m´as valores, asociados al mismo identificador, donde todos los valores son del mismo tipo. Existen arreglos de una o m´as dimensiones. Los arreglos de una dimensi´on se conocen con el nombre de vectores. Los de dos dimensiones se llaman matrices y los dem´as, reciben el nombre de multidimensionales. Las notas de los 35 estudiantes de un grupo, los nombres de 100 libros en la biblioteca o el valor de la matr´ıcula un n´ umero especificado de estudiantes de la universidad. Cuando se necesita manejar muchos datos (todos del mismo tipo), se utiliza un arreglo, especificando el tipo y el nombre del arreglo. El nombre del arreglo deber´a ser un identificador v´alido y a continuaci´on ir´an corchetes ([ ]) vac´ıos. Por ejemplo, int Vector [ ];. Al momento de crear el espacio de memoria, antes de usar el arreglo, se debe escribir la instrucci´on Vector = new int [ N ];, donde Vector es el nombre del arreglo, new es la instrucci´on que se utiliza para solicitar la memoria, int indica que el arreglo es de enteros y N indica el tama˜ no o n´ umero de posiciones del arreglo. Es importante anotar que N puede ser una constante, variable o un n´ umero claramente especificado, por ejemplo 8. Cuando Java encuentra la declaraci´on de un arreglo (float Nota [ ];), sabe que el usuario utilizar´a un arreglo llamado Nota. M´as adelante, deber´a indicar el n´ umero de posiciones que desea utilizar. En este caso, si usa 183
184
CAP´ITULO 13. ARREGLOS UNIDIMENSIONALES
Nota = new float [ 50 ]; indicar´a que desea reservar 200 bytes contiguos para Nota, de tal manera que en cada espacio de 4 bytes sea almacenado un n´ umero flotante perteneciente al arreglo. Para identificar cada uno de los elementos de un arreglo, se debe usar un valor sub´ındice que se˜ nala la posici´on del elemento dentro del arreglo. Para distinguir el primer elemento se usar´a el sub´ındice 0. El segundo elemento se usar´a el sub´ındice 1, y as´ı sucesivamente. El u ´ltimo elemento siempre estar´a en la posici´on especificada por el tama˜ no del arreglo menos uno. Para un arreglo de tama˜ no n, los elementos son: Ver “Elementos de un arreglo”. Elementos de un arreglo Dato[0] Dato[1] Dato[2] ... Dato[n - 2] Dato[n - 1]
Suponga que el valor de n es 5 y que los valores son: 0
100
1
2
200 300
3
4
400 500
Una forma de asignar los valores a las diferentes posiciones de un arreglo es usando el acceso directo. Ver “Acceso directo a las posiciones de un arreglo”. Ahora bien, es u ´til emplear una variable entera como sub´ındice que sirva para acceder a las posiciones del arreglo. Por ejemplo: si se desea asignar 2000 en la posici´on 3 usando un sub´ındice.
185 Acceso directo a las posiciones de un arreglo int Dato[ ]; Dato = new int [ 5 ]; Dato[0] Dato[1] Dato[2] Dato[3] Dato[4]
= = = = =
100; 200; 300; 400; 500;
Ver “Acceso indirecto a las posiciones de un arreglo”. Acceso indirecto a las posiciones de un arreglo int i; i = 3; Dato[i] = 2000;
Las valores almacenados en las posiciones de un arreglo son variables. Por lo tanto, ahora el valor de Dato[ 3 ] es 2000 y no 400 como estaba inicialmente. 0
1
100
200
2
3
300 2000
4
500
Es es muy pr´actico utilizar ciclos con el fin de acceder a todas las posiciones del arreglo, ya sea para leer, asignar, manipular o imprimir los valores que se encuentran almacenados en las diferentes posiciones. Ver “Acceso a un arreglo usando ciclos do - while y for”.
CAP´ITULO 13. ARREGLOS UNIDIMENSIONALES Acceso a un arreglo usando ciclos do - while y for
186
i = 0; do { Dato[ i ] = 0; i++; } while ( i < 5);
for ( i = 0 ; i < 5 ; i++ ) { Dato[ i ] = 0; }
A pesar de que en el ejemplo anterior no fue considerado el ciclo while, esta clase de ciclo tambi´en puede ser utilizada para este fin. No obstante, generalmente se utiliza el ciclo for, por facilidad en la programaci´on.
13.1.
Problemas resueltos
1. Elaborar un programa que sume los elementos de un arreglo de enteros. Ver programa 41 “Sumar los elementos de un arreglo”. Programa 41 - Sumar los elementos de un arreglo import java.io.*; public class P_Arr_01 { public static void main ( String args[ ] ) throws IOException { int Vector[ ]; int N, Suma; System.out.println ( "SUMA DE LOS ELEMENTOS!!" );
13.1. PROBLEMAS RESUELTOS
187
Continuaci´ on programa 41 N = Entrada_Int
( "Numero de elementos : "
Vector = new int
[ N ];
Entrada_Vec_Int
( "Numero " , Vector
);
);
System.out.println ( ); Salida_Vec_Int
( "Numero " , Vector
);
Suma = Calculo
( Vector
);
Salida_Int
( "Suma: " , Suma
);
}
Este programa lee los elementos de un arreglo de enteros llamado Vector. Primero, indica que va a usar un arreglo de enteros llamado Vector (int Vector[ ];). Despu´es de conocer la cantidad de elementos que va a contener el arreglo, se indica a Java que construya un arreglo unidimensional de N elementos con la instrucci´on Vector = new int [ N ];. A continuaci´on, mediante el llamado al m´etodo Entrada_Vec_Int, al cual le pasa como argumentos un mensaje que se imprime al leer cada elemento y el nombre del arreglo. Luego, imprime completamente el contenido del arreglo que acaba de ingresar llamando al m´etodo Salida_Vec_Int con los mismos argumentos. El m´etodo Calculo suma los elementos del arreglo y finamente se imprime el resultado.
CAP´ITULO 13. ARREGLOS UNIDIMENSIONALES Continuaci´ on programa 41
188
static void Entrada_Vec_Int ( String Msj, int Vec[ ] ) throws IOException { int I; for ( I = 0 ; I < Vec.length ; I++ ) { Vec[ I ] = Entrada_Int ( Msj + I + " : "); } }
El m´etodo Entrada_Vec_Int solicita la entrada de un entero dentro de un ciclo el cual se ejecuta todas las veces necesarias para leer la cantidad especificada de elementos del vector. Todo arreglo en Java tiene un atributo llamado length el cual almacena el n´ umero de posiciones del arreglo (longitud). En este caso, el arreglo se llama Vec, luego su longitud se accede con Vec.length. Continuaci´ on programa 41 static void Salida_Vec_Int ( String Msj, int Vec[ ] ) { int I; for ( I = 0 ; I < Vec.length ; I++ ) { Salida_Int ( Msj + I + " : ", Vec[I] ); } }
13.1. PROBLEMAS RESUELTOS
189
El m´etodo Salida_Vec_Int es similar a Entrada_Vec_Int, y se utiliza para mostrar en pantalla el contenido de un arreglo cuya referencia pasa como par´ametro, al igual que la cadena que se imprime. Continuaci´ on programa 41 static int Calculo ( int Vec[ ] ) { int I, S; S = 0; for ( I = 0 ; I < Vec.length ; I++ ) { S += Vec[I]; } return S; } }
El m´etodo Calculo recibe como par´ametro una referencia al arreglo que se quiere sumar. El acumulador se inicia en cero (S = 0;) y conociendo la longitud del vector (Vec.length) se ejecuta un ciclo que sumar´a los elementos del arreglo. El valor final de S es retornado. 2. Construir un programa que lea los elementos de un vector de enteros, invierta el orden y lo imprima. Ver programa 42 “Orden inverso”. Este programa lee el n´ umero de elementos que conformar´a el vector. A continuaci´on solicita memoria para la creaci´on de dos vectores, el original y otro en el cual ser´a almacenado el vector invertido. Con el llamado al m´etodo Entrada_Vec_Int se leen los datos del vector. El m´etodo Invertir_Vec_Int se encarga de generar un vector con elementos enteros a partir del vector que ha sido ingresado por el usuario. Finalmente se imprime el vector resultante a trav´es del m´etodo Salida_Vec_Int.
CAP´ITULO 13. ARREGLOS UNIDIMENSIONALES
190
Programa 42 - Orden inverso import java.io.*; public class P_Arr_02 { public static void main ( String args[ ] ) throws IOException { int Vector[ ], Vector_Inv[ ]; int N; System.out.println
( "ORDEN INVERSO!!"
);
N = Entrada_Int
( "Numero de elementos : " );
Vector = new int [ N ]; Vector_Inv = new int [ N ];
}
Entrada_Vec_Int Invertir_Vec_Int
( "Numero " , Vector ( Vector, Vector_Inv
); );
System.out.println
( "\n ORDEN INVERSO \n"
);
Salida_Vec_Int
( "Numero " , Vector_Inv
);
13.1. PROBLEMAS RESUELTOS
191
Continuaci´ on programa 42 static void Invertir_Vec_Int ( int Vec[ ], int Vec_Inv[ ] ) { int I, J; J=0; for ( I = Vec.length -1 ; I >= 0 ; I-- ) { Vec_Inv[ J ] = Vec[ I ]; J++; } } }
El m´etodo Invertir_Vec_Int recibe como par´ametros el vector original y el vector en el cual se almacenar´a el resultado de invertir los elementos. Mediante el uso de los contadores I y J se controlan las posiciones en los dos vectores. 3. Construir un programa que lea los elementos de un vector de enteros, y lo divida en dos vectores, uno con los pares y otro con los impares. Ver programa 43 “Dividir en pares e impares”. Programa 43 - Dividir en pares e impares import java.io.*; public class P_Arr_03 {
Este programa lee un vector de enteros. Con el m´etodo Cuenta_Pares se obtiene la cantidad de n´ umeros pares y al restarlo del total de elementos del vector original se puede solicitar la memoria necesaria para
CAP´ITULO 13. ARREGLOS UNIDIMENSIONALES Continuaci´ on programa 43
192
public static void main ( String args[ ] ) throws IOException { int Vector[ ], Vec_Par[ ], Vec_Impar[ ]; int N, N_Pares, N_Impares; System.out.println
( "DIVISION EN PARES E IMPARES!!" );
N = Entrada_Int
( "Numero de elementos : "
Vector
[ N ];
= new int
Entrada_Vec_Int
( "Numero " , Vector
);
);
N_Pares = Cuenta_Pares ( Vector ); N_Impares = N - N_Pares; Vec_Par = new int Vec_Impar = new int
[ N_Pares ]; [ N_Impares ];
System.out.println
( );
Dividir
( Vector, Vec_Par, Vec_Impar
if ( N_Pares > 0 ) { System.out.println ( "\n PARES \n" Salida_Vec_Int ( "Numero " , Vec_Par }
); );
if ( N_Impares > 0 ) { System.out.println ( "\n IMPARES \n" ); Salida_Vec_Int ( "Numero " , Vec_Impar ); } }
);
13.1. PROBLEMAS RESUELTOS
193
los vectores Vec_Par y Vec_Impar. A continuaci´on se utiliza el m´etodo Dividir donde los argumentos son el vector con los datos, el vector que almacenar´a los pares y el vector donde ser´an guardados los impares. Finalmente, se imprimen los vectores resultantes, siempre y cuando tengan elementos. Continuaci´ on programa 43 static int Cuenta_Pares ( int Vec[ ] ) { int I, J; J = 0; for ( I = 0 ; I < Vec.length ; I++ ) { if ( Vec[I] % 2 == 0) { J++; } } return J; }
El m´etodo Cuenta_Pares recorre el vector que recibe por par´ametro con el fin de llevar la cuenta del n´ umero de elementos pares.
CAP´ITULO 13. ARREGLOS UNIDIMENSIONALES Continuaci´ on programa 43
194
static void Dividir ( int Vec[ ], int Vec1[ ], int Vec2[ ] ) { int I, J, K; J = 0; K = 0; for ( I = 0 ; { if ( Vec[I] { Vec1[ J ] J++; } else { Vec2[ K ] K++; } }
I < Vec.length ; I++ ) % 2 == 0) = Vec[ I ];
= Vec[ I ];
} }
El m´etodo Dividir recibe el vector con los elementos enteros y se encarga de generar dos vectores resultantes, uno para n´ umeros pares y otro para impares. 4. Elaborar un programa que lea un vector de enteros y una posici´on determinada. El programa deber´a generar un vector con los mismos elementos excepto el que se encuentre en la posicion especificada. Ver programa 44 “Eliminar un dato”. Este programa lee un vector de enteros y la posici´on del elemento que no se desea pasar al vector de salida. En caso de que la posici´on especificada no corresponda a un elemento del vector original se imprime un mensaje de error.
13.1. PROBLEMAS RESUELTOS
195
Programa 44 - Eliminar un dato import java.io.*; public class P_Arr_04 { public static void main ( String args[ ] ) throws IOException { int Vector[ ], Vec_Sal[ ]; int N, Posicion; System.out.println
( "ELIMINAR UN ELEMENTO!!"
);
N = Entrada_Int
( "Numero de elementos : "
);
Vector Vec_Sal
[ N ]; [ N - 1 ];
= new int = new int
Entrada_Vec_Int Posicion
( "Numero " , Vector
);
= Entrada_Int ( "Posicion del elemento : " );
if ( Eliminado ( Vector, Posicion, Vec_Sal ) == true ) { Salida_Vec_Int ( "Elemento ", Vec_Sal ); } else { System.out.println ( "ERROR!!" ); } }
CAP´ITULO 13. ARREGLOS UNIDIMENSIONALES Continuaci´ on programa 44
196
static boolean Eliminado ( int Vec[ ], int Pos, int V_Sal[ ] ) { int I, J; J = 0; if ( Pos >= 0 && Pos < Vec.length ) { for ( I = 0 ; I < Vec.length ; I++ ) { if ( I != Pos ) { V_Sal [ J ] = Vec[ I ]; J++; } } return true; } else { return false; } } }
El m´etodo Eliminado genera un vector de enteros con los elementos de un vector de datos excepto el elemento de una posici´on determinada por el par´ametro Pos. Si la posici´on Pos no hace parte del vector se retorna un valor false en otro caso, se copia el vector elemento a elemento sin tener en cuenta el elemento de la posici´on Pos. Observe que cada vector es controlado por su propio contador. 5. Construir un programa que permita insertar un elemento dentro de un vector de enteros a partir de una posici´on especificada.
13.1. PROBLEMAS RESUELTOS
197
Ver programa 45 “Insertar y desplazar”. Programa 45 - Insertar y desplazar import java.io.*; public class P_Arr_05 { public static void main ( String args[ ] ) throws IOException { int Vector[ ], Vec_Sal[ ]; int N, Posicion, Elemento; System.out.println
( "INSERTAR UN ELEMENTO!!"
);
N = Entrada_Int
( "Numero de elementos : "
);
Vector = new int Vec_Sal = new int Entrada_Vec_Int
[ N ]; [ N + 1 ]; ( "Numero " , Vector
);
Elemento
= Entrada_Int ( "Elemento a insertar
: " );
Posicion = Entrada_Int ( "Posicion del elemento : " if ( Insertado ( Vector, Posicion, Elemento, Vec_Sal == true ) { Salida_Vec_Int ( "Elemento ", Vec_Sal } else { System.out.println ( "ERROR!!" }
); )
);
);
}
Este programa lee un vector de enteros, un elemento a insertar y la posici´on en la cual se desea introducir. Mediante el llamado al m´etodo
CAP´ITULO 13. ARREGLOS UNIDIMENSIONALES
198
Insertado se puede imprimir en la pantalla el vector de salida. Si no es posible insertar dicho elemento, se obtiene un mensaje de error. Continuaci´ on programa 45 static boolean Insertado ( int Vec[ ], int Pos, int Elem, int V_Sal[ ] ) { int I, J; J = 0; if ( Pos >= 0 && Pos < Vec.length ) { for ( I = 0 ; I < Vec.length ; I++ ) { if ( I == Pos ) { V_Sal [ J ] = Elem; J++; } V_Sal [ J ] = Vec[ I ]; J++; } return true; } else { return false; } } }
13.2. PROBLEMAS PROPUESTOS
199
El m´etodo Insertado recibe como par´ametros el vector de datos, la posici´on en la cual se desea insertar el elemento, el elemento a insertar y el vector de salida que se va a generar. En caso de que la posici´on no sea posible, se retorna un valor booleano de false. Si el proceso se realiz´o correctamente, se retorna un true.
13.2.
Problemas propuestos
1. Concatene dos arreglos, donde el primer arreglo es de n elementos, y el segundo es de m elementos, en un tercer arreglo. Los valores m y n est´an entre 1 y 20. 6
4
9
5
6
4
9
5
2
2
5
2
3
8
0
5
2
3
8
0
2. Generar e imprimir un arreglo de 40 elementos similara al que se muestra a continuaci´on. 1
4
9
16
25
36
49
···
3. Inicializar un vector de 50 elementos enteros con la serie que se puede apreciar en el siguiente arreglo. Finalmente, encuentre la suma de sus elementos utilizando una funci´on. 0
3
6
9
0
3
6
9
0
3
6
9
···
6
···
4. Generar e imprimir el arreglo de 50 elementos. 1
1
2
2
3
3
4
4
5
5
6
CAP´ITULO 13. ARREGLOS UNIDIMENSIONALES
200
5. Dado un vector a de n elementos que ingresa ordenado de menor a mayor, hallar la mediana. n−1 a[ 2 ], M ediana =
si n es impar
a[ n ]+a[ n −1] 2 2 2
si n es par
Por ejemplo, dado el siguiente arreglo de 8 elementos: 1
2
2
5
7
M ediana =
8
8
9
a[ n2 ] + a[ n2 − 1] 2
a[ 82 ] + a[ 82 − 1] 2 a[4] + a[3] 7+5 M ediana = = =6 2 2 M ediana =
6. Dado un arreglo de 10 enteros y un n´ umero x entre cero y nueve, cree un segundo arreglo de nueve posiciones igual al primero, al cual se le ha eliminado el elemento de la posici´on x. 5
7
2
5
1
1
6
3
5
6
5
7
2
5
1
6
3
5
x=5 6
13.2. PROBLEMAS PROPUESTOS
201
7. Dado un arreglo de 8 enteros, un n´ umero x entero entre cero y siete, y un entero cualquiera m, cree un segundo arreglo de nueve posiciones al que se le ha adicionado el elemento m en la posici´on x. 4
3
2
3 4
7 3
8 2
9 8
3 3
x=3 7
8
9
m=8 3
8. Dados dos arreglos de tama˜ nos m y n respectivamente, determinar si son iguales o no. Si el tama˜ no de los vectores es diferente, determinar si existe contenencia, en el orden estricto. 5
3
6
2
8
4
3
⊃
6
2
8
9. Dado un vector de 15 elementos enteros que ingresa en orden de menor a mayor, imprima un segundo vector igual al primero sin repeticiones. 1
1
2
3
3
3
4
6
8
8
8
1
2
3
4
6
8
9
8
9
9
9
10. Dado un vector de 15 elementos enteros que ingresa en cualquier orden, imprima un segundo vector igual al primero sin repeticiones. 6
9
3
2
6 6
0 9
2 3
5 2
1 0
4 5
0 1
3 4
2
1
5
202
CAP´ITULO 13. ARREGLOS UNIDIMENSIONALES
Cap´ıtulo 14 Matrices Un arreglo bidimensional es una formaci´on organizada de elementos, dispuestos en filas y columnas. Los arreglos de dos dimensiones se conocen con el nombre de matrices o tablas. Al igual que los arreglos unidimensionales, las matrices se utilizan para agrupar un conjunto de datos del mismo tipo, asociados a un mismo identificador y tienen m´ ultiples aplicaciones en la soluci´on de problemas de diferentes ´areas. Las notas de varias materias para los estudiantes de un grupo, cuatro notas parciales de un grupo de estudiantes, la venta semanal de los vendedores de una empresa o la temperatura de un estanque cada hora en los diferentes d´ıas de la semana, entre otros. Para indicarle a Java que se utilizar´a un arreglo de dos dimensiones, se debe especificar el tipo de dato y el nombre del arreglo. A continuaci´on del nombre de la matriz, ir´an corchetes dobles ([ ][ ]) vac´ıos. Por ejemplo, int Matriz [ ][ ];. Para solicitar la memoria que ocupar´a la matriz, se debe utilizar la instrucci´on Matriz = new int [ N ][ M ];, donde Matriz es el nombre del arreglo bidimensional, new es la instrucci´on que se utiliza para solicitar memoria, int indica que el arreglo es de enteros, N indica el n´ umero de posiciones horizontales del arreglo (filas) y M corresponde a la cantidad de posiciones verticales (columnas).
203
CAP´ITULO 14. MATRICES
204
Al igual que sucede con los arreglos unidimensionales, Java debe separar memoria suficiente para almacenar todos los elementos de la matriz. En el caso del ejemplo anterior, ser´ıa necesario reservar espacio para N por M elementos. Para el caso de los enteros la memoria reservada ser´ıa 4 x N x M bytes. Cada elemento de una matriz se identifica con dos ´ındices, donde el primero indica la fila y el segundo corresponde a la columna. La primera fila tiene como ´ındice el n´ umero cero, y sucede lo mismo con la columna. Naturalmente, en una matriz de N filas, la u ´ltima tendr´a el ´ındice N - 1, y para M columnas, se identifica la u ´ltima con el ´ındice M - 1. Ver tabla 14.1. [ [
0 1
][ 0 ] [ ][ 0 ] [ .. .
0 1
][ 1 ] [ ][ 1 ] [ .. .
0 1
][ 2 ] ][ 2 ] .. .
... ... ...
[ [
0 1
][ M-1 ] ][ M-1 ] .. .
[ N-1 ][ 0 ] [ N-1 ][ 1 ] [ N-1 ][ 2 ]
...
[ N-1 ][ M-1 ]
Cuadro 14.1: Matriz de N filas por M columnas
Para tener acceso a los elementos de una matriz se puede utilizar el acceso directo o el acceso. Ver “Acceso directo a las posiciones de una matriz”. Despu´es de la asignaci´on anterior, la matriz tiene almacenada en la tabla 14.2:
0 1 2
0
1
10 20 30
15 25 35
Cuadro 14.2: Matriz de 3 filas por 2 columnas
205 Acceso directo a las posiciones de una matriz int Tabla[ ][ ]; Tabla = new int [ 3 ][ 2 ]; Tabla[0][0] Tabla[0][1] Tabla[1][0] Tabla[1][1] Tabla[2][0] Tabla[2][1]
= = = = = =
10; 15; 20; 25; 30; 35;
Tambi´en es posible utilizar variables enteras como sub´ındices para acceder a las posiciones de la matriz. Por ejemplo: si se desea asignar 85 en la posici´on de la fila 1 y columna 0. Ver “Acceso indirecto a las posiciones de una matriz”. Acceso indirecto a las posiciones de una matriz int i,j; i = 1; j = 0; Tabla[i][j] = 85;
Al realizar la anterior modificaci´on a la tabla, los nuevos valores se encuentran en la tabla 14.3.
CAP´ITULO 14. MATRICES
206 0 1 2
0
1
10 85 30
15 25 35
Cuadro 14.3: Actualizaci´on de valores de una Matriz
Es es muy pr´actico utilizar ciclos con el fin de acceder a todas las posiciones del arreglo, ya sea para leer, asignar, manipular o imprimir los valores que se encuentran almacenados en las diferentes posiciones. Ver “Acceso a un arreglo usando el ciclo for”. Acceso a un arreglo usando el ciclo for for ( i = 0 ; i < 4 ; i++ ) { for ( j = 0 ; j < 3 ; j++ ) { Dato[ i ][ j ] = 10 * i + j; } }
Observe que el ciclo externo controla el ´ındice de las filas y el interno se utiliza para recorrer las columnas. Ver tabla 14.4.
0 1 2 3
0
1
2
0 10 20 30
1 11 21 31
2 12 22 32
Cuadro 14.4: Acceso a los elementos de una matriz
14.1. PROBLEMAS RESUELTOS
14.1.
207
Problemas resueltos
1. Elabore un programa que genere la Matriz Identidad de orden N. La Matriz Identidad se compone de n´ umeros enteros, donde todos los elementos de la diagonal principal son unos y el resto de la matriz son ceros. Ver tabla 14.5. 0 1 2
0
1
2
1 0 0
0 1 0
0 0 1
Cuadro 14.5: Matriz Identidad de orden 3 Ver programa 46 “Inicializar la Matriz Identidad”. Programa 46 - Inicializar la Matriz Identidad import java.io.*; public class P_Mat_01 { public static void main ( String args[ ] ) throws IOException { int Matriz[ ][ ]; int N; System.out.println N
( "MATRIZ IDENTICA!!" );
= Entrada_Int ( "Orden : "
Matriz = new int
);
[ N ] [ N ];
Este programa utiliza una matriz entera (int Matriz[ ][ ];), la cual tendr´a N filas y N columnas, es decir, ser´a una matriz cuadrada. La ins-
CAP´ITULO 14. MATRICES Continuaci´ on programa 46
208
Mat_Identidad
( Matriz );
Salida_Mat_Int
( Matriz );
}
trucci´on Matriz = new int [ N ] [ N ]; solicita la memoria necesaria para crearla. El m´etodo Mat_Identidad asigna a la matriz que se referencia en el llamado, la matriz identidad. Finalmente se muestra en la pantalla la matriz generada. Continuaci´ on programa 46 static void Mat_Identidad ( int Mat[ ][ ] ) { int I, J; for ( I = 0 ; I { for ( J = 0 ; { if ( I == J { Mat[ I ][ } else { Mat[ I ][ } } } }
< Mat.length ; I++ ) J < Mat[0].length ; J++ ) ) J ] = 1;
J ] = 0;
14.1. PROBLEMAS RESUELTOS
209
El m´etodo Mat_Identidad asigna a la matriz recibida como par´ametro la Matriz Identidad. Este m´etodo utiliza el atributo length asociado a la matriz para determinar el n´ umero de filas. Igualmente se obtiene de la primera fila este mismo atributo para determinar el n´ umero de columnas de la matriz. Observe que la variable I controla las filas y J se encarga de controlar las columnas. La decisi´on interna determina que cuando I y J sean iguales se asigne un 1 y en caso contrario se asigne un 0. Es decir, los elementos de la diagonal principal tienen el mismo ´ındice en la fila y la columna. Continuaci´ on programa 46 static void Salida_Mat_Int ( int Mat[ ][ ] ) { int I, J; for ( I = 0 ; I < Mat.length ; I++ ) { for ( J = 0 ; J < Mat[0].length ; J++ ) { System.out.print ( "\t" + Mat[ I ][ J ] ); } System.out.println ( ); } } }
El m´etodo Salida_Mat_Int se encarga de imprimir en la pantalla una matriz especificada. Los elementos de la matriz se separan por un tabulador (\t). Cada fila se imprime en un rengl´on independiente, separadas por la instrucci´on System.out.println ( );.
CAP´ITULO 14. MATRICES
210
2. Escriba un programa que sume los elementos de la diagonal principal de una matriz cuadrada. Ver programa 47 “Suma de los elementos de la diagonal”. Programa 47 - Suma de los elementos de la diagonal import java.io.*; public class P_Mat_02 { public static void main ( String args[ ] ) throws IOException { int Matriz[ ][ ]; int N, Suma; System.out.println N
( "SUMA DE LA DIAGONAL!!\n" );
= Entrada_Int ( "Orden : "
);
Matriz = new int
[ N ][ N ];
Entrada_Mat_Int
( "Elemento " , Matriz );
Suma
( Matriz );
= Calc_Diag
Salida_Mat_Int
( Matriz );
System.out.println
( );
Salida_Int
( "La suma es: ", Suma );
}
Este programa lee los elementos de la matriz mediante el llamado al m´etodo Entrada_Mat_Int. Este m´etodo recibe dos argumentos, un letrero que acompa˜ na cada entrada de elemento individual y una referencia a la matriz que ser´a le´ıda por el teclado. El m´etodo Calc_Diag se
14.1. PROBLEMAS RESUELTOS
211
encarga de calcular la suma de los elementos de la diagonal. Finalmente se imprime la matriz y el resultado de la suma. Continuaci´ on programa 47 static void Entrada_Mat_Int ( String Msj, int Mat[ ][ ] ) throws IOException { int I, J; for ( I = 0 ; I < Mat.length ; I++ ) { for ( J = 0 ; J < Mat[0].length ; J++ ) { Mat[ I ][ J ] = Entrada_Int ( Msj + " [ " + I + " , " + J + " ]: "); } System.out.println ( ); } }
El m´etodo Entrada_Mat_Int lee la matriz desde el teclado. Este m´etodo indica al usuario las coordenadas del elemento que se est´a solicitando. El m´etodo Calc_Diag se encarga de sumar los elementos de la diagonal principal de la matriz. Debido a que dichos elementos tienen en sus coordenadas el mismo n´ umero para la fila y la columna, u ´nicamente se utiliza un ciclo.
CAP´ITULO 14. MATRICES Continuaci´ on programa 47
212
static int Calc_Diag ( int Mat[ ][ ] ) { int I, Num; Num = 0; for ( I = 0 ; I < Mat.length ; I++ ) { Num += Mat [ I ][ I ]; } return Num; }
3. Construir un programa que imprima la transpuesta de una matriz. Ver programa 48 “Imprimir la transpuesta de una matriz”. Programa 48 - Imprimir la transpuesta de una matriz import java.io.*; public class P_Mat_03 { public static void main ( String args[ ] ) throws IOException { int Matriz[ ][ ], Matriz_T[ ][ ]; int Filas, Columnas; System.out.println
( "MATRIZ TRANSPUESTA!!\n" );
Filas = Entrada_Int ( "Numero de filas Columnas = Entrada_Int ( "Numero de Columnas
: " ); : " );
14.1. PROBLEMAS RESUELTOS
213
Continuaci´ on programa 48
}
System.out.println
( );
Matriz = new int Matriz_T = new int
[ Filas ][ Columnas ]; [ Columnas ][ Filas ];
Entrada_Mat_Int
( "Elemento " , Matriz
);
Transpuesta_Mat System.out.println
( Matriz, Matriz_T ( "MATRIZ ORIGINAL\n"
); );
Salida_Mat_Int
( Matriz
);
System.out.println
( "\nMATRIZ TRANSPUESTA\n" );
Salida_Mat_Int
( Matriz_T
);
CAP´ITULO 14. MATRICES
214
Este programa lee los elementos de una matriz, crea la matriz transpuesta con el llamado al m´etodo Transpuesta_Mat y las imprime. Continuaci´ on programa 48 static void Transpuesta_Mat ( int Mat [ ][ ], int Mat_T[ ][ ] ) { int I, J; for ( I = 0 ; I < Mat.length ; I++ ) { for ( J = 0 ; J < Mat[0].length ; J++ ) { Mat_T[ J ][ I ] = Mat[ I ][ J ] ; } } }
Este m´etodo invierte el orden de los ´ındices de tal manera que la disposici´on en filas y columnas de la matriz origen se convierta en una formaci´on de columnas y filas. Es decir, si la matriz origen es de N x M, la transpuesta ser´a de M x N. 4. Escriba un programa que intercambie dos filas de una matriz. Ver programa 49 “Intercambiar dos filas”. Este programa lee la matriz origen y las filas que se desea intercambiar. A continuaci´on llama al m´etodo Intercambio_Filas al cual le pasa como argumentos referencia a las matrices origen y destino, y las filas que se va a intercambiar. Luego se imprimen las dos matrices. El m´etodo Intercambio_Filas utiliza decisiones anidadas dentro de los ciclos que controlan todos los elementos de la matriz para establecer si el valor de la variable I corresponde a una de las dos filas que se quieren intercambiar o no. En todos los casos, se realiza la asignaci´on correspondiente para formar la matriz de salida.
14.1. PROBLEMAS RESUELTOS
215
Programa 49 - Intercambiar dos filas import java.io.*; public class P_Mat_04 { public static void main ( String args[ ] ) throws IOException { int Matriz[ ][ ], Matriz_Sal[ ][ ]; int Filas, Columnas, Fil1, Fil2; System.out.println Filas Columnas
( "INTERCAMBIO DE FILAS!!\n" );
= Entrada_Int( "Numero de filas = Entrada_Int( "Numero de Columnas
: " : "
); );
System.out.println ( ); Matriz = new int Matriz_Sal = new int
[ Filas ] [ Columnas ]; [ Filas ] [ Columnas ];
Entrada_Mat_Int
( "Elemento " , Matriz
Fil1 Fil2
}
= Entrada_Int( "Fila 1: " = Entrada_Int( "Fila 2: "
); ); );
Intercambio_Filas
( Matriz, Fil1, Matriz_Sal, Fil2 );
System.out.println
( "MATRIZ ORIGINAL\n"
);
Salida_Mat_Int
( Matriz
);
System.out.println
( "\nMATRIZ DE SALIDA\n"
);
Salida_Mat_Int
( Matriz_Sal
);
CAP´ITULO 14. MATRICES
216
Continuaci´ on programa 49 static void Intercambio_Filas ( int Mat [ ][ ], int F1, int Mat_S[ ][ ], int F2 ) { int I, J, Aux; for ( I = 0 ; I < Mat.length ; I++ ) { for ( J = 0 ; J < Mat[0].length ; J++ ) { if ( I != F1 && I != F2 ) { Mat_S[ I ][ J ] = Mat[ I ][ J ]; } else { if ( I == F1 ) { Mat_S[ I ][ J ] = Mat[ F2 ][ J ]; } else { Mat_S[ I ][ J ] = Mat[ F1 ][ J ]; } } } } }
14.1. PROBLEMAS RESUELTOS
217
5. Escriba un programa que genere cuadrados m´agicos de orden impar. Un cuadrado m´agico es una disposici´on especial de n´ umeros enteros en una matriz, donde la suma de los elementos de las filas, las columnas o las diagonales es el mismo. Ver tabla 14.6.
0 1 2 3 4
0
1
2
3
4
17 23 4 10 11
24 5 6 12 18
1 7 13 19 25
8 14 20 21 2
15 16 22 3 9
Cuadro 14.6: Cuadrado M´agico de orden 5 Ver programa 50 “Cuadrados m´agicos de orden impar”. Programa 50 - Cuadrados m´ agicos de orden impar import java.io.*; public class P_Mat_05 { public static void main ( String args[ ] ) throws IOException { int Matriz[ ][ ]; int N; System.out.print ( "CUADRADO MAGICO DE "); System.out.println ( "ORDEN IMPAR!!\n" ); N =
Entrada_Int
( "Orden
: "
);
Este programa valida que el orden de la matriz sea impar para poder realizar correctamente su ejecuci´on, debido a que se utiliza un algoritmo exclusivamente para matrices de tama˜ no impar. A continuaci´on, se
CAP´ITULO 14. MATRICES Continuaci´ on programa 50
218
if ( N % 2 == 1 ) { Matriz = new int Inicializa_Matriz Cuadro_Magico Salida_Mat_Int } else { System.out.println }
[ ( ( (
N ][ N Matriz Matriz Matriz
]; ); ); );
( "ERROR!!" );
}
inicializa la matriz con ceros, para facilitar la identificaci´on de posiciones vac´ıas. Luego se llama al m´etodo Cuadro_Magico para generar el cuadrado m´agico correspondiente que finalmente se imprime. Continuaci´ on programa 50 static void Inicializa_Matriz ( int Mat[ ][ ] ) { int I, J; for ( I = 0 ; I < Mat.length ; I++ ) { for ( J = 0 ; J < Mat[ 0 ].length ; J++ ) { Mat[ I ][ J ] = 0; } } } }
14.1. PROBLEMAS RESUELTOS
219
El m´etodo Inicializa_Matriz se encarga de poner en 0 todos los elementos de la matriz cuya referencia se recibi´o por par´ametro. Es importante tener en cuenta que para efectos del algoritmo, un cero corresponde a un espacio sin ocupar en el cuadrado m´agico. Continuaci´ on programa 50 static void Cuadro_Magico ( int Mat[ ][ ] ) { int Fil, Col, Num, Prox_F, Prox_C; Fil = 0; Col = Mat.length / 2; for ( Num = 1 ; Num <= Mat.length*Mat.length ; Num++ ) { Mat[ Fil ][ Col ] = Num; Prox_F = ( Fil - 1 + Mat.length ) % Mat.length; Prox_C = ( Col + 1 + Mat.length ) % Mat.length; if ( Mat[ Prox_F ][ Prox_C ] == 0 ) { Fil = Prox_F; Col = Prox_C; } else { Fil = Fil + 1; } } }
CAP´ITULO 14. MATRICES
220
El m´etodo Cuadro_Magico se encarga de asignar las diferentes posiciones de la matriz, siguiendo el siguiente procedimiento: El n´ umero 1 se ubica en la primera fila en la columna del centro. El siguiente n´ umero se escribe en la celda de la siguiente columna y fila anterior, en forma circular. Es decir, la fila anterior a la primera es la u ´ltima o la columna siguiente a la u ´ltima es la primera, mientras est´e libre. En caso de que una posici´on est´e ocupada, el n´ umero ser´a ubicado en la misma columna, de la fila siguiente. Un cuadrado m´agico de tama˜ no N tiene N 2 elementos. Por lo tanto, el procedimiento termina cuando el cuadrado est´a completamente lleno.
14.2.
Problemas propuestos
Suponga por cada problema, la existencia de una matriz de tama˜ no N por M. 1. Encuentre los elementos mayor y menor. Adem´as, calcule el promedio de todos sus elementos. 2. Determine si la matriz es o no sim´etrica. Una matriz es sim´etrica si es cuadrada (N es igual a M), los elementos por encima de la diagonal son iguales a los elementos por debajo en forma de espejo. Ver un ejemplo en la tabla 14.7.
0 1 2
0
1
2
a b
a c
b c -
Cuadro 14.7: Matriz sim´etrica de orden 3
3. Determine si la matriz es o no un cuadrado m´agico.
14.2. PROBLEMAS PROPUESTOS
221
4. Elimine una fila y columna especificadas y construya otra matriz con el resultado. 5. En la matriz se almacenan las notas de un curso. Suponga que una fila corresponde a las notas parciales de un estudiante. Calcule la nota definitiva de todos los estudiantes, el promedio general del curso, el n´ umero de estudiantes que ganaron y la cantidad de estudiantes que perdieron el curso. 6. Determine si todos y cada uno de los elementos de la diagonal principal, est´an otra posici´on de la matriz. 7. Indique si los elementos de la diagonal principal corresponden a los elementos de la diagonal secundaria. Ver tabla 14.8.
0 1 2
0
1
2
a c
b -
a c
Cuadro 14.8: Matriz con digonales iguales de orden 3
8. Determine si en la matriz existen por lo menos dos ceros consecutivos en una misma fila, o en una misma columna. 9. Calcule el producto entre la matriz de N x M y por otra matriz dada por el usuario de M x N. Recuerde que el producto de estas dos matrices produce una tercera matriz de N x N elementos. ci,j =
M −1 X
ai,k × bk,j
∀ a ∈ A, ∀ b ∈ B,
k=0
i = 0, 1, ..., N − 1
j = 0, 1, ..., N − 1
10. Dadas dos matrices de N x M llamadas A y B respectivamente, calcule el valor de k, si existe, en donde la matriz A sea igual a k por la matriz B.
222
CAP´ITULO 14. MATRICES
Cap´ıtulo 15 Para el Volumen II Este cap´ıtulo pretende mostrar r´apidamente algunos elementos que ser´an tratados en el libro “JAVA 1.3 volumen II: Objetos”, tales como el manejo de excepciones, cadenas de caracteres, argumentos del m´etodo main, archivos de acceso secuencial y directo, clases, entre otros. Naturalmente, no se har´a una explicaci´on detallada, simplemente, esperamos que con este cap´ıtulo se puedan complementar los fundamentos de Java 1.3.
15.1.
Manejo de Excepciones
Una excepci´on es un mecanismo que captura la ocurrencia de errores y mejora su tratamiento evitando as´ı que un programa sea abortado, por ejemplo, al ocurrir una divisi´on por cero, un desbordamiento aritm´etico, o tener el ´ındice de un arreglo por fuera de los l´ımites, entre otros. El uso de las excepciones aumenta la claridad del c´odigo escrito en Java y lo hace m´as robusto frente a posibles fallas en la ejecuci´on normal de un programa. Adem´as, se utilizan en aquellas situaciones en las que es posible que el sistema se recupere ante el error que la gener´o. Las excepciones son apropiadas cuando se desarrollan componentes de un sistema por separado, facilitando su integraci´on. En todos los casos se recomienda incluir el manejo de excepciones desde el momento en que se dise˜ na una aplicaci´on, y no despu´es de su implementaci´on. 223
CAP´ITULO 15. PARA EL VOLUMEN II
224
Para el manejo de excepciones es necesario utilizar las instrucciones try y catch.
Ejemplos 1. Elaborar un programa que realice la divisi´on entre dos n´ umeros enteros. Controle la excepci´on generada por un cero en el divisor de manera que pueda evitar que el programa termine de manera anormal. Ver programa 51 “Excepciones 1”. Programa 51 - Excepciones 1 import java.io.*; public class P_Exc_01 { public static void main ( String args[ ] ) throws IOException { int Dividendo, Divisor, Cociente; System.out.println
( "DIVISION ENTERA!!" );
Dividendo = Entrada_Int ( "Dividendo: " Divisor = Entrada_Int ( "Divisor : "
); );
try { Cociente = Calc_Cociente( Dividendo, Divisor ); Salida_Int ( "Resultado: ", Cociente ); } catch (ArithmeticException Exp) { System.err.println ( "ERROR!! Division por cero. "); } }
15.1. MANEJO DE EXCEPCIONES
225
La explicaci´on de este programa sin el uso de excepciones se encuentra en la p´agina 79 (P_Dec_01). Debido a esta situaci´on, nos centraremos u ´nicamente en las instrucciones que permiten el manejo de las excepciones. El bloque que se escribe a continuaci´on de la instrucci´on try es el que posiblemente genere un error. En este caso, se puede generar una divisi´on por cero. La instrucci´on catch requiere un argumento en el que se especifica la excepci´on que se desea manipular. En el programa anterior, la excepci´on a manejar es ArithmeticException, es decir, excepci´on aritm´etica. El identificador que acompa˜ na la excepci´on es un nombre que captura el mensaje que Java reporta al usuario. La instrucci´on System.err.println se utiliza para imprimir el mensaje especificado en el dispositivo de error por defecto, normalmente la pantalla. 2. Elabore un programa que mediante el uso de un vector de enteros ilustre el manejo de diferentes excepciones. Ver programa 52 “Excepciones 2”. Programa 52 - Excepciones 2 import java.io.*; public class P_Exc_02 { final static int MAXIMO = 5; public static void main ( String args[ ] ) throws IOException { int Indice; int Vector[ ]; Vector = new int [ MAXIMO ]; System.out.println
( "EXCEPCIONES DE ARREGLOS!!" );
CAP´ITULO 15. PARA EL VOLUMEN II Continuaci´ on programa 52
226
try { Indice = Entrada_Int ( "Posicion: " ); Vector[ Indice ] = 100 / Indice; } catch (NumberFormatException Exp) { System.err.println ( "ERROR!! Formato no valido " ); } catch (ArrayIndexOutOfBoundsException Exp) { System.err.println ( "ERROR!! Fuera del rango." ); } catch (Exception Exp) { System.err.println ( "* ERROR manejado por JAVA *\n" ); System.err.println ( Exp.toString( ) ); } }
El programa P_Exc_02 no tiene ninguna utilidad en particular. Simplemente es utilizado con el fin de ilustrar el manejo de algunas excepciones frecuentemente presentadas en Java. En este caso, la variable Indice debe capturar un entero. Si por alguna raz´on el usuario ingresa un cero en la variable Indice, el programa genera la excepci´on exception. Por otra parte, si el usuario utiliza una posici´on por fuera de los l´ımites de un arreglo, se genera la excepci´on ArrayIndexOutOfBoundsException. En el ejemplo solo se aceptan n´ umeros enteros entre 0 y 4 (MAXIMO - 1). De acuerdo al programa anterior, en caso de que se genere otra excepci´on, no tenida en cuenta en las ya especificadas, Exception las captura. Es de anotar que solo uno de los bloques catch se ejecuta. En caso de que se ejecute el u ´ltimo, es decir, la excepci´on por defecto, se
15.1. MANEJO DE EXCEPCIONES
227
imprime el mensaje de error enviado por Java mediante la instrucci´on Exp.toString( ), donde Exp es el objeto que contiene la informaci´on de la excepci´on y el m´etodo toString( ) la convierte a cadena de tal manera que se pueda imprimir en la pantalla. 3. Elabore un programa que utilice las excepciones para controlar los datos de entrada de manera que evite los errores producidos por entradas no v´alidas. Ver programa 53 “Excepciones 3”. Programa 53 - Excepciones 3 import java.io.*; public class P_Exc_03 { final static int MAXIMO = 5; public static void main ( String args[ ] ) throws IOException { int Indice; int Vector[ ]; boolean Repetir; Vector = new int [ MAXIMO ]; System.out.println
( "EXCEPCIONES DE ARREGLOS!!" );
El programa P_Exc_03 es el mismo programa P_Exc_02 con la diferencia que mediante el ciclo do - while y la variable booleana Repetir se valida la entrada para evitar errores derivados de excepciones.
CAP´ITULO 15. PARA EL VOLUMEN II
228
Continuaci´ on programa 53 do { Repetir = false; try { Indice = Entrada_Int ( "Posicion: " ); Vector[ Indice ] = 100 / Indice; } catch (NumberFormatException Exp) { System.err.println ( "ERROR!! Formato no valido " ); Repetir = true; } catch (ArrayIndexOutOfBoundsException Exp) { System.err.println ( "ERROR!! Fuera del rango." ); Repetir = true; } catch (Exception Exp) { System.err.println ( "* ERROR manejado por JAVA *" ); System.err.println ( Exp.toString( ) ); Repetir = true; } } while ( Repetir == true ); }
15.2. CADENAS DE CARACTERES
15.2.
229
Cadenas de caracteres
Una cadena de caracteres es una serie de caracteres que son tratados como una unidad, la cual puede contener letras, n´ umeros y s´ımbolos. En Java, una cadena se maneja como un objeto de la clase String.
Ejemplos 1. Elabore un programa que concatene dos cadenas de caracteres y muestre la longitud de la cadena resultante. Ver programa 54 “Cadenas 1”. Programa 54 - Cadenas 1 import java.io.*; public class P_Cad_01 { public static void main ( String args[ ] ) throws IOException { String Cad1, Cad2, Cad3; int Longitud; System.out.println ( "CONCATENAR DOS CADENAS!!" ); Cad1 Cad2
= Entrada_Str ( "Ingrese un mensaje: " ); = Entrada_Str ( "Ingrese otro mensaje: " );
Cad3 Longitud
= Cad1 + Cad2; = Cad3.length ( );
Salida_Str ( "La cadena concatenada es: ", Cad3 ); Salida_Int ( "La longitud es: ", Longitud ); }
CAP´ITULO 15. PARA EL VOLUMEN II
230
El programa anterior concatena dos cadenas y calcula la longitud de la cadena concatenada. Al finalizar, imprime los resultados. La uni´on o concatenaci´on de las cadenas se realiza mediante la instrucci´on Cad3 = Cad1 + Cad2;, donde Cad3 es la cadena resultante de unir Cad1 y Cad2. El s´ımbolo + es el encargado de realizar esta operaci´on. Esta instrucci´on se podr´ıa cambiar por Cad3 = Cad1.concat(Cad2); para realizar la misma funci´on. El m´etodo length ( ), asociado al objeto Cad3 permite obtener su longitud. Continuaci´ on programa 54 static String Entrada_Str ( String Msj ) throws IOException { //---------------------------------------------BufferedReader Teclado; Teclado = new BufferedReader ( new InputStreamReader ( System.in ) ); //---------------------------------------------String Cadena; System.out.print ( Msj ); Cadena = Teclado.readLine( ); return Cadena; }
El m´etodo Entrada_Str es similar a los m´etodos utilizados en el libro para leer datos de cualquier tipo. En este caso, observe que el tipo de dato que retorna este m´etodo es String, lo mismo que la variable temporal Cadena. Algo similar ocurre con el m´etodo Salida_Str.
15.2. CADENAS DE CARACTERES
231
2. Elabore un programa que convierta una cadena de caracteres a su equivalente en may´ usculas. Ver programa 55 “Cadenas 2”. Programa 55 - Cadenas 2 import java.io.*; public class P_Cad_02 { public static void main ( String args[ ] ) throws IOException { String Cad1, Cad2; System.out.println ( "CONVERTIR A MAYUSCULA!!" ); Cad1
= Entrada_Str ( "Ingrese un mensaje: " );
Cad2
= Cad1.toUpperCase();
Salida_Str ( "La cadena en mayusculas es: ", Cad2); }
Este programa convierte una cadena a may´ usculas mediante el m´etodo asociado al objeto Cad2, llamado toUpperCase(). En caso de que el usuario desee convertir a min´ usculas, el m´etodo ser´ıa toLowerCase(). 3. Elaborar un programa que compare dos cadenas de caracteres y determine si son iguales o no. Ver programa 56 “Cadenas 3”. Este programa compara dos cadenas para determinar si son iguales o no. Para encontrar el valor de verdad de la comparaci´on de las cadenas se utiliza el m´etodo equals.
CAP´ITULO 15. PARA EL VOLUMEN II
232
Programa 56 - Cadenas 3 import java.io.*; public class P_Cad_03 { public static void main ( String args[ ] ) throws IOException { String Cad1, Cad2; System.out.println ( "COMPARAR DOS CADENAS!!" ); Cad1 Cad2
= Entrada_Str ( "Ingrese un mensaje: " ); = Entrada_Str ( "Ingrese otro mensaje: " );
if ( Cad1.equals ( Cad2 ) ) { System.out.println ( "Son iguales" ); } else { System.out.println ( "Son diferentes" ); } }
´ 15.3. ARGUMENTOS DEL METODO MAIN
15.3.
233
Argumentos del m´ etodo main
Los argumentos del m´etodo main es la forma que ofrece Java para recibir datos desde la l´ınea de comandos con el fin de que sean procesados desde el programa. La forma de pasar argumentos a un programa es en el momento de la ejecuci´on, escribiendo en forma de cadena de caracteres uno a uno el grupo de argumentos para que sea procesado en el programa.
Ejemplos 1. Elabore un programa que imprima los argumentos con los cuales se hace el llamado a un prorgama. Ver programa 57 “Argumentos 1”. Programa 57 - Argumentos 1 import java.io.*; public class P_Arg_01 { public static void main ( String args[ ] ) throws IOException { int I; System.out.println ( "ARGUMENTOS DEL METODO MAIN!!" ); for ( I = 0; I < args.length; I++ ) { System.out.println ( "argumento [ " + I + " ]: " + args[ I ] ); } } }
CAP´ITULO 15. PARA EL VOLUMEN II
234
Este programa imprime la lista de argumentos con los cuales fue llamado el programa desde la l´ınea de comandos. Es decir, el usuario, debe llamar al programa compilado utilizando la palabra java, el nombre del programa y a continuaci´on los argumentos. Ejemplo: java P_Arg_01 uno dos tres cuatro El resultado de la ejecuci´on ser´ıa: Ver “Resultado Argumentos 1”. Resultado Argumentos 1 ARGUMENTOS DEL METODO PRINCIPAL!! argumento [ 0 ]: uno argumento [ 1 ]: dos argumento [ 2 ]: tres argumento [ 3 ]: cuatro
Observe que el arreglo de cadenas de caracteres se compone de cuatro elementos llamados uno, dos, tres y cuatro y corresponden a las primeras cuatro posiciones 0...3. 2. Elabore un programa que sume dos n´ umeros enteros. El programa deber´a soportar la entrada de los n´ umeros a trav´es de los argumenos del m´etodo principal. Ver programa 58 “Argumentos 2”. Este programa pretende sumar dos enteros que son pasados como par´ametros desde la l´ınea de comandos, por ejemplo: java P_Arg_02 4 6 En este caso, se asigna a la variable Num1 el valor de 4 y a Num2 el valor de 6. Si el n´ umero de argumentos Argum.length no es exactamente 2, se solicitan desde el teclado los dos n´ umeros que ser´an sumados.
´ 15.3. ARGUMENTOS DEL METODO MAIN
Programa 58 - Argumentos 2 import java.io.*; public class P_Arg_02 { public static void main ( String Argum [ ] ) throws IOException { int Num1, Num2, Suma; System.out.println ( "ARGUMENTOS DEL METODO MAIN!!" ); if ( Argum.length == 2) { Num1 = Integer.parseInt ( Argum [ 0 ] ); Num2 = Integer.parseInt ( Argum [ 1 ] ); } else { Num1 = Entrada_Int ( "Ingrese el primer numero: " ); Num2 = Entrada_Int ( "Ingrese el primer numero: " ); } Suma = Num1 + Num2; Salida_Int ( "La suma es: ", Suma); }
235
CAP´ITULO 15. PARA EL VOLUMEN II
236
Observe la forma como se convierte a entero el valor del argumento, y que el nombre del vector de cadenas que se recibe desde la l´ınea de comandos es arbitrario, es decir, el usuario puede utilizar el que desee.
15.4.
Archivos
Un archivo es un mecanismo que permite almacenar los datos en alg´ un dispositivo de almacenamiento secundario (disco duro, diskete, CD-R, entre otros), de manera que no se pierdan al terminar la ejecuci´on de un programa. Los datos que se almacenan en archivos se conocen con el nombre de datos persistentes. Para Java, un archivo es un flujo secuencial de bytes el cual termina con un marcador de fin de archivo o en un n´ umero de bytes especificado. Cuando un arhivo se abre, se crea un objeto y se asocia un flujo (stream) a dicho objeto. Un flujo permite comunicar un programa y un archivo o dispositivo en particular. Existen diferentes clases de archivos. Con un archivo de acceso secuencial cada solicitud de entrada y salida sucesiva lee o escribe el siguiente conjunto de datos consecutivos en el archivo. Por otra parte, los archivos de acceso directo pueden dirigirse a cualquier parte del archivo.
Ejemplos 1. Elabore un programa que permita crear un archivo de acceso secuencial e imprimir su contenido. Ver programa 59 “Archivos de acceso secuencial”. Este programa lee del teclado l´ıneas de texto hasta que el usuario ingresa una cadena que contiene u ´nicamente el caracter \n, es decir, presiona la tecla <Enter> al comienzo de una nueva l´ınea. Cada l´ınea ingresada es almacenada en el archivo y cuando el usuario indique el final de la entrada el contenido del archivo se imprime en la pantalla. Este programa llama al m´etodo Escr_Arch_Dir para leer el texto que se desea almacenar, y Leer_Arch_Dir para imprimir en pantalla el contenido del archivo especificado.
15.4. ARCHIVOS
Programa 59 - Archivos de acceso secuencial import java.io.*; public class P_Arc_01 { public static void main ( String args[ ] ) throws IOException { System.out.println ( "ARCHIVO DE ACCESO SECUENCIAL!!\n" ); System.out.println ( "Presione <Enter> en una nueva" ); System.out.println ( " linea para terminar!!\n " ); try { Escr_Arch_Sec ( "Temp1.txt" ); Leer_Arch_Sec ( "Temp1.txt" ); } catch (IOException Exp) { System.err.println ( "ERROR!! en el archivo" ); } }
237
CAP´ITULO 15. PARA EL VOLUMEN II Continuaci´ on programa 59
238
static void Escr_Arch_Sec ( String Nombre ) throws IOException { DataOutputStream Arch_Out; String Cadena; Arch_Out = new DataOutputStream ( new FileOutputStream ( Nombre ) ); do { Cadena
= Entrada_Str ( "Ingrese un mensaje: " );
if ( Cadena.equals("") == true ) { break; } Arch_Out.writeUTF ( Cadena ); } while ( true ); Arch_Out.close ( ); }
El m´etodo Escr_Arch_Sec recibe como par´ametro el nombre del archivo en el que se desea almacenar un texto. Para enviar informaci´on al archivo es necesario crear un flujo de salida de datos llamado Arch_Out, mediante el comando DataOutputStream Arch_Out;. La instrucci´on DataOutputStream Arch_Out; indica que Arch_Out es un objeto de la clase DataOutputStream, es decir, archivo de acceso secuencial. Para poder utilizar el flujo de salida, es necesario inicializarlo para asociar al flujo el archivo especificado con la cadena Nombre, mediante el comando
15.4. ARCHIVOS
239
Arch_Out = new DataOutputStream ( new FileOutputStream ( Nombre ) ); La variable Cadena recibe una entrada desde el teclado. El contenido de la variable Cadena se almacena en el archivo, siempre y cuando esta cadena no est´e vac´ıa, es decir, que el usuario no haya presionado la tecla <Enter> u ´nicamente. Observe el uso del comando break, para finalizar la entrada de datos y el proceso de escritura en el archivo. La instrucci´on Arch_Out.writeUTF ( Cadena ); indica que se escribir´a el contenido de Cadena en el archivo asociado al flujo Arch_Out en formato UTF. El formato UTF reserva dos bytes al inicio de cada entrada separada por la tecla <Enter>, para almacenar la longitud de la l´ınea, es decir, no utiliza ning´ un finalizador de l´ınea. El m´etodo finaliza cerrando el archivo asociado al flujo Arch_Out. El m´etodo Leer_Arch_Sec recibe como par´ametro el nombre del archivo que se quiere imprimir en la pantalla. Es importante anotar que por tratarse de un m´etodo diferente a Escr_Arch_Sec, es necesario indicar que Arch_Out es un un objeto que representa un archivo de acceso secuencial sin formato. La instrucci´on Arch_In = new DataInputStream ( new FileInputStream ( Nombre ) ); abre el archivo especificado y lo asocia con el objeto Archivo. Dentro de un ciclo infinito se lee el contenido del archivo en formato UTF y lo imprime en la pantalla. Cuando se termina de leer el archivo se genera la excepci´on EOFException Exp. Al terminar de ejecutar normalmente este m´etodo se cierra el archivo asociado al flujo Arch_In.
CAP´ITULO 15. PARA EL VOLUMEN II
240
Continuaci´ on programa 59 static void Leer_Arch_Sec ( String Nombre ) throws IOException { DataInputStream Arch_In; String Cadena; Arch_In = new DataInputStream ( new FileInputStream ( Nombre ) ); try { while ( true ) { Cadena = Arch_In.readUTF ( ); System.out.println ( Cadena ); } } catch ( EOFException Exp ) { } Arch_In.close( ); }
15.4. ARCHIVOS
241
2. Elabore un programa que permita crear un archivos de acceso directo e imprimir su contenido. Ver programa 60 “Archivos de acceso directo”. Programa 60 - Archivos de acceso directo import java.io.*; public class P_Arc_02 { public static void main ( String args[ ] ) throws IOException { System.out.println ( "ARCHIVO DE ACCESO DIRECTO!!\n" ); System.out.println ( "Presione <Enter> en una nueva" ); System.out.println ( " linea para terminar!!\n " ); try { Escr_Arch_Dir ( "Temp2.txt" ); Leer_Arch_Dir ( "Temp2.txt" ); } catch (IOException Exp) { System.err.println ( "ERROR!! en el archivo" ); } }
De manera similar a los archivos de acceso secuencial, este programa llama los m´etodos Escr_Arch_Dir y Leer_Arch_Dir para crear e imprimir en pantalla el contenido del archivo especificado.
CAP´ITULO 15. PARA EL VOLUMEN II Continuaci´ on programa 60
242
static void Escr_Arch_Dir ( String Nombre ) throws IOException { RandomAccessFile Archivo; String Cadena; Archivo = new RandomAccessFile ( Nombre, "rw" ); do { Cadena = Entrada_Str ( "Ingrese un mensaje: " ); Cadena += "\n"; if ( Cadena.equals("\n") == true) { break; } Archivo.writeBytes( Cadena ); } while ( true ); Archivo.close( ); }
El m´etodo Escr_Arch_Dir recibe como par´ametro el nombre del archivo en el que se desea almacenar un texto. La instrucci´on RandomAccessFile Archivo; indica que Archivo es un objeto de la clase RandomAccessFile, es decir, archivo de acceso directo. La instrucci´on Archivo = new RandomAccessFile ( Nombre ,"rw"); abre el archivo cuyo nombre se ha especificado en el par´ametro Nombre y lo asocia con el objeto Archivo. La cadena "rw" indica que este archivo se ha abierto para leer y escribir. En este caso, s´olo se va a escribir.
15.4. ARCHIVOS
243
El m´etodo Entrada_Str lee una cadena. Al utilizar este m´etodo para capturar una cadena desde el teclado, no se almacena el salto de l´ınea (\n). Por esta raz´on se debe a˜ nadir al final del mensaje antes de almacenarlo con la instrucci´on Archivo.writeBytes( Cadena );, donde Archivo es el objeto, writeBytes es el m´etodo que escribe en ´el y Cadena es el texto que se va a almacenar. Observe que el formato del texto es diferente al UTF, especialmente porque una l´ınea termina con el caracter \n y no se almacena la longitud de la l´ınea de texto. Cuando el usuario presiona la tecla <Enter> de tal manera que corresponda a una cadena vac´ıa el ciclo se rompe sin almacenar este caracter <Enter>. Finalmente, el archivo se cierra utilizando el m´etodo Close asociado al objeto Archivo. Continuaci´ on programa 60 static void Leer_Arch_Dir ( String Nombre ) throws IOException { RandomAccessFile Archivo; String Cadena; Archivo = new RandomAccessFile ( Nombre, "r" ); while ( Archivo.getFilePointer( ) < Archivo.length( ) ) { Cadena = Archivo.readLine( ); System.out.println ( Cadena ); } Archivo.close( ); }
244
CAP´ITULO 15. PARA EL VOLUMEN II El m´etodo Leer_Arch_Dir recibe como par´ametro el nombre del archivo que se quiere imprimir. Archivo = new RandomAccessFile ( Nombre ,"r"); abre el archivo cuyo nombre se ha especificado en el par´ametro Nombre y lo asocia con el objeto Archivo. La cadena "r" indica que este archivo se ha abierto con el objeto de leer u ´nicamente. El m´etodo Archivo.readLine( ) lee una l´ınea de texto del objeto asociado (Archivo), la cual es almacenada en la variable Cadena. Esta instrucci´on est´a dentro de un ciclo con el prop´osito de imprimir hasta terminar el archivo. Archivo.getFilePointer( ) < Archivo.length( ) quiere decir que mientras la posici´on en el archivo sea menor que su longitud, puede leer del archivo su contenido.
Bibliograf´ıa [1] http://www.cybercursos.net: JAVA desde cero. [2] DEITEL, Harvey M. y DEITEL, Paul J.: C´ omo programar en JAVA. Prentice Hall. M´exico, D.C., 1998. [3] Escuela Superior de Ingenieros Industriales: Aprenda Java como si estuviera en primero. Universidad de Navarra. San Sebasti´an, 1999. ´ ´ [4] GOMEZ, Carlos Eduardo y GUTIERREZ, Juli´an Esteban: Hojas de C´ alculo con StarOffice 5.2. Armenia, 2001. [5] MEYERS, Nathan: Edici´on Especial Programaci´ on Java en Linux. Pearson Educaci´on S.A. Madrid, 2000. [6] MORGAN, Mike: Descubre Java 1.2. Prentice Hall. Madrid, 1999. [7] NAUGHTON, Patrick y SCHILDT, Herbert: Java Manual de Referencia. McGraw Hill. Madrid, 1997. [8] WEISS, Mark Allen: Estructuras de datos en Java. Prentice Hall. Madrid, 2000.
245
246
BIBLIOGRAF´IA
´Indice alfab´ etico A actividad . . . . . . . . . . . . . . . . . . . . . . . . 4 actualizar . . . . . . . . . . . . . . . . . . . . . . 61 acumulador . . . . . . . . . . . . . . . . . . . 148 agenda . . . . . . . . . . . . . . . . . . . . . . . . . . 4 algoritmo . . . . . . . . . . . . . . . . . . . . . . . 3 almacenamiento secundario . . . 236 an´alisis. . . . . . . . . . . . . . . . . . . . . . . . . 94 ANSI . . . . . . . . . . . . . . . . . . . . . . . . . . 42 aplicaciones . . . . . . . . . . . . . . . . . . . . 38 applets . . . . . . . . . . . . . . . . . . . . . . . . . 38 archivo. . . . . . . . . . . . . . . . . . . . . . . .236 acceso directo . . . . . . . . . . . . . . . . . . 241 secuencial . . . . . . . . . . . . . . . 236 archivos . . . . . . . . . . . . . . . . . . . . . . . 223 argumentos . . . . . . . . . . . . . . . . . 48, 64 del main . . . . . . . . . . . . . . . . . . 223 arquitectura . . . . . . . . . . . . . . . . . . . . 38 arreglo . . . . . . . . . . . . . . . . . . . . . . . . 183 ´ındice . . . . . . . . . . . . . . . . . . . . . 184 acceso directo . . . . . . . . . . . . . . . . . . 184 indirecto . . . . . . . . . . . . . . . . 184 bidimensional . . . . . . . . . . . . . 203 multidimensional . . . . . . . . . . 183 reservar memoria . . . . . . . . . . 183 sub´ındice. . . . . . . . . . . . . . . . . .184 unidimensional . . . . . . . . . . . . 183 ASCII. . . . . . . . . . . . . . . . . . . . . . . . . .41
atributo . . . . . . . . . . . . . . . . . . . . 38, 49 B bloque . . . . . . . . . . . . . . . . . . . . . . . . . 49 browser . . . . . . . . . . . . . . . . . . . . . . . . 38 C c´odigo. . . . . . . . . . . . . . . . . . . . . . . . . .61 binario . . . . . . . . . . . . . . . . . . . . . 38 Green . . . . . . . . . . . . . . . . . . . . . . 37 reutilizar . . . . . . . . . . . . . . . . . . . 61 cadenas . . . . . . . . . . . . . . . . . . . . . . . 229 de caracteres . . . . . . . . . . . . . . 223 caracteres especiales . . . . . . . . . . . . 41 catch . . . . . . . . . . . . . . . . . . . . . . . . . 224 ciclo . . . . . . . . . . . . . . . . . . . . . . . . . . 139 acumulador . . . . . . . . . . . . . . . 148 anidado . . . . . . . . . . . . . . . . . . . 162 break . . . . . . . . . . . . . . . . . . . . . 166 condicionado al comienzo . . . . . 33, 151, 165 al final . . . . . . . . . . . . . . 32, 139 contador . . . . . . . . . . . . . . . . . . 148 continue . . . . . . . . . . . . . . . . . . 167 do - while . . . . . . . . . . . . . . . . . 139 condici´on. . . . . . . . . . . . . . . .141 incremento . . . . . . . . . . . . . . 141 inicializaci´on . . . . . . . . . . . . 140 for . . . . . . . . . . . . . . . . . . . . . . . . 165 condici´on. . . . . . . . . . . . . . . .166 ejecuci´on . . . . . . . . . . . . . . . . 166 247
248 estructura . . . . . . . . . . 139, 165 incremento . . . . . . . . . . . . . . 166 inicializaci´on . . . . . . . . . . . . 166 while . . . . . . . . . . . . . . . . . . . . . . 151 estructura . . . . . . . . . . . . . . . 151 clase . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 BufferedReader . . . . . . . . . . . . . 49 p´ ublica . . . . . . . . . . . . . . . . . . . . . 46 clases . . . . . . . . . . . . . . . . . . . . . . . . . 223 columna . . . . . . . . . . . . . . . . . . . . . . 203 comparaci´on . . . . . . . . . . . . . . . . . . . 11 compilador . . . . . . . . . . . . . . . . . . . . . 38 compilar . . . . . . . . . . . . . . . . . . . . . . . 45 comportamiento . . . . . . . . . . . . . . . . . 8 compromiso . . . . . . . . . . . . . . . . . . . . . 4 computadora . . . . . . . . . . . . . . . . . . . . 9 condici´on . . . . . . . . . . . . . . . . . . . . . . 77 constante . . . . . . . . . 9, 38, 52, 70, 94 contador . . . . . . . . . . . . . . . . . . . . . . 148 D dato. . . . . . . . . . . . . . . . . . . . . . . . . . . . .9 tipo . . . . . . . . . . . . . . . . . . . . . . . . 10 alfanum´erico . . . . . . . . . . . . . 11 de punto flotante . . . . . . . . . 11 entero . . . . . . . . . . . . . . . . . . . . 11 decisi´on . . . . . . . . . . . . . . . . . . . . . 7, 77 ´arbol . . . . . . . . . . . . . . . . . . . . . . 103 anidada . . . . . . . . . . . . . . . . . . . . 93 m´ ultiple . . . . . . . . . . . . . . . . . . . 113 declaraci´on . . . . . . . . . . . . . . . . . . . . . 26 constantes . . . . . . . . . . . . . . . . . . 26 variables . . . . . . . . . . . . . . . . . . . 26 depurar . . . . . . . . . . . . . . . . . . . . . . . . 61 directorio . . . . . . . . . . . . . . . . . . . . . . 46 dispositivo est´andar . . . . . . . . . . . . 49 de entrada . . . . . . . . . . . . . . . . . 49 de salida . . . . . . . . . . . . . . . . . . . 50
´INDICE ALFABETICO ´ E ejecutar . . . . . . . . . . . . . . . . . . . . . . . . 45 entrada/salida . . . . . . . . . . . . . . . . . 49 estructuras de repetici´on . . . . . . 139 excepciones. . . . . . . . . . . . . . . .48, 223 ArithmeticException . . . . . . 225 ArrayIndexOutOfBoundsException . . . . . . . . . . . . . . . . . . . 226 NumberFormatException . . 226 excluyente . . . . . . . . . . . . . . . . . . . . . 77 expresi´on . . . . . . . . . . . . . . . . . . . 12, 15 algebr´aica . . . . . . . . . . . . . . . . . . 15 aritm´etica . . . . . . . . . . . . . . . . . . 15 de asignaci´on . . . . . . . . . . . . . . . 17 l´ogica . . . . . . . . . . . . . . . . . . . 15, 77 m´ ultiple . . . . . . . . . . . . . . . . . . 15 simple . . . . . . . . . . . . . . . . . . . . 15 F fila . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 funci´on. . . . . . . . . . . . . . . . . . . . . . . . .14 predefinida . . . . . . . . . . . . . . . . . 14 G getFilePointer . . . . . . . . . . . . . . . . . 244 I identificador . . . . . . . . . . . . . 9, 26, 38 v´alido . . . . . . . . . . . . . . . . . . . . . . 10 IEEE . . . . . . . . . . . . . . . . . . . . . . . . . . 42 imprimir . . . . . . . . . . . . . . . . . . . . . . . 50 informaci´on . . . . . . . . . . . . . . . . . . . . . 9 Internet . . . . . . . . . . . . . . . . . . . . 37, 38 Explorer . . . . . . . . . . . . . . . . . . . 38 ISO Unicode . . . . . . . . . . . . . . . . . . . 41 iteraci´on . . . . . . . . . . . . . . . . . . . . . . 141 J Java . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
´INDICE ALFABETICO ´ API . . . . . . . . . . . . . . . . . . . . . . . . 46 Development Kit . . . . . . . . . . . 38 Runtime Environment . . . . . . 38 Virtual Machine . . . . . . . . . . . . 37 JDK . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 jerarqu´ıa . . . . . . . . . . . . . . . . . . . . . . . 12 JRE . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 JVM . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 L leer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 length . . . . . . . . . . . . . . . . . . . . . . . . 188 lenguaje de programaci´on . . . . . . . . . 3, 10 M m´aquina virtual . . . . . . . . . . . . . . . . 38 m´etodo . . . . . . . . . . . . . . . . . 38, 48, 61 argumentos. . . . . . . . . . . . . . . . .63 estructura general . . . . . . . . . . 61 generalidades . . . . . . . . . . . . . . . 63 identificador . . . . . . . . . . . . . . . . 61 llamar . . . . . . . . . . . . . . . . . . . . . . 61 longitud . . . . . . . . . . . . . . . . . . . . 64 main . . . . . . . . . . . . . . . . . . . . . . . 63 Math.sqrt . . . . . . . . . . . . . . . . . . 56 nombre. . . . . . . . . . . . . . . . . . . . .63 par´ametros . . . . . . . . . . . . . . . . . 63 pasar valores . . . . . . . . . . . . . . . 74 principal. . . . . . . . . . . . . . . .48, 63 recomendaciones . . . . . . . . . . . 63 retornar . . . . . . . . . . . . . . . . . . . . 66 tipo de dato . . . . . . . . . . . . . . . . 61 variable local . . . . . . . . . . . . . . . 63 matriz . . . . . . . . . . . . . . . . . . . 183, 203 ´ındice . . . . . . . . . . . . . . . . . . . . . 204 acceso directo . . . . . . . . . . . . . . . . . . 204
249 indirecto . . . . . . . . . . . . . . . . 205 columna . . . . . . . . . . . . . . . . . . 203 fila . . . . . . . . . . . . . . . . . . . . . . . . 203 memoria . . . . . . . . . . . . . . . . . . . . . . . . 9 modificar. . . . . . . . . . . . . . . . . . . . . . .61 modularizar . . . . . . . . . . . . . . . . . . . . 61 N n´ umeros enteros . . . . . . . . . . . . . . . . . . . . . 41 reales . . . . . . . . . . . . . . . . . . . . . . 42 navegador . . . . . . . . . . . . . . . . . . . . . . 38 Explorer . . . . . . . . . . . . . . . . . . . 38 Netscape . . . . . . . . . . . . . . . . . . . 38 notaci´on cient´ıfica . . . . . . . . . . . . . . 42 O Oak . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 objeto . . . . . . . . . . . . . . . . . . . . . . 49, 66 objetos. . . . . . . . . . . . . . . . . . . . . . . .223 operadores aritm´eticos . . . . . . . . . . . . . . . . . 11 de agrupaci´on . . . . . . . . . . . . . . 12 de asignaci´on . . . . . . . . . . . . . . . 12 de signo . . . . . . . . . . . . . . . . . . . . 12 jerarqu´ıa . . . . . . . . . . . . . . . . . . . 12 equivalente . . . . . . . . . . . . . . . 12 l´ogicos . . . . . . . . . . . . . . . . . . 11, 29 conjunci´on . . . . . . . . . . . . . . . 11 disyunci´on . . . . . . . . . . . . . . . 11 precedencia . . . . . . . . . . . . . . . . 12 equivalente . . . . . . . . . . . . . . . 12 prioridad . . . . . . . . . . . . . . . . . . . 12 equivalente . . . . . . . . . . . . . . . 12 relacionales. . . . . . . . . . . . . . . . .11 orden . . . . . . . . . . . . . . . . . . . . . . . . . . 27 P palabras reservadas . . . . . . . . . 10, 39
250 break . . . . . . . . . . . . 113, 166, 239 case . . . . . . . . . . . . . . . . . . . . . . . 114 catch. . . . . . . . . . . . . . . . . . . . . .224 char . . . . . . . . . . . . . . . . . . . 40, 162 continue . . . . . . . . . . . . . . . . . . 167 DataOutputStream. . . . . . . .239 default . . . . . . . . . . . . . . . . . . . . 114 do . . . . . . . . . . . . . . . . . . . . . . . . 139 double . . . . . . . . . . . . . . 40, 42, 52 else . . . . . . . . . . . . . . . . . . . . . . . . 79 final . . . . . . . . . . . . . . . . . . . . . . . . 52 float . . . . . . . . . . . . . . . . . . . . 40, 42 for . . . . . . . . . . . . . . . . . . . . . . . . 165 getFilePointer . . . . . . . . . . . . . 244 if . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 import . . . . . . . . . . . . . . . . . . . . . 46 IOException . . . . . . . . . . . . . . . 49 length . . . . . . . . . . . . . . . . . . . . . 188 main . . . . . . . . . . . . . . . . . . . 48, 63 Math.sqrt . . . . . . . . . . . . . . . . . . 56 public . . . . . . . . . . . . . . . . . . . . . . 48 RandomAccessFile . . . . . . . . 242 static . . . . . . . . . . . . . . . . . . . 48, 63 String . . . . . . . . . . . . . . . . . 48, 229 switch. . . . . . . . . . . . . . . . . . . . .113 throws . . . . . . . . . . . . . . . . . . . . . 49 toLowerCase . . . . . . . . . . . . . . 231 toUpperCase . . . . . . . . . . . . . . 231 try . . . . . . . . . . . . . . . . . . . . . . . . 224 void . . . . . . . . . . . . . . . . . . . . . . . . 48 while . . . . . . . . . . . . . . . . . 139, 151 pantalla . . . . . . . . . . . . . . . . . . . . . . . . 50 paquetes java.applet . . . . . . . . . . . . . . . . . 46 java.awt . . . . . . . . . . . . . . . . . . . . 46 java.io. . . . . . . . . . . . . . . . . . . . . .46 java.lang . . . . . . . . . . . . . . . . . . . 46 java.util . . . . . . . . . . . . . . . . . . . . 46
´INDICE ALFABETICO ´ par´ametros . . . . . . . . . . . . . . . . . . . . . 64 par´entesis anidados. . . . . . . . . . . . .13 plazo corto . . . . . . . . . . . . . . . . . . . . . . . . 4 largo . . . . . . . . . . . . . . . . . . . . . . . . 4 mediano . . . . . . . . . . . . . . . . . . . . . 4 portabilidad . . . . . . . . . . . . . . . . . . . . 38 posdecremento . . . . . . . . . . . . . . . . . 44 posici´on . . . . . . . . . . . . . . . . . . . . . . . 184 posincremento. . . . . . . . . . . . . . . . . .44 precedencia . . . . . . . . . . . . . . . . . . . . 12 predecremento . . . . . . . . . . . . . . . . . 44 predefinidos . . . . . . . . . . . . . . . . . . . . 46 preincremento . . . . . . . . . . . . . . . . . . 44 prioridad . . . . . . . . . . . . . . . . . . . . . . . 12 problema . . . . . . . . . . . . . . . . . . . . 9, 25 c´alculo matem´atico . . . . . . . . . 25 entrada . . . . . . . . . . . . . . . . . . . . 25 proceso. . . . . . . . . . . . . . . . . . . . .25 salida . . . . . . . . . . . . . . . . . . . . . . 25 programa . . . . . . . . . . . . . . . . . . . . . . 25 ciclo anidado . . . . . . . . . . . . . . . . . . 34 decisiones anidadas . . . . . . . . . . . . . . . . . 29 m´ ultiples . . . . . . . . . . . . . . . . . 31 simples . . . . . . . . . . . . . . . . . . . 28 estructura . . . . . . . . . . . . . . . . . . 26 secuencial. . . . . . . . . . . . . . . .7, 27 programa fuente. . . . . . . . . . . . . . . .46 punto decimal . . . . . . . . . . . . . . . . . . 42 R RandomAccessFile . . . . . . . . . . . . 242 rango . . . . . . . . . . . . . . . . . . . . . . . . . . 11 repetici´on . . . . . . . . . . . . . . . . . . . . . . . 8 reutilizar . . . . . . . . . . . . . . . . . . . . . . . 61
´INDICE ALFABETICO ´ S secuencias de escape. . . . . . . . . . . .41 seudoc´odigo . . . . . . . . . . . . . . . . . . . . . 9 stream . . . . . . . . . . . . . . . . . . . . . . . . 236 String . . . . . . . . . . . . . . . . . . . . . . . . . 229 sub´ındice . . . . . . . . . . . . . . . . . . . . . 184 Sun Microsystems . . . . . . . . . . . . . . 37 T tabla . . . . . . . . . . . . . . . . . . . . . . . . . . 203 teclado . . . . . . . . . . . . . . . . . . . . . 49, 66 tiempo . . . . . . . . . . . . . . . . . . . . . . . . . . 5 tipos de datos. . . . . . . . . . .10, 38, 40 char . . . . . . . . . . . . . . . . . . . . . . . . 40 double . . . . . . . . . . . . . . . . . . . . . 40 float. . . . . . . . . . . . . . . . . . . . . . . .40 primitivos . . . . . . . . . . . . . . . . . . 40 toLowerCase . . . . . . . . . . . . . . . . . . 231 toUpperCase . . . . . . . . . . . . . . . . . . 231 try . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 U Unicode . . . . . . . . . . . . . . . . . . . . . . . . 41 V valor de verdad . . . . . . . . . . . . . . . . 77 valor l´ogico. . . . . . . . . . . . . . . . . . . . .11 falso . . . . . . . . . . . . . . . . . . . . . . . 11 verdadero . . . . . . . . . . . . . . . . . . 11 variable . . . . . . . . . . . . . 9, 38, 49, 183 alcance . . . . . . . . . . . . . . . . . . . . . 64 vida diaria . . . . . . . . . . . . . . . . . . . . . . 3 W World Wide Web. . . . . . . . . . . . . . .37
251