modulo grado11

Informática 1. Versión 1.3 Enero de 2010 .

1

UNIVERSIDAD AUTÓNOMA DE OCCIDENTE

FACULTAD DE INGENIERÍAS DEPARTAMENTO DE OPERACIONES Y SISTEMAS

PROGRAMA DE INGENIERÍA INFORMÁTICA

INFORMÁTICA 1

(Algoritmos con Java)

MATERIAL RECOPILADO POR LOS PROFESORES

J. ANTONIO LEMOS B. Y EDUARDO VICTORIA Z.

SANTIAGO DE CALI, FEBRERO DE 2007


2

ASIGNATURA: INFORMÀTICA 1 CODIGO: 532219 CREDITOS: 3 PRERREQUISITOS: (Ninguno) CARACTERÍSTICAS: HOMOLOGABLE, VALIDABLE FACULTAD: INGENIERÍA PROGRAMA: INGENIERÎA INFORMÁTICA, ELECTRICA,

MECANICA, ELECTRÓNICA, MECATRÓNICA, BIOMÉDICA, INDUSTRIAL, AMBIENTAL, MULTIMEDIA

DEPARTAMENTO QUE OFRECE: CIENCIAS DE LA INFORMACIÓN AREA: INFORMÂTICA PERIODO ACADÉMICO: 2007 – 1 ( Enero – Mayo ) I. OBJETIVO GENERAL

Capacitar al estudiante en el diseño e implementación de algoritmos computacionales, utilizando los conceptos básicos de la algoritmia, e introduciéndolo en el estudio de la programación orientada a objetos.

II. OBJETIVOS ESPECÍFICOS • Identificar los sistemas básicos de numeración y sus operaciones fundamentales. • Comprender las operaciones básicas de la lógica booleana. • Modelar procesos mediante técnicas algorítmicas. • Reconocer y aplicar correctamente las diferentes estructuras de decisión y de repetición

en programación de computadores. • Conocer y apropiar el paradigma Orientado a Objetos y su aplicación en la programación.

III. CONTENIDO PROGRAMÁTICO

UNIDAD 1 – Algoritmos 1.1 Procedimiento 1.2 Ciclo de Diseño 1.3 Definición 1.4 Propiedades de los Algoritmos 1.5 Representación de los datos 1.6 Estructuras secuenciales 1.7 Estructuras condicionales 1.8 Estructuras de repetición


3

1.9 Ejercicios resueltos 1.10 Ejercicios propuestos UNIDAD 2 – Introducción a Java 2.1 Historia de Java 2.2 Características básicas de Java 2.2.1 Orientado a objetos puro 2.2.2 Simple 2.2.3 Distribuido 2.2.4 Robusto 2.2.5 Seguro 2.2.6 Arquitectura Neutral 2.2.7 Portable 2.2.8 Interpretado 2.2.9 Alto desempeño 2.2.10 Multihilos 2.2.11 Dinámico 2.3 La estructura de Java 2.4 Instalación de Java 2.5 Construcción básica de una aplicación 2.5.1 Edición 2.5.2 Compilación 2.5.3 Carga 2.5.4 Verificación 2.5.5 Ejecución UNIDAD 3 - Tipos de datos, variables y Operadores (Java) 3.1 Variables 3.1.1 Nombres de Variables 3.2 Palabras reservadas 3.3 Tipos de datos 3.3.1 Tipos Primitivos de Datos 3.3.2 Tipos Referencia a Objeto 3.4 Declaración e inicialización de las variables 3.5 Promoción de datos (Casting) 3.5.1 Conversión automática de Java 3.5.2 Conversión de tipos incompatibles 3.6 Visibilidad y vida de las variables 3.7. Operadores de java 3.7.1 Operadores aritméticos 3.7.2 Operador módulo ( % ) 3.7.3 Operadores de asignación 3.7.4 Operadores unarios 3.7.5 Operador instanceof


4

3.7.6 Operador condicional ?: 3.7.8 Operadores de incremento y decremento 3.7.9 Operadores relacionales 3.7.10 Operadores lógicos boléanos 3.7.11 Operador de concatenación de cadenas de caracteres (+) 3.7.12 Operadores que actúan a nivel de bits 3.8 Precedencia y asociatividad de los operadores

UNIDAD 4 - Sentencias de control en Java 4.1 Estructura Secuencial 4.1.1 Salida de datos estándar 4.1.2 Entrada de datos estándar 4.2 Sentencias de decisión o selección 4.2.1 Selección simple ( if ) 4.2.2 Selección doble ( if – else ; if – else - if ) 4.2.3 Selección múltiple ( switch ) 4.3 Sentencias de Repetición ( ciclos o bucles) 4.3.1 Ciclo para ( for ) 4.3.2 Ciclo mientras ( while ) 4.3.3 Ciclo haga mientras ( do – while ) UNIDAD 5 – Métodos 5.1 Definición de métodos 5.2 Paso de Parámetros 5.3 Llamado a Métodos Apendice A – Algunos conceptos de la programación orientada a objetos (P.O.O)

IV. METODOLOGÍA Durante el curso se emplearán las siguientes Métodos Pedagógicos:

• Clase: Mediante la cual el profesor da explicaciones sobre algunos temas, resuelve interrogantes y aclara dudas. Los estudiantes, por su parte, escuchan las exposiciones, toman notas, preguntan y participan opinando y aclarando dudas.

• Estudio Independiente: El estudiante de manera independiente realiza lecturas, tareas, consulta libros, realiza composiciones escritas y ejercicios.

• Taller : En el cual se realizan ejercicios de práctica de los conceptos revisados en el curso.

• Tutoría : Donde profesor y estudiante trabajan sobre el proceso, las dificultades y los problemas que va teniendo el estudiante: le ayuda a interpretar lo que está ocurriendo.

Trabajos de Consulta: 1. Sistemas de Numeración. Sistema Binario, Octal, Hexadecimal. Conversión entre

sistemas. Suma, Resta, Multiplicación y División en Sistema Binario.


5

2. Sistemas lógicos. Tautología y contradicciones, equivalencia lógica, enunciados condicional y bicondicional, y argumentos 3. Programación Orientada a Objetos. Historia, Características, Aspectos Básicos. Historia de JAVA. V. EVALUACIÓN

La evaluación del curso considerará los siguientes momentos evaluativos: • Primer Examen Parcial • Segundo Examen Parcial • Examen Final (acumulativo) • Talleres • Prácticas • Quices • Trabajos de Consulta

VI. REFERENCIAS

BIBLIOGRÁFICAS 1. Área de Informática UAO, Módulo de Informática 1, Publicaciones UAO. 2. CEBALLOS, Francisco J., JAVA 2 Curso de Programación. Ed. Alfaomega. Ra–Ma. 2000. 3. Joyanes Aguilar Luis & Zahonero Martínez Ignacio, “Programación en Java 2 – Algoritmos, Estructuras de Datos y Programación orientada a Objetos”, Ed. McGrawHill, 2002. 4. DEITEL, H.M., DEITEL, P. J. How to program Java. 3ª Edición. Ed. Prentice Hall. 2000. 5. FROUFE, Augustín. JAVA2 Manual de Usuario y Tutorial. 2ª Edición Ed. Alfa Omega 2000. 6. WU, Thomas C. Introducción a la programación orientada a objetos con Java. Ed. Mc Graw Hill. España. 2000. 7. ARNOW, David. WEISS, Gerald, Introducción a la programación con Java. Un enfoque orientado a objetos. Ed. Addison Wesley. España.2001 ELECTRÓNICAS 1. Descargar el software – J2SE, del sitio web: ) http://java.sun.com/javase/downloads/index.jsp 2. Descargar el editor – NetBeans del sitio web:

http://www.netbeans.org/downloads/start.html?platform=windows&lang=en&option=all&version=6.7.1

3. Documentación de JAVA (JDK 1.6) http://java.sun.com/javase/downloads/index.jsp 4. Tutorial de Java http://java.sun.com/docs/books/tutorial/ 5. Free Electronic Books in Java and C++: http://www.ibiblio.org/pub/docs/books/eckel/


6

6. Aprenda Java como si estuviera en primero http://www.abcdatos.com/tutoriales/tutorial/l7041.html

7. Tutorial de Java (Augustin Froufe) http://www.cica.es/formacion/JavaTut/ 8. Java en Castellano http://programacion.com/java/

FUENTES DE DONDE SE RECOPILÓ EL MATERIAL PARA LA EL ABORACIÓN DE ESTE MÓDULO DE INFORMÁTICA I.

- Universidad de Valencia, España, Depto. de Informática http://informatica.uv.es/docencia/fguia/TI/Libro/PDFs/CAPI4.pdf

- Universidad de Oviedo,España, Depto. de Informática Profesor Daniel Gayo.

http://di002.edv.uniovi.es/~dani/asignaturas/ - Aprenda Java como si estuviera en primero, Escuela Superior de Ingenieros Industriales de San Sebastián.

http://mat21.etsii.upm.es/ayudainf/aprendainf/Java/Java2.pdf - Matemáticas para Computación, Seymour Lipschutz, McGraw – Hill, 1992


7

UNIDAD 1. ALGORITMOS 1.1 Procedimiento de Datos 1.2 Ciclo de Diseño

• Requerimiento - Características que se desea que posea un sistema o un software.

• Diseño - proceso previo de configuración mental en la búsqueda de una solución en cualquier campo.

• Especificación - documento técnico oficial que establece de forma clara todas las características,

los materiales y los servicios necesarios para producir componentes destinados a la obtención de productos.

• Implementación – Traducir a un lenguaje de programación concreto un algoritmo.

• Formas y métodos para llevar a cabo algo.


8

1.3 Concepto de Algoritmo Definición de algoritmo. Etimología del término algoritmo En general, un algoritmo es una secuencia de instrucciones o pasos que es llevada a cabo de forma mecánica y sistemática por un actor que se desenvuelve en un ambiente o entorno dado, para resolver un problema determinado en un tiempo finito. Esa es una definición válida de algoritmo. Otras posibles definiciones son las siguientes: Un algoritmo es un conjunto de instrucciones combinadas de forma adecuada para resolver un determinado problema en una cantidad finita de tiempo. Cada instrucción es una indicación sencilla y no ambigua. Secuencia de instrucciones o pasos que es llevada a cabo de forma mecánica y sistemática por un actor que se desenvuelve en un ambiente o entorno dado, para resolver un problema determinado en un tiempo finito. Despues de los siguientes ejemplos, el lector debería tener bastante claro qué es un algoritmo, en qué consiste y dar ejemplos de algoritmos. Ahora, es probable que se esté preguntando de dónde procede el mismo término, “ALGORITMO”, ¿por qué denominamos “algoritmos” a los algoritmos y no “recetas” o “combinaciones de indicaciones sencillas y no ambiguas...”? El término proviene de Mahommed ibn Musa al-Khowârizmî (Mahommed, hijo de Musa, natural de Kharizm), matemático persa del siglo IX; las matemáticas le deben la introducción del sistema de numeración actual y del álgebra. En su libro De numero indiorum (Sobre los números hindúes) proporciona las reglas para realizar las operaciones aritméticas (con los nuevos números, por supuesto), dichas reglas se denominaron “reglas de al-Khowârizmî” y, por deformación “algoritmos”, haciéndose extensivo el término a cualquier conjunto de reglas para resolver un problema determinado. Como nota curiosa, un esbozo del rostro de al-Khowârizmî aparece en la portada del clásico libro de Álgebra del Profesor Cubano Aurelio Baldor, muy conocido en la Literaura de las Matemáticas Hispanoparlantes.


9

1.4 Propiedades de los Algoritmos

• Su lógica de construcción debe ser • Independiente del lenguaje

• Simplicidad

• Definido: sin ambigüedades

• Preciso: orden específico de sentencias

• Finito: principio y fin

• Efectivo: Funciona y funciona de acuerdo a los requerimientos

Ejemplos de Algoritmos : Ejemplo 1: Elaborar el análisis general que responda a la pregunta: ¿Qué debo hacer para ver la película Avatar?.

1. Ir al cine donde proyectan Avatar. 2. Comprar una entrada. 3. Ver la película. 4. Regresar a casa.

Ejemplo 2: Elaborar el análisis para obtener el área de un círculo y la longitud de su circunferencia.

1. Utilizar las fórmulas del área y la circunferencia en función del radio. 2. Las entradas de datos se reducen al dato correspondiente al radio del círculo. 3. Las salidas serán los datos solicitados: área y longitud de la circunferencia.

Ejemplo 3: Instrucciones para subir una escalera [...] Las escaleras se suben de frente, pues hacia atrás o de costado resultan particularmente incómodas. La actitud natural consiste en mantenerse de pie, los brazos colgando sin esfuerzo, la cabeza erguida aunque no tanto tal que los ojos puedan ver los peldaños inmediatamente superiores al que se pisa, y respirando lenta y regularmente. Para subir una escalera se comienza por levantar esa parte del cuerpo situada a la derecha abajo, envuelta casi siempre en cuero o gamuza, y que salvo excepciones cabe exactamente en el escalón. Puesta en el primer peldaño dicha parte, que para abreviar llamaremos pie, se recoge la parte equivalente de la izquierda (también llamada pie, pero que no ha de confundirse con el pie antes citado), y llevándola a la altura del pie, se le hace seguir hasta colocarla en el segundo peldaño, con lo cual en éste descansará el pie, y en el primero descansará el pie. Los primeros peldaños son siempre los más difíciles, hasta adquirir la coordinación necesaria. La coincidencia de nombre entre el pie y el pie hace difícil la explicación. Cuídese especialmente de no levantar al mismo tiempo el pie y el pie. Llegando en esta forma al segundo peldaño, basta repetir alternadamente los movimientos hasta encontrarse con el final de la escalera. Se sale de ella fácilmente, con un ligero golpe de talón que la fija en su sitio, del que no se moverá hasta el momento del descenso.


10

Ejemplo 4: Elaborar Tortilla de patatas a la española (6 personas) Ingredientes: - 2 vasos (de los de agua) de aceite (1/2 litro) - Sal - 8 huevos - 1 kg de patatas Se pelan las patatas, se lavan y se secan con un paño; se parten en dos a lo largo y después se cortan en láminas finitas. Se pone el aceite a calentar en la sartén y se fríen las patatas, moviéndolas de vez en cuando y echándoles un poco de sal. Una vez fritas (más o menos doradas, según gusten), se separan y se ponen a escurrir en un colador grande. Se quita el aceite sobrante de la sartén. Aparte se baten los huevos con tenedor y muy fuerte; se pone un poco de sal; en el mismo plato de los huevos se echan las patatas y se mueven con un tenedor. En una sartén grande (o en dos pequeñas) se ponen 3 cucharadas soperas de aceite para que sólo cubra el fondo. Cuando está caliente se vierte la mezcla de huevos y patatas. Se mueve la sartén por el mango para que no se pegue la tortilla. Cuando se vea que está bien despegada y dorada (esto depende del gusto de cada cual), se pone una tapadera encima, se vuelca la sartén y se escurre suavemente la tortilla otra vez en la sartén. Se vuelve a mover por el mango y cuando esté cuajada (a gusto) se pasa a una fuente redonda y se sirve. Ejemplo 5: Algoritmo “infantil”: Multiplicación de números enteros Para obtener el producto de dos números enteros utilizando lápiz y papel se debe escribir el primer factor (multiplicando) y, justo debajo y alineado a la derecha, el segundo factor (multiplicador). Se recorren todas las cifras del multiplicador de derecha a izquierda y se operan con cada una de las cifras el multiplicando, también de derecha a izquierda, escribiendo los resultados intermedios en líneas separadas; cada línea estará desplazada una posición a la izquierda respecto a la línea inmediatamente superior. Una vez se han obtenido todos los resultados intermedios se suman columna a columna obteniéndose el resultado final. Numerando cada uno de los pasos a seguir en cada uno de los algoritmos, formalizamos un poco nuestro lenguaje cotidiano para escribir algoritmos, veamos:


11

Ejemplo 6: Cambiar la rueda pinchada de un automóvil teniendo un gato mecánico en buen estado, una rueda de reemplazo y una llave inglesa. Los pasos del algoritmo son:

1. Inicio. 2. Aflojar los tornillos de la rueda pinchada con la llave inglesa. 3. Ubicar el gato mecánico en su sitio. 4. Levantar el gato hasta que la rueda pinchada pueda girar libremente. 5. Quitar los tornillos y la rueda pinchada. 6. Poner rueda de repuesto y los tornillos. 7. Bajar el gato hasta que se pueda liberar. 8. Sacar el gato de su sitio. 9. Apretar los tornillos con la llave inglesa. 10. Fin.

Podríamos modificar este algoritmo, bien sea escribiendo más líneas de detalle ó uniendo algunos pasos, y aún así funcionaría para resolver nuestro problema. Esto quiere decir que podemos tener algoritmos diferentes, con diferente diseño, que resuelven el mismo problema. ¿Cuál de ellos es más eficiente, hablando desde el punto de vista computacional? Ese es tema de otro curso, por el momento nos debemos concentrar en cuál algoritmo es más claro, cual es más fácil de entender. Ejemplo 7: Un cliente hace un pedido a una fábrica. La fábrica examina en su banco de datos la ficha del cliente, si el cliente es solvente entonces la empresa acepta el pedido; en caso contrario lo rechaza. Elabore el algoritmo correspondiente. Los pasos del algoritmo son:

1. Inicio. 2. Leer el pedido. 3. Examinar la ficha del cliente. 4. Si el cliente es solvente, aceptar pedido; en caso contrario, rechazarlo. 5. Fin.

Ejemplo 8: Averiguar si un número entero positivo es primo o no, dado que conocemos la definición de número primo: un número entero positivo, N, es primo si sólo puede dividirse por si mismo y por la unidad. Un método que nos puede dar la solución sería dividir sucesivamente el número por 2, 3, 4...N, y, según el resultado, podríamos resolver el problema. Un diseño del mismo sería:

1. Inicio. 2. Solicitar el valor del número entero positivo y guardarlo en la variable N 3. Poner X igual a 2 ( X = 2, donde X es una variable que representa a los posibles divisores

de N ). 4. Dividir N por X ( o sea, operar N / X ) 5. Si el resultado de N / X es entero, entonces N no es primo ( pues esto indicaría que N es

divisible entre X ) y saltar al punto 10; en caso contrario continuar el proceso en el siguiente punto, 6.

6. Incrementar el divisor X en una unidad ( X = X + 1 ) 7. Si X es menor que N saltar al punto 4, en caso contrario continuar el proceso en el siguiente

punto, 8.


12

8. Declarar que N es primo. 9. Saltar al Fin (punto 11). 10. Declarar que N no es primo. 11. Fin.

Como parte del diseño de un algoritmo está la selección de aquél que sea razonablemente aceptable, entre todos los muchos posibles que resuelven el mismo problema (el ejemplo que acabamos de dar es claramente mejorable, pues si N no era divisible por 2 no tiene mucho sentido volverse a preguntar si lo es por 4). Durante el diseño es posible y aconsejable, realizar comparaciones entre algoritmos que resuelven el mismo problema. La bondad de un algoritmo puede medirse por dos factores:

• El tiempo que se necesita para ejecutarlo. Para tener una idea aproximada de ello, basta con saber el número de instrucciones de cada tipo necesarias para resolver el problema.

• Los recursos que se necesitan para implementarlo. Así, una vez diseñado un primer algoritmo, conviene realizar una evaluación del mismo, cuestión a veces nada fácil. Si se decide que éste no es eficiente será necesario o bien diseñar uno nuevo o bien optimizar el original. Optimizar un algoritmo consiste en introducir modificaciones en él, tendientes a disminuir el tiempo que necesita para resolver el problema o a reducir los recursos que utiliza. Por ejemplo, el algoritmo del número primo se optimiza si N se declara como primo cuando X supera a N / 2 y no esperar hasta que X llegue a N. Ejemplo 9: Realizar la suma de todos los números pares entre 2 y 1000. El problema consiste en sumar 2 + 4 + 6 + 8 + 10 + . . . + 998 + 1000. Utilizaremos las palabras SUMA y NUMERO (que llamaremos más tarde variables) para representar las sumas sucesivas (2 + 4), (2 + 4 + 6), (2 + 4 + 6 + 8), etc. La solución se puede escribir con el siguiente algoritmo:

1. Inicio. 2. Establecer SUMA a 0. 3. Establecer NUMERO a 2. 4. Sumar NUMERO a SUMA. El resultado será el nuevo valor de la suma (SUMA). 5. Incrementar NUMERO en 2 unidades. 6. Si NUMERO <= 1000 bifurcar (ó, ir) al paso 4; en caso contrario, escribir el último valor

de SUMA y terminar el proceso. 7. Fin.

Si se estudia con atención cada uno de los algoritmos anteriores, descubriremos una serie de características interesantes que definen la naturaleza de lo que es un algoritmo:

• Un algoritmo resuelve un problema específico: subir una escalera, obtener una tortilla de patatas, hacer una multiplicación o determinar el máximo común divisor de dos números.

• Un algoritmo es llevado a cabo por una entidad que trabaja en un entorno dado: una persona cuyo universo inmediato se reduce a su propio cuerpo y una escalera; un cocinero con una sartén, huevos, patatas, aceite, sal y cebolla; o un estudiante con lápiz y papel.


13

• Un algoritmo consta de una serie de pasos que deben llevarse a cabo siguiendo una secuencia marcada: algunos de los pasos, en uno de los algoritmos anteriores, serían: dar la vuelta a la tortilla, batir los huevos, pelar las patatas o cascar los huevos; dichos pasos deben aplicarse en un orden prefijado y no de cualquier manera.

• Un algoritmo se aplica de forma mecánica: un algoritmo no precisa decisiones subjetivas ni creatividad en su ejecución, cualquiera con una receta adecuada para obtener tortilla de patatas logrará una tortilla de patatas. Sin embargo, sí es necesario un acto creativo para desarrollar un nuevo algoritmo.

• Un algoritmo termina en un tiempo finito: todos los algoritmos deben finalizar, pueden tardar más o menos tiempo en lograr un resultado pero dicho tiempo debe ser finito.

Diseño Descendente (Top Down), ó, Modular

Los problemas complejos se pueden resolver más eficazmente cuando se descomponen en subproblemas que sean más fáciles de resolver que el original. Este método se denomina divide y vencerás (Divide and conquere) y consiste en convertir un problema complejo en otros más simples que, una vez resueltos, en su conjunto nos solucionen el original. Al procedimiento de descomposición de un problema en subproblemas más simples, llamados módulos, para, a continuación, seguir dividiendo estos subproblemas en otros más simples (otros módulos), se le denomina diseño descendente (top down, en inglés). Las ventajas más importantes de este tipo de diseño son:

1. El problema se comprende más fácilmente al dividirse en módulos o partes más simples. Cuando se realice la programación, utilizaremos esta idea constantemente, de forma que hablaremos

también de subprogramas ó métodos ( procedimientos y / o funciones ). 2. Las modificaciones en los módulos son más fáciles, pues estamos ante algoritmos más sencillos. 3. La comprobación del problema se puede realizar más fácilmente, al poder localizar los posibles

fallos con mayor precisión. Refinamiento por pasos Durante el diseño, entenderemos por refinamiento por pasos, la metodología por la que en un primer esbozo del algoritmo nos limitamos a señalar o describir un reducido numero de pasos, que deberán ser expresados con mayor detalle posteriormente. Tras esta primera descripción, éstos se especifican con mayor minuciosidad, de forma más extensa y con más pasos específicos. En cada nivel de refinamiento hay que considerar dos fases: ¿Qué hace el módulo? para, a continuación, responder a ¿Cómo lo hace? Como es natural, dependiendo de la complejidad del problema se necesitarán diferentes y sucesivos niveles de refinamiento antes de que pueda obtenerse un algoritmo con suficiente nivel de detalle. Así, en el ejemplo del cálculo de la longitud de una circunferencia y la superficie de su círculo, a pesar de presentar en su diseño un bajo nivel de complejidad, se puede descomponer en subproblemas más simples: 1. leer datos de entrada, 2. calcular superficie y longitud, 3. escribir resultados. El ejemplo siguiente, nos muestra el diseño de un algoritmo para un problema de carácter no numérico


14

Ejemplo: Diseñar un algoritmo que responda a la pregunta: ¿Qué debo hacer para ver la película MatriX?. Un primer análisis nos conduce a un esbozo de solución, descomponiéndolo en cuatro módulos sucesivos: 1. Ir al cine donde proyectan MatriX 2. Comprar una entrada 3. Ver la película 4. Regresar a casa Estos cuatro pasos se pueden refinar un poco más y así este problema lo podríamos descomponer de la siguiente forma, usando el lenguaje natural:

INICIO ALGORITMO para ver la película MatriX consultar la cartelera de cines SI proyectan XYZ ENTONCES

ir al teatro correspondiente SINO proyectan XYZ

declarar el fracaso del objetivo y terminar SI hay cola ENTONCES

ponerse en ella MIENTRAS haya personas delante en la cola HACER

esperar el instante para avanzar en la cola

preguntar si quedan entradas SI hay entradas ENTONCES

comprar una entrada SINO quedan entradas

declarar el fracaso del objetivo, regresar a casa y terminar

encontrar el asiento correspondiente MIENTRAS proyectan la película HACER

ver la película abandonar el cine regresar a casa

FIN ALGORITMO para ver la película MatriX Algunas de estas acciones son primitivas para nosotros; es decir, no es necesario descomponerlas más, como el abandonar el cine. Sin embargo hay otras acciones que son susceptibles de mayor descomposición. Este es el caso de la acción:

“encontrar el asiento correspondiente” si los números de los asientos están impresos en la entrada, esta acción compuesta se resuelve con el siguiente algoritmo: INICIO ALGORITMO para encontrar el asiento del espectador

caminar hasta llegar a la primera fila de asientos REPETIR

comparar número de fila con número impreso en la boleta SI no son iguales, ENTONCES

pasar a la siguiente fila HASTA_QUE se localice la fila correcta


15

MIENTRAS número de asiento no coincida con número impreso en la boleta HACER avanzar a través de la fila a la siguiente butaca

sentarse en la butaca

FIN ALGORITMO para encontrar el asiento del espectador De esta forma, podríamos seguir hasta la descomposición de las distintas acciones en instrucciones susceptibles de ser interpretadas directamente por el computador. Si un algoritmo puede ser ejecutado por una computadora, se dice que es un algoritmo computacional; en caso contrario, se dice que es un algoritmo no computacional. Los que se trabajaran en el curso de informática 1, serán los algoritmos computacionales. Programación del Algoritmo Una vez que el algoritmo está diseñado y representado, se debe pasar a la fase de resolución práctica del problema con el computador. Esta fase se descompone a su vez en las siguientes subfases: (Ver Figura 1.3) 1. Codificación del algoritmo en un programa. 2. Ejecución del programa 3. Comprobación del programa.

Fig. 1.3 Programación del algoritmo La fase de conversión de un algoritmo en instrucciones de un lenguaje de programación se denomina codificación. El código deberá estar escrito de acuerdo con la sintaxis del lenguaje de programación, ya que solamente las instrucciones sintácticamente correctas pueden ser interpretadas por el computador. Nótese que durante el proceso de programación, se debe separar el diseño del algoritmo de su posterior implementación en un lenguaje de programación específico. Por ello distinguimos entre el concepto más general de programación y el más particular de codificación, que depende del lenguaje de programación utilizado. Al llegar a este punto, es posible que el lector conozca al menos uno de estos lenguajes y éste es el momento en el que podría mostrar sus habilidades para efectuar una codificación lo más correcta y eficiente posible. Tras la codificación del programa, éste deberá ejecutarse en un computador. El resultado de esta primera ejecución es incierto, ya que existe una alta probabilidad de que aparezcan errores, bien en la codificación, bien en el propio algoritmo. Por tanto, el paso siguiente consiste en comprobar el correcto funcionamiento del programa y en asegurarse, en la medida de lo posible, de la validez de los resultados proporcionados por la máquina.

Programación del algoritmo

Codificación en un programa

Ejecución del programa

Comprobación del programa


16

Formas de describir un algoritmo Dado que los algoritmos permiten resolver problemas de forma mecánica, está claro que resulta muy interesante compartir dicho algoritmo de tal manera que otras personas puedan conocerlo y aplicarlo; así surge el problema de describir los algoritmos de forma tal que todas las características que los definen se mantengan invariables. Lenguaje natural. La primera y más sencilla forma de describir un algoritmo es empleando el lenguaje natural; por ejemplo, el algoritmo para encontrar las raíces de una ecuación de segundo grado (ó, ecuación cuadrática) del tipo aX2 + bX + C = 0 ( a diferente de cero ), podría describirse así: 1. Definir (o, leer) los coeficientes de la ecuación de segundo grado: a, b y c , donde a no es cero. 2. Determinar el valor del discriminante: d = b2 - 4ac. 3. Si el discriminante es cero, sólo hay una solución: -b / (2a). 4. Si el discriminante es positivo, hay dos soluciones: (-b ± d ) / (2a). 5. Si el discriminante es negativo, no hay soluciones reales. La ventaja fundamental es la facilidad de comprensión, pues cualquier persona (hispanoparlante, por supuesto) que lea dicho algoritmo podría entenderlo y aplicarlo; sin embargo, son varios los problemas que plantea describir un algoritmo de esta forma:

• El lenguaje natural no es universal, este algoritmo sería completamente inútil para los no hispanoparlantes. • El lenguaje natural es ambiguo y, por tanto, susceptible de errores. • El lenguaje natural es demasiado amplio, lo que para una persona puede ser una instrucción

sencilla, puede no serlo para otra y, desde luego, no lo será para un computador. Por todo ello, se han buscado nuevas formas de describir los algoritmos que, cuando menos, sean más universales, estén mejor delimitadas y no sean ambiguas; dos técnicas que logran esto son los organigramas y las notaciones en pseudocódigo. Diagramas de Flujo (Organigramas) Los diagramas de flujo u organigramas permiten describir los algoritmos de forma gráfica; para ello utilizan una serie de bloques que indican distintas circunstancias y flechas que muestran bajo qué condiciones se pasa de un bloque a otro. Algunos de los símbolos son los siguientes:


17

A continuación, se muestra un organigrama que describe el algoritmo anterior.


18

Los organigramas presentan varias ventajas frente al lenguaje natural: • Los símbolos son universales. • Son menos propensos a la ambigüedad. • Por estar basados en un número pequeño de bloques y reglas para su empleo permiten

delimitar mejor los algoritmos. • Se aproximan más a la forma en que trabaja el computador.

Sin embargo:

• El hecho de emplear símbolos supone que una persona que desconozca los símbolos puede tener dificultades para comprender el algoritmo o no entenderlo en absoluto.

• Aunque los símbolos son universales, el texto que se coloca en su interior sigue siendo lenguaje natural.

• La representación gráfica puede resultar bastante tediosa y, en el caso de algoritmos complejos, extremadamente confusa.

• Un computador no es capaz de utilizar una representación visual como descripción de un algoritmo.

Actualmente, los organigramas no son muy utilizados, aunque para mostrar el funcionamiento de algoritmos sencillos continúan resultando prácticos.

1.5 Pseudocódigo El pseudocódigo pretende juntar en un solo tipo de representación las ventajas del lenguaje natural y de los organigramas sin ninguno de sus problemas; por tanto, el pseudocódigo:

• Es fácilmente comprensible para una persona que lo vea por vez primera. • Está bien delimitado. • Elimina las ambigüedades del lenguaje natural. • Se representa de una forma compacta.

De esta forma, el pseudocódigo se suele ver como un subconjunto de un lenguaje natural que proporciona un número limitado de operaciones para la construcción de algoritmos; la única finalidad del pseudocódigo (como de los organigramas) es la comunicación entre seres humanos. La ventajas del uso del pseudocódigo residen en:

• Su uso en la planificación de un programa; permitiendo que el programador se pueda concentrar en la lógica y en las estructuras de control y no tenga que preocuparse, por ahora, de detalles acerca de las reglas sintácticas y semánticas de un lenguaje específico.

• Consecuentemente, es más fácil de modificar en el caso de que se descubran errores o

anomalías en la lógica del algoritmo.

• Aunque el pseudocódigo es independiente del lenguaje de alto nivel que vaya a utilizarse, un algoritmo expresado en pseudocódigo puede ser traducido más fácilmente a muchos de dichos lenguajes.

Elementos de construcción de un algoritmo: • Inicio del algoritmo


19

• Finalización del algoritmo • Comentarios • Declaración de variables • Expresiones • Instrucciones de Salida • Instrucciones de Entrada

� Inicio y finalización del algoritmo

- Inicio del algoritmo algoritmo NombreAlgoritmo {

principal ( ) { }

} - Finalización del algoritmo Ejemplos de iniciar y finalizar un algoritmo: algoritmo Edad {

principal ( ) { // Cuerpo del Algoritmo … …

} }

� Comentarios Los comentarios son la documentación interna del algoritmo. Y se hacen de 2 formas, las cuales son:

� Párrafo o bloque (más de una línea): Inicia con /* Termina con */

� Una línea: Inicia con //

Ejemplos de comentarios: // Este es comentario de una línea /* Este es un comentario de un bloque de líneas. Este es un comentario de un bloque de líneas.*/ Nota: Los comentarios se insertan en el cuerpo del algoritmo.


20

� Variables Una variable es una localización o casilla en la memoria principal que almacena un valor que puede cambiar en el transcurso de la ejecución del programa. Cuando un programa necesita almacenar un dato, necesita una variable. Toda variable tiene un nombre ó identificador, un tipo de dato, el valor concreto que va a guardar y una dirección en la memoria del computador. Dicho de otra forma, Son espacios de memoria reservados para guardar datos que pueden variar durante la aplicación de un algoritmo. El tipo de la variable depende del tipo de dato que pueda guardar. Antes de poder utilizar una variable es necesario declararla especificando su tipo de dato y su nombre. Para declarar variables usaremos los siguientes formatos: Declaración de una variable: tipo_de_variable nombre_de_la_variable = valor_inicial; Declaración de varias variables con el mismo tipo de dato: tipo_de_variables nombre_de_la_variable1 = valor_inicial, nombre_de_la_variable2 = valor_inicial, nombre_de_la_variable3 = valor_inicial, ... , nombre_de_la_variableN = valor_inicial ; Donde:

tipo_de_variable Depende del tipo de dato que va a guardar la variable y se nombra con dicho tipo. El tipo puede ser: Primitivos: entero (si la variable almacenará un número entero) , real (si la variable almacenará un número con parte decimal) , caracter (si la variable almacenará un caracter), booleana (si la variable almacenará el valor verdadero o el valor falso, también conocida como de tipo logico). Objetos: cadena (si la variable almacenará un conjunto de caracteres).

nombre_de_la_variable Nombres (ó identificadores) válidos de las variables. El nombre de una variable debe comenzar con un carácter alfabetico o un símbolo de subrayado ( _ ) . Los demás caracteres del nombre pueden ser alfabéticos (a..z, A..Z), numéricos (0..9) y el carácter subrayado ( _). Debe considerarse también que una letra mayúscula se considera diferente de una letra minúscula. No tiene restricción en su longitud No pueden contener ningún otro carácter (*, +, ?, =, (, ), /, &, %, $, #, !, @, …). No se pueden utilizar las palabras clave reservadas para el lenguaje, estas varían de acuerdo al lenguaje utilizado. Deben ser auto-documentadas y Generalmente se escribe en letras minúsculas

Nombres de variables no validas:

• edad_#01 • _coeficiente(4)


21

• 4_nombre_del_Trabajador • v@lorTerminal • nombre de programa • número 1 • SUELDO-45

Ejemplos de declaración de variables: La siguiente instrucción declara la variable edad de tipo ENTERA y la variable descuento de tipo Real. entero edad=0; real descuento=0.0; Esto crea las casillas de memoria edad y descuento. Luego de la creación, las variables están inicializadas en cero ( 0 ).

edad 0

descuento 0

La siguiente instrucción declara las variables nota1, nota2 y nota3, todas de tipo REAL. real nota1=0.0, nota2=0.0, nota3=0.0; Esto crea los casilleros de memoria nota1, nota2 y nota3. Luego de la creación, las variables están inicializadas en cero ( 0 ).

nota2 0

nota3 0

entero valor1= 0; caracter respuesta = ‘s’; real valor_2 = 3.14; cadena nombre = “ ”; booleano respuesta2 = verdadero;

� Constantes Son variables que después de habérseles asignado una valor, éste no cambia durante el proceso de aplicación del algoritmo. El nombre de las constantes, generalmente, se escribe en letras mayúsculas.

nota1 0


22

Ejemplos de constantes:

real PI = 3.141592; real porcentaje = 0.25;

� Expresiones � Conjunto de valores, variables, constantes y operadores relacionados matemáticamente o

lógicamente, asignados a una variable. � Permite mover contenidos de memoria de una posición a otra � Su resultado es representado por las variables. � Asigna valores a una posición de memoria. Ejemplos de Expresiones: promedio = (n1 + n2 + n3)/3; // Donde n1=4, n2=3 y n3=1 suma = suma + numero; num1 > num2 nombre_completo = nombre + apellido; entero Resultado = numero_1 + numero_2; cadena Nombre = “Jesús Antonio”; real _Sueldo = 45.36 + 854687; booleana Flag = true; caracter Vocal = ‘X’; booleana Opcion = 45 > 0 && true && (18+12)/2 > 0; booleana Otra_Opcion = true && (false || true);

� Instrucciones de Salida Consiste en entregar resultados al usuario mediante el dispositivo estándar de salida, la pantalla. Ya sea, mostrar el valor de una variable o alguna información que desee desplegar al usuario. En general, la forma para realizar esta acción, se expresa en el pseudocódigo mediante la palabra imprimir de la siguiente forma:

Sintaxis imprimir (“El Texto que se va a imprimir”); imprimir (nombre_de_variable); imprimir (“El texto ”+ nombre_de_variable);

Nota: En este caso, el simbolo + es llamado operador de concatenacion y es utilizado para encadenar dos elementos y formar un dato tipo cadena.


23

Ejemplos de Instrucciones de Salida:

• Si se desea desplegar una cadena Hola Mundo: imprimir ( “Hola Mundo” ) ;

• Si se desea desplegar el valor almacenado en la variable importeCompra: imprimir ( importeCompra ) ;

• Si se desea desplegar la cadena El Valor Del Area Es: seguida del valor almacenado en la variable area:

imprimir ( “El Valor Del Area Es: ” +area) ; Pero en el imprimir se puede tener muchas combinaciones entre variables y cadenas, como por ejemplo: Suponiendo que se han hecho las siguientes declaraciones: real area=70.4; entero valor = 21; cadena nombre = “Carlos”;

• imprimir ( “El Valor Del Area Es: ” +area+“ Metros Cuadrados”) ; entonces el anterior ejemplo nos desplegaría en pantalla: El Valor Del Area Es: 70.4 Metros Cuadrados

• imprimir ( “El Terreno De : ” +area+“ Tiene Un Costo De: ” +valor+“ Pesos Por Metro

Cuadrado y vendido por”+nombre); entonces el anterior ejemplo nos desplegaría en pantalla: El Terreno De : 70.4 Tiene Un Costo De: 21 Pesos Por Metro Cuadrado

NOTA: Observe que en las cadenas se dejaron espacios para que en al momento de desplegarse en pantalla, este espacio entre palabras sea conservado. � Instrucciones de Entrada

Consiste en obtener y almacenar en una variable, datos de entrada entregados por el usuario desde un dispositivo de entrada estándar (como el teclado). En general, la acción de ingresar un dato desde un dispositivo de entrada a una variable, se expresa en el pseudocódigo de la siguiente forma:

Sintaxis variable = leer (“mensaje de captura “) ;

Ejemplos de Instrucciones de Entrada:

variable2 = leer (“Digite el segundo valor ”); Suponiendo que se han hecho las siguientes declaraciones: real area=0.0;


24

entero valor=0; cadena nombre=“”;

• nombre = leer ( “Ingrese su nombre ”) ; entonces la anterior instrucción nos almacenaría el nombre ingresado por el usuario en la variable nombre. • valor = leer( “Ingrese el valor de venta por metros cuadrados ”) ; entonces la anterior instrucción nos almacenaría el valor por metro cuadrado ingresado por el usuario en la variable valor. • area = leer ( “Ingrese el area del terreno ”) ; entonces la anterior instrucción nos almacenaría el area del terreno ingresado por el usuario en la variable area.

Por ejemplo, la instrucción: real estatura=0.0; estatura = leer(“Digite la estatura: “ ) ; solicita el ingreso de un valor, desde algún dispositivo de entrada (como el teclado), para la variable estatura.

� Operadores Son símbolos que establecen una relación aritmética, lógica o relacional entre datos.

Tabla 1.1 Operadores aritméticos


25

Tabla 1.2 Operadores relacionales

Tabla 1.3 Operadores lógicos


26

Reglas de jerarquía de los operadores aritméticos Cuando una expresión aritmética tiene más de un operador aritmético, el orden de aplicación de los operadores sigue un orden preciso determinado por las reglas de jerarquía de los operadores aritméticos, que se muestran en la siguiente tabla:

Tabla 1.4 Reglas de Jerarquía de los Operadores Aritméticos, Relacionales y Lógicos

Operadores Precedencia

posfijo expr++ expr--

unario ++expr --expr +expr -expr ~ !

multiplicativo * / %

aditivo + -

cambio << >> >>>

relacionales < > <= >= instanceof

equivalencia == !=

AND bit a bit &

OR bit a bit exclusivo ^

OR bit a bit inclusivo |

AND logico &&

OR logico ||

ternario ? :

asignacion = += -= *= /= %= &= ^= |= <<= >>= >>>=

Si existen paréntesis anidados, se evalúa primero la expresión en el paréntesis más interno. Si varios operadores o paréntesis tienen la misma jerarquía, la evaluación será de izquierda a derecha. Suponga que tenemos estos dos valores: valor1=1, valor2=5; Ejemplo 1: resultado = 10 * ++ valor1; resultado = 10 * 2; //Aumento primero la variable valor1 en uno, es decir su nuevo valor es 2 resultado = 20; resultado = 10 * valor1++; resultado = 10 * 1; //Primero realizo el producto y luego aumento la variable valor1 en uno, es decir su valor final es 2 resultado = 10;


27

Ejemplo 2: valor1>0 && valor2++ <=5 V && (5<=5) V && V V El valor final de valor2 es de 6, por tener el acumulador (++) como posfijo

Ejemplo 3: valor1>0 && ++valor2 <=5 V && (6<=5) V && F F Por haber un acumulador (++) como prefijo, primero se incrementa valor2, obteniendo como nuevo valor 6 y luego realiza la operación lógica. Ejemplo 4: true && valor2 – 4 < valor1 || valor1-- < valor2 – 4 1 1 F F F F Ejemplo: ¿Cuál es el equivalente en pseudocódigo de la siguiente expresión algebraica?

Solución e = a / b / c ;

Como todos los operadores tienen la misma jerarquía, la evaluación será de izquierda a derecha: Primero, se dividirá a entre b. Segundo, el resultado ya obtenido de a / b se dividirá entre c. Note que el orden de ejecución esta de acuerdo con la expresión algebraica, por lo que no se requiere ninguna pareja de paréntesis. Ejemplo:- ¿Cuál es el equivalente en pseudocódigo de la siguiente expresión algebraica?


28

Solución c = a * b * c / d / e ;

Como todos los operadores tienen la misma jerarquía, la evaluación será de izquierda a derecha: Primero, se multiplicará a por b. Segundo, el resultado ya obtenido de a * b se multiplicará por c. Tercero, el resultado ya obtenido de a * b * c se dividirá entre d. Cuarto, el resultado ya obtenido de a * b * c / d se divivirá entre e. Note que el orden de ejecución esta de acuerdo con la expresión algebraica, por lo que no se requiere ninguna pareja de paréntesis. Ejercicio: ¿Cuál es el equivalente en pseudocódigo de la siguiente expresión algebraica?

Solución

e = 4 / ((a + b) / (c / d)) + v / (w / p) + 5 * m * n * q ;

Aplicando las reglas de jerarquía de los operadores aritméticos: Primero, se sumará a más b. Segundo, se dividirá c entre d. Tercero, el resultado ya obtenido de a+b se dividirá entre el resultado ya obtenido de c/d. Cuarto, se dividirá 4 entre el resultado ya obtenido de ( (a+b)/(c/d) ) Quinto, se dividirá w entre p. Sexto, se dividirá v entre el resultado ya obtenido de (w/p). Séptimo, se multiplicará 5 por m. Octavo, se multiplicará el resultado ya obtenido de 5*m por n. Noveno, se multiplicará el resultado ya obtenido de 5*m*n por q. Décimo, se sumará el resultado ya obtenido de 4/( (a+b)/(c/d) ) más el resultado ya obtenido de v/(w/p). Undécimo, se sumará el resultado ya obtenido de 4/( (a+b)/(c/d) ) + v/(w/p) más el resultado ya obtenido de 5*m*n*q. Se ha utilizado la mínima cantidad posible de paréntesis. Pueden usarse paréntesis adicionales, lo que no es un error. Por ejemplo, otra solución posible que arroja el mismo resultado final es:

e = (4/((a+b)/(c/d))) + (v/(w/p)) + (5*m*n*q) ; Note que usando correctamente las reglas de jerarquía, es posible usar menos parejas de paréntesis.


29

� FUNCIONES NATIVAS

• Existen cálculos que han sido, previamente organizados y definidos, mediante funciones, que son expresiones automáticas dirigidas a resolver cierto tipo de cómputo numérico o lógico.

• Las funciones “devuelven” un valor representado por cierto tipo de dato, dependiendo de su naturaleza de procesamiento.

• Por tanto es factible y significativo, asignar ese resultado a una variable que pueda “contenerlo”.

• equivalente en español - Minúscula Sintaxis función (argumento1, argumento2, …); Los argumentos, corresponden a los valores que evalúa la función. Ejemplos de Funciones: raiz (valor real) : calcula la raiz cuadrada de un número real o entero. Devuelve un valor real. absoluto (valor real) : calcula el valor absoluto de un número real o entero. Devuelve un valor real. potencia(valor real, valor entero) : calcula la potencia de un valor real o entero (base) elevado a una potencia entera. Devuelve un valor real. seno (valor real) : calcula el seno de un valor dado en radianes. Devuelve un valor real. ASIGNACIÓN A UNA VARIABLE variable = función (argumentos); 1.6 Estructuras Secuenciales La estructura secuencial es la más sencilla de todas, simplemente indica al procesador que debe ejecutar de forma consecutiva una lista de acciones (que pueden ser, a su vez, otras estructuras de control); para construir una secuencia de acciones basta con escribir cada acción en una linea diferente. A continuación se muestra una composición secuencial de acciones en notación algorítmica. real a=0.0, b=0.0, c=0.0;

a=leer(“Digite a ” ) ; b=leer( “Digite b ” ) ;

c = a + b ; imprimir ( “c tiene un valor de “ + c ) ; Existe una forma alternativa de expresar una estructura secuencial escribiendo varias acciones en la misma línea pero utilizando el punto y coma ( ; ) como separador. Sin embargo, esta última notación es desaconsejable puesto que puede llegar a hacer el código bastante difícil de leer.


30

real a=0.0, b=0.0, c=0.0; a=leer(“Digite a ” ) ; b=leer( “Digite b ” ) ; c = a + b ; imprimir ( “c tiene un valor de “ + c ) ;

Por último, es necesario señalar un aspecto importante de la composición secuencial y es que no es conmutativa. Para mostrar lo realizado hasta ahora tenemos este ejemplo: Algoritmo para expresar en centímetros y en pulgadas una cantidad dada en metros. Esta es una solución en pseudocódigo utilizando los conceptos computacionales descriptos en las paginas anteriores. La solución considera que 1 metro = 100 centímetros y que 1 pulgada = 2.54 centímetros.

Datos de Entrada (con tipos)

Proceso Información (con tipos)

real cantidad_metros

cantidad_metros = leer(“Digite la longitud en metros: ” ) cantidad_centimetros = cantidad_metros * 100 cantidad_pulgadas = cantidad_centimetros / 2.54 imprimir (cantidad_metros + “, en centímetros, equivale a: ” + cantidad_centimetros )

imprimir (cantidad_metros + c, en pulgadas, equivale a: ” + cantidad_pulgadas )

real cantidad_centimetros cantidad_pulgadas

algoritmo Conversion{ principal(){

// Declara las variables m, c y p real cantidad_metros=0.0, cantidad_centimetros=0.0 , cantidad_pulgadas=0.0; // Lectura y asignación de las variables

cantidad_metros = leer(“Digite la longitud en metros: ”); // Calcula la cantidad equivalente en centímetros y lo asigna a la variable c cantidad_centimetros = cantidad_metros * 100 ;

// Calcula la cantidad equivalente en pulgadas y lo asigna a la variable p cantidad_pulgadas = cantidad_centimetros / 2.54 ;

// Muestra los valores de las variables c y p: imprimir (cantidad_metros + “, en centímetros, equivale a: “ + cantidad_centimetros ) ; imprimir (cantidad_metros + c, en pulgadas, equivale a: “ + cantidad_pulgadas ) ;

} }


31



real radio

radio = leer(“Digite el valor del radio: ” ) PI = 3.1415926535 area = PI * potencia(radio,2) imprimir (“El área del cículo de radio “+radio+” es “+area)

real area

algoritmo AreaCirculo {

principal () { // Declaración de variables real radio = 0.0; real area = 0.0; real PI = 3.1415926535; // Captura de datos radio = leer (“Digite el valor del radio: ”); //Cálculos area = PI * potencia(radio,2); // Salida de datos imprimir (“El área del cículo de radio “+radio+” es “+area);

} } 1.7 Estructura Condicionales

La estructura alternativa permite bifurcar el “flujo” del programa en función de una expresión lógica. Disponemos de tres estructuras alternativas diferentes: alternativa simple, alternativa doble y alternativa múltiple. 1.7.1 Estructura Condicional Simple Esta estructura permite evaluar una expresión lógica y en función de dicha evaluación ejecutar una acción (o composición de acciones) o no ejecutarla; también se la suele denominar si-entonces. A continuación se muestra la notación algorítmica para la estructura alternativa simple.

si (<expresión lógica>) entonces acciones si la expresión lógica es

verdadera fin_si


32

En seudocódigo la instrucción si–simple se presenta así: si( <condición> ) { // Bloque de instrucciones que se ejecuta si la condición es verdadera. } // Fin del bloque del si En el siguiente ejemplo, se calcula la longitud de una circunferencia si el radio es positivo:

si ( radio > 0 ) { longitud = 2 * 3.1416 * radio ;

}

Ejemplo: Dada la edad de una persona, imprimir un mensaje solo si ella cumple con la mayoría de edad



entero edad

edad=leer(“Digite la edad de la persona”) si edad >=18 cumple=“Cumple con la mayoría de edad”

imprimir (cumple)

cadena cumple

algoritmo MayoriaDeEdad {

principal () { entero edad=0; cadena cumple=“”; //Lectura de las variables edad=leer(“Digite la edad de la persona”); si (edad>=18){

cumple=“Cumple con la mayoría de edad”; }

imprimir(cumple) ;

} }

Condiciones

Lenguaje natural: La edad debe ser mayor o igual a 18 para poder votar Expresion lógica: edad >=18


33

1.7.2 Estructura Condicional Doble La estructura alternativa doble es similar a la anterior, con la salvedad de que en este tipo de estructura se indican acciones no sólo para la rama “verdadera” sino también para la “falsa”; es decir, en caso de que la expresión lógica evaluada sea cierta, se ejecuta una acción o grupo de acciones y, en el caso de que sea falsa, se ejecuta un grupo diferente de acciones. La sintáxis en la notación algorítmica es la que se muestra a continuación: si (<expresión lógica>) entonces acciones si la expresión lógica es verdadera si no acciones si la expresión lógica es falsa fin_si

En seudocódigo la instrucción si–entonces simple se presenta así: si( <condición> ) { // Bloque de instrucciones que se ejecuta si la condición es verdadera. } // Fin del bloque del si sino { // Bloque de instrucciones que se ejecuta si la condición es falsa. } // Fin del bloque del sino En el siguiente ejemplo se calcula la longitud de una circunferencia si el radio es positivo y, en caso contrario, se proporciona un mensaje de error:

si ( radio > 0 ) { longitud = 2 * 3.1416 * radio ;

} sino { //si radio <= 0

imprimir ( “Radio incorrecto” ) ; }


34

Ejemplo: Dada la edad de una persona, imprimir un mensaje indicando si es mayor de edad o no



entero edad

edad = leer (“Digite la edad de la persona”) si edad >=18 cumple=“Cumple con la mayoría de edad” sino cumple=“No Cumple con la mayoría de edad” imprimir (cumple)

cadena cumple

algoritmo MayoriaDeEdad {

principal () {

//Declaración de las variables entero edad=0; cadena cumple=“”; //Lectura de las variables edad = leer (“Digite la edad de la persona”); si (edad>=18){

cumple=Cumple con la mayoría de edad”; }sino{

cumple=“No Cumple con la mayoría de edad” ; } imprimir(cumple) ;

} }

Condiciones

Lenguaje natural: La edad debe ser mayor o igual a 18 para poder votar Expresion lógica: edad >=18


35

Ejemplo: Informar si un estudiante ha superado o no un determinado examen consistente en 20 preguntas de igual valor y calcular su nota en caso de aprobar.



entero num_correctas

num_correctas = leer (“Digite el numero de preguntas contestadas correctamente”) si num_correctas < 12 pasaExamen=“No ha superado Vd. el examen” sino nota = num_correctas * 0.25 pasaExamen= “aprobó Vd. con un ” + nota imprimir ( pasaExamen);

real nota cadena pasaExamen

algoritmo AprobarExamen1{

principal () { //Declaración de las variables entero num_correctas=0; real nota=0.0; cadena pasaExamen=“”; //Asignación y lectura de las variables num_correctas = leer (“Digite el numero de preguntas contestadas correctamente”); si (num_correctas<0 && num_correctas>20){

imprimir (“Error:el rango (posibles respuesta correctas)es de 0-20”); //valido la entrada de

} //datos si (num_correctas < 12) { pasaExamen=“No ha superado Vd. el examen”;

} sino { //si num_correctas >12

nota = num_correctas * 0.25; pasaExamen = “aprobó Vd. con un ” + nota; } imprimir (pasaExamen);

} }

Condiciones

Lenguaje natural: El numero de preguntas correctas debe ser menor a 12 para perder examen Expresion lógica: num_correctas < 12


36

Ejemplo: Supongamos que tenemos un algoritmo para averiguar si un número es impar o par, que puede ser descrito narrativamente de la siguiente forma: “Si el residuo de la división entera del número entre dos ( 2 ) es igual a cero, entonces el número es par. En caso contrario; es decir, si el residuo es uno ( 1 ), entonces el número digitado es impar. Existe un operador que permite determinar de manera directa el residuo ( o resto ) de la división de dos números. Definición: El residuo ( ó resto ) de la división de dos números a y b se denota como “a % b”, se lee “a módulo b” y nos arroja el residuo de la división de a y b. Ejemplo: 83 % 5 = 4, pues el cociente es 20 y el residuo es 3, que es la respuesta. Este algoritmo escrito en pseudocódigo queda así:



entero n

n=leer(“Digite un número entero”)

si n % 2 == 0 tipo = n + “ es par” sino tipo = n + “es impar” imprimir (tipo);

CADENA tipo

algoritmo ImparPar1{

principal () { //Declarcion de la variable

entero n=0 ; cadena tipo=“”; //Lectura de la variable n=leer(“Digite un número entero”); //Procesos de Calculos si( n % 2 == 0 ) {

tipo= n + “ es par”; } sino{

tipo=n + “ es impar”; } imprimir (tipo);

} }

Condiciones

Expresion lógica: num_correctas < 12


37

1.7.3 Estructura Condicional Multiple Esta estructura evalúa una expresión que puede tomar n valores (enteros o caracteres, pero nunca reales ni cadenas) y ejecuta una acción o grupo de acciones diferente en función del valor tomado por la expresión selectora. La sintáxis en la notación algorítmica es la que se muestra a continuación:

segun expresión caso valor1:

acción 1 break;

caso valor2: acción 2 break;

... caso valorN:

acción n break;

default: acción

fin según En seudocódigo orientado a Java, la instrucción según–casos se presenta así: segun( <expresión entera o caracter> ) { caso valor1: // Bloque de instrucciones que se ejecuta si la expresión // toma el valor valor1 break ; caso valor2: // Bloque de instrucciones que se ejecuta si la expresión // toma el valor valor2 break; // . . . . . . caso valorN: // Bloque de instrucciones que se ejecuta si la expresión // toma el valor valorN break; default : // Bloque de instrucciones que se ejecuta si la expresión // NO toma ninguno de los valores arriba indicados break; // Aquí está de sobra… } // Llave de fin de la estructura de decisión múltiple


38

Notas: 1.- El otro caso o caso por defecto es opcional. Si no se implementa, entonces la estructura no será ejecutada en aquel caso en el que la expresión nunca tome alguno de los valores especificados en los casos.

2.- La instrucción break ; también es opcional. Si no se usa alguna de las instrucciones break; entonces la ejecución continúa hasta encontrar la siguiente instrucción break ; o la llave del fin de la estructura de decisión.

En el siguiente ejemplo se proporciona como salida el número de días de un mes dado:

segun ( mes ) { // Abre según caso caso 1: caso 3: caso 5: caso 7: caso 8: caso 10: caso 12:

imprimir ( “31” ) ; break;

caso 4: caso 6: caso 9: caso 11: imprimir ( “30” ) ; break;

caso 2: imprimir ( “28” ) ; break;

default: imprimir ( “Mes incorrecto” ) ; break; // Aquí está de sobra…

} // Termina la ejecución de la estructura de selección múltiple

Nota: Observar que es posible agrupar varios casos que conduzcan a la ejecución de un bloque común a ellos. 1.5.4. Estructura condicional – SI anidados si ( <condición 1> ) { // Bloque de instrucciones que se ejecuta si la condición 1 es verdadera. } // Fin del bloque del si para la condición 1 sino{

si( <condición 2> ) { // Bloque de instrucciones que se ejecuta si la condición 2 es verdadera.

} // Fin del bloque del si para la condición 2 // . . .

sino { si( <condición N> ) { // Bloque de instrucciones que se ejecuta si la condición N es verdadera. } // Fin del bloque del si para la condición N sino {

// Bloque por defecto: instrucciones que se ejecutan si ninguna condición // anterior es verdadera } // Fin del bloque por defecto

} // Fin del bloque del sino } // Llave de fin de la estructura si anidada


39

Nota: El último sino ( Bloque por defecto ) es opcional. Si no se implementa, entonces la estructura no será ejecutada en aquel caso en el que todas las condiciones sean falsas. Ejemplo: Algoritmo para la ecuación cuadrática del tipo aX2 + bX + C = 0 ( a diferente de cero ).



real a, b, c

solución=“” a = leer (“¿Cuánto vale A?”) b = leer (“¿Cuánto vale B?”) c = leer (“¿Cuánto vale C?”) discr = ( b * b – 4 * a * c ) si discr == 0 s1 = -b / (2 * a) solucion = “Existen dos soluciones iguales, cuyo valor es: “ + s1 sino si discr > 0 s1 = ( -b + raiz(discr) ) / (2 * a) s2 = ( -b - raiz(discr) ) / ( 2 * a) solucion = “Las soluciones son: ”+ s1 + “ y “+ s2 sino solucion = “No hay soluciones en el conjunto de los números reales.”

imprimir (solucion)

real discr, s1, s2 cadena solucion

algoritmo EcuacionCuadrática{

principal () { //Declarcion de las variables

real a=0, b=0, c=0 ;// Declaración de tres variables del tipo número real ( los 3 coeficientes ).

real discr=0; // Declaración de la variable para el discriminante de la ecuación. real s1=0, s2=0; // Declaración de dos variables para las soluciones ( ó raíces ) de la

ecuación. cadena solución=“”; imprimir(“Deme los coeficientes y resolveré una ecuación de 2º grado” );

Condiciones

Expresiones lógicas: discr == 0 discr > 0


40

// Lectura y Asignación de las variables:

a=leer(“¿Cuánto vale A?”); b=leer (“¿Cuánto vale B?”); c=leer (“¿Cuánto vale C?”); // Cálculo del discriminante de la ecuación cuadrática: discr = ( b * b – 4 * a * c ) ; // en discr asigne el valor de la expresión entre paréntesis. si( discr == 0 ){ // ‘ == ‘ significa ‘ igual a ‘

s1 = -b / (2 * a) ; // En s1 asigne el valor de la expresión del segundo miembro solución = “Existen dos soluciones iguales, cuyo valor es: “ + s1;

} sino{

si( discr > 0 ) { s1 = ( -b + raiz(discr) ) / (2 * a) ; // En s1 asigne el valor de la expresión del

segundo //miembro

s2 = ( -b - raiz(discr) ) / ( 2 * a) ; // En s2 asigne el valor de la expresión del segundo //miembro

solución = “Las soluciones son: ” + s1 + “ y “ + s2;

}sino { solución = “No hay soluciones en el conjunto de los números reales.” ;

} }

imprimir(solucion);

} } 1.8 Estructuras de Repetición La estructura repetitiva o iterativa permite, como su propio nombre lo indica, repetir una acción (o grupo de acciones); dicha repetición puede llevarse a cabo un número prefijado de veces o depender de la evaluación de una expresión lógica. Existen tres tipos de estructuras repetitivas: para(ó desde-hasta), mientras y haga-mientras. 1.8.1 Estructura de Repetición para (ó desde-hasta) Esta estructura permite repetir la ejecución de una acción o de un grupo de acciones un número determinado de veces; la sintáxis es la siguiente:


41

A continuación se muestran algunos ejemplos:

para (entero n=1; n < =10; n++){ imprimir (“n = ”+n ); } // Fin del para

El ciclo anterior imprime por pantalla los números del 1 al 10. Ahora, preste atención al siguiente Pseudocódigo:

para (entero n=10; n < =0; n++){ imprimir (“n =”+n);

} //Fin del para

El bucle anterior no se ejecuta nunca puesto que, de entrada, la condición n <= 0 (con n inicializado en 10) va a ser falsa, es decir arroja false. ¿Qué ocurriría si, en el ciclo anterior, se cambia de < por > ?

para (entero n=10; n >=0; n++){

imprimir (“n =”+n); } //Fin del para

El bucle anterior es infinito puesto que la condición n >= 0 (con n inicializado en 10) siempre va a ser verdadera, es decir me arroja true. Si queremos hacer el ejemplo de n <= 0 (con n inicializado en 10), pero con paso – 2, el Pseudocódigo se puede escribir así:

para (n=10; n < =0 ; n = n - 2){ imprimir (“n =”+ n);

} //Fin del para Este bucle escribe los números pares de 10 a 0 en orden inverso. Ejemplo: Escriba un algoritmo que sume los “N” primeros números enteros.



REAL n

suma=0 n = leer(“Ingrese n”) para entero contador = 1; contador <= n;contador++ suma += contador

imprimir(“La suma es: ” + suma);

REAL suma


42

algoritmo Suma {

principal () {

entero suma=0, n=0; n = leer(“Ingrese n”); para (entero contador = 1; contador <= n ; contador++){

suma += contador; } imprimir(“La suma es: ” + suma);

}

} Ejemplo: Escriba un algoritmo que calcule el promedio del curso de informática 1, sabiendo que se tienen “N” estudiantes. Datos de Entrada

(con tipos) Proceso Información

(con tipos) REAL N, nota

acumula=0 n=leer(“Ingrese n”) para entero contador = 1; contador <= n ;contador++ nota = leer(“Ingrese nota: “ + contador + “ : “) acumula += nota promedio = acumula/n imprimir (“Promedio es: ” + promedio)

REAL promedio, acumula

algoritmo Promedio {

principal () { entera n=0;

Condiciones

Expresion lógica: contador <= n

Condiciones

Expresion lógica: contador <= n


43

real nota=0.0, promedio=0.0, acumula=0; n=leer(“Ingrese n); para (entero contador = 1; contador <= n ; contador++){

nota = leer(“Ingrese nota: “ + contador + “ : “); acumula += nota;

} promedio = acumula/n;

imprimir(“Promedio es: ” + promedio); }

} 1.8.2 Estructura de Repetición mientras Cuando usamos la estructura mientras:

• Cuando sea necesario ejecutar los mismos pasos varias veces y se conoce el número de veces que desea repetirse.

• Cuando sea necesario ejecutar los mismos pasos varias veces y NO se conoce el número de veces que desea repetirse.

• Si la condición es cierta el cuerpo del ciclo se ejecuta, sino la ejecución del ciclo termina.

• Si la condición es inicialmente falsa el ciclo no se ejecuta ni una sola vez.

Sintaxis General: mientras ( <expresión lógica> )

acción FIN mientras


44

A continuación se muestra un ejemplo que solicita al usuario el radio de una circunferencia mientras el radio introducido sea incorrecto:

mientras (radio<=0) { //se ejecuta mientras el radio sea mayor que 0 radio = leer(Ingrese el radio);

imprimir ( “Radio :” +radio); } //Fin del mientras

Notar que mientras radio < = 0 el ciclo se ejecuta. Ejemplo: Escriba un algoritmo que lea e imprima todos los nombre de un grupo de estudiantes: Datos de Entrada


(con tipos) cadena nombre caracter seguir

seguir = ‘S’ nombres=“” mientras (seguir == ‘S’) nombre=leer(“Ingrese Nombre”) nombres+=nombre seguir=leer(“Desea continuar”)

cadena nombres

algoritmo Nombres {

principal () { caracter seguir=‘S’; cadena nombre=“”, nombres=“”;

mientras (seguir == ‘S’){ nombre = leer(“Ingrese Nombre”); nombres+=nombre; continuar = leer(“Desea continuar”); } imprimir(nombres);

} }

Condiciones

seguir == ‘S’


45

Ejemplo: Escriba un algoritmo que calcule el promedio del curso de informática I. Datos de Entrada


(con tipos) real nota caracter seguir

seguir = ‘S’ cuenta=0 acumlua=0 mientras (seguir== “S) cuenta++ nota=leer(“Ingrese nota: “ + cuenta + “ : ”) acumula += nota nota=leer(“Desea Continuar”) promedio = acumula/cuenta; imprimir(“Promedio es: ” + promedio);

ENTERA cuenta REAL promedio, acumula

algoritmo Promedio {

principal () { entero cuenta=0; real nota, promedio, acumula; caracter seguir = ‘S’; seguir = leer(“Desea Continuar”); mientras (seguir== ‘S’){ cuenta++; nota=leer(“Ingrese nota: “ + cuenta + “ : “); acumula += nota; seguir=leer(“Desea Continuar”); } promedio = acumula/cuenta; imprimir(“Promedio es: ” + promedio);

} } 1.8.3 Estructura de Repetición haga-mientras

• Cuando sea necesario ejecutar los mismos pasos varias veces y se conoce el número de veces que desea repetirse.

Condiciones

seguir == ‘S’


46

• Cuando sea necesario ejecutar los mismos pasos varias veces y NO se conoce el número de veces que desea repetirse.

• Si la condición es cierta el cuerpo del ciclo se ejecuta, sino la ejecución del ciclo termina. • Si la condición es inicialmente falsa el ciclo no se ejecuta ni una sola vez. • Primero ejecuta y luego evalúa la condición de finalización • Usada para validaciones


47

1.9 EJERCICIOS RESUELTOS NOTA: se realizara la abstracción SIN APLICAR validaciones con el ciclo haga mientras a todos los ejercicios resueltos, pero UNICAMENTE al primer ejercicio se realizara la abstracción con dicha validacion. Ademas en la parte de pseudocogo si se incluye para TODOS los ejercicios las validaciones con el ciclo haga mientras.

Ejercicio 1:- Diseñe un pseudocódigo que halle el área y el perímetro de un rectángulo. Considere que: area = base x altura, y, perimetro = 2 x (base+altura). Sin validación con el ciclo haga mientras:



real base, altura

base=leer (“Digite la medida de la base del rectangulo”) altura=leer(“Digite la medida de la altura del rectangulo”) area = base*altura perímetro = 2*(base+altura) imprimir (“Area :” +area) imprimir (“Perimetro:” +perimetro)

real area, perimetro

Con validación con el ciclo haga mientras:



real base, altura

haga base=imprimir (“Digite la medida de la base del rectangulo”) mientras(base<0) haga altura=imprimir ( “Digite la medida de la altura del rectangulo”) mientras(altura<0) area = base*altura perímetro = 2*(base+altura) imprimir (“Area :” +area) imprimir (“Perimetro:” +perimetro)

real area, perimetro


48

algoritmo Rectangulo {

principal () { // Declaración de variables real base=0.0, altura=0.0, area=0.0perímetro=0.0; // Asignación o Lectura de Datos haga{ base=leer (“Digite la medida de la base del rectangulo”); } mientras(base<0); //Se valida el ingreso de datos para la base haga{ altura=leer(“Digite la medida de la altura del rectangulo”); } mientras(altura<0); //Se valida el ingreso de datos para la altura // Proceso de cálculo area = base*altura; perímetro = 2*(base+altura); // Salida de resultados imprimir (“Area :” +area); imprimir (“Perimetro:” +perimetro);

}

} Ejercicio 2:- Diseñe un pseudocódigo para convertir una longitud dada en metros a sus equivalentes en centímetros, pies, pulgadas y yardas. Considere que: 1 metro = 100 centímetros, 1 pulgada = 2.54 centimetros, 1 pie = 12 pulgadas, 1 yarda = 3 pies.

Condiciones

altura<0 base<0


49



real cmetr

cmetr =leer(“Digite longitud en metros”) ccent = cmetr * 100 cpulg = ccent / 2.54 cpies = cpulg / 12 cyard = cpies / 3 imprimir ( "Cantidad equivalente en centimetros: " + ccent + " cm" ) imprimir ( "Cantidad equivalente en pulgadas: " + cpulg + " pulgadas" ) imprimir ( "Cantidad equivalente en pies: " + cpies + " pies" ) imprimir ( "Cantidad equivalente en yardas: " + cyard + " yardas" )

real ccent, cpulg, cpies, cyard

algoritmo Conversiones1{ principal () {

// Declaración de variables real cmetr=0.0,ccent=0.0, cpies=0.0, cpulg=0.0, cyard=0.0; // Asignación y lectura de variables haga{ cmetr =leer(“Digite longitud en metros”); } mientras(cmetr<0); //Se valida el ingreso de datos para la cmetr // Proceso de cálculo ccent = cmetr * 100; cpulg = ccent / 2.54; cpies = cpulg / 12; cyard = cpies / 3; // Salida de resultados imprimir ( "Cantidad equivalente en centimetros: " + ccent + " cm" ) ; imprimir ( "Cantidad equivalente en pulgadas: " + cpulg + " pulgadas" ) ; imprimir ( "Cantidad equivalente en pies: " + cpies + " pies" ) ; imprimir ( "Cantidad equivalente en yardas: " + cyard + " yardas" ) ;

} }

Condiciones

cmetr<0


50

Ejercicio 3:- Una institución benéfica europea ha recibido tres donaciones en soles, dolares y marcos. La donación será repartida en tres rubros: 70% para la implementación de un centro de salud, 20% para un comedor de niños y el resto para gastos administrativos. Diseñe un algoritmo que determine el monto en euros que le corresponde a cada rubro. Considere que, en la fecha de redactar este ejercicio: 1 dólar = 3.52 soles, 1 dólar = 2.08 marcos, 1 dólar = 1.07 euros. Datos de Entrada


(con tipos) real csoles, cdolares, cmarcos

csoles =leer(“Digite cantidad donada en soles”) cdolares =leer(“Digite cantidad donada en dolares”) cmarcos =leer(“ Digite cantidad donada en marcos”) ceuros = (csoles / 3.52 + cdolares + cmarcos / 2.08 ) * 1.07 rubro1 = ceuros * 0.70 rubro2 = ceuros * 0.20 rubro3 = ceuros * 0.10 imprimir ("Rubro 1 para salud: $ " + rubro1 + " euros") imprimir ("Rubro 2 para comedor: $ " + rubro2 + " euros") imprimir ("Rubro 3 para gastos de admon: $ " + rubro3 + " euros")

real ceuros ,rubro1, rubro2, rubro3

algoritmo Euros1{

principal () { // Declaración de variables real csoles=0.0, cdolares=0.0, cmarcos=0.0, ceuros=0.0, rubro1=0.0, rubro2=0.0;

real rubro3=0.0; //Asignacion y lectura de las variables haga{ csoles =leer(“Digite cantidad donada en soles”); } mientras(csoles<0); //Se valida el ingreso de datos para la csoles haga{ cdolares =leer(“Digite cantidad donada en dolares”); } mientras(cdolares<0); //Se valida el ingreso de datos para la cdolares haga{

Condiciones

csoles<0 cdolares<0 cmarcos<0


51

cmarcos = leer(“Digite cantidad donada en marcos”); } mientras(cmarcos<0); //Se valida el ingreso de datos para la cmarcos // Proceso de cálculo ceuros = (csoles / 3.52 + cdolares + cmarcos / 2.08 ) * 1.07; rubro1 = ceuros * 0.70; rubro2 = ceuros * 0.20; rubro3 = ceuros * 0.10; // Salida de resultados imprimir ("Rubro 1 para salud: $ " + rubro1 + " euros"); imprimir ("Rubro 2 para comedor: $ " + rubro2 + " euros"); imprimir ("Rubro 3 para gastos de admon: $ " + rubro3 + " euros");

} } Ejercicio 4:- En una competencia atlética de velocidad el tiempo se mide en minutos, segundos y centésimas de segundo y, el espacio recorrido se mide en metros. Diseñe un algoritmo para determinar la velocidad promedio de un atleta en km/hr. Considere que: 1 hora = 60 minutos, 1 minuto = 60 segundos, 1 segundo = 100 centésimas de segundo, 1 kilómetro = 1000 metros.



entero tmin, tseg, tcen

tmin = leer (“Tiempo en minutos”) tseg = leer (“Tiempo en segundos”) tcen =leer(“Tiempo en centésimas de segundos”) espmt = leer(“Espacio Recorrido en metros”) thor = tmin / 60 + tseg / 3600 + (tcen / 100) / 3600 espkm = espmt / 1000 velkmhr = espkm / thor imprimir ("Velocidad del atleta: " + velkmhr + " Km / Hr.")

real thor , espkm, velkmhr

Condiciones

tmin <0 tseg <0 tcen <0 espmt<0


52

algoritmo VelocidadAtleta1{ principal () {

// Declaración de variables entero tmin=0, tseg=0, tcen=0; real thor=0.0, velkmhr=0.0, espmt=0.0, espkm=0.0; // Asignación y lectura de las variables haga{ tmin = leer (“Tiempo en minutos”); } mientras(tmin<0); //Se valida el ingreso de datos para la tmin haga{ Tseg=leer (“Tiempo en segundos”); } mientras(tseg<0); //Se valida el ingreso de datos para la tseg haga{ tcen =leer(“Tiempo en centésimas de segundos”); }mientras(tcen<0); //Se valida el ingreso de datos para la tcen

haga{ espmt =leer(“Espacio Recorrido en metros”);

} mientras(espmt<0); //Se valida el ingreso de datos para la espmt // Proceso de Calculos // Cálculo del tiempo total empleado en horas thor = tmin / 60 + tseg / 3600 + (tcen / 100) / 3600;// Aquí sobran los paréntesis. Se dejan // por claridad. // Cálculo del espacio recorrido en kilómetros espkm = espmt / 1000; // Cálculo de la velocidad en km/hr velkmhr = espkm / thor; // Salida de resultados imprimir ( "Velocidad del atleta: " + velkmhr + " Km / Hr." ) ;

} } Ejercicio 5:- Diseñe un algoritmo que determine la cifra de las unidades de un número natural. Solución 1 Análisis Puede comprobarse que la cifra de las unidades de un número es igual al resto de la división del número entre 10. Observe para ello las siguientes divisiones:

3245 | 10 768 | 10 9 | 10 5 324 8 76 9 0


53

Podemos concluir entonces que: unidades = numero % 10 Siendo % el operador residuo. Este operador permite obtener el residuo de una división, así como / permite obtener el cociente.

Datos de Entrada


(con tipos) entero

numero numero = leer (“Digite numero”) unidades = numero % 10 imprimir ( numero+” tiene "+unidades+“ como cifra de las unidades." )

real unidades

algoritmo UnidadesNumero1{

principal () { // Declaración de variables entero numero=0, unidades=0; // Asignación y lectura de las variables haga{ numero = leer(“Digite numero”); } mientras(numero<0); //Se valida el ingreso de datos para la numero // Proceso de cálculo unidades = numero % 10; // Salida de resultados imprimir ( numero+" tiene "+ unidades +" como cifra de las unidades." ) ;

} } Solución 2 Análisis El residuo de una división entera puede obtenerse también sin recurrir al operador % , de la siguiente forma: unidades = numero - (numero / 10) * 10 observe para esto que en la división (numero/10) los operandos son enteros por lo que el cociente será un entero. Así por ejemplo, si numero es igual a 3245, la división (numero/10) produce 324, aunque matemáticamente sea 324.5; es decir, se descarta la parte decimal.

Condiciones

numero <0


54



entero numero

numero=leer(“Digite numero”) unidades = numero - (numero / 10) * 10 imprimir ( numero + " tiene " + unidades + " como cifra de las unidades." )

real unidades

algoritmo UnidadesNumero2{

principal () { // Declaración de variables entero numero=0, unidades=0; // Asignación y lectura de las variables haga{ numero=leer(“Digite numero”); }mientras(numero<0); //Se valida el ingreso de datos para la numero // Proceso de cálculo unidades = numero - (numero / 10) * 10; // Salida de resultados imprimir ( numero + " tiene " + unidades +" como cifra de las unidades." ) ;

} } Ejercicio 6:- Diseñe un algoritmo que determine la suma de las cifras de un número entero positivo de 4 cifras. Solución 1 Análisis Las cifras pueden ser obtenidas mediante divisiones sucesivas entre 10. Para el efecto, considere el caso de un número N igual a 3245: unidades = N % 10 3245 | 10 cociente = N / 10 5 324 decenas = cociente % 10 324 | 10 cociente = cociente / 10 4 32 centenas = cociente % 10 32 | 10 millares = cociente / 10 2 3

Condiciones

numero <0


55



entero N

N=leer(“Digite numero. Debe ser de 4 cifras”) unidades = N % 10 cociente = N / 10 decenas = cociente % 10 cociente = cociente / 10 centenas = cociente % 10 millares = cociente/10 suma = unidades + decenas + centenas + millares imprimir ( "Suma de las cifras del numero: " + suma)

real suma, millares, centenas, decenas, unidades, cociente

algoritmo SumaCifrasNum1{

principal () { // Declaración de variables entero N=0, suma=0, millares=0, centenas=0, decenas=0, unidades=0, cociente=0; // Asignación y lectura de las variables haga{ N=leer(“Digite numero. Debe ser de 4 cifras”); } mientras(N <0); //Se valida el ingreso de datos para la N // Proceso de cálculo unidades = N % 10; cociente = N / 10; decenas = cociente % 10; cociente = cociente / 10; centenas = cociente % 10; millares = cociente/10; suma = unidades + decenas + centenas + millares; // Salida de resultados imprimir ( "Suma de las cifras del numero: " + suma ) ;

} }

Condiciones

N <0


56

Solución 2 Análisis 2 Considerando que el número tiene 4 cifras, las cifras también pueden ser obtenidas mediante divisiones sucesivas entre 1000, 100 y 10. Para el efecto, considere el caso de un número N igual a 3245: millares = N / 1000 resto = N % 1000 centenas = resto / 100 resto = resto % 100 decenas = resto / 10 unidades = resto % 10 Datos de Entrada


(con tipos) entero

N N=leer (“Digite numero. Debe ser de 4 cifras”) millares = N / 1000 resto = N % 1000 centenas = resto / 100 resto = resto % 100 decenas = resto / 10 unidades = resto % 10 suma = unidades + decenas + centenas + millares imprimir ( "Suma de las cifras del numero: " + suma )

real suma, millares, centenas, decenas, unidades, resto

algoritmo SumaCifrasNum2{

principal () {

// Declaración de variables entero N=0, suma=0, millares=0, centenas=0, decenas=0, unidades=0, resto=0; // Asignación y lectura de las variables: haga{ N=leer(“Digite numero. Debe ser de 4 cifras”);

} mientras(N <0); //Se valida el ingreso de datos para la N // Proceso de cálculo millares = N / 1000; resto = N % 1000; centenas = resto / 100; resto = resto % 100; decenas = resto / 10; unidades = resto % 10;

Condiciones

N <0

3245 | 1000

245 3

245 | 100

45 2 45 | 10

5 4


57

suma = unidades + decenas + centenas + millares; // Salida de resultados imprimir ( "Suma de las cifras del numero: " + suma ) ;

} } Ejercicio 7:- Diseñe un algoritmo que lea la hora actual del día HH:MM:SS y determine cuántas horas, minutos y segundos restan para culminar el día. Datos de Entrada


(con tipos) entero

hor1, min1, seg1 hor1 = leer (“Hora actual”) min1=leer(“Minuto actual”) seg1=leer (“Segundo actual”) segres = 86400 - (hor1 * 3600 + min1 * 60 + seg1); hor2 = segres / 3600; resto = segres % 3600; min2 = resto / 60; seg2 = resto % 60; imprimir ( "Para terminar el dia, hacen falta: " + hor2 + " horas, " + min2 + " minutos y " + seg2 + " segundos." )

real hor2,min2, seg2, segres, resto

algoritmo HmsQueFaltan1{

principal () {

// Declaración de variables entero hor1=0, min1=0, seg1=0, hor2=0, min2=0, seg2=0, segres=0, resto=0; // Asignación y lectura de las variables haga{ hor1 = leer(“Hora actual”); } mientras(hor1 <0); //Se valida el ingreso de datos para la hor1 haga{ min1=leer(“Minuto actual”); } mientras(min1 <0); //Se valida el ingreso de datos para la min1

Condiciones

hor1 <0 min1<0 seg1<0


58

haga{ seg1=leer (“Segundo actual”); } mientras(seg1 <0); //Se valida el ingreso de datos para la seg1 // Proceso de cálculo // Cálculo de la cantidad de segundos que restan para culminar el día segres = 86400 - (hor1 * 3600 + min1 * 60 + seg1); // Descomposición de segres en horas, minutos y segundos hor2 = segres / 3600; resto = segres % 3600; min2 = resto / 60; seg2 = resto % 60; // Salida de resultados imprimir ( "Para terminar el dia, hacen falta: " + hor2 + " horas, " + min2 + " minutos y " + seg2 + " segundos." ) ;

} } Ejercicio 8:- Diseñe un algoritmo para sumar dos tiempos dados en horas, minutos y segundos. Datos de Entrada


(con tipos) entero

hor1, min1, seg1 hor1=leer(“Digite Hora 1”) min1=leer(“Digite Minuto 1”) seg1=leer(“Digite Segundo 1”) hor2=leer(“Digite Hora 2”) min2=leer(“Digite Minuto 2”) seg2=leer(“Digite Segundo 2”) totseg = (hor1 + hor2) * 3600 + (min1 + min2) * 60 + (seg1 + seg2) hor3 = totseg / 3600 resto = totseg % 3600 min3 = resto / 60 seg3 = resto % 60 imprimir ( "La suma de los dos tiempos da: " + hor3 + " horas, " + min3 + " minutos y " + seg3 + "segundos." )

real hor2,min2, seg2, hor3,min3, seg3, totseg, resto


59

algoritmo HmsQueFaltan2{

principal () { // Declaración de variables entero hor1=0, min1=0, seg1=0, hor2=0, min2=0, seg2=0, hor3=0, min3=0, seg3=0, totseg=0, resto=0; // Asignación y lectura de las variables haga{ hor1=leer(“Digite Hora 1”); } mientras(hor1 <0); //Se valida el ingreso de datos para la hor1 haga{ min1=leer(“Digite Minuto 1”); } mientras(min1 <0); //Se valida el ingreso de datos para la min1 haga{ seg1=leer(“Digite Segundo 1”); } mientras(seg1 <0); //Se valida el ingreso de datos para la seg1 haga{ hor2=leer (“Digite Hora 2”); } mientras(hor2 <0); //Se valida el ingreso de datos para la hor2 haga{ min2=leer(“Digite Minuto 2”); } mientras(min2 <0); //Se valida el ingreso de datos para la min2 haga{ seg2=leer(“Digite Segundo 2”); } mientras(seg2); //Se valida el ingreso de datos para la seg2 //Proceso de Cálculos // Determina la cantidad total de segundos entre los dos tiempos totseg = (hor1 + hor2) * 3600 + (min1 + min2) * 60 + (seg1 + seg2); // Descompone totseg en horas, minutos y segundos hor3 = totseg / 3600; resto = totseg % 3600; min3 = resto / 60;

Condiciones

hor1 <0 min1<0 seg1<0 hor2 <0 min2<0 seg2<0


60

seg3 = resto % 60; // Salida de resultados imprimir ( "La suma de los dos tiempos da: " + hor3 + " horas, " + min3 + " minutos y " + seg3 + " segundos." ) ;

} } Ejercicio 9:- El sueldo neto de un vendedor se calcula como la suma de un sueldo básico de $2’500.000.oo más el 12% del monto total vendido. Diseñe un algoritmo que determine el sueldo neto de un vendedor sabiendo que hizo tres ventas en el mes. Datos de Entrada


(con tipos) entero venta1, venta2, venta3

venta1=leer(“Digite la primera venta”) venta2=leer(“Digite la segunda venta”) venta3=leer(“Digite la tercer venta”) ventatot = venta1 + venta2 + venta3 comision = ventatot * 12 / 100 sueldoneto = 2500000 + comisión imprimir ( "Sueldo neto: $ " + sueldoneto )

real ventatot, comision, sueldoneto

algoritmo SueldoNeto1{

principal () {

// Declaración de variables real venta1=0.0, venta2=0.0, venta3=0.0, ventatot=0.0, comision=0.0, sueldoneto=0.0; //Asignación y lectura de las variables haga{ venta1=leer(“Digite la primera venta”); } mientras(venta1 <0); //Se valida el ingreso de datos para la venta1 haga{ venta2=leer(“Digite la segunda venta”); } mientras(venta2 <0); //Se valida el ingreso de datos para la venta2 haga{ venta3=leer(“Digite la tercer venta”); } mientras(venta3 <0); //Se valida el ingreso de datos para la venta3

Condiciones

venta1<0 venta2<0 venta3<0


61

// Proceso de cálculo ventatot = venta1 + venta2 + venta3; comision = ventatot * 12 / 100; sueldoneto = 2500000 + comision; // Salida de resultados imprimir ( "Sueldo neto: $ " + sueldoneto ) ;

}

} Ejercicio 10:- Diseñe un algoritmo que determine el porcentaje de varones y de mujeres que hay en un salón de clases. Datos de Entrada


(con tipos) entero

varones, mujeres varones=leer(“Digite cantidad de varones en el salón”) mujeres=leer(“Digite cantidad de mujeres en el salón”) total = varones + mujeres porcvar = varones * 100.0 / total porcmuj = mujeres * 100.0 / total imprimir ( "Porcentaje de mujeres: " + porcmuj + " %" ) imprimir ( "Porcentaje de hombres: " + porcvar + " %" )

real porcvar, porcmuj entero total

algoritmo SueldoNeto1{

principal () { // Declaración de variables real porcvar=0.0, porcmuj=0.0; entero varones=0, mujeres=0, total=0; // Asignación y lectura de las variables haga{ varones=leer(“Digite cantidad de varones en el salón”); } mientras(varones <0); //Se valida el ingreso de datos para la varones haga{ mujeres=leer(“Digite cantidad de mujeres en el salón”); } mientras(mujeres <0); //Se valida el ingreso de datos para la mujeres // Proceso de cálculo total = varones + mujeres; porcvar = varones * 100.0 / total;

Condiciones

varones <0 mujeres <0


62

porcmuj = mujeres * 100.0 / total; // Salida de resultados imprimir ( "Porcentaje de mujeres: " + porcmuj + " %" ) ; imprimir ( "Porcentaje de hombres: " + porcvar + " %" ) ;

} } Ejercicio 11:- En países de habla inglesa es común dar la estatura de una persona como la suma de una cantidad entera de pies más una cantidad entera de pulgadas. Así, la estatura de una persona podría ser 3' 2" ( 3 pies 2 pulgadas ). Diseñe un algoritmo que determine la estatura de una persona en metros, conociendo su estatura en el formato inglés. Considere que: 1 pie = 12 plg, 1 plg = 2.54 cm, 1 m = 100 cm. Datos de Entrada


(con tipos) entero

cpies, cplgs cpies=leer(“De la estatura, digite la cantidad de pies”) cplgs=leer(“De la estatura, digite la cantidad de pulgadas”) estmt = (cpies * 12 + cplgs) * 2.54 / 100 imprimir ( "En metros, su estatura es: " + estmt + " mts.")

real estmt

algoritmo EstaturaMts1{

principal () { // Declaración de variables real estmt=0.0; entero cpies=0, cplgs=0; // Asignación y lectura de las variables haga{ cpies=leer(“De la estatura, digite la cantidad de pies”); } mientras(cpies <0); //Se valida el ingreso de datos para la cpies haga{ cplgs=leer(“De la estatura, digite la cantidad de pulgadas”); } mientras(cplgs <0); //Se valida el ingreso de datos para la cplgs

// Proceso de cálculo

estmt = (cpies * 12 + cplgs) * 2.54 / 100;

Condiciones

cpies <0 cplgs <0 estmt<0


63

// Salida de resultados

imprimir ( "En metros, su estatura es: " + estmt + " mts." ) ; }

} Ejercicio 12:- Diseñe un algoritmo que exprese la capacidad de un disco duro en megabytes, kilobytes y bytes, conociendo la capacidad del disco en gigabytes. Considere que: 1 kilobyte = 1024 bytes, 1 megabyte = 1024 kilobyte, 1 gigabyte = 1024 megabytes. Datos de Entrada


(con tipos) entero cgigabyte

cgigabyte=leer(“De la capacidad del disco en GigaBytes”)

cmegabyte = cgigabyte * 1024 ckilobyte = cmegabyte * 1024 cbyte = ckilobyte * 1024 imprimir ( "La capacidad del Disco Duro es: " + cmegabyte + " Megabytes,\n" + ckilobyte + " Kilobytes y\n" + cbyte + " Bytes." )

real cmegabyte, ckilobyte, cbyte

algoritmo CapacidadDisco1{

principal () { // Declaración de variables real cgigabyte=0.0, cmegabyte=0.0, ckilobyte=0.0, cbyte=0.0; // Asignación y lectura de las variables haga{ cgigabyte =leer(“De la capacidad del disco en GigaBytes”);

} mientras(cgigabyte <0); //Se valida el ingreso de datos para la cgigabyte // Proceso de cálculo cmegabyte = cgigabyte * 1024; ckilobyte = cmegabyte * 1024; cbyte = ckilobyte * 1024; // Salida de resultados imprimir ( "La capacidad del Disco Duro es: " + cmegabyte + " Megabytes,\n" + ckilobyte + " Kilobytes y\n" + cbyte + " Bytes." ) ;

} }

Condiciones

cgigabyte <0


64

Ejercicio 13:- Diseñe un algoritmo que intercambie las cifras de las unidades de dos números naturales. Datos de Entrada


(con tipos) entero numero1, numero2

numero1=leer(“Digite el primer número”) numero2=leer(“Digite el segundo número”) unidades1 = numero1 % 10 unidades2 = numero2 % 10 numero1 = numero1 - unidades1 + unidades2 numero2 = numero2 - unidades2 + unidades1 imprimir ( "Despues de intercambiar la cifra de las ”+ “unidades, \n" + "los numeros quedan asi:\nPrimer numero: " + numero1 + “\nSegundo numero: " + numero2 )

real unidades1, unidades2

algoritmo IntercambiarUnidades1{ principal () {

// Declaración de variables entero numero1=0, numero2=0, unidades1=0, unidades2=0; // Asignación y lectura de las variables haga{ numero1=leer(“Digite el primer número”); } mientras(numero1 <0); //Se valida el ingreso de datos para la numero1 haga{ numero2=leer(“Digite el segundo número”); } mientras(numero2 <0); //Se valida el ingreso de datos para la numero2 // Determina las cifras de las unidades unidades1 = numero1 % 10; unidades2 = numero2 % 10; // Intercambia las cifras de las unidades numero1 = numero1 - unidades1 + unidades2; numero2 = numero2 - unidades2 + unidades1; // Salida de resultados imprimir ( "Despues de intercambiar la cifra de las unidades,\n" + "los numeros quedan asi:\nPrimer numero: " + numero1 + "\nSegundo numero: " + numero2 ) ;

}

}

Condiciones

numero1<0 numero2<0


65

1.10 Ejercicios propuestos

Ejercicios sobre algoritmos Elabore un algoritmo que permita cumplir con las siguientes actividades:

1. Jugar una mano de cartas blackjack (21).

2. Atender un solo cliente en la caja de un supermercado.

3. Recibir el pasa bordo a los pasajeros de un vuelo.

4. Estimar el valor de los libros de una librería, según la calidad de su portada y la cantidad de páginas.

5. Confirmar la asistencia de personas a una primera comunión, vía telefónica.

6. Calcular cuántos soldados de un batallón, pueden votar.

7. Atender una fila de clientes en la caja de un supermercado.

Ejercicios sobre Entradas y Salidas

1. Se tiene una alcancía, que contiene monedas de $500, 200 y 100 únicamente. Se desea

conocer cuanto dinero se tiene ahorrado. Elabore un algoritmo que permita ayudar.

2. Elabore un algoritmo que lea el nombre de una persona y el año de la fecha de nacimiento e imprima tanto el nombre y como la edad.

3. El torque transmitido por un eje de transmisión que produce una cantidad de

caballos de fuerza a una velocidad rotacional constante, se sabe que

N

HPT

.63000=

Donde, T = Momento de torsión (lb-plg) HP = Caballos de fuerza N = Velocidad rotacional (rev/min) Si además,


66

3

.

.16

S

TD

π=

Donde, D = Diámetro del eje (plg)

S = esfuerzo cortante (lb/plg2) Elabore un algoritmo que leyendo HP, D y N, calcule e imprima el esfuerzo cortante permitido por el material del eje.

4. Se desea saber cuanto pagó una señora que fue a la tienda y compró bananos. Se sabe

que la libra cuesta $350. Elabore un algoritmo que permita calcular la solución.

5. Escriba un algoritmo para calcular la desviación estándar estadística σ, de cinco números, mediante la fórmula:

∑=

−=5

1

2_

0.4

0.1

ii xxσ

Donde xi, son los números que deben leerse; _

x denota su promedio; y ∑

=

5

1i establece la

suma de los números indicados.

6. Un administrador desea obtener los datos necesarios para elaborar una tabla de salarios en una empresa en función del puntaje asignado por valoración de méritos. La fórmula empleada para este propósito será:

180001

180002P

S

+=

Donde, S = Salario en pesos P = Puntaje Elabore un algoritmo que encuentre el salario para un puntaje dado.


67

Ejercicios sobre Estrcturas de Secuencia

1. Elabore un algoritmo que calcule el promedio de la estatura de un grupo de 3

personas.

2. Elabore un algoritmo que calcule la nota definitiva de dos estudiantes, sabiendo que tienen 4 notas cada uno con los siguientes porcentajes: 15%, 25%, 35% y 25% respectivamente.

3. Diseñe un algoritmo que lea un número de cuatro (4) cifras y lo imprima en orden

inverso. Por ejemplo si el número es 4751 se debe imprimir como 1574.

4. El departamento de climatología del departamento del Valle ha efectuado recientemente un cambio de conversión al sistema métrico. Diseñe un algoritmo para realizar las siguientes conversiones:

5. Léa la temperatura dada en la escala de Celsius e imprima en su equivalente en

Fahrenheit, en Kelvin y en Rankin. Las fórmulas de conversión son:

6. Fahrenheit = (9.0/5.0) Centigrados + 32.0 7. Kelvin = Centigrados + 273.5 8. Rankin = Fahrenheit + 429.67

9. Léa la cantidad de lluvia en pulgadas e imprima su equivalente en milímetros (25.5

mm = 1 plg).

Ejercicios sobre Estructuras de Decisión

1. Lea la altura y la base de dos (2) triángulos e imprima el área mayor

2. Lea dos números y calcule e imprima su suma, si los dos números son negativos, se debe imprimir además los datos leídos

3. Lea cuatro números y los sume, descartando los negativos.

4. Desarrolle un algoritmo que lea el nombre, la edad, el sexo y el estado civil de

cualquier persona e imprima el nombre de la persona; solo si, corresponde a un hombre casado, mayor de 40 años o una mujer soltera menor de 50 años, y un mensaje que así lo indique.


68

5. Leer el código y el nombre de un empleado, su salario básico por hora, el número de horas trabajadas mensualmente y el porcentaje de retención en la fuente. El algoritmo El algoritmo debe validar los datos de entrada y en caso de error terminar la ejecución del programa de lo contrario, calcular e imprimir el salario neto, el salario bruto y el valor de la retención

6. Lea tres (3) números cualesquiera e imprima el mayor de ellos.

7. Lea tres (3) números cualesquiera y los imprima de mayor a menor.

Ejercicios sobre Estructuras de Decisión Multiple

1. Elabore un algoritmo que solicite un número de día entre 1 y 7; e imprima a que día corresponde. Suponga que le primer día es Lunes. El algoritmo debe garantizar que los valores solicitados al cliente, no tengan error.

2. Elabore un algoritmo que determine si un número es PAR o IMPAR.

3. Un supermercado requiere conocer el nombre, la cantidad de unidades compradas y

el valor unitario del producto, y así poder liquidar la cuenta del cliente. El supermercado tiene como política, que las damas tienen un descuento del 5% y los caballeros del 10%, sobre el valor a pagar. El algoritmo debe garantizar que los valores solicitados al cliente, no tengan error.

4. En un centro médico para su atención, el paciente debe dar su nombre y un número

que indica el tipo de dolencia que padece (1, 2 ó 3). Elabore un algoritmo que genere un mensaje, con el nombre y una descripción, (1= Contagiosa, 2= NO Contagiosa, 3 = NO Sabe) del tipo de dolencia. Se debe garantizar que los valores solicitados al paciente, no tengan error.

5. Elabore un algoritmo que lea dos números y realice una operación seleccionada de

acuerdo al siguiente menú de opciones a. Universidad Autónoma de Occidente

1. Suma 2. Resta 3. Multiplicación 4. División (Validar)


69

6. Teniendo el nombre, el tipo de empleado y su sueldo, se debe calcular el incremento

salarial y el valor del nuevo sueldo; si se conoce que a los empleados tipo 1 y 2, se les aumenta un 5%; y a los tipo 4 y 5 el 12%. El algoritmo debe garantizar que los valores solicitados al empleado, no tengan error.

Ejercicios sobre Estructuras de Decisión Anidada

1. Lea la altura y la base de dos (2) triángulos e imprima el área mayor. El algoritmo

debe indicar si alguno de los datos no es válido, imprimiendo un mensaje con el error y terminando sin realizar ningún cálculo.

2. Desarrolle un algoritmo que lea el nombre, la edad, el sexo

(M=Masculino/F=Femenino) y el estado civil (S=Soltero, C=Casado) de cualquier persona e imprima el nombre de la persona; solo si, corresponde a un hombre casado, mayor de 40 años o una mujer soltera menor de 50 años, y un mensaje que así lo indique. El algoritmo debe indicar si alguno de los datos no es válido, imprimiendo un mensaje con el error y terminando sin realizar ningún cálculo.

3. Leer el código y el nombre de un empleado, su salario básico por hora, el número de

horas trabajadas mensualmente y el porcentaje de retención en la fuente. Se debe calcular e imprimir el salario neto, el salario bruto y el valor de la retención. El algoritmo debe indicar si alguno de los datos numéricos no es válido, imprimiendo un mensaje con el error y terminando sin realizar ningún cálculo.

4. Determine si un número (positivo de 4 cifras) dado es múltiplo de 3, múltiplo de 6 ó

múltiplo de ambos. El algoritmo debe indicar si el dato no es válido, imprimiendo un mensaje con el error y terminando sin realizar ningún cálculo.

5. Lea un número de tres (3) cifras e indique si el dígito que representa las centenas es

par. El algoritmo debe indicar si el dato no es válido, imprimiendo un mensaje con el error y terminando sin realizar ningún cálculo.

6. En una Universidad, los estudiantes tienen asignado un código de 8 cifras, en el que

los 4 primeros dígitos indican el año de matrícula, y el que le sigue, el semestre del año (primero o segundo); si se conoce el código de un estudiante, determine en que año y en que semestre, ingreso a la Universidad. El algoritmo debe indicar si el dato no es válido, imprimiendo un mensaje con el error y terminando sin realizar ningún cálculo.


70

Miscelaneos

1. La utilización de la sentencia break en una estructura de decisión “si” (doble ó simple), permite que la ejecución de las sentencias seleccionadas sea excluyente.

A). Cierto B). Falso

2. Al resolver la sentencia ( ( potencia (2,3) + 1 ) / 2 > 4 ), da como resultado true


3. Se tienen las medidas lineales (largo, ancho y profundidad) correspondientes a dos

piscinas y se desea conocer cuánto vale llenar aquella que tiene mayor capacidad, sabiendo que el metro cúbico de agua está a $25000. Considere que todos los datos han sido ingresados correctamente

4. Determine el pago a realizar por la entrada a un espectáculo donde se pueden comprar sólo hasta 4 localidades (boletas); el costo de 2 entradas tiene un descuento de 10%; si el número de boletas es de 3, el descuento será del 15% y si la compra es por el límite de boletas, tendrá un descuento del 20%. Se debe garantizar que se cumpla con la restricción en la venta de boletas establecida por la organización del evento.

5. La Universidad tiene dos (2) modalidades de matrícula financiera: Completa e Incompleta. La matrícula completa es aquella con número de créditos entre 10 y 18, ambos inclusive, y tiene un valor fijo de $3.446.000. La matrícula incompleta es aquella con número de créditos entre 1 y 9, ambos inclusive, y se cobra según el número de créditos tomados, donde cada crédito tiene un valor fijo de $275.000.

6. Se quiere cuánto debe cancelar un estudiante por concepto de matrícula. Elabore solamente el análisis correspondiente.

7. En una estructura de decisión múltiple, el conjunto de sentencias a ejecutar, está dado por el resultado lógico de la expresión selectora.


8. Si se tiene entero j = 6, en la sentencia: w = j > 45 && (45 / 100) > 100, la variable w

debe ser declarada tipo entero ó real, porque todos los operandos participantes son numéricos.



71

9. Se tienen las medidas lineales (largo y ancho) correspondientes a dos lotes de forma

triangular, el terreno de mayor extensión se desea cubrir con una lona con el fin de protegerlo del clima ¿cuánto valdrá la lona, si se tiene en cuenta que su precio es de $15000 el metro cuadrado?

10. Se quiere realizar el cálculo del sueldo a pagar al empleado de una farmacia de acuerdo al número de horas trabajadas; la ley establece que las horas trabajadas más allá de 40 horas son consideradas horas extras y que esas horas adicionales deben ser pagadas al doble del valor por hora. Además, si el día trabajado es domingo, las horas adicionales serán pagadas al triple y se le otorga un incentivo del 10%, sobre el total pagado.

11. La aerolínea “Viajes Colombia” lanza una promoción para vacaciones de verano en sus vuelos hacia las ciudades de la costa, tomando como base una tabla variable de tarifas que relaciona los precios a sus diferentes destinos. La promoción considera un 35% de descuento en la tarifa básica si hay más de tres pasajeros a la Costa Pacifica, y del 40% si hay dos o más pasajeros a la Costa Atlántica. Se desea determinar el precio final del pasaje, por pasajero, a cualquier destino, teniendo en cuenta un sobrecargo por tasa aeroportuaria de la empresa y los impuestos del gobierno. Elabore solamente el análisis correspondiente

12. Anualmente el gobierno debe calcular el nuevo impuesto que debe pagar cada una de las empresas situadas en el territorio nacional (nunca el impuesto a pagar debe ser inferior a $500.000). El calculo del nuevo impuesto esta basado en: el impuesto del año anterior, el incremento pactado y el tipo de empresa que puede ser privada o estatal. Si este año decidió aplicar un incremento del 5%, y darles como estimulo un descuento de $400000 a las empresas que el año anterior pagaron impuestos entre $1.000.000 y $3.500.000 o son estatales. En cualquier otro caso, incrementará en $300.000 el valor del nuevo impuesto. Construya solo el análisis, adicionando también el proceso correspondiente, que le permita retornar el nuevo impuesto para una de las compañías situadas en el territorio nacional. Nota: no se pueden usar menús ni es necesario validar

13. EL SENA esta ofreciendo un curso de capacitación dirigido a los operarios de las empresas del sector textil, con un costo individual de $ 230.000. Por los vínculos existentes con la industria, el SENA ha decidido dar un descuento del 2.5% sobre el dinero a pagar por cada empresa (que puede ser de tipo privada o estatal). Adicionalmente el SENA ha decidido otorgar un descuento acumulativo del 3.5% a aquellas empresas que inscriba al curso mas de 30 empleados y sean privadas. Construya un algoritmo que permita generar la factura para una empresa que envíe a sus empleados al curso, en la cual se relacione: nombre de la empresa, tipo, el número de empleados inscritos, pago sin descuento (valor a pagar si no existiera ningún descuento), el valor del descuento y el valor a pagar que realmente debe desembolsar la compañía. Nota: no se pueden usar menús y es necesario validar el tipo de empresa


72

14. Una Caja de Compensación tiene unas lindas instalaciones que pueden ser alquiladas por

empleados cuya vinculación puede ser de Afiliado o No afiliado. Los tipos de cuartos existentes en dichas instalaciones son encerrados o con vista al mar. El valor del alquiler y el tipo de cuarto adjudicado, según el tipo de vinculación y la cantidad de salarios mínimos (SM) son resumidos en la siguiente tabla: Vinculación Cantidad Salarios Mínimos Afiliado [2 – 8] SM

$15.000/SM ($15000 por cada SM) encerrado

$23.000/SM ($23000 por cada SM) con vista al mar

No afiliado Al menos 3 SM $35.000/SM ($35000 por cada SM) con vista al mar

$25.000/SM ($25000 por cada SM) encerrado

Construya un algoritmo que permita calcular tanto el valor del alquiler como el tipo de cuarto que será alquilado por dicha caja de compensación. Nota: se pueden usar menús y no es necesario validar

15. Un almacén de venta de computadores ofrece a sus clientes dos formas de pago: Efectivo o Cheque. Si la compra se hace en efectivo el cliente recibe un descuento del 3% sobre el valor total de la compra; el pago con cheque tendrá un recargo del 1%. El valor del IVA es del 16% y se calcula después de realizados los descuentos o recargos respectivos. Debe imprimir el número de cédula del cliente, el valor total de la compra, el valor del IVA y el valor a pagar. Debe hacer el análisis/diseño y construir el algoritmo para este almacén.

16. EL SENA esta ofreciendo un curso de capacitación dirigido a los operarios de las empresas del sector textil, con un costo individual de $ 230.000. Por los vínculos existentes con la industria, el SENA ha decidido dar un descuento del 2.5% sobre el dinero a pagar por cada empresa (que puede ser de tipo privada o estatal). Adicionalmente el SENA ha decidido otorgar un descuento acumulativo del 3.5% a aquellas empresas que inscriba al curso mas de 30 empleados y sean privadas. Construya un algoritmo que permita generar la factura para una empresa que envíe a sus empleados al curso, en la cual se relacione: nombre de la empresa, tipo, el número de empleados inscritos, pago sin descuento (valor a pagar si no existiera ningún descuento), el valor del descuento y el valor a pagar que realmente debe desembolsar la compañía. Nota: no se pueden usar menús y es necesario validar el tipo de empresa

17. Gran preocupación ha surgido, desde hace algunos meses, en los funcionarios de la empresa que presta los servicios de energía eléctrica en nuestra región, debido a los bajos niveles en las fuentes hídricas, provocados por el fenómeno del “niño”. Se implementa, entonces, una campaña de ahorro de energía que consiste en conservar o disminuir el consumo mensual, respecto al mes inmediatamente anterior al facturado. A favor del cliente que cumpla con el mencionado ahorro, se establece un descuento del 15% en el


73

valor corriente del gasto mensual. Se conoce que el valor del kilowatio-hora (kWh) es $292.79. Generar una solución que determine el costo mensual del servicio.

18. El proceso de reposición de equipos blackberry, de una empresa que presta servicios de telefonía celular en modalidad de post-pago, basa sus costos en las siguientes tablas:

EQUIPOS CODIGO MODELO COSTO COMERCIAL 9700 Blackberry Bold 9700 $ 1400000 8520 Blackberry Curve 8520 $ 730000

DESCUENTOS POR REPOSICIÓN PLAN (minutos) % DESCUENTO

100 o menos 0% 101 - 200 20%

201 en adelante 30%

Diseñar una solución algorítmica, que determine el modelo del equipo y su costo comercial mediante el código; ademàs que calcule el precio final del equipo según el plan del cliente.

19. Escriba un algoritmo que permita leer el nombre y salario básico mensual de un empleado, y permita calcular y visualizar los siguientes resultados:

i. Nombre y salario básico. ii. Valor de cada descuento. iii. Total descuentos. iv. Valor subsidio de transporte. v. Total salario neto a pagar.

A continuación, se detallan los conceptos que debe considerar para desarrollar el presente ejercicio.

• Se descuenta 4% por concepto de salud. • Se descuenta 4% por concepto de pensión • Se descuenta 1% sobre salario básico mensual, siempre y cuándo el empleado

devengue más de cuatro (4) salarios mínimos vigentes. • Se otorga subsidio de transporte por valor de $61.500, siempre y cuando el

empleado devengue menos de dos (2) salarios mínimos vigentes.

Nota: salario mínimo vigente = $515.000.


74

PRUEBAS DE ESCRITORIO

1. Realice la prueba de escritorio al siguiente algoritmo en pseudocódigo y explique su funcionalidad

algoritmo NumeroMagico { principal () { entero divisor=10, magico=1, control=1, numero=0; numero=leer ("Digite un número: "); si (numero<0) { numero=numero*(-1); } haga { si (numero / divisor < 1) { imprimir ("El numero mágico es "+magico); control=0; } else { control=1; magico++; divisor=divisor*10; } } while (control==1); } }

2. Realice la prueba de escritorio al siguiente algoritmo en pseudocódigo y explique su funcionalidad

Algoritmo Cuarta_Parte { entero m = 0, n = 0, p = 0; haga { m=leeer (“Digite el dato: “); } mientras (m < 100 && m > 10000); imprimir (“Dato de entrada: “+m); haga { n = m % 10;


75

p = p * 10 + n; m = m / 10; } mientras (m > 0); imprimir (“Dato de salida: “ + p); } }

3. Lea, analice y siga el siguiente algoritmo, indicando qué valores se están asignando a las variables de la tabla adjunta y qué valores imprime. Realice la prueba de escritorio con los siguientes datos:

Cantidad datoS (registre la respuesta) numeroR

8 4 Su nombre? 20.0 Nombre de su mamá? 12.0 Nombre de su papá? 25.0 Nombre de un amigo? 19.0

algoritmo PruebaEscritorio { principal ( ){ real numeroR = 0.0; cadena datoS = “ ”; real numeroX = 0.0; cadena datoX = “ “; entero cantidad = 0; entero veces=1; haga{ cantidad = leer ("Ingrese Cantidad")); si (cantidad <= 0 || cantidad > 5){ imprimir (“Intente de nuevo”); } }mientras(cantidad <=0 || cantidad > 5); mientras (veces <= cantidad){ datoS = leer ("Ingrese datoS"); numeroR = leer ("Ingrese numeroR")); si (numeroR > numeroX){ numeroX = numeroR; datoX = datoS; } ++veces; }


76

imprimir ("Respuesta: " + datoX); } }

4. // Algoritmo parcial 2, debe realizar la prueba de escritorio e indicar lo que se

imprime

algoritmo Parcial_2 {

principal ( ) {

entero num, res, div, bin, t, r, s ;

num = leer (“Digite un numero entero: ”); // Asuma que se ingresa el

numero 13

s = 0;

t = 1;

r = 1;

mientras (num > 1) {

res = num % 2 ;

div = num / 2 ;

si (res == 1) {

s = s + (t * r) ;

}

r = r * 10;

num = div;

}

bin = r + s;

imprimir (“El resultado es: ” + bin) ;

}

}

cantidad veces numeroR

datoS numeroX

datoX !!(impresión)!!


77

Tabla Prueba de Escritorio

num res div t r s bin

13

5. Analice, realice seguimiento al algoritmo escrito a continuación, y determine qué

valores se están asignando en las variables de la tabla adjunta y qué se imprime

como resultado final:

NOTA: Adelante la prueba con valor de ‘a’ igual a 6627

algoritmo Parcial2 {

principal ( ) {

entero a, b, tmp, x;

a = leer ( “Digite un número: “ );

haga {

x=10;

b = 0;

mientras ( a!=0 ) {

tmp = a – ( a / x ) * x;

b = tmp + b * x;

a = a / x;

}

} mientras ( a==b );

imprimir ( “El resultado es “ + b );

}

}


78

a b tmp X

6627

Valor que se imprime como resultado final: ______________


79

UNIDAD 2. INTRODUCCIÓN A JAVA.

2.1 HISTORIA DE JAVA Una de las áreas reconocidas de avance para la computación e informática, es la de los dispositivos electrónicos inteligentes. En razón de esto, Sun Microsystems financió un proyecto de investigación interno con el nombre Proyecto Green en 1991. Uno de los resultados de este poyecto fue un lenguaje basado en C y C++, llamado Oak, creado por James Gosling, Patrick Naughton, Chris Warth, Ed Frank y Mike Sheridan. Poco después se descubrió que ya existía un lenguaje con este nombre, así que surgió el nombre de JAVA (una clase de café). El prototipo original, desarrollado en 18 meses, fue mejorado con la ayuda de muchas personas, lo cual tomó más de 3 años. El propósito inicial con el proyecto fue crear un lenguaje independiente de la plataforma, que facilitara el uso en diferentes dispositivos electrónicos. Hasta el momento, C y C++ eran los lenguajes más empleados, sin embargo no permitían la facilidad requerida ya que debe proveerse del compilador especifico para la CPU necesaria, lo cual puede llevar algún tiempo de construcción. Sin embargo, mientras se desarrollaba JAVA apareció el otro elemento que formaría parte esencial de su construcción, la World Wide Web; de no ser por este aspecto, JAVA probablemente no habría pasado a ser un lenguaje más empleado por los diseñadores de hardware en sus laboratorios. Es conveniente aclarar que aunque JAVA basó su desarrollo en C y C++, de ninguna manera es una versión avanzada de estos, no es compatible con alguna versión de C++, ni intenta reemplazarlo; más bien maneja otras características importantes que se requerían en su momento, dando a los programadores un ambiente familiar.

Respecto a la programación, JAVA presenta muchas ventajas, como mencionan Naugthon y Schildt: "Java fue diseñado, probado y refinado por programadores auténticos. Es un lenguaje que se basa en las necesidades y experiencia de la gente que lo ha inventado.... Java es un lenguaje coherente y lógicamente consistente.... Java le permite al programador tener el control total, excepto en aquellas limitaciones impuestas por Internet. Si uno programa bien, el programa lo reflejará; si uno programa mal, el programa también lo reflejará. Dicho de otro modo, Java no es un lenguaje con ruedas de entrenamiento, sino que es un leguaje para programadores profesionales". La intención de Sun Microsystems con el desarrollo de JAVA no fue el lucro, sino facilitar sus propias labores en la construcción de dispositivos de hardware. Por tanto, JAVA y sus herramientas asociadas siempre han sido de dominio público, de forma que basta entrar al sitio de sun (www.java.sun.com), para obtener la versión actualizada del JDK (Java Development Kit). Exactamente, en el sitio web http://java.sun.com/downloads , usted puede descargar el kit de desarrollo de Java. 2.2 CARACTERÍSTICAS BÁSICAS DE JAVA JAVA posee muchas características importantes. A continuación se mencionarán aquellas más sobresalientes:


80

2.2.1 Orientado a objetos puro Muchos lenguajes tienen como característica ser orientado a objetos, lo cual implica que permitan crear clases, manejar herencia y mantener el encapsulamiento. No obstante, existen dos clases de lenguajes orientados a objetos:

Aquellos que permiten las características del manejo de objetos, pero también mantienen características de otros estilos de programación (v.g. programación procedimental); a estos lenguajes se les conoce normalmente como híbridos. Un ejemplo clásico de este tipo de lengujes es el C++ que, además de soportar el manejo de objetos, también permite la escritura de código propio de C.

La otra clase de lenguajes son los denominados puros, tal como Java o Smalltalk, en donde sólo se pueden manejar clases y objetos. Por lo tanto, cualquier fragmento de código que se quisiera escribir debe formar parte de una clase. 2.2.2 Simple Una preocupación de SUN es mantener el lenguaje simple. Desde su comienzo, las instrucciones propuestas, similares al C, tienen por objeto facilitar al programador su comprensión, incluso con estándares muy sencillos como que las clases se escriben iniciando en mayúscula y los objetos con minúsculas. Con miras a esto, se quitaron algunos aspectos que C++ maneja; tales como sobrecarga de operadores, herencia múltiple y apuntadores; por considerar que no aportaban de manera significativa en relación con la complejidad que revestían y se adicionaron otros aspectos para facilitar la vida del programador, tal como el colector de basura. 2.2.3 Distribuido Java ha sido diseñado para interactuar de manera sencilla con el conjunto de protocolos TCP / IP (manejados en Internet), de manera que las aplicaciones de Java puedan abrir y acceder a objetos a través de URLs de manera tan sencilla como si estuvieran en la misma máquina. 2.2.4 Robusto La robustez de un software es una de las características de calidad más importantes y se refiere a la posibilidad del software de prevenir posibles errores que, de ocurrir, podrían interrumpir la ejecución adecuada del mismo. Java se preocupa por ello y hace un especial énfasis en la detección de problemas, chequeo dinámico (en tiempo de ejecución) y eliminar posibles situaciones de error. 2.2.5 Seguro Una de las intenciones de Java es que éste sea empleado en entornos de red y distribuidos, pero se debe tener conciencia de la importancia de la seguridad en ambientes de este estilo. Por ello, el lenguaje mismo provee mecanismos apropiados para evitar la construcción de virus o trampas. También tiene mecanismos de autenticación basados en encriptamiento de llaves (SSL).


81

2.2.6 Arquitectura Neutral Para que las aplicaciones que se hacen en java puedan efectivamente viajar a través de la red, el lenguaje debe proveer mecanismos que permitan ejecutar el software en cualquier sistema, independiente de su plataforma; por ello, Java provee una archivo en un formato de arquitectura neutra que puede ser ejecutado en diferentes procesadores con la ayuda del adecuado sistema de ejecución de java. 2.2.7 Portable La arquitectura neutra es la base para la portabilidad, pero para lograr que el software sea portable se requiere mucho más. Por ejemplo, el manejo de los diferentes tipos de datos y las interfaces gráficas deben ser independientes de la plataforma en que se ejecutan. El sistema Java mismo es altamente portable, el compilador está escrito en JAVA y el runtime (ejecutador) está escrito en ANSI C. 2.2.8 Interpretado El interpretador de Java puede ejecutar directamente los bytecodes (código de bytes, generado después de la compilación) directamente en la máquina en la cual se encuentra instalado. Muchas personas han visto esta característica como una desventaja de Java, debido a que el proceso de enlace (link, p. ej. en C / C ++) es mucho más rápido y liviano. Sin embargo, debe reconocerse que la interpretación ayuda en los procesos de depuración. 2.2.9 Alto desempeño Aunque el desempeño del interpretador comúnmente es suficiente, si se requiere un mayor nivel de desempeño puede traducirse el bytecode a un código particular para la máquina en la cual se ejecuta. 2.2.10 Multihilos Multihilo es es la forma de construir aplicaciones de manera que puedan realizar varias actividades (hilos) al mismo tiempo. Java tiene primitivas básicas que permiten monitorear y usar los hilos; esto logra una mejor interacción y un comportamiento de tiempo real (limitado sólo por la máquina en la cual está corriendo). 2.2.11 Dinámico Java fue diseñado para adaptarse a un entorno cambiante. El hecho de manejar objetos permite que los cambios que se requieran en un software determinado no afecten de manera significativa los procesos existentes.


82

2.3 LA ESTRUCTURA DE JAVA ¿Compilado o Interpretado? Una de las primeras inquietudes que surgen cuando se empieza a interactuar con Java es si realmente es un lenguaje compilado o interpretado; la respuesta es sencilla: los dos. La forma de operar de Java es un tanto diferente a la forma en que operan otros lenguajes más tradicionales y esto es, justamente, lo que permite que los programas desarrollados en Java puedan emplearse en diferentes plataformas. El siguiente gráfico, presenta la forma como se debería procesar un programa en Java.

Procesamiento de un programa en JAVA ( Fuente: Java Tutorial)

Como se puede observar, el programa fuente (myProgram.java) debe ser compilado para crear el programa en bytecode (myProgram.class), el cual puede ser ejecutado en cualquier plataforma, ya que la máquina que lo ejecutará en particular tiene su intepretador (diferente para cada máquina) que lee, interpreta y ejecuta cada una de las instrucciones que encuentra en el bytecode. Plataforma de Java Como plataforma se conoce al entorno Hardware – Software en el cual se ejecuta un programa. Normalmente se asocia con el sistema operativo y la máquina sobre la que este corre; así, se tienen como plataformas: Windows (en cada una de sus formas), MacOS, Linux, Uníx, Solaris, etc. La plataforma de Java se compone de dos elementos básicos: Java Application Programming Interface (Java API) y la Java Virtual Machine (JVM). Su ubicación se presenta en el siguiente gráfico.

Plataforma de Java (Fuente: Java Tutorial)

• El Java Virtual Machine es el intérprete de Java. Como se dijo anteriormente, existen un JVM para cada plataforma y es el que permite que un programa sea escrito una vez y ejecutado en varias plataformas sin requerir cambios.


83

El JRE o Java 2 Runtime Environment es: la máquina virtual, la plataforma de clases y los archivos de soporte. El SDK (Standard Developer Kit) incluye el JRE y las herramientas de desarrollo como compiladores y depuradores. 2.4 INSTALACIÓN DE JAVA Java pertenece al software de dominio libre, es decir que cualquier persona puede entrar al sitio de Internet y bajarlo sin pagar ningún costo.

• Para iniciar la instalación de Java, entre al sitio http://java.sun.com/downloads y escoja la versión apropiada de JDK acorde a su plataforma.

• El archivo java_ee_sdk-5_07-jdk-6u18-windows-ml.exe debe quedar en su disco, este es el instalador del SDK. Al ejecutar este programa, se instalará el Java en su disco, normalmente se instala en el directorio C:\Program Files\Java\jdk1.6.0_16 (NOTA: los nombres de los archivos podrían variar dependiendo de la versión de Java disponible).

• Luego descargue el programa Netbeans, el cual se puede descargar del sitio web http://www.netbeans.org/features/index.html.

Ahora puede empezar a hacer sus primeros programas en Java.

2.5 CONSTRUCCIÓN BÁSICA DE UNA APLICACIÓN Un programa desarrollado en JAVA pasa por cinco fases para poder ejecutarse: Edición, Compilación, Carga, Verificación, Ejecución. 2.5.1 Edición La edición de un archivo corresponde a la escritura del código fuente. Dentro del Kit original de JAVA no se incluye un editor, por lo que el programador deberá proveerse de uno, en nuestro caso utilizaremos Netbeans. Debe tenerse en cuenta que los programas de código fuente en JAVA deben tener la extensión .java.

2.5.2 Compilación La compilación es el proceso por el cual el código fuente es traducido a un código de bytes (bytecode) que será interpretado durante la etapa de ejecución. Esta operación se realiza presionando el botón compilar, en la cual se revisa la sintaxis y semántica del programa fuente escrito y, si todo es correcto, creará un programa con el mismo nombre del programa fuente y la extensión .class1.

Edición Disco Se crea un programa .java

Compilación Disco Se crea un programa .class


84

2.5.3 Carga Para que una aplicación pueda ejecutarse, debe ser cargada, ó, subida a memoria. Lo mismo ocurre con las aplicaciones de JAVA. El comando java se encargará, en primera instancia, de esta labor aunque también realiza la verificación y la ejecución.

2.5.4 Verificación En esta etapa se determina si la aplicación que se desea ejecutar tiene o no errores, principalmente de seguridad. Esto es muy importante, considerando que las aplicaciones comúnmente son enviadas a través de Internet.

2.5.5 Ejecución Finalmente, cubiertos todos los pasos, se interpretan las instrucciones del código de bytes, traduciéndolos a instrucciones que la máquina pueda realizar (lenguaje de máquina).

Carga

Disco Se carga el programa a memoria Memoria

Verificación

Se verifican que el bytecode sea válido y aspectos de seguridad

Memoria

Interpréte

Lee cada instrucción del bytecode y las ejecuta Memoria


85

UNIDAD 3. TIPOS DE DATOS, VARIABLES Y OPERADORES. PROGRAMACIÓN EN JAVA En este capítulo se presentan las características generales de Java como lenguaje de programación algorítmico. En este apartado Java es muy similar a C/C++, lenguajes en los que está inspirado. 3.1 VARIABLES Una variable es un nombre que contiene un valor que puede cambiar a lo largo del programa. De acuerdo con el tipo de información que contienen, en Java hay dos tipos principales de variables:

1. Variables de tipos primitivos. Están definidas mediante un valor único que puede ser entero, de punto flotante, caracter o booleano. Java permite distinta precición y distintos rangos de valores para estos tipos de variables (char, byte, short, int, long, float, double, boolean). Ejemplos de variables de tipos primitivos podrían ser: 123, 3456754, 3.1415, 12e-09, 'A', true, etc.

2. Variables referencia. Las variables referencia son referencias o nombres de una información más compleja: arrays u objetos de una determinada clase.

Desde el punto de vista del papel o misión en el programa, las variables pueden ser: 1. Variables miembro de una clase: Se definen en una clase, fuera de cualquier método; pueden

ser tipos primitivos o referencias. 2. Variables locales: Se definen dentro de un método o más en general dentro de cualquier

bloque entre llaves {}. Se crean en el interior del bloque y se destruyen al finalizar dicho bloque. Pueden ser también tipos primitivos o referencias.

3.1.1 Nombres de Variables Los nombres de variables en Java se pueden crear con mucha libertad. Pueden ser cualquier conjunto de valores numéricos y alfanuméricos, siempre que el primer caracter sea una letra ( preferentemente en minúscula ), un caracter signo de pesos ( $ ) o un caracter de subrayado ( _ ), excluyendo los nombres especiales utilizados por Java para el lenguaje: Palabras Reservadas del Lenguaje. Es una sana práctica que el nombre de la variable, ó identificador, sea descriptivo del valor que está guardando.

3.2. Palabras Reservadas Existe una serie de palabras reservadas las cuales tienen un significado especial para Java y por lo tanto no se pueden utilizar como nombres de variables. Dichas palabras son:

abstract: Especifica la clase o método que se va a implementar más tarde en una subclase. boolean: Tipo de dato que sólo puede tomar los valores verdadero o falso. break: Sentencia de control para salirse de los bucles. byte: Tipo de dato que soporta valores en 8 bits. byvalue: Reservada para uso futuro. case: Se utiliza en las sentencias switch para indicar bloques de texto.


86

cast: Reservada para uso futuro. catch: Captura las excepciones generadas por las sentencias try. char: Tipo de dato que puede soportar caracteres Unicode sin signo en 16 bits. class: Declara una clase nueva. const: Reservada para uso futuro. continue: Devuelve el control a la salida de un bucle. default: Indica el bloque de código por defecto en una sentencia switch. do: Inicia un bucle do-while. double: Tipo de dato que soporta números en coma flotante, 64 bits. else: Indica la opción alternativa en una sentencia if. extends: Indica que una clase es derivada de otra o de una interfaz. final: Indica que una variable soporta un valor constante o que un método no se sobrescribirá. finally: Indica un bloque de código en una estructura try - catch que siempre se ejecutará. float: Tipo de dato que soporta un número en coma flotante en 32 bits. for: Utilizado para iniciar un bucle for. future: Reservada para uso futuro. generic: Reservada para uso futuro. goto: Reservada para uso futuro. if: Evalúa si una expresión es verdadera o falsa y la dirige adecuadamente. implements: Especifica que una clase implementa una interfaz. import: Referencia a otras clases. inner: Reservada para uso futuro. instanceof: Indica si un objeto es una instancia de una clase específica o implementa una interfaz específica. int : Tipo de dato que puede soportar un entero con signo de 32 bits. interface: Declara una interfaz. long: Tipo de dato que soporta un entero de 64 bits. native: Especifica que un método está implementado con código nativo (específico de la plataforma). new: Crea objetos nuevos. null : Indica que una referencia no se refiere a nada. operator: Reservado para uso futuro. . outer: Reservado para uso futuro. package: Declara un paquete Java. private: Especificador de acceso que indica que un método o variable sólo puede ser accesible desde la clase en la que está declarado. protected: Especificador de acceso que indica que un método o variable sólo puede ser accesible desde la clase en la que está declarado (o una subclase de la clase en la que está declarada u otras clases del mismo paquete). public: Especificador de acceso utilizado para clases, interfaces, métodos y variables que indican que un tema es accesible desde la aplicación (o desde donde la clase defina que es accesible). rest: Reservada para uso futuro. return : Envía control y posiblemente devuelve un valor desde el método que fue invocado. short: Tipo de dato que puede soportar un entero de 16 bits. static: Indica que una variable o método es un método de una clase (más que estar limitado a un objeto particular).


87

super: Se refiere a una clase base de la clase (utilizado en un método o constructor de clase). switch: Sentencia que ejecuta código basándose en un valor. synchronized: Especifica secciones o métodos críticos de código multihilo. this: Se refiere al objeto actual en un método o constructor throw: Crea una excepción. throws: Indica qué excepciones puede proporcionar un método, transient: Especifica que una variable no es parte del estado persistente de un objeto. try: Inicia un bloque de código que es comprobado para las excepciones. var: Reservado para uso futuro. void: Especifica que un método no devuelve ningún valor. volatile: Indica que una variable puede cambiar de forma asíncrona.

while: Inicia un bucle while. 3.3. TIPOS DE DATOS 3.3.1 Tipos Primitivos de Datos Se llaman tipos primitivos de variables de Java a aquellas variables sencillas que contienen los tipos de información más habituales: valores boolean, caracteres y valores numéricos enteros o de punto flotante.

Java dispone de ocho tipos primitivos de variables: un tipo para almacenar valores true y false (boolean); un tipo para almacenar caracteres (char), y 6 tipos para guardar valores numéricos, cuatro tipos para enteros (byte, short, int y long) y dos para valores reales de punto flotante (float y double). Los rangos y la memoria que ocupa cada uno de estos tipos se muestran en la Tabla 4.1.

Tipo de variable Descripción bolean 1 byte. Valores true y false char 2 bytes. Unicode. Comprende el código ASCII byte 1 byte. Valor entero entre -128 y 127 short 2 bytes. Valor entero entre -32768 y 32767 int 4 bytes. Valor entero entre -2.147.483.648 y 2.147.483.647 long 8 bytes. Valor entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807 float 4 bytes (entre 6 y 7 cifras decimales equivalentes). De -3.402823E38 a -1.401298E-45

y de 1.401298E-45 a 3.402823E38 double 8 bytes (unas 15 cifras decimales equivalentes). De -1.79769313486232E308 a

-4.94065645841247E-324 y de 4.94065645841247E-324 a 1.79769313486232E308

Tabla 3.1. Tipos primitivos de variables en Java.

Los tipos primitivos de Java tienen algunas características importantes que se resumen a continuación:

1. El tipo boolean no es un valor numérico: sólo admite los valores true o false. El tipo boolean no se identifica con el igual o distinto de cero, como en C/C++. El resultado de la ex presión lógica que aparece como condición en un bucle o en una Decisión debe ser boolean.

2. El tipo char contiene caracteres en código UNICODE (que incluye el código ASCII), y ocupan 16 bits por carácter. Comprende los caracteres de prácticamente todos los idiomas.


88

3. Los tipos byte, short, int y long son números enteros que pueden ser positivos o negativos, con distintos valores máximos y mínimos. A diferencia de C/C++, en Java no hay enteros unsigned.

4. Los tipos float y double son valores de punto flotante (números reales) con 6-7 y 15 cifras decimales equivalentes, respectivamente.

5. Se utiliza la palabra void para indicar la ausencia de un tipo de variable determinado. 6. A diferencia de C/C++, los tipos de variables en Java están perfectamente definidos en todas

y cada una de las posibles plataformas. Por ejemplo, un int ocupa siempre la misma memoria y tiene el mismo rango de valores, en cualquier tipo de computador.

7. Existen extensiones de Java 1.2 para aprovechar la arquitectura de los procesadores Intel, que permiten realizar operaciones de punto flotente con una precisión extendida de 80 bits.

3.3.2 Tipos Referencia a Objeto Estas variables son referencias a objetos de alguna clase perteneciente al API de Java o generada por el usuario, que indica dónde está guardado un objeto en la memoria del computador. 3.4 CÓMO SE DEFINEN E INICIALIZAN LAS VARIABLES Una variable se define especificando el tipo y el nombre de dicha variable. Estas variables pueden ser tanto de tipos primitivos como referencias a objetos de alguna clase perteneciente al API de Java o generada por el usuario. Si no se especifica un valor en su declaración, las variables primitivas se inicializan a cero (salvo boolean y char, que se inicializan a false y '\0'). Análogamente las variables de tipo referencia son inicializadas por defecto a un valor especial: null .

Es importante distinguir entre la referencia a un objeto y el objeto mismo. Una referencia es una variable que indica dónde está guardado un objeto en la memoria del computador (a diferencia de C/C++, Java no permite acceder al valor de la dirección, pues en este lenguaje se han eliminado los punteros). Al declarar una referencia todavía no se encuentra “apuntando” a ningún objeto en particular (salvo que se cree explícitamente un nuevo objeto en la declaración), y por eso se le asigna el valor null . Si se desea que esta referencia apunte a un nuevo objeto es necesario crear el objeto utilizando el operador new. Este operador reserva en la memoria del computador espacio para ese objeto (variables y funciones). También es posible igualar la referencia declarada a otra referencia a un objeto existente previamente.

Un tipo particular de referencias son los arrays o vectores, sean éstos de variables primitivas (por

ejemplo, un vector de enteros) o de objetos. En la declaración de una referencia de tipo array hay que incluir los corchetes [ ]. En los siguientes ejemplos aparece cómo crear un vector de 10 números enteros y cómo crear un vector de elementos MyClass. Java garantiza que los elementos del vector son inicializados a null o a cero (según el tipo de dato) en caso de no indicar otro valor.

Pseudocodigo: Java: entero x; int x;

real y; double y;

Ejemplos de declaración e inicialización de variables: int x; // Declaración de la variable primitiva x. Se inicializa a 0 int y=5; //Declaración de la variable primitiva y. Se inicializa a 5 MyClass unaRef; // Declaración de una referencia a un objeto MyClass.

// Se inicializa a null


89

unaRef = new MyClass(); // La referencia “apunta” al nuevo objeto creado // Se ha utilizado el constructor por defecto

MyClass segundaRef = unaRef; // Declaración de una referencia a un objeto MyClass. // Se inicializa al mismo valor que unaRef

int [ ] vector; // Declaración de un array. Se inicializa a null vector = new int[10]; // Vector de 10 posiciones enteras, inicializadas a 0 double [ ] v = {1.0, 2.65, 3.1}; // Declaración e inicialización de un vector de 3

// elementos con los valores entre llaves MyClass [ ] lista=new MyClass[5]; // Se crea un vector de 5 referencias a objetos

// Las 5 referencias son inicializadas a null lista[0] = unaRef; // Se asigna a lista[0] el mismo valor que unaRef lista[1] = new MyClass(); // Se asigna a lista[1] la referencia al nuevo objeto

// El resto (lista[2]…lista[4] siguen con valor null En el ejemplo mostrado las referencias unaRef, segundaRef y lista[0] actuarán sobre el mismo objeto. Es equivalente utilizar cualquiera de las referencias ya que el objeto al que se refieren es el mismo. 3.5 PROMOCIÓN DE DATOS (CASTING) Si tiene experiencia previa en programación, entonces ya sabrá que es bastante común asignar un valor de un tipo a una variable de otro tipo. Si los dos tipos son compatibles, entonces java realizará la conversión automáticamente. Por ejemplo, siempre es posible asignar un valor int a una variable long. Sin embargo no todos lo tipos son compatibles y, por tanto, no todas las conversiones de tipo se realizan implícitamente. Por ejemplo, no esta definida la conversión de double a byte. Afortunadamente, es posible realizar conversión entre tipos incompatibles. A continuación analizaremos la conversión automática ( ó implícita ) de tipos y la explícita. 3.5.1 Conversión automática de Java Cuando se asigna un tipo de dato a otro tipo de variable, se realiza una conversión de tipo automática si se proceden las condiciones siguientes:

• Los tipos son compatibles • El tipo de destino es más grande que el tipo de origen.

Cuando se cumplen estas dos condiciones se produce un ensanchamiento o promoción. Por ejemplo, el tipo int es lo suficientemente grande para almacenar un valor byte, por lo que no necesita una conversión explicita. Cuando se realiza ensanchamiento, los tipos numéricos, incluyendo los tipos enteros y en coma flotantes, son compatibles con el resto. Sin embargo, los tipos numéricos no son compatibles con char o boolean. Además, los tipos char o boolean no son compatibles con el resto. Como mencionamos anteriormente, Java también realiza una conversión de tipos automática cuando se almacena una constante literal entera en variables de tipo byte, char o long.


90

3.5.2 Conversión de tipos incompatibles Aunque las conversiones de tipo automática son útiles, no cubren todas las necesidades. Por ejemplo, ¿Qué ocurre si se quiere asignar un valor int a una variable byte? Esta conversión no se realizara automáticamente, ya que byte es más pequeña que int. A este tipo de conversión se le llama a veces estrechamiento, dado que se estrecha explícitamente el valor para que quede en el tipo destino. Para crear una conversión entre dos tipos incompatibles se debe usar un cast. Un cast es simplemente una conversión de tipo explícita y tiene la siguiente forma; (tipo)valor Aquí, tipo indica el tipo al que se ha de convertir el valor especificado. Por ejemplo, el siguiente fragmento de código convierte un int a byte, si el valor del entero es más grande que el rango de un byte, se reduciré el módulo (resto de la división entera) del rango de tipo byte. int a; byte b; // … b = (byte )a; Cuando se asigna un valor en coma flotante a un tipo entero se produce una conversión de tipo diferente truncando la componente fraccional. Como ya sabe, los enteros no tienen componente fraccional, por lo que cuando se asigna un valor en coma flotante a un tipo entero, se pierde la componente fraccional. Por ejemplo, si se asigna el valor 1.23 a un entero el valor resultante será simplemente 1. el 0.23 habrá sido truncado. Por supuesto, si el tamaño de la componente es demasiado grande para caber en el tipo entero destino, entonces ese valor será reducido al módulo del rango del tipo destino. El siguiente programa muestra algunas conversiones de tipo explícitas: // ejemplo de conversión de tipo explicita public class Conversion { public static void main (String args [] ) { byte b; int i = 257; double d = 323.142; System.out.println ("\nConversión de int a byte "); b = (byte ) i ; System.out.println ("i y b :"+ i + " " + b ); System.out.println ("\nConversión de double a int "); i = (int ) d ; System.out.println ("d y i :"+ d + " " + i ); System.out.println ("\nConversión de double a byte "); b = (byte ) d ; System.out.println ("d y b :"+ d + " " + b ); } }


91

Este programa genera la siguiente salida: Veamos cada una de las conversiones. Cuando el valor 257 es convertido de forma explícita a una variable byte, el resultado es el resto de dividir 257 entre 256 (el rango del tipo byte). que es 1. cuando la variable d se convierte a int, su componente fraccional se pierde. Cuando la variable d se convierte a byte, su componente fraccional se pierde y el valor se reduce al módulo de 256, que este caso es 67. 3.6 VISIBILIDAD Y VIDA DE LAS VARIABLES Se entiende por visibilidad, ámbito o scope de una variable, la parte de la aplicación donde dicha variable es accesible y por lo tanto puede ser utilizada en una expresión. En Java todas las variables deben estar incluidas en una clase. En general las variables declaradas dentro de unas llaves {}, es decir dentro de un bloque, son visibles y existen dentro de estas llaves. Por ejemplo las variables declaradas al principio de una función existen mientras se ejecute la función; las variables declaradas dentro de un bloque if no serán válidas al finalizar las sentencias correspondientes a dicho if y las variables miembro de una clase (es decir declaradas entre las llaves {} de la clase pero fuera de cualquier método) son válidas mientras existe el objeto de la clase. Las variables miembro de una clase declaradas como public son accesibles a través de una referencia a un objeto de dicha clase utilizando el operador punto (.). Las variables miembro declaradas como private no son accesibles directamente desde otras clases. Las funciones miembro de una clase tienen acceso directo a todas las variables miembro de la clase sin necesidad de anteponer el nombre de un objeto de la clase. Sin embargo las funciones miembro de una clase B derivada de otra A, tienen acceso a todas las variables miembro de A declaradas como public o protected, pero no a las declaradas como private. Una clase derivada sólo puede acceder directamente a las variables y funciones miembro de su clase base declaradas como public o protected. Otra característica del lenguaje es que es posible declarar una variable dentro de un bloque con el mismo nombre que una variable miembro, pero no con el nombre de otra variable local que ya existiera. La variable declarada dentro del bloque oculta a la variable miembro en ese bloque. Para acceder a la variable miembro oculta será preciso utilizar el operador this, en la forma this.varname. Uno de los aspectos más importantes en la programación orientada a objetos (OOP) es la forma en la cual son creados y eliminados los objetos. En Java la forma de crear nuevos objetos es utilizando el operador new. Cuando se utiliza el operador new, la variable de tipo referencia guarda la posición de memoria donde está almacenado este nuevo objeto. Para cada objeto se lleva cuenta de por cuántas variables de tipo referencia es apuntado. La eliminación de los objetos la realiza el programa denominado garbage collector, quien automáticamente libera o borra la memoria ocupada por un objeto cuando no existe ninguna referencia apuntando a ese objeto. Lo anterior significa que aunque una variable de tipo referencia deje de existir, el objeto al cual apunta no es eliminado si hay otras referencias apuntando a ese mismo objeto. Casos especiales: Clases BigInteger y BigDecimal Java 1.1 incorporó dos nuevas clases destinadas a operaciones aritméticas que requieran gran precisión: BigInteger y BigDecimal. La forma de operar con objetos de estas clases difiere de las


92

operaciones con variables primitivas. En este caso hay que realizar las operaciones utilizando métodos propios de estas clases (add() para la suma, subtract() para la resta, divide() para la división, etc.). Se puede consultar la ayuda sobre el package java.math, donde aparecen ambas clases con todos sus métodos.

Los objetos de tipo BigInteger son capaces de almacenar cualquier número entero sin perder información durante las operaciones. Análogamente los objetos de tipo BigDecimal permiten trabajar con el número de decimales deseado. 3.7. OPERADORES DE JAVA Java es un lenguaje rico en operadores, que son casi idénticos a los de C/C++. Estos operadores se describen brevemente en los apartados siguientes. 3.7.1 Operadores aritméticos Son operadores binarios (requieren siempre dos operandos) que realizan las operaciones aritméticas habituales: suma (+), resta (-), multiplicación (*), división (/) y resto de la división (%). 3.7.2 Operadores módulo (%) De vuelve el resto de una división. Se puede aplicar tanto a tipos en como flotantes y como a tipos enteros. Esto es diferente a C/C++, donde el operador % solo puede aplicar a tipos enteros. El siguiente ejemplo muestra cómo funciona el operador anulador. public class Modulo { public static void main (String args [] ){ int x = 42; double y = 42.3; System.out.println ("x mod 10 = " + x % 10 ) ; System.out.println ("y mod 10 = " + y % 10 ) ; } } Salida

3.7.3 Operadores de asignación Los operadores de asignación permiten asignar un valor a una variable. El operador de asignación por excelencia es el operador igual (=). La forma general de las sentencias de asignación con este operador es:

variable = expression;

Java dispone de otros operadores de

Operador Utilización Expresión equivalente += op1 + = op2 op1 = op1 + op2 -= op1 -= op2 op1 = op1 - op2 *= op1 *= op2 op1 = op1 * op2 /= op1 /= op2 op1 = op1 / op2 %= op1 %= op2 op1 = op1 % op2

Tabla 3.2. Otros operadores de asignación.


93

asignación. Se trata de versiones abreviadas del operador (=) que realizan operaciones “acumulativas” sobre una variable. La Tabla 4.2 muestra estos operadores y su equivalencia con el uso del operador igual (=). 3.7.4 Operadores unarios Los operadores más (+) y menos (-) unarios sirven para mantener o cambiar el signo de una variable, constante o expresión numérica. Su uso en Java es el estándar de estos operadores. 3.7.5 Operador instanceof El operador instanceof permite saber si un objeto pertenece o no a una determinada clase. Es un operador binario cuya forma general es, objectName instanceof ClassName y que devuelve true o false según el objeto pertenezca o no a la clase. 3.7.6 Operador condicional ?: (Operador ternario) Este operador, tomado de C/C++, permite realizar decisiones condicionales sencillas. Su forma general es la siguiente:

booleanExpression ? res1 : res2

Donde se evalúa booleanExpression y se devuelve res1 si el resultado es true y res2 si el resultado es false. Es el único operador ternario (tres argumentos) de Java. Como todo operador que devuelve un valor puede ser utilizado en una expresión. Por ejemplo las sentencias:

x=1 ; y=10; z = (x<y)?x+3:y+8;

asignarían a z el valor 4, es decir x+3. 3.7.7 Operadores incremento y decremento Java dispone del operador incremento (++) y decremento (--). El operador (++) incrementa en una unidad la variable a la que se aplica, mientras que (--) la reduce en una unidad. Estos operadores se pueden utilizar de dos formas:

1. Precediendo (prefijo) a la variable (por ejemplo: ++i). En este caso primero se incrementa la variable y luego se utiliza (ya incrementada) en la expresión en la que aparece.

2. Siguiendo (posfijo) a la variable (por ejemplo: i++). En este caso primero se utiliza la variable en la expresión (con el valor anterior) y luego se incrementa.

En muchas ocasiones estos operadores se utilizan para incrementar una variable fuera de una

expresión. En este caso ambos operadores son equivalente. Si se utilizan en una expresión más complicada, el resultado de utilizar estos operadores en una u otra de sus formas será diferente. La actualización de contadores en bucles for es una de las aplicaciones más frecuentes de estos operadores.


94

3.7.8 Operadores relacionales Los operadores relacionales sirven para realizar comparaciones de igualdad, desigualdad y relación de menor o mayor. El resultado de estos operadores es siempre un valor boolean (true o false) según se cumpla o no la relación considerada. La Tabla 4.3 muestra los operadores relacionales de Java.

Estos operadores se utilizan con mucha frecuencia en las decisiones y en los bucles, que se verán en próximos apartados de este capítulo. 3.7.9 Operadores lógicos Los operadores lógicos se utilizan para construir expresiones lógicas, combinando valores lógicos (true y/o false) o los resultados de los operadores relacionales. La Tabla 4.4 muestra los operadores lógicos de Java. Debe notarse que en ciertos casos el segundo operando no se evalúa porque ya no es necesario (si ambos tienen que ser true y el primero es false, ya se sabe que la condición de que ambos sean true no se va a cumplir). Esto puede traer resultados no deseados y por eso se han añadido los operadores (&) y (|) que garantizan que los dos operandos se evalúan siempre. Operador Nombre Utilización Resultado && AND op1 && op2 true si op1 y op2 son true. Si op1 es false ya no se evalúa op2 || OR op1 || op2 true si op1 u op2 son true. Si op1 es true ya no se evalúa op2 ! negación ! op true si op es false y false si op es true & AND op1 & op2 true si op1 y op2 son true. Siempre se evalúa op2 | OR op1 | op2 true si op1 u op2 son true. Siempre se evalúa op2

Tabla 3.4. Operadores lógicos.

3.7.10 Operador de concatenación de cadenas de caracteres (+) El operador más (+) se utiliza también para concatenar cadenas de caracteres. Por ejemplo, para escribir una cantidad con un rótulo y unas unidades puede utilizarse la sentencia:

System.out.println("El total asciende a: " + result + " unidades." ) ;

donde el operador de concatenación se utiliza dos veces para construir la cadena de caracteres que se desea imprimir por medio del método println() . La variable numérica result es convertida automáticamente por Java en cadena de caracteres para poderla concatenar. En otras ocasiones se deberá llamar explícitamente a un método para que realice esta conversión. 3.7.11 Operadores que actúan a nivel de bits Java dispone también de un conjunto de operadores que actúan a nivel de bits. Las Operaciones de bits se utilizan con frecuencia para definir señales o flags, esto es, variables de tipo entero en las quecada uno de sus bits indican si una opción está activada o no. La Tabla 4.5 muestra los operadores de Java que actúan a nivel de bits.

Operador Utilización El resultado es true > op1 > op2 si op1 es mayor que op2 >= op1 >= op2 si op1 es mayor o igual que op2 < op1 < op2 si op1 es menor que op2 <= op1 <= op2 si op1 es menor o igual que op2 == op1 == op2 si op1 y op2 son iguales != op1 != op2 si op1 y op2 son diferentes

Tabla 3.3. Operadores relacionales.


95

Operador Utilización Resultado >> Op1 >> op2 Desplaza los bits de op1 a la derecha una distancia op2 << Op1 << op2 Desplaza los bits de op1 a la izquierda una distancia op2 >>> Op1 >>> op2 Desplaza los bits de op1 a la derecha una distancia op2 (positiva) & Op1 & op2 Operador AND a nivel de bits | Op1 | op2 Operador OR a nivel de bits ^ Op1 ^ op2 Operador XOR a nivel de bits (1 si sólo uno de los operandos es 1) ~ ~op2 Operador complemento (invierte el valor de cada bit)

Tabla 3.5. Operadores a nivel de bits.

En binario, las potencias de dos se representan con un único bit activado. Por ejemplo, los números (1, 2, 4, 8, 16, 32, 64, 128) se representan respectivamente de modo binario en la forma (00000001, 00000010, 00000100, 00001000, 00010000, 00100000, 01000000, 10000000), utilizando sólo 8 bits. La suma de estos números permite construir una variable flags con los bits activados que se deseen. Por ejemplo, para construir una variable flags que sea 00010010 bastaría hacer flags=2+16. Para saber si el segundo bit por la derecha está o no activado bastaría utilizar la sentencia,

if (flags&2==2){...} La Tabla 3.6 muestra los operadores de asignación a nivel de bits.

Operador Utilización Equivalente a &= op1 &= op2 op1 = op1 & op2 |= op1 |= op2 op1 = op1 | op2 ^= op1 ^= op2 op1 = op1 ^ op2 <<= op1 <<= op2 op1 = op1 << op2 >>= op1 >>= op2 op1 = op1 >> op2 >>>= op1 >>>= op2 op1 = op1 >>> op2

Tabla 3.6. Operadores de asignación a nivel de bits.

3.8 Precedencia y asociatividad de los operadores El orden en que se realizan las operaciones es fundamental para determinar el resultado de una expresión. Por ejemplo, el resultado de x/y*z depende de qué operación (la división o el producto) se realice primero. La siguiente lista muestra el orden en que se ejecutan los distintos operadores en un sentencia, de mayor a menor precedencia:


96

Operadores Precedencia

posfijo expr++ expr--

unario ++expr --expr +expr -expr ~ !

multiplicativo * / %

aditivo + -

cambio << >> >>>

relacionales < > <= >= instanceof

equivalencia == !=

AND bit a bit &

OR bit a bit exclusivo ^

OR bit a bit inclusivo |

AND logico &&

OR logico ||

ternario ? :

asignacion = += -= *= /= %= &= ^= |= <<= >>= >>>=

Tabla 3.7. Jerarquía de los Operadores.

En Java, todos los operadores binarios, excepto los operadores de asignación, se evalúan de izquierda a derecha. Los operadores de asignación se evalúan de derecha a izquierda, lo que significa que el valor de la derecha se copia sobre la variable de la izquierda.


97

UNIDAD 4. SENTENCIAS DE CONTROL EN JAVA Introducción Los algoritmos vistos hasta el momento han consistido en simples secuencias de instrucciones; sin embargo, existen tareas más complejas que no pueden ser resueltas empleando un esquema tan sencillo, en ocasiones es necesario repetir una misma acción un número determinado de veces o evaluar una expresión y realizar acciones diferentes en base al resultado de dicha evaluación. Para resolver estas situaciones existen las denominadas estructuras de control que poseen las siguientes características: • Una estructura de control tiene un único punto de entrada y un único punto de salida. • Una estructura de control se compone de sentencias o de otras estructuras de control. Tales características permiten desarrollar de forma muy flexible todo tipo de algoritmos aún cuando sólo existen tres tipos fundamentales de estructuras de control: • Secuencial. • Selección. • Repetitiva. A lo largo de esta lección se presentarán las distintas estructuras de control, la forma de representarlas en la notación algorítmica y las correspondientes sentencias JAVA para poder utilizarlas en nuestros programas. 4.1 Estructura Secuencial La estructura secuencial es la más sencilla de todas, simplemente indica al procesador que debe ejecutar de forma consecutiva una lista de acciones (que pueden ser, a su vez, otras estructuras de control); para construir una secuencia de acciones basta con escribir cada acción en una linea diferente. 4.1.1 Salida de Datos Estándar algoritmo EstructuraSecuencial{ principal( ){

imprimir( "Bienvenido al curso de Informatica 1" );

} } // Ejemplo 1 Esta aplicación Java muestra un mensaje de Bienvenida // en la salida estandar (pantalla), ó consola Java: Public class SalidaBasica1 { public static void main( String[ ] args ) { System.out.println( "Bienvenido al curso de Informatica 1" ) ; } } // Fin de la clase SalidaBasica1


98

Salida: // Ejemplo 2 Esta aplicación Java muestra imprimir con JOptionPne import javax. swing.JOptionPane ; // importa el paquete de entrada - salida de swing. public class SalidaBasica2 { public static void main( String[ ] args ) { JOptionPane.showMessageDialog(null, "Bienvenido al curso de Informatica 1") ; } } // Fin de la clase SalidaBasica3 Salida: 4.1.2 Entrada de Datos Estándar Ejemplo 1: algoritmo EntradaBasica1 { principal( ){

//Declaración de las variables cadena nombre; //Lectura de las variables nombre=leer( "Escriba su nombre y pulse ENTER o haga CLICK en aceptar: " );

//Despliegue de resultado imprimir( "Hola " + nombre + ", bienvenido a Java 2");

} } // Esta aplicación Java muestra cómo ingresar una cadena de caracteres (String) // desde el teclado.


99

import javax. swing. JOptionPane ; // importa el paquete de entrada - salida de swing. public class EntradaBasica1 { public static void main( String[ ] args ) { String nombre = JOptionPane.showInputDialog( "Escriba su nombre y pulse ENTER o haga CLICK en aceptar: " ); // Guardar el nombre en la variable nombre // Muestre en consola el nombre ingresado, concatenado con un mensaje: JOptionPane.showMessageDialog(null, "Hola " + nombre + ", bienvenido a Java 2" ) ; } } // Fin de la clase EntradaBasica1 Entrada: Salida:

Ejemplo 2: algoritmo EntradaBasica2{ principal( ){

//Declaración de las variables entero numero; //Lectura de las variables numero=leer( " Digite un numero entero y pulse ENTER o haga CLICK en aceptar: " ); //Operación aritmetica c = a + b; //Despliegue de resultado imprimir( "Usted ha digitado el numero entero " + numero);

} } // Esta aplicación Java muestra cómo ingresar un número entero // desde el teclado. import javax. swing. JOptionPane ; // importa el paquete de entrada - salida de swing. public class EntradaBasica2 { public static void main( String[ ] args ) {


100

String cadenaNum; // Declara la variable cadena del tipo String (cadena de caracteres) int numero ; // Declara la variable entero del tipo int (número entero) cadenaNum = JOptionPane.showInputDialog( " Digite un numero entero y pulse ENTER o haga CLICK en aceptar: " ); // Lee el número como una cadena de caracteres numero = Integer.parseInt(cadenaNum) ;//Convierte de String a entero (int), //pues el método parseInt( String ) de la clase Integer recibe un parámetro //String y lo convierte a su equivalente numérico en formato entero (int). // Muestre en consola el número ingresado, concatenado con un mensaje: JOptionPane.showMessageDialog(null, "Usted ha digitado el numero entero " + numero) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica2 Entrada: Salida:

//Otra forma de hacer parseo // Esta aplicación Java muestra cómo ingresar un número entero // desde el teclado. import javax. swing. JOptionPane ; // importa el paquete de entrada - salida de swing. public class EntradaBasica3 { public static void main( String[ ] args ) { int numero; // Declara la variable entero del tipo int (número entero) numero = Integer.parseInt( JOptionPane.showInputDialog( " Digite un numero entero y pulse ENTER o haga CLICK en aceptar: " )); // Muestre en consola el número ingresado, concatenado con un mensaje: JOptionPane.showMessageDialog(null, "Usted ha digitado el numero entero " + numero) ; System.exit( 0 ) ; // Salga de la Aplicación


101

} // Fin del método main( ) } // Fin de la clase EntradaBasica3 Entrada: Salida:

Ejemplo 3: algoritmo EntradaBasica4{ principal( ){

//Declaración de las variables real numero; //Lectura de las variables numero=leer( " Digite un numero real y pulse ENTER o haga CLICK en aceptar: " ); //Operación aritmetica c = a + b; //Despliegue de resultado imprimir( "Usted ha digitado el numero real " + numero);

} } // Esta aplicación Java muestra cómo ingresar un número entero // desde el teclado. import javax. swing. JOptionPane ; // importa el paquete de entrada - salida de swing. public class EntradaBasica4 { public static void main( String[ ] args ) { double numero; // Declara la variable real del tipo dobuel (número real) numero = Double.parseDouble( JOptionPane.showInputDialog( " Digite un numero real y pulse ENTER o haga CLICK en aceptar: " )); // Muestre en consola el número ingresado, concatenado con un mensaje: JOptionPane.showMessageDialog(null, "Usted ha digitado el numero real " + numero) ; System.exit( 0 ) ; // Salga de la Aplicación


102

} // Fin del método main( ) } // Fin de la clase EntradaBasica4 Entrada: Salida:

4.1.3 Ejemplo estructura secuencial algoritmo EstructuraSecuencia{ principal( ){

//Declaración de las variables entero a; entero b; entero c; //Lectura de las variables a=leer(“Digite a”); b=leer(“Digite b”); //Operación aritmetica c = a + b; //Despliegue de resultado imprimir( c );

} } En Java: import javax. swing.JOptionPane; // Importa el paquete de entrada / salida (input / output) public class EstructuraSecuencial1 { public static void main( String[ ] args ){ //Declaración de las variables double a; double b; double c; //Lectura de las variables a = Double.parseDouble( JOptionPane.showInputDialog( " Digite a" )); b = Double.parseDouble( JOptionPane.showInputDialog( " Digite b" )); //Operación aritmetica c = a + b;


103

//Despliegue de resultado JOptionPane.showMessageDialog(null, "a + b = " + c) ; System.exit( 0 ) ; // Salga de la Aplicación

} // Fin del método main( ) } // Fin de la clase EstructuraSecuencial1 NOTA: Es necesario señalar un aspecto importante de la composición secuencial y es que no es conmutativa. 4.2 Sentencias de decisión o selección

Estas son las estructuras condicionales, explicadas en la unidad 3, implementadas en java. Java admite dos sentencias de selección: if y switch. Estas sentencias permiten controlar el flujo de ejecución de un programa en java en función de condiciones conocidas sólo en tiempo de ejecución. Si su experiencia en programación no incluye C/C++, quedará gratamente sorprendido por el poder y flexibilidad de estas dos sentencias.

Pseudocodigo: Java: si if

sino else

segun switch

caso case

4.2.1 Selección simple ( if ) La sentencia if es la sentencias de ramificación condicional de Java. A continuación se muestra la notación en JAVA para la selección simple.

Cada sentencia puede ser una sentencia simple o un bloque, es decir, un conjunto de sentencias entre llaves. La condicional es cualquier expresión que devuelva un valor boolean. En el siguiente ejemplo se calcula la longitud de una circunferencia si el radio es positivo no nulo: Pseudocodigo:

si ( radio > 0 ) { longitud = 2 * Math.PI * radio ;

}

En pseudocodigo es: si( <expresión lógica> ) {

acciones }

En java es: if ( <expresión lógica> ) {

acciones }


104

Java: if ( radio > 0 ) {

longitud = 2 * Math.PI * radio ; }

4.2.2 Selección doble (if else) Esta sentencia funciona de la siguiente forma: si la condicional es true, entonces se ejecuta acciones 1. En caso contrario, se ejecuta acciones 2 (si existe). En ningún caso se ejecutarán ambas sentencias. Ejemplo

Pseudocodigo: si ( radio > 0 ) {

longitud = 2 * Math.PI * radio ; } sino { imprimir ( “Error” ) ; } Java: if ( radio > 0 ) {

longitud = 2 * Math.PI * radio ; } else { System.out.println ( “Error” ) ; }

En este ejemplo, si el radio es positivo se calcula la longitud de la circunferencia, de lo contratio muestra el siguiente mensaje “Error”. Ejemplo:- Informar si un estudiante ha superado o no un determinado examen consistente en 20 preguntas de igual valor y calcular su nota en caso de aprobar. En Pseudocodigo: algoritmo AprobarExamen1 { principal( ){

//Declaración de las variables cadena nombre ; entero numOk, faltan ;

En pseudocodigo es: si ( <expresión lógica> ) {

acciones 1 } sino { acciones 2 }

En java es: if ( <expresión lógica> ) {

acciones 1 } else { acciones 2 }


105

real nota ; //Lectura de las variables nombre=leer( "Digite su nombre : "); numOk =leer"Digite el numero de respuestas correctas (1 a 20): "); // Sentencia de decisión si: // ************************* si( numOk < 12 ) { imprimir( nombre + ", Ud. NO ha ganado el examen!!" ) ; faltan = 12 - numOk ; imprimir( "Le faltaron " + faltan

+ " respuestas correctas para obtener 3.0!!" ) ; }sino{ nota = numOk * 0.25F ;

imprimir( nombre + ", Ud. ha ganado el examen con " + "una nota de " + nota ) ; }

} } En Java: import javax. swing.JOptionPane; // Importa el paquete de entrada / salida (input / output) public class AprobarExamen1 { public static void main( String[ ] args ) { // Declaración de variables: String nombre ; int numOk, faltan ; float nota ; // Entrada de datos: nombre = JOptionPane.showInputDialog( "Digite su nombre : " ) ; numOk = Integer.parseInt(JOptionPane.showInputDialog( "Digite el numero de respuestas correctas (1 a 20): " )); // Sentencia de decisión if: // ************************* if( numOk < 12 ) { System.out.println( nombre + ", Ud. NO ha ganado el examen!!" ) ; faltan = 12 - numOk ; System.out.println( "Le faltaron " + faltan + " respuestas correctas para obtener 3.0 !!" ) ; JOptionPane.showMessageDialog(null,"Le faltaron " + faltan + " respuestas correctas para obtener 3.0 !!" ) ; }else { nota = numOk * 0.25F ; System.out.println( nombre + ", Ud. ha ganado el examen con " + "una nota de " + nota ) ; JOptionPane.showMessageDialog(null, nombre + ", Ud. ha ganado el examen con " + "una nota de " + nota ) ;


106

} System.exit( 0 ) ; } //Fin del método main( ) } Entradas:

Salidas:

4.2.3 Selección múltiple (switch) La sentencia switch es la sentencia de ramificación múltiple de java. Proporciona una forma fácil de ir a partes diferentes del código en función del valor de una expresión. De hecho, es la mejor alternativa a una larga serie de sentencias if-else-if. La sintaxis de esta estructura es la siguiente:

La implementación de la selección múltiple se escribe así, en Pseudocodigo: segun( expresión ) { // Llave de apertura del bloque según-caso caso valor1: // Acción 1: secuencia de instrucciones break ; caso valor2: // Acción 2: secuencia de instrucciones break ; …

case valorN: // Acción N: secuencia de instrucciones break ; default: // El caso default: es opcional // Acción: secuencia de instrucciones break ; // Aquí, el break ; es opcional, pues es la última del bloque según-caso } // Llave de cierre del bloque según-caso


107

En el siguiente ejemplo se proporciona como salida el número de días de un mes dado: En Pseudocodigo: algoritmo EstructuraMultialternativa1_switch { principal( ){

//Declaración de las variables entero mes ; //Lectura de las variables mes=leer("Digite un numero entero [1 a 12] para el mes: "); // Se utilizará una instrucción switch para determinar el número de // días del mes digitado (número entero de 1 a 12):

segun( mes ) { // LLave de apertura del según caso caso 1: caso 3: caso 5: caso 7: caso 8: caso 10: caso 12: imprimir( "El mes " + mes + " tiene 31 dias." ) ; break ; caso 4: caso 6: caso 9: caso 11: imprimir ( "El mes " + mes + " tiene 30 dias." ) ; break ; caso 2:

imprimir ( "Si el anio NO es bisiesto, el mes " + mes + " tiene 28 dias." ) ; imprimir ( "Si el anio es bisiesto, el mes " + mes + " tiene 29 dias." ) ; break ; default: imprimir ( "ERROR al digitar el numero para el mes" ) ; break ; // Aquí, este break; es opcional. } //LLave de cierre del switch }

La implementación de la selección múltiple se escribe así, en Java: switch( expresión ) { // Llave de apertura del bloque switch case valor1: // Acción 1: secuencia de instrucciones break ; case valor2: // Acción 2: secuencia de instrucciones break ; …

… … case valorN: // Acción N: secuencia de instrucciones break ; default: // El caso default: es opcional // Acción: secuencia de instrucciones break ; // Aquí, el break ; es opcional, pues es la última del bloque switch } // Llave de cierre del bloque switch


108

} En Java: import javax. swing.JOptionPane; // Importa el paquete de entrada / salida (input / output)

public class EstructuraMultialternativa1_switch {

// Método principal:

public static void main( String args[ ] ) {

// Declaración de variables:

int mes;

// Entrada de datos:

mes = Integer.parseInt(JOptionPane.showInputDialog( "Digite un numero entero [1 a 12] para el

mes: " ));

// Se utilizará una instrucción switch para determinar el número de

// días del mes digitado (número entero de 1 a 12):

switch( mes ) { // LLave de apertura del switch

case 1: case 3: case 5: case 7: case 8: case 10: case 12:

System.out.println( "El mes " + mes + " tiene 31 dias." ) ;

break ;

case 4: case 6: case 9: case 11:

System.out.println( "El mes " + mes + " tiene 30 dias." ) ;

break ;

case 2:

System.out.println( "Si el anio NO es bisiesto, el mes " + mes + " tiene 28 dias." ) ;

System.out.println( "Si el anio es bisiesto, el mes " + mes + " tiene 29 dias." ) ;

break ;

default:

System.out.println( "ERROR al digitar el numero para el mes" ) ;

break ; // Aquí, este break; es opcional.

} //LLave de cierre del switch

System.exit( 0 ) ;

} // Fin del método main( )

} // Fin de la clase EstructuraMultialternativa1_switch Entrada:


109

Salidas:

Nota: Obsérvese que es posible que un caso conste de múltiples valores. 4.3 Sentencias de repetición o iteración ( ciclos o bucles )

Las sentencias de iteración de Java son: for, while, do-while. Estas sentencias crean lo que común mente se llaman bucles. Como probablemente sepa, un bucle ejecuta el mismo conjunto de instrucciones hasta que se cumpla una condición de terminación. Como veremos, Java tiene un bucle adecuado para cada situación. 4.3.1 Ciclo para ( for )

Esta es una construcción poderosa y versátil.

Si sólo se ejecuta una sentencia, no es necesario utilizar las llaves ({}).

El Ciclo para se implementa así, en Pseudocodigo: para( inicialización; condición; iteración ) { // Acción: secuencia de instrucciones } El Ciclo for (para) se implementa así, en Java: for( inicialización; condición; iteración ) { // Acción: secuencia de instrucciones } 1. El ciclo (ó bucle) for es controlado por una variable que, por su oficio, también se denomina variable de

control. 2. En su forma más común, la parte de inicialización del ciclo asigna un valor inicial a la variable de control

del ciclo. 3. La condición es una expresión booleana que analiza la variable de control del ciclo. Si el resultado de ese

análisis es true (verdadero), el ciclo for continúa. Si es false (falso), el ciclo termina. 4. La expresión iteración determina cómo cambia el valor de la variable de control del ciclo en cada iteración

del mismo.


110

El ciclo for funciona de la siguiente manera: cuando el ciclo comienza la primera vez, se ejecuta la parte de inicialización. Generalmente, esta es una expresión que asigna un valor a la variable de control del ciclo, que actúa como contador para controlar el ciclo. Es importante entender que la expresión de inicialización sólo se ejecuta una vez. Después, se ejecuta la condición, que debe ser una expresión boolean. En esta expresión normalmente se compara la variable de control del ciclo con un valor determinado. Si la expresión es verdadera, entonces se ejecuta el cuerpo del ciclo. Si es falsa, entonces el ciclo termina. A continuación se ejecuta la parte de iteración, que suele ser una expresión que incrementa o decrementa la variable de control del ciclo. En cada pasada del ciclo, se vuelve a evaluar la expresión condicional, se ejecuta el cuerpo del bucle y se vuelve a ejecutar la expresión de iteración. Este proceso se repite hasta que la expresión de control se ha falsa. A continuación se muestran algunos ejemplos:

Pseudocodigo: para( int n = 1; n <= 10; n = n + 1 ) { imprimir (“n = “ + n ) ; }

Java:

for( int n = 1; n <= 10; n = n + 1 ) { System.out.println (“n = “ + n ) ; }

El ciclo anterior imprime por pantalla los números del 1 al 10. Ahora, preste atención al siguiente código:

Pseudocodigo: para( int n = 10; n <= 0; n = n + 1 ) { imprimir( “n = “ + n ) ; }

Java:

for( int n = 10; n <= 0; n = n + 1 ) { System.out.println( “n = “ + n ) ; }

El bucle anterior no se ejecuta nunca puesto que, de entrada, la condición n <= 0 (con n = 10) arroja false. ¿Qué ocurriría si, en el ciclo anterior, se cambia < por > ? Analice y responda !! Si queremos hacer lo anterior, por ejemplo con paso – 2, el código se puede escribir así:

Pseudocodigo: para( int n = 10; n >= 0; n = n - 2 ) { imprimir( “n = “ + n ) ; } Java: for( int n = 10; n >= 0; n = n - 2 ) { System.out.println( “n = “ + n ) ; }

Este bucle escribe los números pares de 10 a 0 en orden inverso.


111

La siguiente aplicación resume estos casos: Pseudocodigo: algoritmo CicloFor1{ principal( ){

//Declaración de las variables entero n ; // Se utilizará una instrucción switch para determinar el número de // días del mes digitado (número entero de 1 a 12):

// Ciclo for con paso unitario positivo: para( n = 1; n <= 10; n = n + 1 ) { imprimir( n + ", " ) ; } imprimir( "\n Ahora, el ciclo for con el paso negativo (-2):" ) ; // Ciclo for con paso negativo (-2): para( n = 10; n >= 0; n = n - 2 ) { imprimir( n + ", " ) ; } }

} Java: public class CicloFor1 { public static void main( String[ ] args ) { int n ; // Declara la variable entera n. Ésta, será la variable de control del ciclo. // Ciclo for con paso unitario positivo: for( n = 1; n <= 10; n = n + 1 ) { System.out.print( n + ", " ) ; } System.out.println( "\n Ahora, el ciclo for con el paso negativo (-2):" ) ; // Ciclo for con paso negativo (-2): for( n = 10; n >= 0; n = n - 2 ) { System.out.print( n + ", " ) ; } System.out.println( ) ; System.exit( 0 ) ; } }


112

Salida:

4.3.2 Ciclo mientras (while) La sentencia de bucle más rápida de Java es el ciclo while, que repite una sentencia o bloque mientras su expresión de control sea verdadera; la sintáxis en la notación JAVA es la siguiente:

La condición puede ser cualquier expresión booleana. El cuerpo del bucle se ejecutará mientras la expresión condicional sea verdadera. Cuando la condición sea falsa, el control pasa a la siguiente línea de código que hay inmediatamente después del ciclo, las llaves no son necesarias si el cuerpo del ciclo está formado por una única sentencia. En Pseudocodigo: algoritmo EstructuraMientras1 { principal( ){

//Declaración de las variables real radio ; //Lectura de las variables radio =leer("Digite el valor del radio (cm): ");

imprimir( "Radio antes del ciclo: " + radio ) ; imprimir( "*******************************" ) ; mientras( radio < 0 ) { // LLave de apertura del bloque while // Lee de nuevo, vía teclado, el radio: radio =leer ( "Digite el valor [ >= 0 ] del radio (cm): " ) ; imprimir( "Radio dentro del ciclo: " + radio ) ; }// LLave de cierre del bloque while imprimir( "*******************************" ) ; // Muestra el último valor del radio: imprimir( "Ultimo valor del radio: " + radio ) ; }

}

Así queda en Java: while( <Condición> ) {

// Acción: conjunto de // instrucciones que conforman el // cuerpo del ciclo.

}

Así queda en Pseudocodigo: mientras( <Condición> ) {


}


113

En Java: import javax.swing.JOptionPane; // Importa el paquete de entrada / salida (input / output)

public class EstructuraMientras1 {

// Método principal:

public static void main( String args[ ] ) {

double radio ; // Declaración de la variable real radio

// Lectura, vía teclado, de la variable radio:

radio = Double.parseDouble(JOptionPane.showInputDialog( "Digite el valor del radio (cm): " )) ;

System.out.println( "Radio antes del ciclo: " + radio ) ;

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

while( radio < 0 ) { // LLave de apertura del bloque while

// Lee de nuevo, vía teclado, el radio:

radio = Double.parseDouble(JOptionPane.showInputDialog( "Digite el valor [ >= 0 ] del

radio (cm): " )) ;

System.out.println( "Radio dentro del ciclo: " + radio ) ;

} // LLave de cierre del bloque while

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

// Muestra el último valor del radio:

System.out.println( "Ultimo valor del radio: " + radio ) ;

System.exit( 0 ) ; // Termine el programa (salir del sistema)

} // Fin del método main( )

} // Fin de la clase EstructuraMientras1 Entradas: Antes del while: Dentro del while:

Salidas:


114

Notar que mientras radio < 0 el ciclo se ejecuta. Ahora, note en la siguiente salida, que si desde la primera vez se digita un radio positivo, entonces el ciclo while no se ejecuta:

4.3.2 Ciclo haga-mientras (do-while)

Como hemos visto, si la expresión condicional de control de un ciclo while es inicialmente false, entonces el cuerpo del ciclo no se ejecutará. Sin embargo, algunas veces es necesario ejecutar el cuerpo de un ciclo al menos una vez, incluso si la expresión condicional tiene el valor false la primera vez. En otras palabras, hay ocasiones en las que se desea evaluar la expresión de terminación al final del bucle en lugar de la principio. Afortunadamente, el bucle do-while de Java perite hacer esto. El ciclo do-while siempre ejecuta su cuerpo al menos una vez, ya que su expresión condicional está en la parte inferior del ciclo. La sintáxis en la notación Java es la siguiente: Cada iteración del ciclo do-while primero ejecuta el cuerpo del ciclo, y después evalúa la expresión condicional. Si esta expresión es verdadera, el ciclo se repetirá. En caso contrario, el ciclo termina. Igual que en el resto de ciclos en Java, la condición debe ser una expresión booleana. Se aplicará el ciclo de control do-while del lenguaje de programación Java, en la implementación de un sencillo menú y su equivalencia en pseudocodigo: En Pseudocodigo: algoritmo Menu3 { principal( ){

//Declaración de las variables int opcion; haga{ imprimir( " Opciones del menu:" ) ; imprimir ( " ******************" ) ; imprimir ("" ) ; imprimir ( " 1.- Opcion 1" ) ; imprimir ( " 2.- Opcion 2" ) ; imprimir ( " 3.- Opcion 3" ) ;

Así queda en Java: do {


} while( <Condición> ) ;

Así es en Pseudocodigo: haga {


} mientras( <Condición> ) ;


115

imprimir ( " 4.- Opcion 4" ) ; imprimir ( " 5.- Terminar" ) ; imprimir ("") ; opcion = leer ( "\n Ingrese su opcion: " ) ; } mientras( opcion < 1 || opcion > 5 ) ; segun( opcion ) { caso 1: caso 2: caso 3: caso 4: imprimir( "\nUsted ha seleccionado la opcion No. " + opcion ) ; break; caso 5: imprimir ( "\nUsted ha seleccionado Terminar\n" ) ; break; } //Fin del según-caso

} } En Java: import javax.swing.JOptionPane;

public class Menu3 { public static void main( String args[] ) { int opcion; do {

opcion = Integer.parseInt(JOptionPane.showInputDialog ( " Opciones del menu: \n" +"

****************** \n 1.- Opcion 1 \n 2.- Opcion 2 \n 3.- Opcion 3 \n 4.- Opcion 4"

+ "\n 5.- Terminar \n Ingrese su opcion:"));

} while( opcion < 1 || opcion > 5 ) ;

switch( opcion ) { case 1: case 2: case 3: case 4: System.out.println( "\nUsted ha seleccionado la opcion No. " + opcion ) ; break; case 5: System.out.println( "\nUsted ha seleccionado Terminar\n" ) ; System.exit( 0 ); } //Fin del switch

} //Fin del main( )

}//Fin de la clase Menu3


116

Entrada:

Vuelve a salir la pantalla, debido a que la opción ingresada es incorrecta.

Salidas:


117

Ejercicios de Algoritmos de decisión (selectivos):

1. Elabore un algoritmo que lea tres valores diferentes y determine el mayor, el menor y el promedio. 2. Elabore un programa que valide mediante un mensaje si una pareja (x, y) pertenece o no a la

siguiente función: y = 3x - 4. Ejemplo: la pareja (2,2) sí pertenece a esta función.

3. Diseñe un algoritmo que determine e imprima la hora correspondiente al segundo después de una

hora digitada por el usuario ( hh, mm, ss ). 4. La siguiente ecuación corresponde a la ecuación general de segundo grado en la incógnita X o

ecuación cuadrática

aX2 + bX + c = 0 con a,b y c constantes y a ≠ 0

La formula general para hallar su solución es:

xb b ac

a= − ± −2 4

2

A. Elabore un algoritmo para hallar las soluciones reales. B. Haga la prueba de escritorio para las siguientes ecuaciones.

• X2 - 4X - 5 = 0 • X2 - 4X + 4 = 0 • 4X2 - 8X + 3 = 0

Nota: para efectuar la prueba de escritorio use la siguiente propiedad de las raíces de la ecuación

de segundo grado: x xb

ax x

c

a1 2 1 2+ = − ⋅ =; y

5. Modifique el algoritmo de las ecuación general de segundo grado para que calcule las raíces

imaginarias, si existen. 6. Escribir un algoritmo que permita determinar cuál es el ganador de la matricula de honor de entre

4 estudiantes . El algoritmo deberá hallar la nota definitiva de c/u de ellos (4 materias.) Si es mayor que 4.5 el alumno podrá aspirar a la matricula de honor, de lo contrario no.


118

7. Diseñe un algoritmo que determine si un año leído por el teclado es o no bisiesto. 8. Diseñar un algoritmo que permita descomponer un número ( 10 <= x <= 999 ) en sus dígitos e

imprimirlos. 9. Elabore un algoritmo que descomponga un número entero (máximo de tres cifras) en sus dígitos y

luego imprima cada uno de ellos en letras. 10. Diseñe un algoritmo que tome un valor entero positivo (máximo cuatro cifras), lo descomponga y

lo imprima invertido pero como un único número entero.

Ejemplo: sea 3845 el número digitado se debe mostrar en pantalla el número 5483 Nota: para la prueba de escritorio escriba cualquier número de cifras decrecientes en uno como

8765, 6543, 3421, etc. y restele su inverso y vera que siempre dará 3087

11. Escriba un algoritmo para la resolución de una ecuación de primer grado (ax + b = 0). 12. Diseñe un algoritmo que lea una fecha como un número entero de ocho dígitos (ddmmaaaa), y

luego imprima el mes en letras (ejemplo: si se digita el número 02011999 entonces imprime "2 de enero de 1999.")

13. Lea dos números por teclado y determine si uno es divisor del otro. 14. Se lee un número de máximo tres dígitos (verifique que efectivamente sea de máximo tres dígitos)

y se debe determinar si es un número capicúa, es decir, que leído de izquierda a derecha es igual que leído de derecha a izquierda. Por ejemplo: 727, 343, etc.

15. Usted debe realizar un algoritmo para un cajero automático, que dispone de billetes de algunas

denominaciones existentes (10000, 20000 y 50000), de forma que se le indique una cantidad a pagar y determine cuál es la combinación apropiada de billetes para formarla. La cantidad que se va a retirar debe ser un múltiplo de 10000 y el algoritmo debe chequar que así sea.

16. En una universidad se ha variado el sistema de calificaciones, por tanto se requiere un algoritmo

que indique la valoración en letras cuando se tiene la nota en números, siguiendo la tabla mostrada a continuación

Nota Numérica Valoración en letras 0.0 – 1.0 P (Pésimo) 1.1 – 2.0 M (Mal) 2.1 – 2.9 R (Regular) 3.0 – 4.0 B (Bien) 4.1 – 5.0 E (Excelente)


119

17. En una multinacional se cuenta con tres departamentos de ventas, en los cuales los empleados devengan el mismo salario. Sin embargo se tiene un incentivo de acuerdo al cual, si un departamento vende más del 50% del total de ventas, se da una bonificación del 20% del salario a

18. los empleados de ese departamento. Considerando el total de ventas como la suma de las ventas de los tres departamentos, indique cuánto devengarán los empleados de cada uno de los tres departamentos en un mes dado.

19. Realice un algoritmo que indique el valor de la función f(x) para un valor de x determinado por el

usuario. La función ha sido definida de la siguiente forma:

20. En una organización se tiene a los empleados agrupados por categoría, los de categoría 1 ganan

$20.000, los de categoría 2, $15.000, los de categoría 3, $10.000 y los de categoría 4, $7.500. Se quiere un algoritmo que permita determinar cuanto debe pagarse a un empleado si se conoce el número de horas que trabajó durante el mes y la categoría a la que pertenece. Se sabe que a todos se les descuenta un 7.2% por concepto de salud, y si el salario total devengado (mensual) es menos de 1´000.000, se le da un subsidio del 15% sobre su salario mensual (sin descuentos).

21. Se debe leer un número y determinar en qué categoría se encuentra; se sabe que la categoría A,

son los números entre 0 y 2 inclusive, la categoría B son los números entre 3 y 6 inclusive, la categoría C, los números 7 y 8, y la categoría D el número 9. (Adivinó, los números validos son entre 0 y 9).

22. Se quiere determinar el valor de depreciación de un artículo en una empresa, se sabe que el valor

de depreciación anual se determina dividiendo el valor de compra del mismo, entre el número de años de vida útil; la vida útil se determina de acuerdo a la clase de artículo, los edificios tienen 20 años, la maquinaria, muebles y enseres, 10 años, los vehículos 5 años y los computadores 3.

23. En un concesionario de vehículos, se pagan las comisiones a los vendedores según el valor de la

venta (ver tabla). Al final del mes se desea saber ¿Cuánto ganó un vendedor en total por todas las comisiones, si se sabe que hizo 4 ventas?

Valor de Venta Comisión para el Vendedor Hasta 10.000.000 2%

Más de 10 y Menos de 15 millones

4%

Mas de 15 millones 10% 24. En una empresa comercializadora, cada vendedor debe realizar 5 ventas al mes, por cada venta

ganará una comisión de acuerdo a la tabla de comisiones. Cada vendedor tiene un salario básico

f(x) = 0 para cualquier otro valor de x.

1032 −+ xx

85 +− xx

xxx 23 23 +−

10≤x

2010 << x

20>x

=)( xf


120

(que usted debe leer) y de acuerdo a la suma del básico y las comisiones, se le genera un descuento para salud, pensiones y otros como señala la tabla de descuentos. Usted debe imprimir el código del vendedor, el total de sus ventas, el total ganado por comisiones, el total devengado (básico + comisiones), el total de descuentos, y el salario a pagar por cada empleado.

Valor Venta Comisión Devengado (salario+comisiones) Descuentos 0-1.000.000 5% 0-500.000 5%

1.000.001-1.500.000 7% 500.001-1.000.000 6% 1.500.001 ó más 10% 1.000.001 ó más 8%

25. El teniente encargado del planetario desea que se diseñe un algoritmo para que al digitar el

nombre del día indique el astro que dio origen a ese nombre. Recuerde los astros:

Nombre del día Astro Domingo Sol Sábado Saturno Viernes Venus Jueves Júpiter

Miércoles Mercurio Martes Marte Lunes Luna

26. Realice el algoritmo para un algoritmo que calcule si un triángulo es isósceles, equilátero o

escaleno dados sus tres lados A, B y C

• Isósceles => dos lados iguales • Escaleno => A ≠ B ≠ C • Equilátero => A = B = C

27. Haga un algoritmo que muestre en pantalla si un ángulo es: recto, obtuso o agudo

• Recto = 90° • Agudo < 90° • Obtuso > 90°

28. Con relación a sus ángulos un triángulo puede ser:

• Rectángulo => Un ángulo recto • Acutángulo => 3 ángulos agudos • Obtusángulo => 1 ángulo obtuso

Elabore un algoritmo que calcule si un triángulo es rectángulo, acutángulo u obtusángulo.

29. Elabore un algoritmo que seleccione personal para un empleo con las siguientes características:

mujeres adultas, solteras y que practiquen algún deporte.


121

30. Para el cálculo con interés compuesto se utilizan las siguientes fórmulas:

• Hallar una cuota mensual conociendo el interés efectivo mensual (i), número de meses (n), y el precio del articulo

Cuota = Precio x ( )

( )i i

i

n

n

1

1 1

+

+ −

• Hallar el precio de un articulo conociendo el valor de la cuota mensual, el interés efectivo

mensual (i), y el número de meses (n)

Precio = Cuota x ( )

( )1 1

1

+ −

+

i

i i

n

n

• Hallar el valor futuro de una precio actual conociendo el interés efectivo mensual (i), y el número de meses (n)

Valor Futuro = Precio x (1 + i)n

Elabore un algoritmo que permita de un menú de opciones calcular el valor deseado. (cuota, precio o valor futuro)

Nota: si i = 30% se debe usar i como: i = 30%

100%= 0.3

31. Elabore un algoritmo que muestre el dígito que más se repite en un número de 5 cifras, en caso de

no repetirse ninguno imprimir un mensaje que diga "no hay dígitos repetidos". 32. El recargo por trabajar horas nocturnas en una empresa es del 70%, el recargo por trabajar festivos

es del 100%, haga un algoritmo que lea los días laboradas por un empleado, las horas nocturnas el valor de la hora normal laborada y calcule e imprima el sueldo a pagar junto con el nombre del empleado.

33. Elabore un algoritmo que tenga cuatro niveles de seguridad para un programa, si el usuario logra

ingresar imprimir el mensaje "Bienvenido", en caso contrario imprimir "Error clave" y el nivel del error.

34. Realice un algoritmo que lea cuatro números y los muestre ordenados de mayor a menor. Ejemplo:

sean los números 5, 3, 7 y 9, debe mostrar 9, 7, 5 y 3. 35. En un club deportivo se cancela la matricula según sea la categoría del deportista, elabore un

algoritmo que calcule el valor de la matricula si los precios por categoría son:

• Infantil 5-8 años $38.000= • Juvenil 9-17 años $40.100=


122

• Adultos mayores a 18 años $45.800=

Se debe hacer un recargo a la matricula del 10% para la liga. Los niños menores a 5 años no pueden ser matriculados

36. A los profesores de cierta universidad se les paga por ‘horas cátedra’ dictadas de 45 minutos.

Elabore un algoritmo que lea el número de horas dictadas en un mes, siendo estas horas de 60 minutos, y calcule el pago mensual para el profesor. Tenga en cuenta que a los profesores se les cancela según la siguiente categoría, donde se indica el precio de la ‘hora cátedra’ :

4 � $ 35.400= 3 � $ 29.200= 2 � $ 25.000= 1 � $ 22.500=

Al final al profesor se le resta el 10% de retención en la fuente.

Ejercicios sobre Algoritmos repetitivos (ciclos) 37. Realice un algoritmo que imprima en pantalla el conjunto de los (n) múltiplos de un número

entero (x) digitado por el usuario. 38. Haga un algoritmo que imprima en pantalla el conjunto de los divisores de un número entero (x)

digitado por el usuario. 39. Elabore un algoritmo que calcule el mínimo común múltiplo (m.c.m) de dos números A y B,

recuerde el m.c.m. como su nombre lo indica es el menor múltiplo común de dos o mas números. Ejemplo: sean los números 8 y 6.

m.c.m. (8, 6) = 24

40. Al divisor común que es mayor que todos los divisores comunes de dos números (A, B) se le

llama máximo común divisor (m.c.d.). Elabore un algoritmo para calcular el m.c.d. de dos números. Ejemplo: sea 8 y 12 (investigue el algoritmo de Euclides).

m.c.d. (8,12) = 4


123

41. Dos números son amigos, si cada uno de ellos es igual a la suma de los divisores del otro.

Ejemplo: 220 y 284 son amigos por que,

284 220 1 1 2 2 4 4

71 5 142 10

11 20 22 44 55 110

220 284 Elabore un algoritmo que calcule si dos número son amigos o no. 42. Elabore un algoritmo que calcule el número de días que existen entre dos fechas. Tenga en cuenta

que existen meses de 30 y 31 días y los años bisiestos. 43. Calcular usando cada uno de los tres ciclos el valor de Xn. 44. Calcule e imprima las tablas de multiplicar del 1 al 9 usando el ciclo mientras(). 45. Calcule e imprima las tablas de multiplicar del 1 al 9 usando el ciclo haga.. mientras(). 46. Calcule e imprima las tablas de multiplicar del 1 al 9 usando el ciclo para(.....). 47. Desarrolle un algoritmo que impriman las siguientes series:

� 1, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44. � 1, 4, 9, 16, 25, 36, 49, 64, 81. � 2, 4, 6, 8, 10, .....100. � -2, +4, -6, +10, ....100.

48. Elabore un algoritmo que imprima las siguientes series para (n) términos :

a.1

2

3

4

5

6

7

8

9

10− + − + −L b.

1

2

3

4

5

6

7

8

9

10! ! ! ! !− + − + −L

c.1

2

3

4

5

6

7

8

9

10

4 6 8 10

− + − + −L d.− − + + − −1

5

3

10

5

15

7

20

9

25L

Divisores

Suma


124

49. Desarrolle un algoritmo que impriman la suma de los términos de las siguientes series:

� Suma = -1 +2 -3 +4 -5, ... hasta N términos.

� Suma =+1 +4 -8 +12 +16 -20 +24 +28, -... hasta N términos.

� terminoshastaSuma N 49

1

25

1

9

1

1

1L++++=

� terminoshastaSuma N 49

1

25

1

9

1

1

1L+−+−+=

� terminoshastaxxx

xSuma N !4!3!2

1432

L+++++=


xSuma N !7!5!3

753

L+−+−=


Suma N !6!4!2

1642

L++++=

� !!7!5!3

1753

n

xxxxxSuma

n

L+++++= (no son exactamente n términos)

� !!4!3!2

1432

n

xxxxxSuma

n

L+++++= (no son exactamente n términos)

50. Escriba un algoritmo que calcule el factorial de un número N. (Ejemplo: el factorial de 4 es igual a: 1x2x3x4=24)

51. Determine el valor del combinatorio C(m,n), definido como ( )! !

!

nmn

m

−

52. Escriba un algoritmo para calcular si un número es primo o no, recuerde que los números primos

son aquellos que solo son divisibles por la unidad y por ellos mismos: ejemplo 5, 11, 17, etc.. 53. Calcular mediante un algoritmo cuantos números primos existen entre 1 y un número M dado por

el usuario. 54. Escriba un algoritmo que muestre el cuadrado de los números del 1 al 50.


125

55. Diseñar un algoritmo para determinar la cantidad de mujeres y de hombres que hay en un grupo de N estudiantes (máximo 45). Además se debe hallar el promedio de edad y de estatura del grupo. (el usuario digitará para cada integrante del grupo, su sexo, edad y estatura).

56. Desarrolle un algoritmo que permita seleccionar personal para un empleo de un total de N

aspirantes. Los aspirantes deben cumplir las siguientes condiciones para ser aceptados: Mayores de edad Ser ingeniero titulado Tener experiencia laboral

Al final el algoritmo debe mostrar el total de aspirantes aceptados. 57. Desarrolle un algoritmo que permita calcular el valor de la tangente de un ángulo dado en grados

usando la serie de Taylor del seno y del coseno. 58. Diseñe un algoritmo que calcule e imprima la suma de los números pares e impares comprendidos

entre 1 y 100. 59. Leer N números y calcular el mayor sin importar que se repita. 60. Leer N números y calcular el menor sin importar que se repita. 61. Leer una serie de M números y mostrar al final cuantos son positivos. 62. Calcular la suma de los cuadrados de los números comprendidos entre 1 y N. 63. Leer 10 números y al final imprimir el promedio de estos. 64. Desarrolle un algoritmo que calcule el valor de π usando la siguiente serie:

L⋅⋅⋅⋅⋅⋅⋅⋅⋅=9

10

9

8

7

8

7

6

5

6

5

4

3

4

3

24π

El número de términos debe ser dado por el usuario (entre mayor sea el número de términos mayor será la precisión del cálculo).

65. Se desea calcular la resistencia equivalente en paralelo de un circuito de N resistencias, para lo cual se le pide que diseñe un algoritmo.

NRRRR

1111 paralelo eequivalent aResistenci

321

+++= L


126

66. Se desea calcular la resistencia equivalente en serie de un circuito de N resistencias, para lo cual se

le pide que diseñe un algoritmo.

NRRRR ++++= L321 serie eequivalent aResistenci

67. Implemente un algoritmo que lea un número entero y lo muestre invertido. 68. Calcular y mostrar los N primeros términos de la serie de Leonardo Fibonacci.

Fibonacci = 0,1, 1, 2, 3, 5,... 69. Calcular suma de los primeros 100 términos de la serie de Fibonacci. 70. Elaborar un algoritmo que convierta un número entero positivo, menor a 257 a sistema binario 71. Elabore un algoritmo que permita convertir un número entero positivo (máximo cuatro cifras) en

su equivalente en sistema octal. 72. Escribir un algoritmo que halle el número de años bisiestos en un intervalo dado por el usuario

(año bisiesto – sí es múltiplo de 4, pero sí es múltiplo de 100 deberá ser también múltiplo de 400). 73. Realizar la tabla de multiplicar de x (número digitado por el usuario, puede ser positivo o

negativo), desde 1 hasta n (número digitado por el usuario, puede ser positivo o negativo). 74. Dada la siguiente serie determine el valor de la suma de sus términos. La serie termina cuando (M-

N)2 sea igual a 0, El valor de M debe ser dado por el usuario. Serie: 1,2,3, (M-0)2,4,5,6,(M-1)2,7,8,9,(M-2)2,.......(M-N)2

75. Dada una fecha (mes, día, año) indicar cuantos días (exactos) han transcurrido desde ese año. 76. En un curso hay 20 alumnos, cada alumno tiene diferente número de notas, se quiere determinar el

promedio de cada estudiante, y el número de estudiantes que perdieron la materia (menos de 3.0). NOTA: La nota definitiva de un estudiante corresponde al promedio simple de sus notas.

77. Se deben leer números hasta que se digite 99 (el 99 no se debe contar), y determinar cuantos

primos hay, y cuantos pares. (recuerde que estas dos condiciones no son exclusivas). 78. Leer un número en base 10, y determinar su equivalente en cualquier base entre 2 y 16. (Puede

escribir el número al revés en la base indicada)


127

79. Elabore un algoritmo para que dos personas puedan jugar tres en línea. El ganador es quien

primero logre colocar tres figuras en línea (ver figura). Como ayuda muestre los cuadros numerados del 1 al 9 a los jugadores para que escojan su jugada.

80. Elabore un algoritmo que lea cinco notas de (n) números de estudiantes, y que calcule e imprima

el promedio de cada alumno y el promedio del grupo además de la nota del estudiante de mayor y menor promedio.

81. Un número es perfecto si la suma de sus divisores excepto él mismo es igual al propio número.

Ejemplos: Número: 6 28 36 Divisores---> 1 1 1 2 2 2 3 4 3 7 4 14 6 9 12 18

Suma 6 28 55 De lo anterior el 6 y el 28 son números perfectos, el 36 no lo es. Desarrolle un algoritmo que Calcule si un número es perfecto o no. 82. Elabore un algoritmo que genere un número aleatorio y que les dé la posibilidad a dos jugadores

de adivinar dicho número, el algoritmo debe pedir el número de partidas, intercalar los turnos para adivinar, mostrar el ganador por partida y el ganador final. El número debe estar entre 0-9. (Use la función aleatorio.)

83. Elabore un algoritmo que lea las ventas de (n) número de vendedores, para los productos (A, B, C,

D y C), si los precios de los productos son ($1000, $2345, $3876, $1235 y $550) respectivamente, calcule el número individual y total de productos vendidos, las ventas totales por producto, el promedio total de ventas, el producto mas vendido, el menos vendido, el vendedor que más ventas realizó.

84. Realice un algoritmo que calcule la suma de (n) números, el producto de estos y cuantos de estos

son negativos y cuantos positivos. Estos datos deben ser mostrados por pantalla.

o x o

o x x

x x o

1 2 3

4 5 6

7 8 9


128

85. Haga un algoritmo que lea las notas de (n) estudiantes, que indique el número de estudiantes que

ganaron la materia (mayor o igual a 3.0), el numero de los que la perdieron (menor o igual a 3), además de indicar cuantos deben habilitar la materia (notas entre 2.5 y menores a 3.0). Todos los datos deben ser mostrados por pantalla.

86. Realice un algoritmo que lea (n) números y halle el mayor número par, el mayor impar, y el

producto de estos dos números. Estos datos deben ser mostrados por pantalla.

87. Elabore un algoritmo para calcular de (n) números leídos cuantos son primos y cuantos no, y los mayores de cada grupo.

88. Haga un algoritmo que lea un número entero de 4 cifras (base 10) y que lo convierta a un binario

(base 2) y un octal (base 8). Utilice instrucciones repetitivas (use el operador residuo).

89. Un profesor necesita calcular las notas finales de su curso, para ello dispone de 7 notas, las 3 primeras componen la nota definitiva de quiz y talleres con un valor de 25%, la 4 nota corresponde al primer examen parcial con un 25%, la 5 al segundo examen parcial con un 25%, las dos ultimas (6 examen escrito y 7 trabajo opcional) al examen final con un valor de 25%.

El profesor desea obtener los siguientes resultados para cada estudiante:

• La nota definitiva de quiz y talleres (promedio de las 3 primeras notas) • La nota definitiva del examen final (en el caso de haber presentado opcional) • La nota final del estudiante

Estos datos deben ser mostrados en pantalla junto con las demás notas.

Desea conocer también cuantos aprobaron el curso (notas superiores a 3.0) y cuantos no cumplieron con los objetivos de este (notas menores a 3.0) y también obtener la mejor nota para promover este estudiante como monitor de la materia para el próximo semestre. (estos últimos datos se deben mostrar por pantalla al final del calculo de las notas finales de todo el curso).

90. Elabore un algoritmo que imprima cual es el vendedor del mes de una empresa. Tabla de Precios

Producto Precio A $57000 B $62000 C $83000

Para lograr el cálculo se leen las cantidades de productos vendidos por cada uno de los M vendedores de la empresa y siguiendo la tabla de precios se determina el mejor como aquel que mayores ventas haya tenido.


129

91. Use la siguiente fórmula para calcular la raíz cuadrada de un número entero positivo:

Raíz = 0.5* )(1

1 X

NX +

Donde N es el número del que se desea conocer la raíz y X1 es una variable que se le asigna un valor inicial de 1. Con estos dos valores iniciales se obtiene el primer valor de la variable Raíz. Si el valor absoluto de |Raíz - X1| es mayor a 0.0000001 se le reasignará a X1 el contenido de la variable Raíz y se hará un nuevo calculo hasta que el valor absoluto sea menor, que es cuando se obtiene el valor real de la raíz.

92. Escriba un programa que calcule el resultado de la siguiente serie para N términos.

L+−+−=!7!5!3

1R642 XXX

93. Algunos pueblos de Rusia emplean el siguiente método para multiplicar: escriben los dos factores uno al lado del otro y se forman con ellos dos columnas: debajo del factor que está a la izquierda se toma la mitad en números enteros, es decir despreciando fracciones, y de esta mitad se toma la mitad, y así sucesivamente hasta llegar a 1; debajo del factor que está a la derecha, y paralelamente, se escribe su duplo, y así sucesivamente hasta emparejar con el ultimo número de la columna de la izquierda, como puede verse en el ejemplo, se tachan de la columna de la derecha todos los números colocados enfrente de los número pares de la otra columna y se suman todos los números no tachados de esta columna; esta suma será el resultado de la multiplicación.

Elabore un algoritmo que emplee este método para multiplicar dos números.

Ejemplo: Multiplicar 22 x 6 = 132

22 X 6 11 12 5 24 2 48 1 96 132


130

UNIDAD 5. MÉTODOS Introducción Cuando se elabora un programa para computador es muy probable que un conjunto de instrucciones (ó fragmento de código ) se requiera ejecutar con determinada frecuencia. Dicho fragmento de código posiblemente necesite de datos que deban ser procesados para ejecutar una tarea específica. Esta situación se puede manejar eficiéntemente si el fragmento de código se escribe ( ó implementa ) en un lugar del programa separado del código principal. La idea que subyace detrás de esto es que el código principal pueda llamar ( ó invocar ) el fragmento de código y, si él lo requiere, enviarle los datos necesarios para que cumpla su misión. Algunos beneficios que se desprenden de este enfoque son: la reutilización del código cada vez que ello se necesario, se facilita el mantenimiento de la aplicación, la búsqueda de errores será menos complicada y se reduce el número de líneas de código del programa completo. 5.1 Definición de Métodos Lo anterior nos lleva al concepto de método. Un método es el conjunto de instrucciones ( ó fragmento de código ) que se implementa para ejecutar una tarea específica y que posiblemente requiera de datos de entrada para poder cumplir el propósito para el cual fue diseñado. Existen dos tipos de métodos, aquellos que devuelven un valor único y aquellos que ejecutan alguna acción distinta de devolver un único valor. Un método es un servicio que prestan los objetos de la clase de donde fue declarado. Un método esta conformado por: Signatura + Cuerpo La signatura esta conformada por: tipoMetodo + nombreMetodo + listaDeParametros El tipoMetodo puede ser de 2 tipos: void (sin retorno) y no void(byte, int, float, doublé, String,etc). El nombreMetodo debe ser un identificar valido y descriptivo. El parámetro, viene de pareja, esta formado por un tipo y un identificador valido. Por ejemplo, el método readLine( ) está diseñado para leer una línea de datos digitada desde el teclado y devuelve la misma línea como una cadena de caracteres ( String ). Observe el siguiente fragmento de código Java (suponiendo que ya se importo el paquete swing): // Declaración de dos variables: String edadS ;

byte edad ;

// Entrada de datos: // Lee la edad digitada y la devuelve ( ó convierte ) como una cadena //(String ) que será almacenad //en la variable edadS de tipo String.


131

edadS = JOptionPane.showInputDialog "Digite su edad: " ) ; edad = Byte.parseByte( edadS ) ; //Convierte la cadena edadS a un entero del tipo byte y lo asigna en

//la variable edad también de tipo byte.

Ahora, el método println( ) es un ejemplo de un método que realiza alguna acción distinta de devolver un valor único. Este método toma la expresión digitada entre los paréntesis ( expresión que se denomina ‘argumento del método’ ) y la convierte a una cadena de caracteres ( String ) para ser desplegada en la pantalla. Observe la siguiente línea de código: System.out.println( “Edad digitada: " + edad ) ;

Nota: Los métodos que realizan alguna acción distinta de devolver un valor se denominan métodos

void

EJERCICIOS RESUELTOS

Ejemplos con métodos en Java

Ejercicio 1: Escriba una aplicación java que defina y utilice un método para calcular el factorial de un número entero no negativo. El número debe ser solicitado e ingresado desde el teclado. (Ejemplo: el factorial de 5 se denota como 5!, se lee “5 factorial” y se define como: 1 x 2 x 3 x 4 x 5 = 120 ). import javax.swing.JOptionPane; public class TestFactorial2 { public static void main( String[ ] args ) { int n; double nfact ; TestFactorial2 obj = new TestFactorial2( ) ; do{ n = Integer.parseInt(JOptionPane.showInputDialog( "Digite un número entero NO negativo: ")); if( n < 0 ) { System.out.println( "El numero debe ser NO negativo!!" ) ; } } while( n < 0 ) ; nfact = obj.fact( n ) ; System.out.println( n + " ! = " + nfact ) ; JOptionPane.showMessageDialog( null, n + " ! = " + nfact, "Factorial", JOptionPane.INFORMATION_MESSAGE ) ; System.exit( 0 ) ; }


132

// Método factorial: public double fact( int p ) { double prod = 1 ; for( int i = 1; i <= p; i ++ ) { prod = prod * i ; // prod *= i ; } return prod ; } } Entradas:

Salidas:

Ejercicio 2: Calcular los factoriales de varios números enteros no negativos ingresados desde el teclado. import javax.swing.JOptionPane ; public class TestFactorialVariosNum2 { public static void main( String[ ] args ) { int cn, num ; String cad ; TestFactorialVariosNum2 obj = new TestFactorialVariosNum2( ) ;


133

do { cn = Integer.parseInt(JOptionPane.showInputDialog( "Digite la cantidad de números a los cuales se les va a " + "calcular el factorial: " ) ) ; if( cn < 1 ) System.out.println( "La cantidad debe ser positiva!!" ) ; } while( cn < 1 ) ; for( int i = 1 ; i <= cn ; i ++ ) { do { num = Integer.parseInt( JOptionPane.showInputDialog( "Digite el número entero NO negativo # " + i + ": " ) ) ; if( num < 0 ) { System.out.println( "El numero debe ser NO negativo!!!" ) ; } } while( num < 0 ) ; cad = num + " ! = " + obj.fact( num ) ; System.out.println( cad ) ; JOptionPane.showMessageDialog( null, cad, "Factorial", JOptionPane.INFORMATION_MESSAGE ) ; } System.exit( 0 ) ; } // Método factorial: public double fact( int p ) { double prod = 1 ; for( int i = 1; i <= p; i ++ ) { prod = prod * i ; // prod *= i ; } return prod ; } }


134

Entradas:

Salidas:

Ejercicio 3: El combinatorio de dos números enteros no negativos, n y k, con n >= k, se denota como c(n, k) y se define así:

c(n, k) = ( )! !

!

knk

n

−

Escriba una aplicación java que lea los valores de n y de k y, usando dos métodos, determine el valor del combinatorio. import javax.swing.JOptionPane ; public class TestCombinatorio3 { public static void main( String[ ] args ) { int n, k ;


135

double comb ; String str ; TestCombinatorio3 obj = new TestCombinatorio3( ) ; do { n = Integer.parseInt( JOptionPane.showInputDialog( "Digite un número entero (n) NO negativo: " ) ) ; k = Integer.parseInt( JOptionPane.showInputDialog( "Digite otro número entero (k) NO negativo, " + "que sea <= que el anterior: " ) ) ; if( n < k || k < 0 ) { System.out.println( "!OJO! n >= k >= 0" ) ; } } while( n < k || k < 0 ) ; comb = obj.nCk( n, k ) ; //Invoca al primer método str = n + " Combinatorio " + k + " = " + comb ; System.out.println( str ) ; JOptionPane.showMessageDialog( null, str, "Combinatorio", JOptionPane.INFORMATION_MESSAGE ) ; System.exit( 0 ) ; } // Método combinatorio (primer método): public double nCk( int np, int kp ) { double resp ; // Variable local resp = fact( np ) / ( fact( kp ) * fact(np - kp) ) ; //Invoca al segundo método return resp ; } // Método factorial (segundo método): public double fact( int p ) { double prod = 1 ; // Variable local for( int i = 1 ; i <= p ; i ++ ) { prod = prod * i ; // prod *= i ; } return prod ; }


136

} Entradas:

Salida:

Ejercicio 4: La serie de Maclaurin de la función Seno está dada por la expresión

Sen( x ) = x x x x x

1 3 5 7 9

3 5 7 9

! ! ! ! !− + − + −L

Siendo x un ángulo en radianes. Escriba una aplicación Java que lea el número de términos de la serie y el valor de un ángulo en grados para determinar el valor del seno de ese ángulo. Tenga presente que debe convertir el ángulo de grados a radianes. Utilice los métodos que considere necesarios. import javax.swing.JOptionPane ; import java.text.DecimalFormat ; public class TestSenoAngRad3 { public static void main( String[ ] args ) { int n ; // Número de términos de la serie


137

double x, angRad, tno, serie = 0 ; String cad ; char cont ; TestSenoAngRad3 obj = new TestSenoAngRad3( ) ; DecimalFormat df = new DecimalFormat( "0.00000" ) ; // Redondear con 5 decimales do { // Invoca el método que solicita y valida el número de términos. // El valor entero retornado por el método es guardado en la // variable entera n n = obj.leerNtnos( ) ; // Solicita el ángulo en grados: x = Double.parseDouble( JOptionPane.showInputDialog( "Digite el ángulo en grados: " ) ) ; // Invoca el método que convierte el ángulo en grados a su // equivalente en radianes. El valor real retornado por el método // es guardado en la variable real angRad angRad = obj.convertirGradRad( x ) ; // Invoca el método que calcula el seno de un ángulo en grados // utilizando la serie de Maclaurin de la función seno. // El valor real retornado por el método es guardado en la // variable real serie serie = obj.senoMaclaurin( n, angRad ) ; cad = "Sen( " + x + " grados ) = " + df.format( serie ) ; System.out.println( cad ) ; JOptionPane.showMessageDialog( null, cad, "Seno", JOptionPane.INFORMATION_MESSAGE ) ; cont = JOptionPane.showInputDialog( " ¿ Desea probar con otros ángulos ? ( Sí / No )" ).charAt( 0 ) ; } while( cont == 's' || cont == 'S' ) ; System.exit( 0 ) ; }


138

// Método que pide y valida el número de términos: public int leerNtnos( ) { int nt ; // Variable local do { nt = Integer.parseInt( JOptionPane.showInputDialog( "Digite la cantidad de términos usados en la serie: " ) ) ; if( nt < 1 ) System.out.println( "El numero de terminos debe ser >= 1" ) ; } while( nt < 1 ) ; return nt ; } // Método que convierte el valor del ángulo en grados a radianes. // El método retorna el ángulo equivalente entre cero y 2*PI radianes. public double convertirGradRad( double xp ) { double x1 ; // Variable local x1 = xp % 360 ; // Para que 0 <= xp < 360 grados x1 = x1 * Math.PI / 180 ; // Convierta a radianes return x1 ; } // Método que calcula el seno de un ángulo empleando el desarrollo en // serie de Maclaurin de la función seno. public double senoMaclaurin( int n, double angRad ) { double tno, suma = 0 ; // Variables locales for( int i = 1; i <= n; i ++ ) { tno = Math.pow( angRad, 2 * i - 1 ) / fact( 2 * i - 1 ) ; // Se invocó el método factorial ( fact ) if( i % 2 == 0 ) { suma -= tno ; } else { suma += tno ; } } return suma ; }


139

// Método factorial: public double fact( int p ) { double prod = 1 ; for( int i = 1; i <= p; i ++ ) { prod = prod * i ; // prod *= i ; } return prod ; } } Entradas:

Salidas:

Ejercicio 5: Escriba una aplicación java que solicite dos números reales como operandos de la operaciones aritméticas básicas. Utilice un menú para seleccionar la operación a ejecutar. Debe emplear un método para cada opción seleccionada. import javax.swing.JOptionPane ; public class MenuOperacionesAritmeticasB { public static void main( String[ ] args ) { // Declaración de variables: double num1, num2, resp ; String menu ; int opcion ;


140

char cont ; MenuOperacionesAritmeticasB obj = new MenuOperacionesAritmeticasB( ) ; // Lectura de los operandos num1 y num2: num1 = Double.parseDouble( JOptionPane.showInputDialog( "\n Digite el primer número: " ) ) ; num2 = Double.parseDouble( JOptionPane.showInputDialog( "\n Digite el segundo número: " ) ) ; // Asignación del texto del menú en la variable menu: menu = "\n\tOpciones del menu:\n\n\t1.- Suma\n\t2.- Resta" + "\n\t3.- Multiplicacion\n\t4.- Division\n\t5.- Residuo" + "\n\t6.- Terminar\n\n\tIngrese su opción: " ; do { // Presentación del menú: do { // Lectura de la opción escogida: opcion = Integer.parseInt( JOptionPane.showInputDialog( menu ) ) ; } while( opcion < 1 || opcion > 6 ) ; // 1 <= opcion <= 6 switch( opcion ) { case 1: resp = obj.suma( num1, num2 ) ; break ; case 2: resp = obj.resta( num1, num2 ) ; break ; case 3: resp = obj.multiplicacion( num1, num2 ) ; break ; case 4: resp = obj.division( num1, num2 ) ; break ; case 5: resp = obj.residuo( num1, num2 ) ; break ; case 6: obj.terminar() ;


141

} // Fin del switch cont = JOptionPane.showInputDialog( "¿Desea probar con otras operaciones ( S / N ) ?").charAt( 0 ) ; } while( cont == 'S' || cont == 's' ) ; System.exit(0) ; } // Fin del método main( ) public double suma( double n1, double n2 ) { double r = n1 + n2 ; String cad = "\n\t" + n1 + " + " + n2 + " = " + r ; System.out.println( cad ) ; JOptionPane.showMessageDialog( null, cad, "SUMA", JOptionPane.PLAIN_MESSAGE ) ; return r ; } public double resta( double n1, double n2 ) { double r = n1 - n2 ; String cad = "\n\t" + n1 + " - " + n2 + " = " + r ; System.out.println( cad ) ; JOptionPane.showMessageDialog( null, cad, "RESTA", JOptionPane.INFORMATION_MESSAGE ) ; return r ; } public double multiplicacion( double n1, double n2 ) { double r = n1 * n2 ; String cad = "\n\t" + n1 + " * " + n2 + " = " + r ; System.out.println( cad ) ; JOptionPane.showMessageDialog( null, cad, "MULTIPLICACIÓN", JOptionPane.WARNING_MESSAGE ) ; return r ; } public double division( double n1, double n2 ) { String cad ; double r = 0 ; if( n2 != 0 ) { r = n1 / n2 ; cad = "\n\t" + n1 + " / " + n2 + " = " + r ;


142

System.out.println( cad ) ; JOptionPane.showMessageDialog( null, cad, "DIVISIÓN", JOptionPane.INFORMATION_MESSAGE ) ; } else { cad = "\n\tNO se puede dividir entre cero !!" ; System.out.println( cad ) ; JOptionPane.showMessageDialog( null, cad, "ERROR DIVISIÓN", JOptionPane.ERROR_MESSAGE ) ; } return r ; } public double residuo( double n1, double n2 ) { String cad ; double r = 0 ; if( n2 != 0 ) { r = n1 % n2 ; cad = "\n\t" + n1 + " % " + n2 + " = " + r ; System.out.println( cad ) ; JOptionPane.showMessageDialog( null, cad, "RESIDUO", JOptionPane.INFORMATION_MESSAGE ) ; } else { cad = "\n\tNO se puede obtener el residuo al " + "dividir entre cero !!" ; System.out.println( cad ) ; JOptionPane.showMessageDialog( null, cad, "ERROR RESIDUO", JOptionPane.ERROR_MESSAGE ) ; } return r ; } public void terminar( ) { String cad = "\n\tUsted ha seleccionado Terminar\n" ; System.out.println( cad ) ; JOptionPane.showMessageDialog( null, cad, "TERMINAR", JOptionPane.PLAIN_MESSAGE ) ; System.exit(0) ; } } // Fin de la clase MenuOperacionesAritmeticas


143

Entradas:

Salidas:


144

Ejercicio 6: Escriba una aplicación java que solicite los dos primeros términos de una sucesión de Fibonacci y el número de términos a generar. El programa debe mostrar la sucesión generada. Debe utilizar un método que reciba como parámetro el número de términos y retorne el término generado por la sucesión en esa posición. La fórmula que genera cada término de Fibonacci es:

Término actual = Término último + Término penúltimo import javax.swing.JOptionPane ; public class TestFibo2 { public static void main( String[ ] args ) { byte numtnos ; double tno ; TestFibo2 obj = new TestFibo2( ) ; do { numtnos = Byte.parseByte( JOptionPane.showInputDialog( "Entre un número entero mayor que 2 ( por ej. 7 ):" ) ) ; } while( numtnos <= 2 ) ; tno = obj.fibonacci( numtnos ) ; System.out.println( ) ; JOptionPane.showMessageDialog( null, "El término número " + numtnos + " es " + tno ) ; System.exit( 0 ) ; } public double fibonacci( byte n ) { int p, u, a = 0 ; p = Integer.parseInt( JOptionPane.showInputDialog( "Entre el primer número entero de la sucesión de Fibonacci:" ) ) ; u = Integer.parseInt( JOptionPane.showInputDialog( "Entre el segundo número entero de la sucesión de Fibonacci:" ) ) ; System.out.print( p + ", " + u + ", " ) ; for( int k = 3; k <= n; k ++ ) { a = p + u ; System.out.print( a + ", " ) ; p = u ; u = a ; } return a ;


145

} } Entradas:

Salidas:

import javax.swing.JOptionPane ; public class CuentaAhorros1 { // Variable de instancia: es una variable que se declara dentro de // la clase PERO fuera de todos los métodos. La variable de instancia es


146

// visible desde el interior de cualquier método de la clase. double saldo = 0 ; // Método principal: public static void main( String[ ] args ) { double cant = 0 ; char cont ; // Creo un objeto de mi clase para, desde él, utilizar sus métodos: CuentaAhorros1 obj = new CuentaAhorros1( ) ; obj.abrirCuenta( ) ; obj.consultarSaldo( ) ; do { cant = Double.parseDouble( JOptionPane.showInputDialog( "Digite la cantidad que va a consignar: $ " ) ) ; obj.consignar( cant ) ; obj.consultarSaldo( ) ; cant = Double.parseDouble( JOptionPane.showInputDialog( "Digite la cantidad que va a retirar: $ " ) ) ; obj.retirar( cant ) ; obj.consultarSaldo( ) ; cont = JOptionPane.showInputDialog( "¿ Desea probar de nuevo ? ( Sí / No )" ).charAt( 0 ) ; }while( cont == 'S' || cont == 's' ) ; System.exit( 0 ) ; } // Método para abrir la cuenta: public void abrirCuenta( ) { do { saldo = Double.parseDouble( JOptionPane.showInputDialog( "Digite la cantidad con la cual abrirá su cuenta ( >= $ 20000 ): $ " ) ) ; } while( saldo < 20000 ) ; }


147

// Método para consultar saldo: public void consultarSaldo( ) { System.out.println( "Nuevo saldo: $ " + saldo ) ; } // Método para consignar dinero: public void consignar( double deposito ) { if( deposito <= 0 ) { System.out.println( "Ha digitado una cantidad negativa " + "o nula: $ " + deposito ) ; return ; } saldo += deposito ; } // Método para retirar dinero: public void retirar( double retiro ) { if( retiro <= 0 || retiro % 10000 != 0 ) { System.out.println( "Solo puede retirar una cantidad " + "positiva multiplo de $ 10000. Try Again !!! " ) ; return ; } if( saldo - retiro < 20000 ) { System.out.println( "NO puede retirar: Recuerde que debe " + "dejar un saldo de $ 20000 o superior !!!! " ) ; return ; } saldo -= retiro ; } } Ver respuestas del sistema en página siguiente.


148

Respuestas del sistema:

modulo grado11

Documents