Apunte De Aed1.pdf

ALGORITMOSYYESTRUCTURAS ESTRUCTURAS DE ALGORITMOS DEDATOS DATOSI I Primer Año – Primer Semestre

PRIMER AÑO – PRIMER SEMESTRE

Carrera: Carrera:

Técnico en de Sistemas Analista Telecomunicaciones Ing. Eduardo Mansilla ING. EDUARDO MANSILLA

– ISSD – EDUARDO MANSILLA –

-2-

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Indice General INDICE GENERAL ________________________________________________ 3 CLASE NÚMERO: 1 ______________________________________________ 7 INTRODUCCIÓN DE LA MATERIA _______________________________________ 7 CONCEPTOS PRINCIPALES ___________________________________________ 8 SÍMBOLOS NORMALIZADOS EN LA DIAGRAMACIÓN _______________________ 8 VENTAJAS DE UN DIAGRAMA DE FLUJO _________________________________ 9 Programa: _____________________________________________________ 9 Algoritmo: _____________________________________________________ 9 Variable: ______________________________________________________ 9 TIPOS DE VARIABLES ______________________________________________ 11 Tipo char _____________________________________________________ 11 Tipo int ______________________________________________________ 11 Tipo float _____________________________________________________ 11 Tipo String ___________________________________________________ 12 OPERADORES ARITMÉTICOS ________________________________________ 12 ESTRUCTURAS SECUENCIALES _______________________________________ 12 EJERCICIOS PROPUESTOS ______________________________________ 20 CLASE NÚMERO: 2 _____________________________________________ 21 ESTRUCTURAS CONDICIONALES _____________________________________ 21 OPERADORES RELACIONALES _______________________________________ 22 Estructura Condional Compuesta __________________________________ 25 Operador “%” _________________________________________________ 27 OPERADORES LÓGICOS ____________________________________________ 29 Tipo “boolean” ________________________________________________ 29 Utilización de los operadores lógicos _______________________________ 29 EJERCICIOS PROPUESTOS ______________________________________ 33 CLASE NÚMERO: 3 _____________________________________________ 35 ESTRUCTURA CONDICIONAL ANIDADA ________________________________ 35 ACTIVIDADES ____________________________________________________ 41 INSTRUCCIÓN SWITCH - CASE _______________________________________ 45 Comentarios___________________________________________________ 49 Comentarios de varias líneas ____________________________________ 49 EJERCICIOS PROPUESTOS ______________________________________ 51 CLASE NÚMERO: 4 _____________________________________________ 53 ESTRUCTURA REPETITIVA __________________________________________ 53 ESTRUCTURA WHILE ______________________________________________ 53 Contadores____________________________________________________ 54 Acumulador ___________________________________________________ 57 Impresión de series matemáticas ___________________________________ 61 ACTIVIDADES ____________________________________________________ 62 – Algoritmos y Estructuras de Datos I –

-3-

– ISSD – EDUARDO MANSILLA – Ingreso de valores hasta que se digite una clave ______________________ 67 EJERCICIOS PROPUESTOS ______________________________________ 70 CLASE NÚMERO: 5 _____________________________________________ 71 ESTRUCTURA FOR ________________________________________________ 71 ACTIVIDADES ___________________________________________________ 80 Búsqueda del mayor de una serie de números ingresados. ______________ 82 EJERCICIOS PROPUESTOS ______________________________________ 85 CLASE NÚMERO: 6 _____________________________________________ 87 ESTRUCTURA DO..WHILE __________________________________________ Concepto De Bandera __________________________________________ Posicionamiento del Cursor ______________________________________ Generación de números aleatorios ________________________________

87 93 93 96

EJERCICIOS PROPUESTOS ______________________________________ 99 CLASE NÚMERO: 7 ____________________________________________ 101 ARRAY _______________________________________________________ Introducción _________________________________________________ Vectores ____________________________________________________ Carga e Impresión de un Vector _________________________________

101 101 102 102

EJERCICIOS PROPUESTOS _____________________________________ 116 CLASE NÚMERO: 8 ____________________________________________ 117 MÉTODOS EN JAVA ______________________________________________ Introducción _________________________________________________ CLASES EN JAVA ________________________________________________ ZONAS DE UN PROGRAMA COMPLETO EN JAVA ________________________ MÉTODO QUE DEVUELVEN O RETORNAN UN VALOR _____________________ Vectores utilizando Métodos ____________________________________ VECTORES PARALELOS ___________________________________________

117 117 118 118 122 123 131

EJERCICIOS PROPUESTOS _____________________________________ 135 CLASE NÚMERO: 9 ____________________________________________ 137 PROCESOS ALGORÍTMICOS ________________________________________ MAYOR Y MENOR ELEMENTO DE UN VECTOR _________________________ Funciones básicas para el manejo de cadenas de caracteres ___________ Busqueda de un elemento en un vector ____________________________ Ordenamiento de Vectores ______________________________________

137 137 142 143 147

EJERCICIOS PROPUESTOS _____________________________________ 156 CLASE NÚMERO: 10 ___________________________________________ 159 ORDENAMIENTO CON VECTORES PARALELOS _________________________ 159 CONSULTAS EN VECTORES PARALELOS ______________________________ 165 EJERCICIOS PROPUESTOS _____________________________________ 172

-4-

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – CLASE NÚMERO: 11 ___________________________________________ 173 ARREGLOS BIDIMENSIONALES ______________________________________ 173 CARGA E IMPRESIÓN DE UNA MATRIZ ________________________________ 174 PROCESAMIENTO DE MATRICES _____________________________________ 178 EJERCICIOS PROPUESTOS _____________________________________ 187 CLASE NÚMERO: 12 ___________________________________________ 189 MATRICES Y VECTORES PARALELOS _________________________________ 189 EJERCICIOS PROPUESTOS _____________________________________ 199 ANEXO ________________________________________________________ 201 CONSTANTES Y MÉTODOS MATEMÁTICOS ____________________________ 201 Class Math ___________________________________________________ 201 MODELO DE EXAMEN FINAL _______________________________________ 203

– Algoritmos y Estructuras de Datos I –

-5-

– ISSD – EDUARDO MANSILLA –

-6-

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

UNIDAD Nº 1: Introducción a la lógica y la programación

TEMAS: Conceptos Principales. Diagramación. Programación. Tipos de Variables. Estructuras Secuenciales.

Clase

1

Clase Número: 1

Introducción de la materia El objetivo fundamental de esta materia “Algoritmos y Estructuras de Datos I”, es que el alumno aprenda a razonar, realizando problemas generalmente de tipo matemático, aplicando métodos estructurados lógicamente. Esta materia es de vital importancia para el avance del alumno en el plan de estudios, pues brinda los fundamentos lógicos y técnicos esenciales para despertar la habilidad de resolver problemas de uso general, utilizando la computadora como fin específico. En general, se puede decir que la materia presenta dos ejes temáticos importantes, que son: por un lado, la Diagramación y por otro lado, la Programación. En la Diagramación se estudia la simbología y la forma Lógica de relacionar cada uno de los símbolos para obtener la solución de un problema planteado. En la programación, se estudian las instrucciones de un lenguaje determinado y como llegar a codificarlas a través de un programa para ser llevado a la computadora. Aprender a programar, no es un proceso que se adquiere de un momento a otro, sino que requiere de intensas prácticas, desarrollando soluciones a diversos problemas. Mientras más se practique, mas se desarrollará la capacidad de razonamiento individual, y además, gradualmente se irá incrementando la posibilidad de resolver problemas de mayor complejidad. Este material de estudios no es una fuente de información completa o definitiva, sino sólo una guía general. Un estudio profundo de esta asignatura, debería ser complementado con libros y manuales de consulta.

Ing. Eduardo Mansilla

– Algoritmos y Estructuras de Datos I –

-7-

– ISSD – EDUARDO MANSILLA –

Conceptos Principales Se comenzará con dar las definiciones fundamentales para inicializarse en la materia Algoritmos y Estructuras de Datos I.

Diagrama de Flujo:

Se define a un Diagrama de Flujo, como una secuencia de pasos, mediante Símbolos, necesarios para la resolución de un problema planteado. Para realizar el diagrama de una posible solución de un problema, se utilizan símbolos normalizados, que mediante una distribución Lógica y Razonable de los mismos, se obtiene una respuesta al problema presentado. La respuesta obtenida con el desarrollo de un diagrama, no es única, sino que es una de las numerosas que se pueden obtener. Cada persona tiene una forma de razonar distinta de los demás, por lo tanto, distintas personas pueden llegar a la solución de un mismo problema de diversas maneras, es decir, que puede haber varias soluciones para un determinado problema.

Símbolos Normalizados en la Diagramación Símbolo

Nombre Líneas de Flujo

Comienzo o final de Proceso

Introducción de Datos

Símbolo de Asignación

-8-

Acción que realiza Muestra la Dirección y Sentido del flujo del proceso, conectando cada uno de los símbolos. En su interior, se coloca Inicio o Fin del Diagrama Se utiliza para ingresar datos. En su interior, se detalla la variable a ingresar. Se utiliza cuando se quiere asignar un valor a una variable.

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Símbolo

Nombre

Acción que realiza

Símbolo de impresión

Se utiliza cuando se desea imprimir una determinada información.

Toma de Decisión

Se utiliza cuando se debe decidir que camino corresponde seguir.

Conector

En su interior se coloca un número, que indica donde debe continuar el diagrama.

Ventajas de un Diagrama de Flujo Favorecen la comprensión del proceso a través de mostrarlo como un dibujo. El cerebro humano reconoce fácilmente los dibujos. Un buen diagrama de flujo reemplaza los diagramas varias páginas de texto. Permiten identificar los problemas y las oportunidades de mejora del proceso. Se identifican los pasos redundantes, los conflictos, las responsabilidades, y los puntos de decisión.

Programa:

Se define a un programa, como una secuencia de instrucciones, realizadas en un orden Lógico mediante un lenguaje determinado. Un Lenguaje de Programación, es un idioma artificial, creado para comunicarse con las computadoras. Existen diversos tipos de Lenguajes de Programación, cada uno de ellos se adapta para una actividad en particular. En esta materia, se programará en lenguaje Java.

Algoritmo:

Es un conjunto preescrito de instrucciones o reglas bien definidas, que permite realizar una actividad mediante pasos sucesivos. También se puede decir que un algoritmo, es el método o la técnica descripta para desarrollar una determinada tarea o actividad.

Variable: Se

define a una variable, como el espacio físico para albergar un dato. Los datos pueden ser de diversos tipos y por lo tanto, se debe definir una variable de un determinado tipo, de acuerdo al dato que almacenará.

– Algoritmos y Estructuras de Datos I –

-9-

– ISSD – EDUARDO MANSILLA – Se puede imaginar a una variable como un “casillero” en el cual se deposita un determinado valor. Toda variable tiene tres parámetros, que son: El nombre de la variable, llamado Identificador, el tipo al que pertenece y el dato almacenado. Ejemplo: Suponer que se quiere Conceptualmente se tendría lo siguiente:

definir

la

variable

sueldo.

Dato almacenado

5800

sueldo

Variable (Pertenece al tipo numérico)

Identificador

Se debe tener presente, que lo que se almacena en una variable es un dato, y los datos son siempre Constantes. El nombre identificador de una variable, lo decide el programador y es necesario seguir ciertas reglas para colocar dicho nombre. Las reglas son bastantes simples, y son las siguientes: 1. El nombre identificador debe comenzar con una letra en minúsculas, los demás caracteres pueden ser otras letras, dígitos o el carácter subrayado. Ejemplo de nombres identificadores válidos: precio, cantidad, dni, folio37, dia_laborable, etc. Ejemplo de nombres identificadores no válidos: código, año, día, 5pesos. Los tres primeros identificadores no son válidos porque los caracteres acentuados y la letra ñ, son especiales, y no están permitidos en Java. El cuarto identificador, no es válido porque comienza con un número. 2. No debe haber espacios en blanco entre carácter y carácter. Cuando un nombre se forma como fusión de dos o más palabras, se comienza siempre con minúsculas y la primera letra de cada palabra posterior se coloca en mayúsculas. Ejemplo: diaDeLaSemana, sueldoDelPersonal, precioUnitario, etc.

- 10 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Tipos de Variables Tipo char: (char viene de la palabra charácter). Una variable definida de tipo

char, puede almacenar un único carácter, es decir, puede almacenar cualquier símbolo de los indicados en el teclado. Para definir una variable, debe colocar primero el Tipo y luego el nombre identificador de la misma. Si se necesita definir varias variables del mismo tipo, se pueden colocar todas separadas por comas. Al final de cada definición, se debe colocar un punto y coma, es la forma en que Java identifica que termina una instrucción. Ocupa 2 bytes de memoria. Ejemplo:

char letra, digito, sexo;

Para asignar un dato a una variable definida de tipo char, se lo debe colocar entre apóstrofes (Comillas Simples). letra = ‘L’ ; digito = ‘7’ ; sexo = ‘M’ ;

Tipo int: (int viene de la palabra integer). Una variable definida de este tipo, puede almacenar un número entero en el rango de [-2147483648..2147483647]. Ocupa 4 bytes de memoria. Ejemplo: int legajo, cantidad, codigo, dia ; legajo = 5832 ; cantidad = 16 ; codigo = 24 ; dia = 12 ;

Tipo float: (float significa flotante). Una variable definida de tipo float, puede almacenar un número con punto decimal flotante en el rango de: [ 1.40239846 x 10–45f a 3.40282347 x 1038f]. Ocupa 4 bytes de memoria. Ejemplo:

float sueldo, precio, altura, distancia, ancho; sueldo = 5436.44f ; precio = 35.50f ; altura = 1.67f ;

Nota: La letra f al final de cada valor, es obligatorio colocarla para indicar a Java que el dato asignado a la variable es de tipo float.

– Algoritmos y Estructuras de Datos I –

- 11 -

– ISSD – EDUARDO MANSILLA –

Tipo String:

(String significa tira o hilera de caracteres). Una variable definida de tipo String, permite almacenar una palabra, frase o texto. Ejemplo: String apellido, nombre, direccion, frase; apellido = “Rodríguez” ; nombre = “Alberto” ; direccion = “9 de Julio 1653” ; frase = “Hoy es un día soleado” ; Observar que para asignar un dato a una variable String, se debe hacerlo entre comillas. Nota: Existen muchos mas tipos de variables, pero serán vistos mas adelante.

Operadores Aritméticos Los operadores aritméticos son los utilizados para realizar cálculos matemáticos en una determinada asignación. Java reconoce los siguientes operadores aritméticos:

Operación Aritmética Suma Resta Multiplicación División Resto de División

Operador + * / %

Estructuras Secuenciales A partir de aquí, comenzaremos a realizar ejemplos de aplicación de Diagramas de Flujo y posteriormente su traducción a lenguaje Java. Ejemplo Nro. 1 : Calcular el importe que deberá abonar una persona ingresando el Precio unitario de un artículo y la cantidad que se quiere comprar. Para la solución, se deben pensar en las variables a utilizar en el diagrama, en este caso, se tienen dos variables de ingreso, que son el precio y la cantidad, y una variable de salida, que sería el importe que se debe abonar.

- 12 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – La solución sería la siguiente: Inicio

Inicio del Diagrama

precio

Introducción de datos

cantidad importe = precio * cantidad

Cálculo del importe a abonar

importe

Impresión del importe a abonar

Fin

Fin del Diagrama

El diagrama de flujo, nos da una idea del orden de ejecución de las actividades en el tiempo. Primero se introducen los datos de entrada, luego se realizan las operaciones necesarias y por último se muestran los resultados. Ejemplo Nro. 2 : Hallar la superficie de un cuadrado conociendo el valor de uno de sus lados.

Inicio lado superficie = lado * lado

superficie

En este caso, se ingresa el valor de un lado del cuadrado, mediante el símbolo de Introducción de Datos (paralelogramo), luego se calcula la superficie como el producto de lado por lado, en el símbolo rectángulo, y por último se imprime el resultado de la superficie.

Fin

– Algoritmos y Estructuras de Datos I –

- 13 -

– ISSD – EDUARDO MANSILLA – Se procederá ahora a realizar la codificación de los ejercicios desarrollados anteriormente, es decir, traducir los símbolos de los diagramas en instrucciones en lenguaje Java, para ello, se debe haber instalado el software necesario, que en nuestro caso, es el “Ready to Program”.

Para la instalación de esta aplicación se deberá seguir los siguientes pasos:  Localizar el instalador de dicha aplicación, por lo general suele venir acompañando en el Cd de estudio. También se puede conseguir en sitios de descarga o bien conseguirlo a través del campus o ayudantes del laboratorio.

 Para instalarlo, se puede ejecutar el instalador desde el cd o bien copiar los archivos y directorios a una unidad local (C:\ o D:\) Una vez instalado, y ejecutado el programa, se mostrará una pantalla como la siguiente:

- 14 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Allí se puede comenzar a tipear las instrucciones para que Java las interprete, tener en cuenta que, a cada símbolo del diagrama, le corresponde una instrucción en Java. Por ejemplo: Inicio

{

precio

precio = c.readFloat();

cantidad

cantidad = c.readInt();

importe = precio * cantidad

importe

Fin

Esta asignación se coloca como está

c.println (importe);

}

El programa debe comenzar con una llave, que indica el inicio de la actividad, luego se debe pedir el precio, para ello se utiliza la instrucción c.readFloat(), que significa: leer un valor con punto decimal flotante y almacenarlo en la variable precio, posteriormente, se ingresa la cantidad con la instrucción c.readInt(), que significa: leer un valor entero, y almacenarlo en la variable cantidad. La asignación del cálculo del importe, se coloca en el programa exactamente igual como está en el diagrama, y por último, para mostrar el resultado obtenido, se utiliza la instrucción c.println(), con la variable que se quiere mostrar dentro de los paréntesis. Para finalizar el programa, se coloca otra llave, pero observar, que esta es de cierre, mientras que la inicial es de apertura. Para comenzar a tipear el programa, se debe previamente indicarle a Java con que paquete de librerias se va a trabajar, esto se consigue con la instrucción: import hsa.Console; que le indica a Java que importe la librería de clases hsa.Console. Esta librería contiene las funciones y métodos apropiados de Entrada y Salida. Se debe tener en cuenta, que en Java, todo programa es una clase y por lo tanto debe llevar un nombre que debe comenzar en Mayúsculas y es precisamente con ese nombre como debe ser grabado en el disco.

– Algoritmos y Estructuras de Datos I –

- 15 -

– ISSD – EDUARDO MANSILLA – El programa una vez tipeado y grabado, quedará de la siguiente forma:

En este caso, a la clase se le dió el nombre de Ejemplo1. La instrucción: static Console c ; se realiza para poder utilizar los métodos de Entrada y Salida (readInt, readFloat, println) con el objeto c, mas adelante, se explicará en mayor medida esta línea. La línea: public static void main(String arg[]) es la cabecera del programa principal. Todos los programas que realicemos por el momento comenzarán de la misma forma. El inicio del programa empieza definiendo las variables a utilizar, en este caso, las variables precio e importe son definidas de tipo float y la cantidad de tipo int. Se define la variable como un objeto de la Console, por lo tanto, estará capacitada para acceder a los métodos de entrada y salida. La línea: c.print ("ingrese Precio: "); no figura en el diagrama, pero es necesario colocarla para que la computadora, antes de detenerse pidiendo un dato con la línea: precio

= c.readFloat();

muestre la leyenda correspondiente para ingresar el precio. Las demás - 16 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – líneas, continúan secuencialmente, de acuerdo con el diagrama de flujo. La instrucción:

println();

Se utiliza para dejar un renglón en blanco entre los datos introducidos y el resultado que nos entrega la computadora. Observar, que para realizar la impresión del resultado, se ha colocado una leyenda y al lado la variable correspondiente separadas por un signo mas ( + ). Este signo, al utilizarlo con constantes o variables de tipo String realiza la concatenación de los elementos, es decir, que en este caso, va ha producir la unión entre leyenda “El importe a abonar es:” con el valor que le corresponde a la variable importe. Una vez realizado codificado el programa, se lo debe ejecutar, para ello se accede al botón [Run (F1)], que realiza la compilación del programa y posteriormente la ejecución. Compilar en programa, significa traducir cada una de las líneas escritas en Java, a un lenguaje entendible por la computadora. Si la traducción no registra ningún error, se observará una pantalla de salida del programa, como se muestra en la siguiente figura:

En caso de haber errores en las líneas tipeadas, el programa no se ejecutará, y se mostrará más reasaltada la línea en la cual se detectó el error, indicándose el tipo de error en la parte inferior de la ventana. Codificación del ejemplo número 2: Hallar la superficie de un cuadrado conociendo el valor de uno de sus lados. {

Inicio

lado = c.readFloat();

lado superficie = lado * lado

superficie = lado * lado c.println(“La superficie es: “ + superficie);

superficie Fin

}

– Algoritmos y Estructuras de Datos I –

- 17 -

– ISSD – EDUARDO MANSILLA –

Ejemplo Nro. 3 : Ingresar tres nombres con sus respectivas altura y determinar e imprimir, la altura promedio.

Inicio n1, a1 n2, a2 n3, a3 promedio = (a1 + a2 + a3) / 3

promedio

En el símbolo de introducción de datos, se pueden colocar más de una variable, pero se debe tener en cuenta que por cada variable, se debe tener una instrucción read en el programa. En este caso será: n1 = c.readLine(); a1 = c.readInt();

Nota: para pedir in dato de tipo String, se utilizará la instrucción c.readLine(), que significa leer una linea.

Fin

- 18 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – El programa del ejemplo 3, sería el siguiente: import hsa.Console; class Ejemplo3 { static Console c; public static void main(String arg[]) { String n1, n2, n3; float a1, a2, a3; float promedio; c = new Console(); c.print("Ingrese primer nombre: "); n1 = c.readLine(); c.print("Ingrese su altura: "); a1 = c.readFloat(); c.print("Ingrese segundo nombre: "); n2 = c.readLine(); c.print("Ingrese su altura: "); a2 = c.readFloat(); c.print("Ingrese tercer nombre: "); n3 = c.readLine(); c.print("Ingrese su altura: "); a3 = c.readFloat();

}

}

promedio = (a1 + a2 + a3)/3; c.println(); c.println("La altura promedio es: " + promedio);

– Algoritmos y Estructuras de Datos I –

- 19 -

– ISSD – EDUARDO MANSILLA –

Ejercicios Propuestos 1.1 Calcular el sueldo mensual de un operario conociendo la cantidad de horas trabajadas y el valor por hora. 1.2 Realizar el ingreso de dos números por teclado e imprimir su suma y su producto. 1.3 Ingresar la base y la altura de un triángulo, imprimir posteriormente la superficie del mismo. (Recordar que la superficie de un triangulo es base por altura sobre 2). La fórmula sería: superficie = b * h / 2 ; 1.4 Ingresar el nombre de un artículo con su respectivo precio. Imprimir el importe a pagar si recibe un descuento del 12 % por abonarlo de contado.

- 20 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

UNIDAD Nº 1: Estructuras condicionales.

TEMAS: Estructuras condicionales Operadores relacionales. Condicional Simple y compuesta.

Clase

2

Clase Número: 2

Estructuras Condicionales En algunos casos, se pueden presentar condiciones que influyen sobre la secuencia de pasos a seguir para resolver un problema. Según se cumplan o no determinadas condiciones, la secuencia de pasos a seguir puede continuar por caminos diferentes. En este caso, estamos frente a Estructuras Condicionales, que son las que determinan cual será el camino a seguir, de acuerdo a una determinada condición. En diagramación, la estructura condicional se representa con un rombo de la siguiente manera:

Falso

Condición

Verdadero

Sentencia 1; Sentencia 2; : Sentencia n;

Se puede observar que la estructura tiene una entrada y dos salidas, por el Falso y por el Verdadero. Si la condición en su interior resulta verdadera, el programa continuará ejecutando las sentencias 1, 2, n. Por el contrario, si la condición resulta Falsa, no se ejecutan dichas sentencias.

Se debe tener en cuenta que luego de procesar el bloque de sentencias del lado Verdadero, el camino en el diagrama se junta con el Falso y continúa por una sola trayectoria. Esta fracción de diagrama realizada anteriormente, recibe el nombre de – Algoritmos y Estructuras de Datos I –

- 21 -

– ISSD – EDUARDO MANSILLA –

Estructura Condicional Simple,

porque hay actividades a realizar

únicamente por el camino del verdadero. En programación en lenguaje Java, se conoce a la estructura condicional con el nombre de if, que significa sí, por lo tanto, se puede leer el diagrama anterior de la siguiente forma: “ Sí la condición resulta verdadera, realizar el bloque de sentencias de la derecha, en caso contrario, no realizar ninguna actividad “. Traducido a lenguaje Java, las instrucciones quedarían como: if (Condición) { Sentencia 1; Sentencia 2; Sentencia n; }

Operadores Relacionales El contenido de una variable puede ser igual, mayor o menor que el contenido de otra variable. Para ello, se utilizan unos símbolos llamados Operadores Relacionales. Estos operadores son los mismos que se utilizan en matemática, pero con alguna diferencia en su escritura. A continuación, se describen los operadores relacionales en matemática, y su escritura en lenguaje Java:

Descripción

Igual Mayor Menor Mayor o Igual Menor o Igual Distinto o No Igual

En Matemática = > < ≥ ≤ ≠

En Java == > < >= <= !=

Ejemplo Nro. 4 : Ingresar el sueldo de un operario e imprimir el sueldo a cobrar teniendo en cuenta que si el valor es mayor a $5000, realizarle un descuento del 10%.

- 22 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Inicio sueldo descuento = 0

Falso

sueldo > 5000

Verdadero

descuento = sueldo * 10 / 100

sueldoACobrar = sueldo – descuento

sueldoACobrar

Fin import hsa.Console; class Ejemplo4 { static Console c; public static void main(String arg[]) { float sueldo, descuento, sueldoACobrar; c = new Console(); c.print("Ingrese Sueldo: "); sueldo = c.readFloat(); descuento = 0.0f; if (sueldo > 5000) { descuento = sueldo * 10 / 100; } sueldoACobrar = sueldo - descuento; c.println(); c.println("El sueldo a cobrar es: " + sueldoACobrar); } }

– Algoritmos y Estructuras de Datos I –

- 23 -

– ISSD – EDUARDO MANSILLA – En este caso, se inicializa la variable descuento en cero, tener en cuenta que para inicializar una variable de tipo float, se le debe colocar la letra “f” al final del dato, para indicar que es una constante de tipo float, luego, si el sueldo es superior a 5000 se le realiza el cálculo del descuento. Por último, se imprime el sueldo a cobrar. Ejemplo Nro. 5 : Ingresar dos valores de longitud de tipo float, y calcular su promedio. Si el promedio es menor a 10 metros, incrementarlo en 2 metros. Por último, imprimir el valor de dicho promedio. Inicio valor1 valor2 promedio = (valor1 + valor 2) / 2

Falso

promedio < 10

Verdadero

promedio = promedio + 2

promedio

Fin La única instrucción nueva en este diagrama es la asignación: promedio = promedio + 2 esta asignación indica que a la variable promedio se le asigne el valor que tenía promedio anteriomente, mas 2. Esto es, de la siguente manera, se realiza en primera medida el cálculo de la suma (promedio + 2) y al resultado, se lo reasigna nuevamente a la variable promedio.

- 24 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – La codificación del ejemplo 4 sería: import hsa.Console; class Ejemplo5 { static Console c; public static void main (String arg []) { float valor1, valor2, promedio; c = new Console (); c.print ("Ingrese Primer Valor: "); valor1 = c.readFloat (); c.print ("Ingrese Segundo Valor: "); valor2 = c.readFloat (); promedio = (valor1 + valor2) / 2; if (promedio < 10) { promedio = promedio + 2; }

}

}

c.println (); c.println ("El resultado es: " + promedio);

Estructura Condional Compuesta Cuando se presenta la elección, se t i e n e la opción de realizar una actividad u otra. Es decir que puede haber actividades tanto por el verdadero como por el falso de la condición. Lo más importante que hay que tener en cuenta, es que NUNCA se realizan las dos actividades simultáneamente, siempre una o la otra. El esquema del diagrama sería el siguiente:

Falso

Condición

Actividades a realizar, si la condición resultara falsa

Verdadero Actividades a realizar, si la condición resultara verdadera

– Algoritmos y Estructuras de Datos I –

- 25 -

– ISSD – EDUARDO MANSILLA – La codificación de esta fracción de diagrama en lenguaje Java seria de la siguiente forma: if ( Condición ) { Sentencia1 Sentencia2 } else { SentenciaX SentenciaZ }

; ;

Actividades a realizar si la condición es Verdadera

; ;

Actividades a realizar si la condición es Falsa

Si la condición resultara verdadera, se procesarían las Sentencia1 y la Sentencia2, en caso contrario, se procesarían las SentenciaX y la SentenciaZ. Cada vez que se debe realizar alguna actividad por el lado del falso, se debe colocar la instrucción “else” en el programa. Ejemplo Nro. 6 : Relizar un programa que permita ingresar dos números distintos y que muestre cual es el mayor de ellos.

Inicio

n1 n2

Falso

Verdadero

n1 > n2

“El mayor es: “ + n2

“El mayor es: “ + n1

Fin

- 26 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Desarrollo del programa: import hsa.Console; class Ejemplo6 { static Console c; public static void main (String arg []) { int n1, n2; c = new Console (); c.print ("Ingrese Primer numero: "); n1 = c.readInt (); c.print ("Ingrese Segundo numero: "); n2 = c.readInt ();

}

}

c.println (); if (n1 > n2) { c.println ("El mayor es: " + n1); } else { c.println ("El mayor es: " + n2); }

Operador “%” Para saber si un número es par o impar, se utiliza el que devuelve el resto de una división, por ejemplo: 4%2=0 7%2=1 16 % 2 = 0 21 % 2 = 1

operador “%”,

En estos ejemplos se tiene que: El resto de la división del numero 4 con el número 2 es igual a cero, lo mismo se puede observar que el resto de cualquier número par con el valor 2 es cero.

Ejemplo Nro. 7 : Desarrollar un programa para determinar si un número ingresado por teclado es par o impar. Se puede realizar una estructura condicional que en su interior tenga la condición: ( n % 2 == 0 ), en donde la variable “n” contiene el número que se quiere determinar si es par o impar. En este caso, se tendrá que si el resultado de la condición es verdadero, el número será par, de lo contrario, será impar. En la siguiente página, se observa el diagrama de flujo y programa correspondiente.

– Algoritmos y Estructuras de Datos I –

- 27 -

– ISSD – EDUARDO MANSILLA –

Inicio

n

Falso

n % 2 == 0

“El número es impar”

Verdadero

“El número es par”

Fin

import hsa.Console; class Ejemplo7 { static Console c; public static void main (String arg []) { int n; c = new Console (); c.print ("Ingrese un numero: "); n = c.readInt ();

}

- 28 -

}

c.println (); if (n % 2 == 0) { c.println ("El numero es Par"); } else { c.println ("El numero es Impar"); }

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Operadores Lógicos Los operadores Lógicos se utilizan cuando se presentan problemas en donde se deben evaluar dos o mas condiciones en una misma estructura. Los operadores Lógico mas utilizados son los siguientes: Operador Y (And) O (Or) No (Not)

Nomenclatura && || !

Ejemplos ( sueldo > 4000 && antiguedad < 10) ( edad > 21 || dni > 25000000 ) ( ! existe )

Significado de los ejemplos de la tabla anterior: ( sueldo > 4000 && antiguedad < 10): Indica que la condición será verdadera si se verifican que las dos condiciones son verdaderas, esto es lo que especifica el símbolo &&. ( edad > 21 || dni > 25000000 ): En este caso, verificándose una de las dos condiciones como verdadera, edad>21 ó dni>25000000, toda la condición será verdadera. ( ! existe ) : Esta Condición contiene un tipo de variable particular: el tipo “boolean”

Tipo “boolean” Una variable definida de tipo boolean, puede contener únicamente las constantes true o false, es decir, puede ser verdadera o falsa. En el ejemplo anterior, en la instrucción (!existe), el signo de admiración niega o invierte todo lo que está a la derecha del mismo, por lo tanto, si la variable existe contiene true, la línea (!existe) quedará como false, y viceversa.

Utilización de los operadores lógicos Ejemplo Nro. 8 : Desarrollar un programa que permita ingresar el día y el mes de una fecha, y que muestre si corresponde a navidad. En este caso, se deberá tener una condición doble que indique que el día sea 25 y que además, el mes corresponda a diciembre (12). El diagrama y programa correspondiente, puede observarse en la próxima página.

– Algoritmos y Estructuras de Datos I –

- 29 -

– ISSD – EDUARDO MANSILLA –

Inicio

dia mes

dia == 25 && mes == 12

Falso

“No corresponde a Navidad”

Verdadero

“Corresponde a Navidad”

Fin import hsa.Console; class Ejemplo8 { static Console c; public static void main (String arg []) { int dia, mes; c = new Console (); c.print ("Ingrese dia: "); dia = c.readInt (); c.print ("Ingrese mes: "); mes = c.readInt ();

}

- 30 -

c.println (); if (dia == 25 && mes == 12) { c.println ("La Fecha corresponde a Navidad"); } else { c.println ("La Fecha no corresponde a Navidad"); } }

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 9 : Elaborar un algoritmo que me muestre la edad de una persona: si es menor que 12 años mostrar Chico, si está entre 12 y 21 (ambos inclusive) mostrar Joven, si es mayor que 21, mostrar Adulto.

Inicio

edad

Falso

edad < 12

Verdadero

“Chico”

Falso

edad >= 12 && edad <=21

Verdadero

“Joven”

Falso

edad >21

Verdadero

“Adulto”

Fin

– Algoritmos y Estructuras de Datos I –

- 31 -

– ISSD – EDUARDO MANSILLA – El programa quedaría resuelto de la siguiente forma: import hsa.Console; class Ejemplo9 { static Console c; public static void main (String arg []) { int edad; c = new Console (); c.print ("Ingrese la edad: "); edad = c.readInt ();

}

- 32 -

}

c.println (); if (edad < 12) { c.println ("Es un Chico"); } if (edad >= 12 && edad <= 21 ) { c.println ("Es un Joven"); } if (edad > 21) { c.println ("Es un Adulto"); }

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Ejercicios Propuestos 2.1 – Ingresar un número por teclado en el rango de 0 a 99 y determinar si tiene uno dos dígitos. 2.2 – Realizar un programa que lea por teclado dos números, si el primero es mayor al segundo, informar su suma y diferencia, en caso contrario, informar el producto y la división del primero por el segundo. 2.3 – Ingresar el largo y el ancho de una habitación, y calcular su superficie. Si la superficie es mayor a 10, imprimir la leyenda “Habitación adecuada”, de lo contrario, imprimir la leyenda “Habitación pequeña”. (Superficie = largo * ancho) 2.4 – Ingresar una fecha por teclado, día mes y año, y determinar si corresponde al primer trimestre del año. Mostrarlo las leyendas: “Corresponde al primer Trimestre” o “No corresponde al primer Trimestre”, según corresponda. 2.5 – Ingresar el precio de un artículo y un código que informe lo siguiente: Si el código es 1, es porque se abona de contado. Si el código es 2, es porque se abona con tarjeta. Imprimir el importe abonar teniendo en cuenta que: Si se abona de contado, se debe realizar un descuento del 5% del precio de venta. Si se abona con tarjeta, se debe realizar un incremento del 10 % del precio de venta. 2.6 – Ingresar tres valores numéricos por teclado, si todos son iguales, imprimir la leyenda: “Todos los números ingresados son iguales”, de lo contrario, imprimir la leyenda “No todos los números son iguales”. 2.7 – Realizar un programa que permita ingresar el sueldo y los años de antigüedad de un operario y que informe el sueldo a cobrar, teniendo en cuenta lo siguiente: a) Si el sueldo es inferior a 4500 y su antigüedad es superior o igual a 10 años, otorgarle un aumento del 10%. b) Si el sueldo es inferior a 4500 y su antigüedad es menor a 10 años, otorgarle un aumento del 5%. c) Si el sueldo es mayor o igual a 4500, no realizarle ningún aumento. 2.8 – Se debe ingresar tres números por teclado, si al menos uno de los números es menor a 10, imprimir la leyenda “Alguno de los números es menor a 10” de lo contrario, “Ninguno de los números es menor a 10”. 2.9 – Ingresar la altura de una persona e imprimir si es Baja, Normal o Alta, de acuerdo con las siguientes condiciones: – Algoritmos y Estructuras de Datos I –

- 33 -

– ISSD – EDUARDO MANSILLA – a) Si la altura es menor a 1.60, es una persona baja. b) Si la altura está comprendida entre 1.60 y 1.75 (ambos inclusive), es una persona Normal. c) Si la altura supera a la medida de 1.75, es una persona Alta. 2.10 – Ingresar una letra, y determinar si es una vocal o una consonante. Nota: para poder ingresar una letra, la variable debe ser definida de tipo char, y para pedir el dato, se lo debe realizar con la instrucción c.readChar(). Solución del ejercicio 2.10 import hsa.Console; class PropuestoDos10 { static Console c; public static void main (String arg []) { char letra; c = new Console (); c.print ("Ingrese una Letra: "); letra = c.readChar (); c.println (); if (letra=='a' || letra=='A' || letra=='e' || letra=='E' || letra=='i' || letra=='I' || letra=='o' || letra=='O' || letra=='u' || letra=='U' ) { c.println ("Es una vocal"); } else { c.println ("Es una consonante"); } }

}

Observar que las variables de tipo char, se preguntan con el carácter entre apóstrofes y no entre comillas.

- 34 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

UNIDAD Nº 1: Estructuras condicionales.

Clase

TEMAS: Estructura condicional anidada. Instrucción Switch-Case

3

Clase Número: 3

Estructura Condicional Anidada Se dice que una estructura condicional es anidada cuando por la rama del verdadero o el falso de una estructura condicional hay otra estructura condicional. Ejemplo Nro. 10: Ingresar un número y determinar si es positivo, negativo o nulo. Para saber si un número es positivo, simplemente se lo debe comparar con el cero, si el número en cuestión es mayor a cero, será positivo y si es menor a cero será negativo. Si no cumple con ninguna de las condiciones anteriores, será nulo. Inicio

numero

Falso

numero > 0

Verdadero

“Numero Positivo” Falso

“Numero Nulo”

Numero < 0

Verdadero

“Numero Negativo”

Fin

– Algoritmos y Estructuras de Datos I –

- 35 -

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo10 { static Console c; public static void main (String arg []) { int numero; c = new Console (); c.print ("Ingrese un numero: "); numero = c.readInt ();

}

}

c.println (); if (numero > 0) { c.println ("El numero es Positivo"); } else if (numero < 0) { c.println ("El numero es Negativo"); } else { c.println ("El numero es Nulo"); }

Ejemplo Nro. 11: Realizar un programa que lea por teclado tres notas de un alumno, y calcule el promedio, imprimiendo algunos de los siguientes mensajes: Si el promedio es mayor o igual a 7, mostrar “Alumno Promocionado”. Si el promedio es mayor o igual a 4 y además, menor a 7, mostrar “Alumno Regular”. Si el promedio es menor a 4, mostrar “Alumno Reprobado”.

- 36 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Inicio nota1, nota2, nota3

prom = (nota1 + nota2 + nota3) / 3

Falso

prom >= 7

Verdadero

“Promocionado” Falso

“Reprobado”

prom >= 4

Verdadero

“Regular”

Fin

En este ejemplo, se ingresan tres valores por teclado que representan las notas de un alumno y se obtiene el promedio sumando los tres valores y dividiendo por 3 dicho resultado. Primeramente, se pregunta si el promedio es superior o igual a 7, en caso afirmativo por la rama del verdadero de la estructura condicional se muestra un mensaje que indique “Promocionado” (con comillas indicamos un texto que debe imprimirse en pantalla). En caso que la condición sea Falsa, por la rama del Falso aparece otra estructura condicional, porque todavía se tienen dos posibilidades, que el promedio del alumno sea superior o igual a cuatro, o tabién, se puede dar el caso de que sea inferior a cuatro. En la segunda condición, se averigua si el promedio es mayor o igual a 4, si es verdadero, se imprime “Regular” y en caso contrario, se imprime “Reprobado”, ya que, por descarte, el promedio es menor a 4. El programa se observa en la página siguiente:

– Algoritmos y Estructuras de Datos I –

- 37 -

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo11 { static Console c; public static void main (String arg []) { int nota1, nota2, nota3; float prom; c = new Console (); c.print nota1 = c.print nota2 = c.print nota3 =

}

línea:

}

("Ingrese c.readInt ("Ingrese c.readInt ("Ingrese c.readInt

Primer nota: "); (); Segunda nota: "); (); Tercer nota: "); ();

prom = (float)(nota1 + nota2 + nota3) / 3; c.println (); c.println ("El promedio es: " + prom); if (prom >= 7) { c.println ("Alumno Promocionado"); } else if (prom >= 4) { c.println ("Alumno Regular"); } else { c.println ("Alumno Reprobado"); }

La única instrucción nueva en este programa es la palabra (float) en la prom = (float)(nota1 + nota2 + nota3)/3;

Esta palabra float encerrada entre paréntesis, indica que se debe transformar el valor que figure al lado de ella en un valor de tipo float, debido a lo siguiente: Cada una de las notas son de tipo entero (int), y la suma de valores enteros en Java es otro entero, además, la división de dos enteros, es también otro entero. Por lo tanto, si se ingresaran como ejemplo las notas: 7, 7 y 8 el promedio daría como resultado el valor de 7 (sin decimales) y no de 7.33, que sería lo correcto. Por este motivo, es que se coloca la palabra float delante de la suma de las notas, para transformar dicha suma en un valor de tipo float, y , al dividir un valor float con un entero, el resultado es un float, por lo tanto, ahora sí dará el valor del promedio correcto con decimales.

- 38 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 12: Ingresar tres números y determinar el mayor de ellos.

Inicio n1 n2 n3

Falso

n1 > n2 && n1 > n3

Verdadero

“El Mayor es: ” + n1 Falso

n2 > n3

“El Mayor es: ” + n3

Verdadero

“El Mayor es: ” + n2

Fin

La lógica de este proceso sería la siguiente: Luego de ingresar los tres valores, se comienza preguntando se el primer número es mayor a los otros dos, esto se logra con una condición doble utilizando el operador lógico and (&&). La condición se lee de esta manera: Si el valor almacenado en n1 es mayor al valor almacenado en n2, y además, el valor almacenado en la variable n1 es mayor al valor almacenado en la variable n3, entonces imprimir “El Mayor es: “ n1, de lo contrario, (descartado que el valor de n1 es el mayor), se pregunta si el valor almacenado en n2 es mayor al valor almacenado en n3, que en caso de ser verdadero, se muestra que “el Mayor es: “ n2 , de lo contrario se muestra “El mayor es: “ n3.

– Algoritmos y Estructuras de Datos I –

- 39 -

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo12 { static Console c; public static void main (String arg []) { int n1, n2, n3; c = new Console (); c.print ("Ingrese Primer Numero: "); n1 = c.readInt (); c.print ("Ingrese Segundo Numero: "); n2 = c.readInt (); c.print ("Ingrese Tercer Numero: "); n3 = c.readInt ();

}

}

c.println (); if (n1 > n2 && n1 > n3) { c.println ("El Mayor es: " + n1); } else if (n2 > n3) { c.println ("El Mayor es: " + n2); } else { c.println ("El Mayor es: " + n3); }

Se debe tener en cuenta que en la condición doble: if (n1 > n2 && n1 > n3) Se deben cumplir obligatoriamente las dos condiciones independientes para que toda la condición resulte verdadera (True en inglés). Esto es indicado por el signo and (&&). Si alguna de las dos no se cumple, toda la condición resultará falsa (False en inglés).

- 40 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Actividades Actividades Es de fundamental importancia realizar los diagramas de flujo y la posterior codificación en Java, de los siguientes problemas: 3.1 – Se deben ingresar tres valores por teclado, si todos son iguales imprimir la suma del primero con el segundo y a este resultado multiplicarlo por el tercero. Si no son iguales, mostrar una Leyenda. 3.2 – Escribir un programa que pida ingresar las coordenadas de un punto en el plano, es decir dos valores enteros x e y. Posteriormente imprimir en pantalla en que cuadrante se ubica dicho punto. 1º Cuadrante: x > 0 2º Cuadrante: x < 0 3º Cuadrante: x < 0 4º Cuadrante: x > 0

, , , ,

y>0 y>0 y<0 y<0

y

2º Cuadrante

1º Cuadrante

3º Cuadrante

4º Cuadrante

x

3.3 – De un postulante a un empleo, que realizó un test de capacitación, se obtuvo la siguiente información: nombre del postulante, cantidad total de preguntas que se le realizaron y la cantidad de preguntas que contestó correctamente. Se pide confeccionar un programa que lea los datos del postulante e informe el nivel del mismo según el porcentaje de respuestas correctas que ha obtenido, sabiendo que:    

Nivel superior: Nivel medio: Nivel regular: Fuera de nivel:

Porcentaje>=90%. Porcentaje>=75% y <90%. Porcentaje>=50% y <75%. Porcentaje<50%.

3.4 – Ingresar un valor de frecuencia e indicar a que banda corresponde, según la siguiente clasificación en telecomunicaciones: BANDA ULF ELF ILF VLF LF MF HF VHF UHF SHF EHF

SUBDIVISIÓN DE FRECUENCIA Frecuencia ultra baja Frecuencia extremadamente baja Frecuencia infra baja Frecuencia muy baja Frecuencia baja Frecuencia media Frecuencia alta Frecuencia muy alta Frecuencia ultra alta Frecuencia super alta Frecuencia extremadamente alta

RANGO DE FRECUENCIA 3 a 30 Hz 30 a 300 Hz 300 Hz a 3 Khz 3 a 30 Khz 30 a 300 Khz 300 Khz a 3 Mhz 3 a 30 Mhz 30 a 300 Mhz 300 Mhz a 3 Ghz 3 a 30 Ghz 30 a 300 Ghz

– Algoritmos y Estructuras de Datos I –

- 41 -

– ISSD – EDUARDO MANSILLA – Para el rango de la frecuencia, colocar en el programa, todos los valores expresados en Hertz (Hz), o sea, que todos los múltiplos quedrán de la siguiente manera: 3 KHz = 3000 Hz; 30 KHz = 30000Hz; 300 Khz = 300000 Hz 3 MHz = 3000000 Hz; 30 Mhz = 30000000 Hz; 300 Mhz = 300000000 Hz 3 GHz = 3000000000 Hz; 30 GHz = 30000000000; 300 GHz = 300000000000 Hz Como los valores expresados en algunos casos, son demasiados grandes, la variable debería ser de tipo long o float. A continuación, se muestran los diagramas de las actividades, quedando el programa para realizar por el alumno. Actividad 3.1 Inicio valor1 valor2 valor3

valor1 == valor2 && valor2 == valor3

Falso

Verdadero

suma = valor1 + valor2 multi = suma * valor3

“Los tres valores no son iguales” “La solucion es: ” + multi

Fin

- 42 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Actividad 3.2

Inicio x y

Falso

Verdadero

x > 0 && y > 0

“Primer Cuadrante”

Falso

“Cuarto Cuadrante”

Falso

x<0 && y>0

x > 0 && y > 0

Verdadero

Verdadero

“Segundo Cuadrante”

“Tercer Cuadrante”

Fin

– Algoritmos y Estructuras de Datos I –

- 43 -

– ISSD – EDUARDO MANSILLA –

Actividad 3.3

Inicio Nota: La variable nombre, debe ser definida de tipo String, y para pedir un nombre, se lo debe hacer con la instrucción readLine(), de la siguiente manera:

nombre total

String nombre; c.print("Ingrese nombre"); nombre = c.readLine();

correctas

por = (correctas / total) * 100

Falso

por >= 90

Verdadero

“Nivel Superior”

Falso

“Fuera de Nivel”

Falso

por >= 75

por >= 50

Verdadero

Verdadero

“Nivel Medio”

“Nivel Regular”

Fin

- 44 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – La Actividad 3.4, es muy similar a la actividad 3.3. Queda como tarea a desarrollar por el alumno, el diagrama y programa.

Instrucción Switch - Case La instrucción switch() es una instrucción de decisión múltiple, donde el compilador prueba o busca el valor contenido en una variable con una lista de constantes ints o chars, cuando el computador encuentra el valor de igualdad entre variable y constante, entonces ejecuta el grupo de instrucciones asociados a dicha constante, si no encuentra el valor de igualdad entre variable y constante, entonces ejecuta un grupo de instrucciones asociados a la instrucción default, aunque esta última instrucción es opcional. Existen numerosas simbologias sobre la instracción switch para realizar un diagrama de flujo, pero la más utilizada es la siguiente:

variable

Caso 1

Actividad 1; break;

Caso 2

Actividad 2; break;

Caso 3

Actividad 3; break;

Caso 4

Actividad 4; break;

Actividad por defecto

fin

– Algoritmos y Estructuras de Datos I –

- 45 -

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 13: Ingresar un número, y mostrar a que mes le corresponde.

Inicio mes

mes

Caso 1

“Enero”

Caso 2

“Febrero”

Caso 11

“Noviembre”

Caso 12

“Diciembre”

“No es Valido”

- 46 -

fin

Fin del switch

fin

Fin del programa

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo13 { static Console c; public static void main (String arg []) { int mes; c = new Console (); c.print ("Ingrese un Numero: "); mes = c.readInt ();

}

}

switch (mes) { case 1: c.println break; case 2: c.println break; case 3: c.println break; case 4: c.println break; case 5: c.println break; case 6: c.println break; case 7: c.println break; case 8: c.println break; case 9: c.println break; case 10: c.println break; case 11: c.println break; case 12: c.println break; default: c.println break; }

("Corresponde a Enero"); ("Corresponde a Febrero"); ("Corresponde a Marzo"); ("Corresponde a Abril"); ("Corresponde a Mayo"); ("Corresponde a Junio"); ("Corresponde a Julio"); ("Corresponde a Agosto"); ("Corresponde a Septiembre"); ("Corresponde a Octubre"); ("Corresponde a Noviembre"); ("Corresponde a Diciembre"); ("No Corresponde a un mes valido");

Explicación: El programa comienza con la introducción del número y luego se ingresa a la estructura de la instrucción switch. Esta instrucción es muy facil de seguirla, es este caso, si el mes es 1 se imprime la leyenda “Corresponde a Enero”, si el mes es 2, se imprime la leyenda “Corresponde a Febrero” y así sucesivamente. Observar que, al finalizar cada línea, se coloca una sentencia break. El uso del break en un switch es critico ya que, si no se coloca, se continúan evaluando los distintos valores restantes, e ingresando en cada una de las alternativas. Al final, se puede colocar la instrucción default, que es opcional, indicando que no corresponde a ninguna de las alternativas anteriores.

– Algoritmos y Estructuras de Datos I –

- 47 -

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 14: Determinar el sueldo que se deberá abonar a un empleado, teniendo en cuenta que se le debe realizar un incremento, de acuerdo a la categoría que pertenece. Se debe ingresar el sueldo básico y la categoría. Inicio sb

categoria

Categoría 1 2 3 4

categoria

categoria = 1

incremento = sb * 20 / 100

categoria = 2

incremento = sb * 15 / 100

categoria = 1

incremento = sb * 10 / 100

categoria = 1

incremento = sb * 5 / 100

incremento = 0

Fin del switch

sueldo = sb + incremento

sueldo Fin

- 48 -

– Algoritmos y Estructuras de Datos I –

Incremento 20% 15% 10% 5%

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo14 { static Console c; public static void main (String arg []) { float sb; // Sueldo Basico float incremento, sueldo; int categoria; c = new Console ();

}

}

c.print ("Ingrese Sueldo Basico: "); sb = c.readFloat(); c.print ("Ingrese Categoria: "); categoria = c.readInt (); switch (categoria) { case 1: incremento = sb * 20 /100; break; case 2: incremento = sb * 10 /100; break; case 3: incremento = sb * 15 /100; break; case 4: incremento = sb * 5 /100; break; default : incremento = 0; break; } sueldo = sb + incremento; c.println("El sueldo a cobrar es: " + sueldo);

Comentarios

En el programa anterior, se agregaron dos barras inclinadas al lado de la sentencia float sb. Estas dos barras inclinadas se utilizan para colocar comentarios en el programa. Los comentarios no son tenidos en cuenta por el compilador, y pueden colocarse en cualquier lugar del programa. Se utilizan para hacer una determinada acotación, observación o nota en el programa.

Comentarios de varias líneas:

Para colocar un comentario de varias líneas en el programa, se utilizan los símbolos: /* y */ para abrir y cerrar un comentario. Ejemplo: /*

*/

Esto es un comentario de tres lineas en el progama desarrollado.

– Algoritmos y Estructuras de Datos I –

- 49 -

– ISSD – EDUARDO MANSILLA – En algunos casos, se desea realizar una misma actividad para varias alternativas, en este caso, se coloca cada altenaviva sin la sentencia break, y a la última alternativa de una determinada actividad, se le coloca el break. Ejemplo Nro. 15: Ingresar una fecha, y determinar cuantos días le corresponden al mes de esa fecha. (Se deberá imprimir: 28,29, 30 o 31). import hsa.Console; class Ejemplo15 { static Console c; public static void main (String arg []) { int dia, mes, anio, cantidad; c = new Console (); c.print ("Ingrese dia: "); dia = c.readInt (); c.print ("Ingrese mes: "); mes = c.readInt (); c.print ("Ingrese anio: "); anio = c.readInt ();

}

}

cantidad = 0; switch (mes) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: cantidad = 31; break; case 4: case 6: case 9: case 11: cantidad = 30; break; case 2: if ( ((anio%4 == 0) && !(anio%100 == 0)) || (anio % 400 == 0) ) cantidad = 29; else cantidad = 28; break; } c.println(); c.println("Al mes de esa fecha, le coresponden: " + cantidad + " dias");

Nota: Tener presente que la letra ñ, no puede ser utilizada como variable. Debido a esto, se colocó la variable anio. - 50 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – En este caso, para las alternativas 1, 3, 5, 7, 8, 10 y 12 se le asigna a la variable cantidad el valor de 31, luego, para las alternativas 4, 6, 9 y 11, se le asigna a la variable cantidad, el valor de 30. Por último, si la alternativa es 2, se pregunta si el año es bisiesto, que, en caso de ser verdadero, se le asigna a la cantidad el valor de 29, de lo contrario, se le asigna 28. Al final se imprime la variable cantidad.

Ejercicios Propuestos 3.1 – Ingresar un número de hasta 5 cifras, y determinar cuantos digitos tiene. 3.2 – Ingresar los sueldos de 4 empleados, y calcular el promedio de ellos. Se deberá imprimir una leyenda que indique si el promedio está por encima o por debajo del Nivel de Pobreza. Este valor de Nivel de Pobreza, también deberá ser ingresado por teclado. 3.3 – Escribir un programa en el cual: dada una lista de tres valores numéricos distintos se calcule e informe su rango de variación (debe mostrar el menor y el mayor de ellos). Ejemplo: Si se introducen los números: 8 , 2 y 5 La impresión debería ser: Rango = [2..8] 3.4 – Leer un valor entero. Mostrar el número de día que corresponde a ese valor. Suponer que 0 corresponde a domingo, se debe mostrar el nombre del día que le corrresponde. Ingrese número de día: 4

Ejemplo:

Corresponde al día: Jueves

3.5 – Obtener un algoritmo quedetermine el Sueldo Neto a cobrar por un empleado ingresando el Sueldo Básico y su antigüedad. Tener en cuenta que al Sueldo Básico, se le debe realizar aumento por antigüedad, según los siguiente: • • •

Hasta 5 años un 3% Entre 5 y 10 años un 5% Más de 10 años un 8%

En todos los casos se practica un descuento del 10% en concepto de aportes. 3.6 – Ingresar 4 números y mostrar el mayor de ellos.

– Algoritmos y Estructuras de Datos I –

- 51 -

– ISSD – EDUARDO MANSILLA – 3.7 – Ingresar 3 números y realizar lo siguiente: • • •

Si los tres son iguales, imprimir el cubo de ellos. Si dos son iguales, imprimir el cuadrado de ellos. Si todos son distintos, imprimir la leyenda: “Todos son distintos”.

3.7 – Ingresar dos ángulos de un triángulo y determiner a que tipo de tiángulo corresponde (Equilátero: 3 ángulos iguales, Isósceles: 2 ángulos iguales, Escaleno: todos los ángulos desiguales). Ejemplo:

Ingrese un ángulo: 40 Ingrese otro ángulo: 70 Corresponde a un Triángulo Isosceles

3.8 – Ingresar el precio de una prenda y la categoría a la que pertenece. Se deberá imprimir el importe a pagar, teniendo en cuenta el porcentaje a incrementar, de acuerdo a su categoría: Categoría ‘A’ ‘B’ ‘C’ ‘D’

Porcentaje 5% 8% 10% 12%

3.9 – Imprimir el importe que deberá abonar una persona por el alquiler de un vehículo, ingresando el tipo de vehiculo y la cantidad de días, sabiendo lo siguiente: Tipo de Vehículo 1 2 3 4

Característica Sedan 4 puertas Coupe Pick up 4x4

Precio por día $ 800 $ 1000 $ 1200 $ 1500

Ejemplo: Ingrese Tipo de Vehiculo: 2 Ingrese cantidad de días: 5 Importe a abonar: $ 5000

- 52 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

TEMAS:

UNIDAD Nº 2: Estructuras Repetitivas.

Estructuras Repetitivas Estructura While Contadores - Acumuladores.

Clase

4

Clase Número: 4

Estructura Repetitiva Una estructura repetitiva permite ejecutar una instrucción o un conjunto de instrucciones varias veces, dependiendo de una condición que sea falsa o verdadera. Si la condición que determina la ejecución de las instrucciones es siempre verdadera, estamos en presencia de un ciclo repetitivo infinito. Dicha situación es un error de programación, porque nunca finalizaría un programa.

Estructura While Es un tipo de estructura repetitiva en donde la condición que repetirá las instrucciones, se encuentra al principio de la misma. Su símbolo en diagramación es el siguiente:

Condicion Verdadero

Sentencia1; Sentencia2; : SentenciaN;

Falso

While, significa Mientras, y en el diagrama de la estructura se puede observar que, mientras la condición sea Verdadera, se procesarán las Sentencias indicadas, de lo contrario, si la condición es falsa, sale del ciclo repetitivo y continúa con la secuencia de instrucciones fuera del ciclo. Cabe hacer notar que, si la condición es falsa de entrada, no se procesarán las sentencias indicadas ni una sola vez.

– Algoritmos y Estructuras de Datos I –

- 53 -

– ISSD – EDUARDO MANSILLA –

Contadores Un contador, es una variable cuyo valor se incrementa o decrementa en una cantidad constante, cada vez que se produce un determinado suceso o acción. Los contadores se utilizan con la finalidad de contar sucesos o acciones internas de un bucle. Deben realizar una operación de inicialización y posteriormente sucesivos incrementos o decrementos del mismo. La inicialización consiste en asignarle al contador un valor. Se situará antes y fuera del ciclo repetitivo. Es decir que se utilizan para llevar el control del número de ocasiones en que se realiza una operación o se cumple una condición. Los incrementos son generalmente de uno en uno, pero puede haber contadores de dos en dos, tres en tres, etc. La simbología es la de asignación, o sea, un rectángulo como, por ejemplo: i=i+1 La forma de un contador es:

i = i + Constante

En esta asignación, se establece que a la variable i, se le debe asignar el valor que resulte de sumar el valor que tenía la variable anteriormente, mas uno o un valor constante. Por lo tanto, el computador tomará el valor que tiene la variable i, le sumará uno, y volverá a almacenar el resultado en la misma variable i. Es decir, que independientemente del valor que tenga la variable i, cada vez que se procese esta instrucción, se incrementará en uno el valor de la variable. Ejemplo Nro. 16: Imprimir todos los números del 1 al 100 Inicio

Valor Inicial

i=1 Valor Final i <= 100

Falso

Verdadero

i+“ “

i=i+1

Fin - 54 -

– Algoritmos y Estructuras de Datos I –

Incremento

– ISSD – EDUARDO MANSILLA – El diagrama comienza por colocar el Valor Inicial del contador en uno, que es el valor del cual se quiere comenzar a contar, luego se ingresa al ciclo repetitivo con la condición de verificar que el valor de la variable i se mantenga por debajo o igual a 100, que es el Valor Final al cual llegará la variable. Si el valor de la variable i es menor o igual a 100 se ingresará al ciclo, la primera vez, la variable i tiene el valor de uno, por lo tanto, la condición resulta verdadera y se ingresa al ciclo imprimiendo el valor de la variable i, (uno en este caso), posteriormente se encuentra el contador, con lo cual se incrementa el valor de la variable en una unidad (dos en este caso) y se vuelve a la condición, ahora se preguntará si el valor de 2 es menor o igual 100, resulta nuevamente verdadero, imprimiéndose el número dos en la pantalla, luego se incrementa nuevamente en una unidad, volviendo a la verificación de la condición, y así sucesivamente. Es muy comun, de utilizar en vez de la linea i=i+1; la línea i++, la cual indica que se debe incrementar en una unidad a la variable i. Mientras la variable i tenga un valor entre 1 y 100, el programa se mantendrá dentro del ciclo, cuando la variable i alcance el valor de 101, la condición resulta falsa, y sale del ciclo finalizando la ejecución del programa. En la impresión, se colocó la línea: i + “ “, esto significa que se debe imprimir el valor que tiene la variable i con un espacio en blanco al lado de la misma, la única misión de este espacio en blanco, es para que no salgan todos los números encimados. La codificación sería la siguiente: import hsa.Console; class Ejemplo16 { static Console c; public static void main (String arg []) { int i; c = new Console (); i = 1; while (i <= 100) { c.print (i + " "); Se puede colocar i++; i = i + 1; en vez de esta línea. } } } Ejemplo Nro. 17: Imprimir todos los números pares entre 100 y 300 En este caso el Valor Inicial del contador es 100, el Valor Final es 300 y el incremento es de dos en dos. Ver el diagrama y el programa en la página siguiente.

– Algoritmos y Estructuras de Datos I –

- 55 -

– ISSD – EDUARDO MANSILLA –

Inicio i = 100

i <= 300

Falso

Verdadero

i+“ “

i=i+2

Fin

import hsa.Console; class Ejemplo17 { static Console c; public static void main (String arg []) { int i; c = new Console (); i = 100; while (i <= 300) { c.print (i + " "); i = i + 2; } } }

- 56 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Acumulador Es una variable que suma sobre sí misma, un conjunto de valores para de esta manera, tener la suma de todos ellos en una sola variable. La diferencia entre un contador y un acumulador es que un contador varía su contenido en incrementos constantes, mientras el acumulador, va aumentando en una cantidad variable. La forma de un acumulador es:

a = a + otraVariable;

Ejemplo Nro. 18: Ingresar 10 valores por teclado y mostrar la suma de todos ellos. Inicio i=1 a=0

i <= 10 Verdadero

n

a=a+n i=i+1

a

Fin

Falso

Se comienza inicializando el contador en uno y el acumulador en cero. El contador será el encargado de permitir recorrer el ciclo 10 veces, mientras que el acumulador será en encargado de sumar los 10 números que se ingresen. Se ingresa al ciclo, mientras el valor de la variable i sea menor o igual a 10, la primera vez tendrá el valor de uno, indicando que se deberá ingresar el primer valor. Este primer valor se almacena en la variable n, indicado en el símbolo de introducción de datos (paralelogramo), luego el programa ejecuta la instrucción a = a + n. Esta línea realiza lo siguiente: Busca el valor de a (cero en este caso), se lo suma con el valor de n y lo vuelve a almacenar a la variable a. Luego el contador pasa a valer 2 y se ingresa nuevamente a la condición, pidiendo otro valor para n, que será acumulado en la variable a. el proceso continúa hasta que la variable i, alcance el valor de 11, con el cual se imprime el valor acumulado en a.

– Algoritmos y Estructuras de Datos I –

- 57 -

– ISSD – EDUARDO MANSILLA – El programa, resulta ser el siguiente: import hsa.Console; class Ejemplo18 { static Console c; public static void main (String arg []) { int i, a, n; c = new Console (); i = 1; a = 0; while (i <= 10) { c.print("Ingrese un numero: "); n = c.readInt(); a = a + n; i = i + 1; } c.println(); c.println("La suma de los numeros ingresados es: " + a); } } La ejecución del programa, arrojaría la siguiente pantalla si se ingresan los números del 1 al 10.

- 58 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 19: Ingresar 12 números por teclado y determinar: ♦ Cuántos fueron múltiplos de 3. ♦ Cuántos fueron múltiplos de 5. ♦ Cuántos fueron múltiplos de 3 y de 5 al mismo tiempo.

Inicio i=1 m3 = 0 m5 = 0 m35 = 0

i <= 12

Falso

Verdadero

n Falso

n % 3 == 0

Verdadero

m3 ++

Falso

n % 5 == 0

Verdadero

m5 ++

Falso

n % 3 == 0 && n % 5 ==0

Verdadero

m3, m5, m35

Fin

m35 ++

i=i+1

– Algoritmos y Estructuras de Datos I –

- 59 -

– ISSD – EDUARDO MANSILLA – Para saber si un número es múltiplo de 3, simplemente se toma el número y se lo divide por 3, si la división es exacta, o sea, que el Resto es cero, el número en cuestión es múltiplo de 3. Por lo tanto, lo único que interesa saber, es si el Resto de la división del número con 3 es cero, para ello se utiliza el operador %, que devuelve precisamente el resto de la división de los operandos. De la misma forma, se averigua si es múltiplo de 5 o de cualquier otro valor. Para saber si un número, es múltiplo de 3 y 5 al mismo tiempo, solo se realiza una condición doble: (n%3 && n%5). A continuación, se realiza el programa correspondiente: import hsa.Console; class Ejemplo19 { static Console c; public static void main (String arg []) { int i, m3, m5, m35, n; c = new Console (); i = 1; m3 = 0; m5 = 0; m35 = 0; while (i <= 12) { c.print ("Ingrese un numero: "); n = c.readInt (); if (n % 3 == 0) m3++; if (n % 5 == 0) m5++; if (n % 3 == 0 && n % 5 == 0) m35++; i = i + 1; } c.println (); c.println ("La cantidad de multiplos de 3 es: " + m3); c.println ("La cantidad de multiplos de 5 es: " + m5); c.println ("La cantidad de multiplos de 3 y 5 es: " + m35); } } Nota: En esta codificación del programa, las instrucciones if, fueron utilizadas sin tener en cuenta las llaves limitadoras de principio y fin de bloque. Esto es debido a lo siguiente: Cuando en una estructura, (como por ejemplo en un if) se encuentra una sola sentencia, no es necesario colocar las llaves, ahora, si se deben procesar más de una instrucción, tanto por el verdadero como por el falso, sí es obligatorio coloca las llaves que limiten el bloque de instrucciones a ejecutar.

- 60 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Impresión de series matemáticas Una serie matemática es una suceción de términos en donde hay una relación entre cada uno de dichos términos. Ejemplo Nro. 20: Imprimir los 30 términos de la serie:

10 – 16 – 22 – 28 …

Cuando se debe imprimir los términos de una serie, se debe encontrar en primera medida cual es la relación entre un elemento y otro. Tener en cuenta que no se deben ingresar datos, si no que, el programa debe generar cada uno de los términos que se van a imprimir. Razonando y observando los términos de la serie a imprimir, se puede deducir que es un contador que va de seis en seis y comienza en 10, es decir, que se tiene una instrucción de la forma: t = t + 6. Cada término está formado como el anterior más seis. Teniendo ya la fórmula que rige a la serie, el resto simplemente consiste en encerrar a dicha fórmula en un ciclo que se repita 30 veces, previa impresión de la variable t. A continuación, se desarrolla el algoritmo: Inicio

i=1 t = 10

i <=30

t+" " t=t+6 i = i +1

Fin

– Algoritmos y Estructuras de Datos I –

- 61 -

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo20 { static Console c; public static void main (String arg []) { int i, t; c = new Console (); i = 1; t = 10; c.println("Impresion de la serie: "); c.println(); while (i <= 30) { c.print(t + " "); t = t + 6; i = i + 1; } } }

Actividades Actividades Actividad 4.1: Obtener la suma de todos los números menores o iguales a 100. Se deberá imprimir la suma de: 1 +2 + 3 + 4 + … + 98 + 99 + 100 = Actividad 4.2: Ingresar 7 valores de tipo float y obtener su promedio, indicando si es mayor o menor de 100. Actividad 4.3: Ingresar 15 valores, e imprimir: ♦ Cuántos fueron pares. ♦ Cuántos fueron impares. ♦ Cuántos terminados en cero. Actividad 4.4: Ingresar 10 números y mostrar la suma de los cinco últimos. Actividad 4.5: Imprimir la suma de los 50 términos de la serie: 5*6+5*7+5*8+5*9+… Actividad 4.6: Imprimir los 15 términos de la serie: 500 – 525 – 550 – 575 …

- 62 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – En caso de tener dificultad en resolver los ejercicios, se desarrollan a continuación algunos diagramas de los mismos. Actividad 4.1 Inicio i=1 a=0

i <= 100

Falso

Verdadero

a=a+i

a

i=i+1

Fin

Actividad 4.2 Inicio i=1 a=0

i <= 7

2

Falso

Verdadero

valor

3

1

– Algoritmos y Estructuras de Datos I –

- 63 -

– ISSD – EDUARDO MANSILLA –

2

1

3

a = a + valor i=i+1

prom = a / 7

prom >= 100

“El promedio es menor a 100”

“El promedio es mayor o igual a 100”

Fin

- 64 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Actividad 4.3 Inicio i=1 par = 0 impar = 0 cero = 0

i <= 15

Falso

Verdadero

n Falso

n % 2 == 0

impar ++

Falso

Verdadero

par ++

n % 10 == 0

Verdadero

cero ++

i=i+1

“Cantidad de Pares: “ + par “Cantidad de Impares: “ + impar “Terminados en cero: “ + cero Fin

– Algoritmos y Estructuras de Datos I –

- 65 -

– ISSD – EDUARDO MANSILLA – Actividad 4.4

Inicio i=1 a=0

i <= 10

Falso

Verdadero

n

Falso

i>5

Verdadero

a=a+n

i=i+1

a

Fin

- 66 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Ingreso de valores hasta que se digite una clave En algunos casos, no se tienen en cuenta la cantidad de valores a ingresar, si no que se ingresan datos hasta que se digite un valor clave. Este valor clave, indica la finalización del ingreso de datos. Ejemplo Nro. 21: Ingresar sueldos de personas hasta que se digite el valor clave de 99999. Determinar, cuántos fueron mayores o iguales a $5000, cuántos menores de $5000 y mostrar, además, el sueldo promedio de todos los ingresados. Nota: El valor de 99999 es el que indica la finalización de ingresos de datos, este valor no debe ser tenido en cuenta en la cantidad de mayores a $5000, ni tampoco para el cálculo del promedio Inicio a=0 cantidad = 0 mayores = 0 menores = 0

sueldo

sueldo != 99999

Falso

Verdadero

cantidad ++ Falso

sueldo >= 5000

menores ++

Verdadero

mayores ++

1 a = a + sueldo

sueldo

– Algoritmos y Estructuras de Datos I –

- 67 -

– ISSD – EDUARDO MANSILLA –

1

Falso

cantidad > 0

Verdadero

p = a / cantidad

“No se ingresaron sueldos”

“Mayores a $5000: “ + mayores “Menores a $5000: “ + menores “Promedio de sueldos: “ + p

Fin

El diagrama comienza inicializando las variables en cero, tanto el acumulador, como los contadores. Antes de entrar en el ciclo, se pide el primer sueldo, que en caso de ser distinto de la clave de finalización (99999) se ingresa al ciclo. Inmediatamente se incrementa la cantidad, porque ya hay un sueldo válido, luego se procesa averiguando si es mayor o menor a $5000, incrementando los contadores correspondientes, sucesivamente, se acumula en la variable a, que es donde se guardará la suma total. Antes de cerrar el ciclo, se debe pedir nuevamente el sueldo y retornar a la condición del while. La repetición de ingreso de sueldos se realizará hasta que se ingrese el valor de 99999, con ello la condición resulta falsa y sale del ciclo while. Para poder calcular el promedio de sueldos es necesario de que por lo menos se haya ingresado un sueldo, ya que, si de entrada se digita el valor de 99999, la variable cantidad quedará con el valor cero y el promedio daría indeterminado. Por lo tanto, se debe verificar que la cantidad sea mayor a cero, en ese caso, se procede a calcular el promedio y a la impresión de los contadores. En caso que la cantidad sea cero, se imprime la leyenda correspondiente.

- 68 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo21 { static Console c; public static void main (String arg []) { int cantidad, mayores, menores; float a, sueldo, p; c = new Console (); a = 0; cantidad = 0; mayores = 0; menores = 0; c.print ("Ingrese un sueldo (99999 para terminar): "); sueldo = c.readFloat (); while (sueldo != 99999) { cantidad++; if (sueldo >= 5000) mayores++; else menores++; a = a + sueldo; c.print ("Ingrese un sueldo (99999 para terminar): "); sueldo = c.readFloat (); }

}

c.println (); if (cantidad > 0) { p = a / cantidad; c.println ("Cantidad mayores o iguales a $5000: " + mayores); c.println ("Cantidad menores a $5000: " + menores); c.println ("Promedio de sueldos: " + p); } else c.println ("No se ingresaron sueldos"); }

– Algoritmos y Estructuras de Datos I –

- 69 -

– ISSD – EDUARDO MANSILLA –

Ejercicios Propuestos 4.1 – Ingresar 12 precios de productos y determinar: ♦ Cuantos fueron menores a $50. ♦ Cuantos fueron entre $50 y $100, ambos inclusive. ♦ Cuantos fueron mayores de $100. 4.2 – Imprimir todos los múltiplos de 7 menores a 100. (0 – 7 – 14 – 21 – 28…) 4.3 – En un Banco se debe ingresar por cada cliente, el número de cuenta y el monto de depósito a realizar. El ingreso de datos se debe realizar hasta que se digite un valor de cuenta negativo. Se deberá imprimir lo siguiente: ♦ ♦ ♦ ♦

Cantidad de clientes procesados. Cantidad de clientes con depósitos superiores a $2000. Suma acumulada de todos los depósitos. Promedio de todos los depósitos.

4.4 – Mostrar la suma de los primeros 50 números impares. 4.5 – Ingresar dos valores numéricos y mostrar todos los números comprendidos. No se deben imprimir los valores ingresados. 4.6 – Dada la siguiente serie: 20 + 25 + 30 + 35 + … imprimir los 30 primeros términos de la misma y además, mostrar también el resultado de la suma. (Tener en cuenta que la serie comienza del valor 20) 4.7 – Ingresar edades de persona hasta que se digite el valor clave de 1111. Se deberá imprimir lo siguiente: ♦ Cuantas personas fueron menores de edad (edad menor de 21 años). ♦ Cuantas personas fueron mayores de edad. ♦ Cuantos mayores de edad fueron adultos (edad mayor o igual a 35 años) 4.8 – Realizar un programa que permita cargar el peso de 10 personas y calcule su promedio, imprimiendo las siguientes leyendas: ♦ ♦ ♦ ♦

Si el promedio es inferior a 55 kg, mostrar “Peso insuficiente” Si el promedio está entre 55 kg y 70 kg, mostrar “Peso Ideal” Si el promedio está entre 70 kg y 85 kg, mostrar “Peso Normal” Si el promedio es superior a 85 kg, mostrar “Peso Excedido”

4.9 – Imprimir los números pares en forma decreciente desde el 800 hasta el 400. 4.10 – Obtener el promedio de los múltiplos de 4 menores a 300.

- 70 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

UNIDAD Nº 2: Estructuras Repetitivas.

TEMAS: Estructura For. Busqueda del mayor.

Clase

5

Clase Número: 5 Estructura for En general, la estructura FOR, se usa en aquellas situaciones en las cuales sen conoce de antemano, la cantidad de veces que se quiere que se ejecute un bloque de instrucciones. Ejemplo: cargar 10 números; ingresar 5 notas de alumnos; etc. Se conoce de antemano la cantidad de veces que queremos que el bloque se repita. Representación gráfica

Inicialización; condidión a evaluar; modificación

Falso

Verdadero

Operaciones

En su forma más típica y básica, esta estructura requiere una variable entera que cumple la función de un CONTADOR de vueltas. En la sección indicada como “inicialización”, se suele colocar el nombre de la variable que hará de contador, asignándole a dicha variable un valor inicial. En la sección de “condición a evaluar” se coloca la condición que deberá ser verdadera para que el ciclo continúe. Y finalmente, en la sección de “modificación” se incrementa o decrementa el valor de la variable que hace de contador (para permitir que alguna vez la condición sea falsa).

– Algoritmos y Estructuras de Datos I –

- 71 -

– ISSD – EDUARDO MANSILLA – Ejemplo: Suponer que se necesitan procesar 10 empleados de una empresa: Condición que indica la finalización del ciclo, mientras la variable i, sea menor o igual a 10 se mantendrá dentro del ciclo

Se inicializa la variable, indicando de qué valor comenzará el ciclo repetitivo

i=1 ;

Contador que se incrementa con cada repetición

i <= 10 ;

Falso

i ++

Verdadero

Operaciones

Todas las operaciones que se encuentren dentro del for, se repetirán 10 veces en este caso.

Explicación: Cada vez que se ingresa al ciclo for, se inicializa la variable en el valor indicado, en este caso i = 1, luego se realiza la verificación que indica la condición i <= 10, en este caso es verdadero (uno es menor a 10), por lo tanto, se ingresa al ciclo y se ejecutan las Operaciones. Al final del ciclo se reingresa nuevamente al for, en donde se incrementa en una unidad, pasando ahora a tener la variable i el valor de 2, nuevamente se verifica la condición, resultando otra vez verdadera, y se realizan de nuevo las Operaciones. El proceso continúa hasta que la variable i alcance el valor de 11, en este caso, la condición resulta falsa y sale del ciclo. Si se conoce la cantidad de veces que se quiere repetir un bloque de programa, es muy sencillo emplear un ciclo for, por ejemplo, si se quiere repetir 50 veces, la instrucción quedará: i=1; i<=50; i++ La variable i puede ser inicializada en cualquier valor y finalizar en cualquier valor. Además, no es obligatorio que la instrucción de modificación sea un incremento del tipo contador (i++). Cualquier instrucción que modifique el valor de la variable es válida. Si por ejemplo se escribe i = i+2 en lugar de i++, el valor de la variable i será incrementado de 2 en 2 en cada vuelta, y no de uno en uno. En este caso, esto significará que el ciclo no efectuará las 50 vueltas sino sólo 25.

- 72 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 22: Realizar un programa que permita imprimir todos los números del 1 al 100. Inicio

i = 1 ; i <= 100 ; i ++

Falso

Verdadero

i+“ “

Fin

import hsa.Console; class Ejemplo22 { static Console c; public static void main (String arg []) { int i; c = new Console (); for (i = 1 ; i <= 100 ; i++) { c.print (i + " "); } } } Al ingresar al ciclo for, se le asigna la variable i el valor 1 y como no es superior a 100 se ejecuta el bloque, imprimiendo el contenido de i , al finalizar el bloque repetitivo se incrementa en una unidad, pasando a tener el valor de 2. Como 2 no es superior a 100 se repite el bloque de instrucciones. Cuando la variable i llega a 101, la condición resulta falsa y sale de la estructura repetitiva for y finaliza el programa. Ejemplo Nro. 23: Desarrollar un programa que permita ingresar la altura de 8 personas y muestre el promedio de ellas.

– Algoritmos y Estructuras de Datos I –

- 73 -

– ISSD – EDUARDO MANSILLA – Inicio suma = 0

i=1

; i <= 8 ; i ++

Falso

Verdadero

altura

suma = suma + altura

promedio = suma / 8

“El promedio es: “ + promedio

Fin import hsa.Console; class Ejemplo23 { static Console c; public static void main (String arg []) { int i; float altura, suma, promedio; c = new Console (); suma = 0; for (i = 1 ; i <= 8 ; i++) { c.print ("Ingrese altura: "); altura = c.readFloat(); suma = suma + altura; } promedio = suma / 8; c.println(); c.println("El promedio es: " + promedio); } }

- 74 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 24: Escribir un programa que lea 10 notas de alumnos e informe cuántos tienen notas mayores a 7, cuantos entre 4 y 7, ambos inclusive, y cuántos menores a 4. Para resolver este problema, se necesitan 4 contadores, uno para la variable del for, para contar las 10 notas, otro para contar la cantidad de notas mayores a 7, otro para contar las notas que están entre 4 y 7 y otro para las notas inferiores a 4. Dentro de la estructura repetitiva for, se deben realizar la carga de la variable nota y verificar con estructuras condicionales, si el contenido de la variable nota, es mayor o igual a 7, si está entre 4 y 7 y si es menor a 4, para incrementar los contadores correspondientes. Inicio mayores = menores = entre = 0

i=1

; i <= 10 ; i ++

Falso

Verdadero

nota Falso

Falso

menores++

Verdadero

nota >7

nota >= 4

Verdadero

mayores ++

entre ++

mayores, entre, menores

Fin

– Algoritmos y Estructuras de Datos I –

- 75 -

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo24 { static Console c; public static void main (String arg []) { int i, nota, mayores, menores, entre; c = new Console (); mayores = menores = entre = 0; for (i = 1 ; i <= 10 ; i++) { c.print ("Ingrese nota: "); nota = c.readInt (); if (nota > 7) mayores++; else if (nota >= 4) entre++; else menores++; }

}

}

c.println c.println c.println c.println

(); ("Cantidad de mayores a 7: " + mayores); ("Cantidad entre 4 y 7: " + entre); ("Cantidad de menores a 7: " + menores);

Una variante de inicializar todos los contadores en cero, es colocar una variable igual a otra, igual a otra y así sucesivamente, y al último colocar igual a cero. En este caso se realizo: mayores = menores = entre = 0; El for permite introducir 10 notas, con las cuales se averigua si es mayor a 7, si se está entre 4 y 7 y si está por debajo de 4, incrementándose los contadores correspondientes. Observar que la impresión de los contadores se realiza después de la finalización del ciclo, que es cuando ya se ingresaron las 10 notas. Ejemplo Nro. 25: Escribir un programa que imprima todos los múltiplos de 6 que hay entre 100 y 200, mostrando, además, la cantidad de ellos. En este caso, se debe tener en cuenta que no se deben introducir datos, ya que la máquina debe generar los números entre 100 y 200. Luego se debe verificar cual es múltiplo de 6, para ello se utiliza el operador %. Ver diagrama en la página siguiente.

- 76 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Inicio

i = 100

; i <= 200 ; i ++

Falso

Verdadero Falso

i % 6 == 0

Verdadero

i+“ “

Fin

import hsa.Console; class Ejemplo25 { static Console c; public static void main (String arg []) { c = new Console (); for (int i = 100 ; i <= 200 ; i++) { if (i%6 == 0) c.print (i + " "); } } }

En este programa, se definió a la variable i dentro del for, en el mismo lugar que donde se inicializa. Esta es otra modalidad de definición de variables, en este caso, la variable i es Local a la estructura for, lo que significa que fuera de dicha estructura, no existe.

– Algoritmos y Estructuras de Datos I –

- 77 -

– ISSD – EDUARDO MANSILLA – En algunos casos se debe ingresar la cantidad de datos a procesar al inicio del programa, es decir, que dicha cantidad de datos es variable. Ejemplo Nro. 26: Escribir un programa que lea “n” números enteros por teclado y calcule la cantidad de valores que fueron mayores 1000 y además, la suma de ellos. Inicio mayores = suma = 0 n

i=1

Falso

; i <= n ; i ++ Verdadero

numero Falso

numero >1000

Verdadero

mayores ++ suma = suma + numero

mayores, suma

Fin

- 78 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo26 { static Console c; public static void main (String arg []) { int n, numero, mayores, suma; c = new Console (); mayores = suma = 0; c.print ("Ingrese cantidad a procesar: "); n = c.readInt (); c.println(); for (int i = 1 ; i <= n ; i++) { c.print ("Ingrese un numero: "); numero = c.readInt (); if (numero > 1000) { mayores++; suma = suma + numero; }

}

}

} c.println (); c.println ("Cantidad de mayores a 1000: " + mayores); c.println ("Suma de los mayores a 1000: " + suma);

Razonamiento Lógico: Lo primero que se realiza es cargar una variable que indique la cantidad de valores a ingresar. Dicha variable se carga antes de entrar a la estructura repetitiva for. La estructura for permite que el valor inicial o final dependa de una variable cargada previamente por teclado.

– Algoritmos y Estructuras de Datos I –

- 79 -

– ISSD – EDUARDO MANSILLA –

Actividades Actividades Actividad 5.1: Confeccionar un programa que lea N pares de datos, cada par de datos corresponde a la medida de la base y la altura de un triángulo. El programa deberá informar:  De cada triángulo la medida de su base, su altura y su superficie.  La cantidad de triángulos cuya superficie es mayor a 12. Actividad 5.2: Desarrollar un programa que solicite la carga de 15 números e imprima la suma de lo últimos 10 valores ingresados. Actividad 5.3: Elaborar un programa que me muestre el mayor de 20 números ingresados. Actividad 5.4: Desarrollar un programa que muestre la tabla de multiplicar del 5 (del 1 al 20). Ejemplo:

5x1=5 5 x 2 = 10 5 x 3 = 15 5 x 4 = 20 : 5 x 20 = 100

Actividad 5.5: Confeccionar un programa que permita ingresar un valor del 1 al 10 y nos muestre los múltiplos del mismo (los primeros 30 términos). Ejemplo: Si se ingresa en número 3, deberá aparecer:

Multiplos de 3 0 – 3 – 6 – 9 – 12 – 15...

Actividad 5.6: Realizar un programa que lea los 3 lados de N triángulos, e informar: a) De cada uno de ellos, qué tipo de triángulo es: equilátero (tres lados iguales), isósceles (dos lados iguales), o escaleno (todos los lados desiguales). b) Cantidad de triángulos de cada tipo. c) Tipo de triángulo que posee menor cantidad.

- 80 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – En caso de tener dificultad en resolver los ejercicios, se desarrollan a continuación algunos diagramas de los mismos. Actividad 5.1 Inicio cant = 0 n

i = 1;

i <= n;

i++

b, h superficie = b * h

b, h, superficie

superficie > 12 cant ++

“Cantidad de triangulos con sup. Mayor a 12: “ + cant

Fin

– Algoritmos y Estructuras de Datos I –

- 81 -

– ISSD – EDUARDO MANSILLA – Actividad 5.2 Inicio suma = 0 i = 1;

i <= 15;

i++

numero

i>5 suma = suma + numero

“Suma de los 10 ultimos numeros: “ + suma

Fin

Actividad 5.3

Búsqueda del mayor de una serie de números ingresados. Para determinar el mayor de 20 números ingresados por teclado, el algoritmo sería de la siguiente manera: 1) Se realiza un for para pedir los 20 números. 2) El primer número que se ingresa, se lo asigna a una variable, por ejemplo: “m”. Hasta ese momento, el valor guardado en “m” es el mayor. 3) Se pregunta si alguno de los siguientes números ingresados es mayor al almacenado en la variable “m”. En caso de resultar verdadero, se le asigna a la variable “m” el nuevo valor. 4) Por último, se imprime el valor de la variable “m”.

- 82 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Desarrollo del algoritmo de Búsqueda del mayor.

Si el valor de la variable i es igual a 1, significa que se tiene el primer número ingresado, por lo tanto, se lo guarda en la variable m.

Inicio

i = 1;

i <= 20;

Falso

i++

Verdadero

numero Falso

i == 1

Verdadero

m = numero

Falso

numero > m

Verdadero

m = numero

“El mayor de los números ingresados es: “ + m

Fin

Si alguno de los sucesivos valores ingresados es mayor al guardado en la variable m, se guarda el nuevo valor en la misma variable m.

– Algoritmos y Estructuras de Datos I –

- 83 -

– ISSD – EDUARDO MANSILLA –

Actividad 5.4

Inicio

i = 1;

i <= 20;

i++

r=5*i

5+“x“+i+“=“+r

Fin

Actividad 5.5 Inicio n termino = 0

i = 1;

i <= 30;

i++

termino + “ – “

termino = termino + n

Fin

- 84 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Ejercicios Propuestos 5.1 – Escribir un programa que pida ingresar coordenadas (x,y) que representan puntos en el plano. Informar cuántos puntos se han ingresado en el primer, segundo, tercer y cuarto cuadrante. Al comenzar el programa se pide que se ingrese la cantidad de puntos a procesar. 5.2 – Se realiza la carga de 10 valores enteros por teclado. Se desea conocer: a) La cantidad de valores ingresados negativos. b) La cantidad de valores ingresados positivos. c) La cantidad de múltiplos de 9. d) El valor acumulado de los números ingresados impares. 5.3 – Se cuenta con la siguiente información:  Las edades de 5 estudiantes del turno mañana.  Las edades de 6 estudiantes del turno tarde.  Las edades de 10 estudiantes del turno noche. Las edades de cada estudiante deben ingresarse por teclado. a) Obtener el promedio de las edades de cada turno (tres promedios). b) Imprimir dichos promedios (promedio de cada turno). c) Mostrar por pantalla un mensaje que indique cual de los tres turnos tiene un promedio de edades mayor 5.4 – Ingresar un número, y mostrar la tabla de multiplicar de ese número. 5.5 – Ingresar dos valores y realizar un programa que muestre la suma de todos los números comprendidos entre esos dos valores. 5.6 – Ingresar un número y mostrar todos los divisores de ese número. Ejemplo:

Ingrese un numero: 50 Los divisores de 50 son: 1; 2; 5; 10; 25; 50

5.7 – Mostrar los 30 términos de la serie: 50 x 3; 50 x 4; 50 x 5; 50 x 6; … 5.8 – Ingresar las 20 notas de un curso y determinar su promedio. Imprimir lo siguiente: a) Si el promedio del curso es inferior a 5, mostrar: “Curso deficiente”. b) Si el promedio está entre 5 y 7, mostrar: “Curso Satisfactorio”. c) Si el promedio es mayor a 7, mostrar: “Curso muy Bueno”.

– Algoritmos y Estructuras de Datos I –

- 85 -

– ISSD – EDUARDO MANSILLA – 5.9 – Calcular el factorial de un número ingresado por teclado. El factorial de un número consiste en tomar al número ingresado y multiplicarlo por todos los inferiores a él, sin incluir el cero. Ejemplo: Factorial de 5 = 5 x 4 x 3 x 2 x 1 Ingrese un número: 5 El Factorial de 5 es: 120

Se asume que el factorial de cero es igual a 1 y no existe factorial de numeros negativos. 5.10 – Ingresar un número y mostrar todos sus múltiplos entre 500 y 1000. 5.11 – Mostrar los términos 40 términos de la serie: 100; -200; 120; -190; 140; -180; 160; -170; … 5.12 – Ingresar dos números por teclado y determinar cuántos valores pares hay entre esos dos números. Ejemplo: Ingrese un Numero: 20 Ingrese otro Numero: 50 Hay 14 numeros pares entre 20 y 50 5.13 – Ingresar los sueldos de 20 empleados y determinar lo siguiente: a) b) c) d)

Cuántos empleados tienen un sueldo inferior $3000. Cuántos tienen un sueldo entre $3000 y $5000. Cuántos tienen un sueldo superior a $5000. Sueldo total a abonar a todos los empleados.

5. 14 – Ingresar un número y determinar cuántos múltiplos tiene entre 0 y100, ambos inclusive. Ejemplo: Ingrese un Numero: 20 El 20 tiene 6 multiplos entre 0 y 100

- 86 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – TEMAS: Estructura do..while Concepto de Bandera. Posicionamiento del cursor. Generación de números aleatorios.

UNIDAD Nº 2: Estructuras Repetitivas.

Clase

6

Clase Número: 6 Estructura do..while La sentencia do..while es otra estructura repetitiva, la cual ejecuta al menos una vez su bloque repetitivo, a diferencia del while o del for que si la condición es falsa la primera ves, no ejecuta el bloque de instrucciones. Esta estructura repetitiva se utiliza cuando se conoce de antemano que por lo menos una vez, se ejecutará el bloque repetitivo. La condición en esta estructura está por debajo del bloque a repetir, a diferencia del while o del for que está en la parte superior. Representación gráfica:

do

Bloque de instruciones a repetir.

Verdadero

Condición Falso

– Algoritmos y Estructuras de Datos I –

- 87 -

– ISSD – EDUARDO MANSILLA – El bloque de operaciones se repite Mientras la condición sea Verdadera. Si la condición retorna Falso, el ciclo se detiene. Es importante analizar y ver que las operaciones se ejecutan como mínimo una vez. La estructura do..while se codifica de la siguiente forma: do {

Sentencia1; Sentencia2; : SentenciaN;

} while (Condicion); Ejemplo Nro. 27: Ingresar números y determinar si son pares o impares. El programa deberá terminar cuando se digite el número cero.

Inicio

do

Estructura if

n

Falso

n % 2 == 0

“El Numero ingresado es impar”

Verdadero

Verdadero

“El Numero ingresado es par”

n != 0 Falso

Fin

- 88 -

– Algoritmos y Estructuras de Datos I –

while

– ISSD – EDUARDO MANSILLA – No hay que confundir los rombos de las estructuras condicionales, con los de las estructuras repetitivas do..while. Observar que el rombo de la estructura condicional (if) tiene los brazos a izquierda y derecha, y el while, tiene uno de los brazos hacia abajo. import hsa.Console; class Ejemplo27 { static Console c; public static void main (String arg []) { int n; c = new Console (); do { c.print("Ingrese un numero (Cero para terminar): "); n = c.readInt (); if (n % 2 == 0) c.println ("El numero ingresado es par"); else c.println ("El numero ingresado es impar"); c.println (); } while (n != 0); c.println (); c.println ("Fin de Proceso"); } } El ciclo repetitivo se lee de esta manera: Hacer las instrucciones siguientes, mientras el valor de la variable n sea distinto de cero. Se ingresa al ciclo introduciendo un valor para almacenarlo en la variable n, y se pregunta si el resto de la división del valor de n con 2, es igual a cero, en caso de ser verdadero, significa que el valor de n es divisible por 2, por lo tanto, es un número par y se imprime la leyenda correspondiente. En caso de ser falso, el número ingresado no es par y se imprime: número impar. Mientras el valor ingresado en n sea distinto de cero, el programa se direccionará nuevamente a la instrucción do, pidiendo otro ingreso de dato. El proceso termina cuando se digite el valor cero para la variable n, en este caso, la condición del while resulta falsa y sale del ciclo.

– Algoritmos y Estructuras de Datos I –

- 89 -

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 28: Escribir un programa que solicite la carga de números por teclado, y obtener su promedio. Finalizar el programa cuando se ingrese el valor de 9999. (El valor de 9999, no debe ser tenido en cuenta para el cálculo del promedio) Inicio cantidad = 0 suma = 0 do n

Falso

Verdadero

n != 9999

cantidad ++ suma = suma + cantidad

Verdadero

n != 9999 Falso

Falso

cantidad != 0

Verdadero

promedio = suma / cantidad “No se ingresaron números“ “El promedio es: “ + promedio

Fin

- 90 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – En este caso, se inicializan las variables “cantidad” y “suma” en cero antes de entrar al ciclo do, luego se pide un número para ser almacenado en la variable “n” y se verifica si el número ingresado es distinto del valor 9999, en caso de ser verdadero, es un número que debe ser procesado, por lo tanto, se incrementa la cantidad y se acumula el valor ingresado, posteriormente se cierra el ciclo con la instrucción while, que retornará al do, si la condición resulta verdadera. Al salir del ciclo do..while, se comprueba que la variable “cantidad” sea distinto de cero, esto es debido a que si la cantidad es igual a cero, no se puede calcular el promedio, porque resultaría una división por cero, dando un error de cálculo. Si la cantidad es distinta de cero, es que por lo menos se ha ingresado un valor y entonces es posible realizar el cálculo del promedio, imprimiendo dicho valor. Si la condición del if resulta falsa, se muestra una leyenda que “No se ingresaron números”. import hsa.Console; class Ejemplo28 { static Console c; public static void main (String arg []) { int n, cantidad, suma; float promedio; c = new Console (); cantidad = 0; suma = 0; do {

}

}

c.print ("Ingrese un numero (9999 para terminar): "); n = c.readInt (); if (n != 9999) { cantidad++; suma = suma + n; }

} while (n != 9999); c.println (); if(cantidad != 0) { promedio = (float) suma / cantidad; c.println ("El promedio es: " + promedio); } else c.println("No se ingresaron numeros.");

– Algoritmos y Estructuras de Datos I –

- 91 -

– ISSD – EDUARDO MANSILLA – En algunos casos, luego de ingresar un dato, la computadora pregunta si se desea realizar otro ingreso, si se le responde que si, nuevamente pide un valor y en caso contrario, se muestra el proceso de los datos ingresados hasta ese momento. Este es un ejemplo típico del uso del do..while, en donde se verifica exclusivamente que la condición se encuentra al final del ciclo. Ejemplo Nro. 29: Desarrollar un programa que solicite una serie de nombres de productos con sus respectivos precios, y mostrar el nombre del producto de menor precio. La computadora debe preguntar si se siguen ingresando datos. Inicio b=0 do nombre precio Falso

b == 0

Verdadero

b=1 nx = nombre px = precio

2

Falso

precio < px

Verdadero

nx = nombre px = precio

“Ingresa otro juego de datos (s/n): “ opcion

1 - 92 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

2

1 Verdadero

opcion == ‘s’ Falso

“El producto de menor precio es “ + nx

Fin

Concepto De Bandera Una bandera es una variable que puede asumir únicamente dos valores, por ejemplo, cero y uno, verdadero o falso, etc. Se utiliza cuando se necesita procesar una porcion de programa si se verifica una determinada condición en un momento adecuado para una alternativa. En el programa siguiente, se utiliza una bandera para poder asignar el primer dato ingresado a una variable arbitraria para poder compararla con los siguientes datos que se ingresarán. El proceso consiste en lo siguiente: 1) 2) 3) 4) 5)

Se asigna a la bandera el valor de cero (b=0), y se ingresa al ciclo do. Se ingresa el primer juego de datos. Se pregunta si la bandera está en cero. Como b es igual a cero, el diagrama se direcciona por el verdadero. Se coloca a b en uno, para establecer de que la condición nunca mas vuelva a ser verdadero y se asignan a las variables auxiliares el primer juego de datos ingresado. 6) Se verifica si alguno de los siguientes datos ingresados es menor al guardado en la variable auxiliar, “if (precio
Posicionamiento del Cursor Para poder posicionar el cursor en un determinado lugar de la pantalla, se utiliza la instrucción: c.setCursor(Fila,Columna), que tiene como parámedtro la fila y la columna en la cual se quiere posicionar. Por ejemplo, si se necesita colocar el cursor en la posición Fila: 10 y Columna: 20, se debe colocar: c.setCursor(10,20);

– Algoritmos y Estructuras de Datos I –

- 93 -

– ISSD – EDUARDO MANSILLA – El programa del diagrama anterior es el siguiente: import hsa.Console; class Ejemplo29 { static Console c; public static void main (String arg []) { c=new Console(); int b; String nombre, nx; float precio, px; char opcion; b=0; px=0; nx=""; do { c.clear (); c.setCursor (3, 15); c.print ("Carga de datos"); c.setCursor (4, 15); c.print ("--------------"); c.setCursor (6, 10); c.print ("Ingrese Nombre de Producto: "); nombre = c.readLine (); c.setCursor (9, 10); c.print ("Ingrese Precio del Producto: "); precio = c.readFloat(); if (b == 0) { b = 1; nx = nombre; px = precio; } if (precio < px) { nx = nombre; px = precio; } c.setCursor (15, 10); c.print ("Ingresa otro juego de datos (S/N): "); opcion = c.readChar ();

} - 94 -

}

} while (opcion == 'S' || opcion == 's'); c.setCursor(18,10); c.print ("El producto de menor precio es: " + nx); c.setCursor(19,10); c.print ("Su precio es de: $ " + px);

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – El programa comienza definiendo las variables e iniciándolas en sus valores nulos. Observar que el elemento nulo de una variable String es "". Se ingresa al ciclo do, limpiando la pantalla en cada ingreso, luego se coloca el cursor en la fila 3, columna 15 y se imprime el Título en esa posición, subrayándolo en la línea siguiente. Se pide en nombre del producto en la fila 6, columna 10 con las instrucciones: c.setCursor (6, 10); c.print ("Ingrese Nombre de Producto: "); nombre = c.readLine (); Y el precio del mismo, en la fila 9, columna 10 con las instrucciones: c.setCursor (9, 10); c.print ("Ingrese Precio del Producto: "); precio = c.readFloat(); Como la bandera está en cero, la condición if(b==0) resulta verdadera, por lo tanto, se ejecutan las instrucciones siguientes: b = 1; nx = nombre; px = precio; Al colocar la bandera en 1, la condición if(b==0) nunca mas será verdadera, entonces se guardan los datos de las variables nombre y precio en las variables auxiliares nx y px respectivamente. Esto se realiza para tener variables con quien comparar los sucesivos pares de datos que se ingresarán. La segunda condición, verifica si alguno de los siguientes precios ingresados es menor al que se encuentra almacenado en la variable auxiliar px, que, en caso de ser verdadero, se reasignan los nuevos valores. Antes de finalizar el ciclo, se realiza la pregunta en pantalla: "Ingresa otro juego de datos (S/N): ", colocando la variable opción para pedir la letra ‘s’ o ‘n’, según se quiera ingresar otro juego de datos o no. El ciclo finaliza con la instrucción: while (opcion == 'S' || opcion == 's'); Que significa que mientras la variable opción tenga almacenado la letra ‘S’, retornará a pedir otro juego de datos. Observar que la constante ‘S’, se ha colocado entre apóstrofes, ya que es un carácter. También se utilizó un operador lógico Or, debido a que el teclado puede estar trabajando en mayúsculas o minúsculas. Luego de salir del ciclo do..while, se imprimen los contenidos de las variables auxiliares nx y px, que han almacenados los respectivos valores del nombre y el precio del producto de menor precio.

– Algoritmos y Estructuras de Datos I –

- 95 -

– ISSD – EDUARDO MANSILLA –

Generación de números aleatorios Para generar números aleatorios, se utiliza la función: Math.random(), que genera números aleatorios entre cero y uno, es decir, números mayores que cero y menores que uno. El número generado es de tipo double. El tipo double es un tipo de dato con punto decimal flotante, similar al tipo float, con la diferencia que el alcance es mucho mayor. El rango numérico para una variable de tipo double es: [4.94065645841246544 x 10–324 a 1.7976931348623157 x 10+308] Ocupa 8 bytes de memoria. Por ejemplo, si se quiere generar números entre cero y 100 se debe colocar la siguiente línea: int n = (int) (Math.random() * 101) Explicación: La función Math.random() genera un número entre cero y uno, por ejemplo, suponer que se generó el valor 0,20. Al multiplicar el valor 0,20 por el número 101, nos da por resultado 20,2. Si a este valor se le saca la parte decimal, cosa que se realiza colocando (int) delante del resultado, se obtiene el número 20 que será almacenado en la variable n. Si se supone que el número mínimo generado por la función sea el 0,0000001, al multiplicarlo por 101, nos da: 0,0000101. Si se quitan los decimales, nos queda el numero 0, que es el mas chico generado. Si se supone que el número máximo generado por la función sea el 0,9999999, (observar que el máximo número generado por la funcion no llega ser uno), al multiplicarlo por 101, nos da por resultado: 100,9999. Si se quitan los decimales, nos queda el número 100, que será almacenado en la variable n, y era el objetivo del ejemplo, generar números entre cero y 100. Ejemplo Nro. 30: Desarrollar un programa que simule la tirada de dos dados, y determinar si salió el número 7, mostrando la leyenda “Ganó” en caso de ser verdadero y la Leyenda “Perdió” en caso de ser falso. Para generar un número entre 1 y 6, se debería colocar la siguiente línea: d1 = (int)(Math.random() * 6) + 1; En este caso, si suponemos que la función genera el mínimo número, por ejemplo: 0,0000001, al multiplicarlo por 6, nos da: 0,0000006. Si se le quitan los decimales, nos queda cero y al sumarle 1 nos da 1, que es el mínimo número que se puede almacenar en la variable d1. Por otro lado, si suponemos que la función genera el máximo número, por ejemplo: 0,9999999, al multiplicarlo por 6, nos da por resultado 5,999999. Si se quitan los decimales con (int), nos queda el valor de 5, que al sumarle 1, nos da - 96 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – el valor de 6, que es el máximo que se almacenará en la variable d1. Por lo tanto, en la variable d1 se almacenará únicamente valores enteros entre 1 y 6. Para el dado 2, la instrucción es exactamente la misma. El diagrama sería el siguiente: Inicio do d1 = (int) (Math.random() * 6) + 1 d2 = (int) (Math.random() * 6) + 1 “Dado 1: “ + d1 “Dado 2: “ + d2

suma = d1 + d2 Falso

suma == 7

“Perdió “

Verdadero

“Ganó “

“Realiza otra tirada de dados (s/n): “

opcion

Verdadero

Opción == ‘S’

Fin

– Algoritmos y Estructuras de Datos I –

- 97 -

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo30 { static Console c; public static void main (String arg []) { int d1, d2, suma; char opcion = ' '; c = new Console (); do { c.clear (); d1 = (int) (Math.random () * 6) + 1; d2 = (int) (Math.random () * 6) + 1; c.setCursor (5, 20); c.print ("Dado 1: " + d1); c.setCursor (7, 20); c.print ("Dado 2: " + d2); suma = d1 + d2; c.setCursor (10, 20); if (suma == 7) c.print ("*** Gano ***"); else c.print ("Perdio"); c.setCursor (15, 20); c.print ("Realiza otra tirada de dados(s/n): "); if (opcion == 'S' || opcion == 's') opcion = c.readChar ();

}

}

opcion = c.readChar (); } while (opcion == 'S' || opcion == 's'); System.exit (0);

El programa no presenta dificultad alguna, solamente se ha colocado una instrucción “if”, de más: if (opcion == 'S' || opcion == 's') opcion = c.readChar (); Estas dos líneas se colocaron debido a lo siguiente: Al finalizar el ciclo do, se pregunta si se quiere otra tirada de dados, resulta ser que la instrucción: opcion = c.readChar(); la primera vez que se ejecuta funciona correctamente, pero para repetir el ciclo mas de dos veces, es necesario colocar otra vez la instrucción: opcion = c.readChar(); de lo contrario, saldría del ciclo, finalizando el programa.

- 98 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Ejercicios Propuestos 6.1 - Se realizó un censo provincial y se desea procesar la información obtenida en dicho censo. De cada una de las personas censadas se tiene la siguiente información: número de documento, edad y sexo ("femenino" o "masculino"). Se pide confeccionar un programa que lea los datos de cada persona censada (Luego de ingresar un juego de datos, se debe preguntar si se quiere ingresar otro juego). Informar lo siguiente: a) b) c) d)

Cantidad de personas censadas. Cantidad de varones. Cantidad de mujeres. Cantidad de varones mayores o iguales a 18 años.

6.2 - Ingresar un número, e imprimir todos sus múltiplos inferiores a 800. Ejemplo: Ingrese un numero: 30 Los multiplos de 30 menores a 800 son: 0 – 30 – 60 – 90 – 120 – 150 – 180 – 210 – 240 – 270 – 300 – 330 – 360 – 390 – 420 – 450 – 480 – 510 – 550 – 570 – 600 – 430 – 660 – 690 – 720 – 750 – 780

6.3 - Leer por teclado N números enteros y calcular e imprimir la media de los números pares y la media de los impares. 6.4 - Representar un modelo informatizado del juego "adivina el número generado por la computadora (del 1 al 15)". Funciona así: El jugador tiene 7 intentos para adivinar el número. Si el número que ingresa el jugador es el valor generado por la computadora, el programa debe imprimir el mensaje “ *** ACE RT O ***” y terminar. En caso contrario, informar sobre si la suposición ha sido más alta o más baja y permitir que el usuario introduzca números hasta que adivine o se terminen las posibilidades, mostrando en este caso la leyenda: “*** PERDIO EL JUEGO ***”. Visualizar también el número de intentos. 6.5 - Para las elecciones de la provincia, se inscribieron una serie de candidatos. Desarrollar un programa para ingresar el Nombre y la cantidad de votos de cada uno. El programa tendrá que determinar quién es el candidato que ganó las elecciones, Mostrando el nombre y la cantidad de votos obtenidos. – Algoritmos y Estructuras de Datos I –

- 99 -

– ISSD – EDUARDO MANSILLA – 6.6 - Laura está de compras en un hipermercado y decide llevar un control sobre lo que va comprando, para saber la cantidad de dinero que tendrá que pagar al llegar a una caja. El supermercado tiene una promoción especial del 15% de descuento sobre aquellos artículos cuya etiqueta sea de color rojo; del 10% sobre los de etiqueta amarilla, y del 5% sobre los de etiqueta verde. Escribir un programa que lea el precio y el color de etiqueta del producto e imprimir la cantidad de dinero que Laura deberá pagar. 6.7 - Una Distribuidora necesita calcular el aumento de sueldo para sus empleados, bajo el siguiente criterio:  Sueldo < $15000: Aumento 15%  Sueldo comprendido entre $15000 y $25000: Aumento 10%  Sueldo superior a $25000: Aumento 5%. Realizar un programa que permita ingresar el Nombre, el Sueldo y el Sexo de cada empleado y determine lo siguiente: el sueldo promedio de las mujeres, el sueldo promedio de hombres y el total a abonar por parte de la distribuidora.

- 100 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

TEMAS: Array Vectores Carga e Impresión de un Vector

UNIDAD Nº 3:

Arreglos

Clase

7

Clase Número: 7

Array Introducción En determinadas situaciones, se tiene la necesidad de procesar una colección de valores que están relacionados entre si, de alguna forma, como por ejemplo una lista de notas, de asistencias, de productos, etc. El procesamiento de tales conjuntos de datos, utilizando datos simples, puede ser extremadamente complicado y por ello, la mayoría de los lenguajes de programación cuentan con procesamiento de estructuras de datos. Anteriormente se han procesado datos sueltos, ahora se estudiará la forma de almacenar un conjunto de datos relacionados entre sí, por ejemplo: un conjunto de nombres de personas, un conjunto de precios de productos, etc. Para al macerar un conjunto de datos, se utilizan las estructuras llamadas Array, que significa: Arreglos. Un Arreglo en Java, es un grupo o conjunto de datos relacionados entre sí y todos del mismo tipo. Es decir, que, si uno de los datos es un valor entero, todos los demás deben ser enteros, si uno es un String, todos los demás deben ser String, y así sucesivamente. Cada elemento del conjunto, está identificado por la posición que ocupa dentro del arreglo. Estas posiciones se encuentran numeradas del cero en adelante, es decir que el primer elemento está en la posición cero, el segundo en la posición uno, y así sucesivamente. En definitiva, un Array es una estructura de datos, representados en una secuencia de posiciones de la memoria central, a las que se puede acceder directamente por medio del uso de índice. Los arreglos se clasifican de acuerdo a la cantidad de variables de posicionamiento que posean, así se denominan: Unidimensionales, Bidimensionales, Tridimensionales, etc. Los arreglos unidimensionales son llamados comúnmente Vectores y los de más de una dimensión se denominan Matrices.

Array

Unidimensionales  Vectores Bidimensionales Tridimensionales Matrices Etc.

– Algoritmos y Estructuras de Datos I –

- 101 -

– ISSD – EDUARDO MANSILLA –

Vectores Se define a un vector, como un grupo o conjunto de datos de un mismo tipo, La variable de un vector se denomina: Variable Subindicada, porque tiene un subíndice que indica la posición de un componente o elemento determinado. Por ejemplo, si se supone que se quiere almacenar las notas de 5 alumnos, matemáticamente se debería colocar:

nota[i] = [8,4,9,5,7] Identificador de la variable

subíndice

componentes

En este caso, se debe tener en cuenta que la cantidad de componentes es cinco y los elementos están enumerados del cero al cuatro. Es decir que: nota[0] nota[1] nota[2] nota[3] nota[4]

= = = = =

8 4 9 5 7

Por lo tanto, la variable “i”, deberá asumir los valores del cero al cuatro. Si en este vector la variable “i”, tomara el valor de cinco, daría un error, porque no existe un elemento en la posición cinco.

Carga e Impresión de un Vector La carga y la impresión de un vector, se realiza componente a componente, indicando en que posición se almacenará cada elemento. Ejemplo Nro. 31: Realizar la carga y la impresión de 5 edades de personas. Tanto para realizar la carga como la impresión de cada uno de los componentes de un vector, se debe realizar un ciclo. El ciclo mas utilizado y mas fácil de implementar para estos propósitos, es el ciclo for, en el cual, la variable del for debería variar de cero a cuatro para este ejemplo. El diagrama y programa para resolver este ejemplo, sería el siguiente:

- 102 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Inicio

i = 0 ; i < 5 ; i++

Falso

Verdadero

Carga del Vector

edad [i]

i = 0 ; i < 5 ; i++ Impresión del Vector

Falso

Verdadero

edad [i]

Fin

El proceso de carga del vector se realiza con un ciclo for, el cual contiene una variable que se inicializa en cero, para la primera componente del vector. Como el primer valor de i es cero, la condición i<5 es verdadera, por lo tanto se ingresa al ciclo y se pide un valor que será almacenado en la variable edad[0], luego se retorna al for incrementándose la variable i al valor 1, que nuevamente al ser menor a 5 se ingresa al ciclo pidiendo el segundo valor, que será almacenado en edad[1], es decir, en la misma variable pero en la posición 1. Se continúa con los sucesivos valores para la variable i, hasta que llege al valor de 5, y al llegar a este valor, la condición i<5, resulta falsa, saliendo del ciclo for y dando como consecuencia el almacenamiento de los 5 valores para la variable edad. Básicamente el programa quedaría de la siguiente manera:

– Algoritmos y Estructuras de Datos I –

- 103 -

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo31 { static Console c; public static void main (String arg []) { c = new Console(); int [] edad; edad = new int[5]; for (int i = 0 ; i < 5 ; i++) { c.print("Ingrese edad [" + i + "]: "); edad[i] = c.readInt (); } c.println(); c.println(); c.print("El vector ingresado es: [ "); for (int i = 0 ; i < 5 ; i++) { c.print(edad[i]+" "); } c.print("]"); } } Explicación: Se comienza por definir la variable Vector con la línea: int [] edad; Los corchetes indican que la variable edad es un vector. Para crear un vector e indicarle la cantidad de elementos o componentes que contendrá, se utiliza la siguiente línea: edad = new int[5]; Esta línea indica que la variable edad, es un vector de 5 elementos de componentes numéricos enteros. Posteriormente, se realiza un ciclo for con una variable índice que comienza en cero y termina en cuatro, observar que se está ejecutando la instrucción c.readInt(), mientras la variable i, se mantenga por debajo de 5. Cuando la variable i, toma el valor de 5, sale del ciclo de carga. La línea: c.print("Ingrese edad [" + i + "]: "); imprime lo siguiente: En primera medida, todo lo que está entre comillas, lo muestra como está, o sea que primeramente mostrará en la pantalla: Ingrese edad [ Al lado de esta leyenda, mostrará el valor que posee la variable i. La primera vez valdrá cero, por lo tanto, se mostrará: Ingrese edad [0 - 104 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Luego se concatena con

"]: " imprimiendo en la pantalla lo siguiente: Ingrese edad [0]:

Allí se detiene la ejecución del programa hasta que se digite un valor para ser almacenado en la variable edad [0]. El proceso de carga continúa hasta ingresar edad [4], que sería el quinto elemento. (del cero al cuatro hay cinco posiciones) Una vez realizado la carga de las 5 edades, se sale del ciclo y nos encontramos con dos renglones en blanco debido a las dos sentencias c.println(). Posteriormente se imprime una leyenda indicando “El vector ingresado es: [ “ Observar que la leyenda finaliza con un corchete abierto, esto es simplemente para darle la forma de vector a la impresión de los valores. Se continúa con el ciclo de impresión, similar al de carga, y luego, cuando se sale del ciclo, se cierra el corchete del vector. La ejecución del programa, arrojará la siguiente salida:

Se puede inicializar los elementos de un vector en el momento de definir la variable, por ejemplo, si se quiere cargar las notas de alumnos, se puede escribir la siguiente línea: int [] notas = { 5, 9, 4, 8 }; si se quiere cargar en un vector, las vocales del abecedario, sería: char [] vocales = { 'a', 'e', 'i', 'o', 'u' }; Cuando se realiza la declaración junto con la inicialización, pareciera que se está omitiendo la asignación del tamaño del vector, pero no es así, el tamaño está implícito en la inicialización, el compilador lo establece según la cantidad de elementos con que se inicializa. Es decir, en el primer caso, el vector nota, tendrá un tamaño de cuatro, y en el caso del vector vocales, tendrá un tamaño de cinco. Se puede acceder al número de elementos de un vector, por medio de la variable miembro length. Por ejemplo: – Algoritmos y Estructuras de Datos I –

- 105 -

– ISSD – EDUARDO MANSILLA –

c.println("Cantidad de notas: " + notas.length); c.println("Cantidad de vocales: " +vocales.length); Nota: A partir de aquí, siempre se utilizará la variable miembro length para conocer la cantidad de componentes almacenados en un vector. Ejemplo Nro. 32: Desarrollar un programa que inicialice un vector con los números pares hasta 12 y luego los imprima mediante un ciclo for. Inicio

numerosPares = { 0, 2, 4, 6, 8, 10, 12 }

i = 0 ; i < numerosPares.length ; i++

Falso

Verdadero

numerosPares [i]

Fin import hsa.Console; class Ejemplo32 { static Console c; public static void main (String arg []) { c = new Console (); int [] numerosPares = {0, 2, 4, 6, 8, 10, 12}; c.print("Los numeros pares hasta 12 son: [ "); for (int i = 0 ; i < numerosPares.length ; i++) { c.print (numerosPares [i] + " "); } c.print ("]"); } }

- 106 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – En el ejemplo siguiente, se puede observar la ventaja de tener almacenadas todas las alturas de las personas en un vector. Si no conociéramos los vectores, s e tendría que cargar otra vez las alturas por teclado, para compararlas con el promedio. Mientras el programa está en ejecución se tiene el vector de alturas, a nuestra disposición. Es importante tener en cuenta que cuando finaliza la ejecución del programa, se pierden los contenidos de todas las variables. (Simples y Vectores) Ejemplo Nro. 33: Definir y c a r ga r un vector de 5 componentes de tipo float que representen las alturas de 5 personas. Obtener el promedio de las mismas. Contar cuántas personas son más altas que el promedio y cuántas más bajas o iguales al promedio. Inicio suma = 0 altas = 0 bajas = 0

i = 0 ; i < alturas.length ; i++

Falso

Verdadero

alturas [i] suma = suma + alturas [i]

promedio = suma / alturas.length

promedio

1

– Algoritmos y Estructuras de Datos I –

- 107 -

– ISSD – EDUARDO MANSILLA –

1

Falso

i = 0 ; i < numerosPares.length ; i++ Verdadero Falso

altura[i] > promedio

bajas ++

Verdadero

altas ++

“Cantidad de Personas altas: ” + altas “Cantidad de Personas bajas: “+ bajas

Fin

import hsa.Console; class Ejemplo33 { static Console c; public static void main (String arg []) { c = new Console (); float [] alturas; alturas = new float [5]; float suma = 0; float promedio; int altas, bajas; altas = bajas = 0; c.println ("Ingrese los valores de las alturas "); c.println (); for (int i = 0 ; i < alturas.length ; i++) { c.print ("alturas[" + i + "]: "); alturas [i] = c.readFloat (); - 108 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

}

}

suma = suma + alturas[i]; } promedio = suma / alturas.length; c.println (); c.println ("El promedio es: " + promedio); for (int i = 0 ; i < alturas.length ; i++) { if (alturas[i] > promedio) altas++; else bajas++; } c.println("Cantidad de Personas altas: " + altas); c.println("Cantidad de Personas bajas: " + bajas);

Explicación: Se comienza definiendo el vector alturas en la línea: float [] alturas; En la línea siguiente, se crea el vector y se indica cuantos elementos contendrá, cinco en este caso. Posteriormente, se definen y se inicializan las demás variables que intervienen. Se inicia el ciclo for con la variable índice en cero y se ingresan las alturas mientras la variable índice sea menor que la cantidad de elementos del vector, esta condición está determinada por: i < alturas.length. Dentro del mismo ciclo for, también se acumulan las alturas ingresadas en la variable suma, inicializada en cero antes de entrar en el ciclo. Luego de cargar las cinco alturas, se sale del ciclo y se calcula el promedio de las mismas, mostrándolo en pantalla. Para poder saber cuántas personas son más altas que el promedio, se debe realizar otro ciclo para recorrer el vector de las alturas, de modo que en este segundo ciclo, se ha colocado un if, preguntando si alguna de las alturas ingresadas es mayor al valor promedio. En caso de ser verdadero, se incrementa el contador de personas altas, y en caso de ser falso, se incrementa el contador de personas bajas. Por último, se imprimen ambas cantidades. Ejemplo Nro. 34: Almacenar en un vector todos los números impares menores de 100 y luego mostrar: a) Cantidad de elementos múltiplos de 3. b) Cantidad de elementos múltiplos de 5 c) Suma total de todos los elementos.

– Algoritmos y Estructuras de Datos I –

- 109 -

– ISSD – EDUARDO MANSILLA –

Inicio Carga del Vector

Inicialización de variables

contador = 1 m3 = m5 = 0 suma = 0 Falso

i = 0 ; i < vector.length ; i++ Verdadero

vector[i] = contador contador = contador + 2 Proceso

Falso

i = 0 ; i < vector.length ; i++ Verdadero

vector[i] + “ “

vector[i] % 3 == 0 m3++

vector[i] % 5 == 0 m5++

suma = suma + vector[i]

1

- 110 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

1

“Cantidad de Multiplos de 3: “ + m3 “Cantidad de Multiplos de 5: “ + m5 “Suma total de impares menores de 100: “ + suma

Fin import hsa.Console; class Ejemplo34 { static Console c; public static void main (String arg []) { c = new Console (); int [] vector; vector = new int [50]; int contador, m3, m5, suma; contador = 1; m3 = m5 = 0; suma = 0; for (int i = 0 ; i < vector.length ; i++) { vector [i] = contador; contador = contador + 2; } c.println ("El vector de impares menores a 100 es: "); for (int i = 0 ; i < vector.length ; i++) { c.print (vector [i] + " "); if (vector [i] % 3 == 0) m3++; if (vector [i] % 5 == 0) m5++; suma = suma + vector[i]; } c.println(); c.println(); c.println ("Cantidad de multiplos de 3: " + m3); c.println ("Cantidad de multiplos de 5: " + m5); c.println ("suma total de impares: " + suma); } }

– Algoritmos y Estructuras de Datos I –

- 111 -

– ISSD – EDUARDO MANSILLA – Explicación: Se comienza definiendo y creando el vector de 50 elementos, ya que estará integrado por los números impares menores que 100, es decir del 1 al 99 y como van de dos en dos, se tienen 50 elementos. Luego se inicializan las variables: contador para ir generando los números impares, m3 para los múltiplos de 3, m5 para los múltiplos de 5 y suma para almacenar la suma total de los impares menores de 100. El primer ciclo for se utiliza para realizar la carga del vector con los números impares, para ello se le asigna a cada elemento del vector el valor que va asumiendo la variable contador, que como va de dos en dos y comienza del valor uno, va conteniendo valores impares. El segundo ciclo es el del procesamiento del vector, imprimiendo todos los números almacenados en él, se continúa preguntando si alguno de los elementos del vector es múltiplo de 3 con la línea: if (vector[i] % 3 == 0) que, en caso de ser verdadero, se incrementa el contador de los múltiplos de 3. El segundo if, es similar al primero, pero con los múltiplos de 5. Antes de cerrar el ciclo for, se realiza el acumulador de todos los elementos almacenados en el vector. Fuera del for, se realizan las impresiones correspondientes. Ejemplo Nro. 35: Almacenar en dos vectores las notas de dos cursos A y B. El curso A tiene 20 alumnos y el curso B tiene 15 alumnos. Luego realizar las siguientes operatorias: a) Cuántos alumnos de cada curso están promocionado (nota mayor o igual a 7). b) Cuántos alumnos de cada curso quedaron Libres (nota menor a 4). c) Promedio general de cada curso. d) Indicar cual es el curso de mayor promedio. Inicio promocionadoA = promocionadoB = libreA = libreB = suma = 0

i = 0 ; i < a.length ; i++

Falso

Verdadero

a [i] suma = suma + a [i] 2

- 112 -

1

– Algoritmos y Estructuras de Datos I –

3

– ISSD – EDUARDO MANSILLA –

1

2 Falso

3

a [i] >= 7

Verdadero

promocionadoA ++

Falso

a [i] < 4

Verdadero

libreA ++

pa = suma / a.length suma = 0

Falso

i = 0 ; i < b.length ; i++ Verdadero

b [i] suma = suma + b [i] Falso

b [i] >= 7

Verdadero

promocionadoB ++

Falso

b [i] < 4

Verdadero

libreB ++ 4

– Algoritmos y Estructuras de Datos I –

- 113 -

– ISSD – EDUARDO MANSILLA – 4 pb = suma / b.length

“Cant. De Promocionados en el curso A: “ + promocionadoA “Cant. De Libres en el curso A: “ + libreA “Promedio del curso A: “ + pa “Cant. De Promocionados en el curso B: “ + promocionadoB “Cant. De Libres en el curso B: “ + libreB “Promedio del curso B: “ + pb

Falso

pa > pb

“Curso de mayor promedio: B”

Verdadero

“Curso de mayor promedio: A”

Fin En este caso, se deben realizar dos ciclos de ingreso de datos, uno para el procesamiento de las notas del curso A y otro para el procesamiento de las notas del curso B, ya que los cursos tienen distinta cantidad de alumnos. Observar que se utiliza una sola variable “suma” para acumular la suma de las notas de cada curso, esto es debido a que luego de obtener la suma del curso A, se calcula el promedio del mismo y se lo almacena en la variable “pa”, a partir de allí, la variable “suma” no vuelve a ser utilizada para el curso A, por lo tanto, se la coloca en cero nuevamente y se la utiliza para acumular las notas del curso B en el segundo ciclo for. Al finalizar el segundo ciclo se calcula el promedio del curso B y se imprimen los contenidos de las variables en juego. Queda por parte del alumno, analizar la lógica completa del Diagrama de Flujo. import hsa.Console; class Ejemplo35 { static Console c; public static void main (String arg []) { c = new Console (); int [] a; a = new int [20]; - 114 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – int [] b; b = new int [15]; int promocionadoA, promocionadoB, int libreA, libreB, suma; promocionadoA=promocionadoB=libreA=libreB=suma = 0; float pa, pb; c.println ("Ingrese las " + a.length + " Notas para el curso A:"); for (int i = 0 ; i < a.length ; i++) { c.print ("Nota [" + (i + 1) + "] = "); a [i] = c.readInt (); suma = suma + a [i]; if (a [i] >= 7) promocionadoA++; if (a [i] < 4) libreA++; } pa = (float) suma / a.length; suma = 0; c.println (); c.println ("Ingrese las " + b.length + " Notas para el curso B:"); for (int i = 0 ; i < b.length ; i++) { c.print ("Nota [" + (i + 1) + "] = "); b [i] = c.readInt (); suma = suma + b [i]; if (b [i] >= 7) promocionadoB++; if (b [i] < 4) libreB++; } pb = (float) suma / b.length; c.println (); c.println (); c.println ("Cantidad de Promocionados en el curso A: " + promocionadoA); c.println ("Cantidad de Libres en el curso A: " + libreA); c.println ("Promedio del curso A: " + pa); c.println (); c.println ("Cantidad de Promocionados en el curso B: " + promocionadoB); c.println ("Cantidad de Libres en el curso B: " + libreB); c.println ("Promedio del curso B: " + pb); c.println ();

}

if (pa > pb) c.print ("Curso de mayor promedio: A"); else c.print ("Curso de mayor promedio: B"); }

– Algoritmos y Estructuras de Datos I –

- 115 -

– ISSD – EDUARDO MANSILLA –

Ejercicios Propuestos 7.1 - Un comercio tiene almacenados los precios de sus productos en un vector de 30 elementos. Realizar las siguientes operatorias: a) b) c) d) e) f)

Carga del vector de Precios. Impresión del vector. Cuántos productos se tienen un precio menor a $100. Cuantos productos tienen un precio entre $100 y $200. Cuántos productos tienen un precio mayor a $200. Importe total que representan todos los productos.

7.2 - Cargar tres vectores numéricos de 10 elementos y determinar cual es el que tiene un valor acumulado mayor. 7.3 - Realizar la carga de 2 vectores de 5 elementos cada uno y obtener la suma de ellos. La suma de dos vectores es componente por componente. Ejemplo: Vector 1: ( 4 6 2 1 5 ) Vector 2: ( 2 1 7 3 4 ) Suma

: (67949)

7.4 - Ingresar un vector de 10 elementos de valores enteros y luego determinar cuántos tienen un valor mayor al valor del quinto elemento. 7.5 - Cargar un vector de 15 elementos y calcular el promedio de los primeros 10 elementos. 7.6 - Realizar la carga de un vector de 12 componentes y dividirlo en dos vectores de 6 componentes cada uno, de manera que el primero tenga los valores de los índices pares y el segundo los valores de los índices impares. Ejemplo:

Vector = ( 5 2 9 4 8 3 5 6 2 5 7 1 ) Vector de indices pares: ( 5 9 8 5 2 7 ) Vector de indices impares: ( 2 4 3 6 5 1 )

- 116 -

Tener presente que la primera componente está en el índice cero que es par.

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

UNIDAD Nº 4:

Métodos Vectores

TEMAS: Métodos en Java Clases en Java Zonas de un programa Métodos que retornan Valores Vectores Paralelos

Clase

8

Clase Número: 8

Métodos en Java Introducción Se puede decir que, en Java, toda la lógica de programación está agrupada en Funciones o Métodos. Se define a una Función o Métodos, a una fracción de programa que cumple una misión específica. Generalmente el término función es utilizado en la Programación Estructurada y el término Método, es utilizado en la Programación Orientada a Objetos. Básicamente un Método es: ♦ ♦ ♦ ♦

Un bloque de código que tiene un nombre, Recibe opcionalmente parámetros o argumentos, Contiene sentencias o instrucciones, Devuelve opcionalmente un valor de algún tipo conocido.

La sintaxis sería la siguiente: TipoDevuelto nombreDelMetodo ( ListaDeParametros ) { Bloque de código; } El TipoDevuelto puede ser cualquiera de los tipos visto hasta el momento, por ejemplo: int, char, float, String. En caso de que el método no devuelva ningún valor se coloca la palabra “void”. Los nombres de los métodos siempre deben comenzar con una letra en minúscula, cuando se deben colocar nombres formados por dos o mas palabras, se coloca la primera letra de la primer palabra en minúscula y la primer letra de las siguientes palabras en mayúsculas. Tener en cuenta que, al igual que los nombres de las variables, no se puede colocar espacios en blanco entre cada palabra del nombre del método a realizar.

– Algoritmos y Estructuras de Datos I –

- 117 -

– ISSD – EDUARDO MANSILLA – Ejemplos válidos de nombres de métodos: void cargarDatos() { Sentencias; } int cubo (int x) { Sentencias; } void listadoDePrecios() { Sentencias; }

Clases en Java Se define a una Clase como una colección de variables y métodos, que a partir de la misma, se pueden crear diversos ejemplares de dicha clase. Cada ejemplar de una clase, recibe el nombre de Instancia de la clase y se pueden crear tantas instancias como se quiera.

Zonas de un programa completo en Java Las diferentes zonas que intervienen en un programa en lenguaje Java son las siguientes: ♦ Importación de librerías. Ejemplo: import hsa.Console ♦

Nombre de la clase. Ejemplo: class Listado

♦ Zona de declaración de variables miembros de la clase. Ejemplo:

String nombre; int edad; float sueldo;

♦ Declaración del Constructor (Opcional) ♦ Zona de declaración de Métodos. ♦ Programa principal Ejemplo: public static void main(String[] args)

- 118 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 36: Desarrollar un programa que tenga dos métodos, uno para la introducción de tres números y otro método para calcular e imprimir el promedio de ellos. import hsa.Console; class Ejemplo36 { static Console c;

Variables Miembros

int n1, n2, n3;

Métodos

void ingresoDeDatos () { c.print ("Ingrese primer Numero: "); n1 = c.readInt (); c.print ("Ingrese primer Numero: "); n2 = c.readInt (); c.print ("Ingrese primer Numero: "); n3 = c.readInt (); } void calcularPromedio () { float prom; prom = (float) (n1 + n2 + n3) / 3; c.println(); c.print ("El promedio es: " + prom); }

}

public static void main (String arg []) { c = new Console (); Ejemplo36 e; e = new Ejemplo36 (); c.println("Promedio de 3 Numeros"); c.println("---------------------"); e.ingresoDeDatos (); e.calcularPromedio (); }

Ejemplar de la clase

Explicación: Al principio se coloca la línea de Importación de librerías: import hsa.Console; Indicando que se incluyan en el programa todas las instrucciones de la clase Console. En la segunda línea, se define la clase, llamada en este caso Ejemplo36, luego, en la tercera línea se define el objeto c de la clase Console, este objeto estará capacitado para utilizar los métodos de entrada y salida. A continuación, se definen las variables miembros que se utilizarán en el – Algoritmos y Estructuras de Datos I – - 119 -

– ISSD – EDUARDO MANSILLA – programa, y luego se realizan los métodos de ingreso y de calcular el promedio de los números ingresados. El programa principal es el encargado de llamar a cada uno de los métodos necesarios para la resolución del problema planteado. En el programa principal, al igual que en los ejemplos anteriores, se crea un objeto de la clase Console, luego se define un objeto de la clase Ejemplo36 llamado “e”: Ejemplo36 e; Posteriormente se crea el objeto “e”, con la línea: e = new Ejemplo36 (); Estas dos líneas realizadas anteriormente, se pueden realizar en una sola, de la siguiente manera: Ejemplo36 e = new Ejemplo36 (); Se coloca a modo de título, la leyenda “Promedio de 3 Números” y se la subraya, luego se llaman a los métodos realizados, teniendo en cuenta que para llamar a un método, se lo realiza colocando el nombre del objeto, luego un punto y luego el nombre del método. En este caso: e.ingresoDeDatos (); e.calcularPromedio (); Ejemplo Nro. 37: Realizar un programa que permita ingresar un numero y muestre la tabla de multiplicar del mismo del 1 al 12. Los diagramas de los métodos serían los siguientes: void tablaDeMultiplicar ( ) void ingresoDeDato ( ) n

i = 1;

i < 12;

i++

Verdadero

n+“x“+i+“=“+r Fin

Fin

- 120 -

– Algoritmos y Estructuras de Datos I –

Falso

– ISSD – EDUARDO MANSILLA – El diagrama del programa principal sería: Inicio ingresoDeDato ( ) tablaDeMultiplicar ( ) Fin

import hsa.Console; class Ejemplo37 { static Console c; int n; void ingresoDeDato () { c.print ("Ingrese un Numero: "); n = c.readInt (); } void tablaDeMultiplicar () { int r; c.println (); c.println ("Tabla de Multiplicar del numero: " + n); c.println (); for (int i = 1 ; i <= 12 ; i++) { r = n * i; c.println (n + " x " + i + " = " + r); } }

}

public static void main (String arg []) { c = new Console (); Ejemplo37 e = new Ejemplo37 (); e.ingresoDeDato (); e.tablaDeMultiplicar (); }

La variable “r” que se define en el método tablaDeMultiplicar, recibe el nombre de Variable Local, y tiene la particularidad de que tiene acción únicamente dentro del método, fuera de él, no existe, es decir, que el espacio que estaba ocupando en el momento en que se encontraba utilizada, queda liberado cuando – Algoritmos y Estructuras de Datos I –

- 121 -

– ISSD – EDUARDO MANSILLA – la ejecución del programa sale del método.

Método que devuelven o retornan un valor Cuando se desea que un método devuelva un valor, es necesario colocar un Tipo en la cabecera del método, delante del nombre del mismo. El Tipo colocado, tiene que ver con el Tipo de valor que se desea que retorne el método. Ejemplo Nro. 38: Desarrollar un programa que tenga un método que acepte un número entero y retorne el cubo del mismo. int cubo ( x )

void proceso ( )

Inicio

z=x*x*x

n

proceso ( )

Retornar z

resultado = cubo ( n )

Fin

Fin

resultado

Fin import hsa.Console; class Ejemplo38 { static Console c; int cubo (int x) { int z; z = x * x * x; return z; } void proceso () { int n, resultado; c.print ("Ingrese un Numero: "); n = c.readInt (); resultado = cubo (n); c.print ("Su cubo es: " + resultado); }

- 122 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – public static void main (String arg []) { c = new Console (); Ejemplo38 e = new Ejemplo38 (); e.proceso (); }

}

Vectores utilizando Métodos Ejemplo Nro. 39: En una empresa se almacenaron los sueldos de 10 personas. Desarrollar un programa para realizar: 1) 2) 3) 4)

Carga de los sueldos en un Vector. Impresión de todos los sueldos. Cuántos tienen un sueldo superior a $4000. Mostrar todos los sueldos que están por debajo del promedio. void cargarSueldos ( )

i = 0; i < s.length; i++

Falso

Verdadero

s [i]

Fin

void imprimirSueldos ( )

i = 0; i < s.length; i++

Falso

Verdadero

s [i]

Fin

– Algoritmos y Estructuras de Datos I –

- 123 -

– ISSD – EDUARDO MANSILLA –

void punto3 ( )

float promedio ( )

superior = 0

i = 0; i < s.length; i++

suma = 0 Falso

i = 0; i < s.length; i++

Verdadero

Verdadero

suma = suma + s[i]

s[i] > 4000 superior++

prom = suma / s.length superior

Retornar prom

Fin

Fin

Programa Principal Inicio void punto4 ( ) cargarSueldos ( ) i = 0; i < s.length; i++

Falso

imprimirSueldos ( )

Verdadero

s[i] < promedio()

punto3 ( ) s[i] punto4 ( )

Fin

- 124 -

Fin

– Algoritmos y Estructuras de Datos I –

Falso

– ISSD – EDUARDO MANSILLA – import hsa.Console; class Ejemplo39 { static Console c; float [] s; Ejemplo39 () { s = new float [10]; } void cargarSueldos () { c.println ("Cargue los sueldos de las 10 personas: "); for (int i = 0 ; i < s.length ; i++) { c.print ("Ingrese sueldo[" + (i + 1) + "]: "); s [i] = c.readFloat (); } } void imprimirSueldos () { c.println ("Sueldos almacenados: "); for (int i = 0 ; i < s.length ; i++) { c.println (" $ " + s [i]); } } void punto3 () { int superior = 0; for (int i = 0 ; i < s.length ; i++) { if (s [i] > 4000) superior++; } c.println (); c.println ("Los sueldos superiores a $4000 son: " + superior); } float promedio () { float suma = 0; float prom; for (int i = 0 ; i < s.length ; i++) { suma = suma + s [i]; } prom = suma / s.length; return prom; } – Algoritmos y Estructuras de Datos I –

- 125 -

– ISSD – EDUARDO MANSILLA – void punto4 () { c.println(); c.println("El promedio de sueldos es: $ " + promedio()); c.println(); c.println("Los sueldos inferiores al promedio son: "); for (int i = 0 ; i < s.length ; i++) { if (s[i] < promedio() ) c.print(s[i] + " "); } }

}

public static void main (String arg []) { c = new Console (); Ejemplo39 e = new Ejemplo39 (); e.cargarSueldos (); c.clear(); e.imprimirSueldos(); e.punto3(); e.punto4(); }

Explicación: El programa comienza definiendo la variable “s” (sueldo) como un vector de componentes float, definiendo así, una variable miembro de la clase. Ejemplo39: En este ejemplo se ha colocado por primera vez, la zona del Constructor. Un Constructor es un método que se utiliza para inicializar las variables miembros de la clase, en este caso, se ha utilizado para crear el vector de sueldos. Todo Constructor, tiene la particularidad de ser el primer método que se ejecuta cuando se inicia la ejecución del programa y no es necesario invocarlo del programa principal. Para que un método sea Constructor, es necesario que tenga el mismo nombre de la clase, en este caso, Ejemplo39, y debe llevar los paréntesis, dentro de los cuales, opcionalmente puede haber parámetros. A continuación se encuentra el método cargarSueldos(), que es el encargado de pedir los sueldos que se quieren almacenar en el vector. La leyenda impresa en el c.print: c.print ("Ingrese sueldo[" + (i + 1) + "]: "); Tiene por objeto, mostrar la palabra sueldo con un subíndice que comienza en 1, debido a (i + 1). Esto es simplemente a modo visual, porque internamente, en la memoria, el vector se almacenará desde la posición cero. En la pantalla aparecerá: Ingrese sueldo[1]: Ingrese sueldo[2]: Etc.

- 126 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Luego esta el método para imprimir los sueldos almacenados en el vector, simplemente consta de un ciclo for con la impresión dentro de él. El siguiente método, es el punto 3 del enunciado del ejercicio, Cuántos tienen un sueldo superior a $4000. Para ello, se utiliza un ciclo for y dentro de él, un if para preguntar si alguno de los sueldos es mayor a 4000, que, en caso de ser verdadero, se incrementa en uno, a la variable “superior”, que es la encargada de almacenar los mayores a 4000. Fuera del ciclo for, se imprime el valor de la variable “superior”. A continuación, se realizó el método del cálculo del promedio, este método retorna un valor, por lo tanto, tiene que tener un tipo delante del nombre. Como un promedio siempre es un resultado numérico Real, se coloca el tipo float y para su cálculo, se realiza la suma de todos los sueldos y posteriormente se la divide por la cantidad de elementos. Antes de finalizar el método, se debe colocar la instrucción return con la variable calculada. El método del punto4 es el encargado de llamar al método promedio para averiguar cuales sueldos son inferiores al promedio, Este proceso consiste en un ciclo for y dentro de él, una pregunta solicitando al método promedio(). En caso de que la pregunta resulte verdadera, se imprime el sueldo en cuestión. Por último, se realiza el programa principal, creando un objeto de la clase Ejemplo39 para poder llamar a los diversos métodos de la clase. La ejecución del programa daría el siguiente resultado:

Ejemplo Nro. 40: Un comercio tiene dos turnos (mañana y tarde) en los que trabajan 8 empleados (4 por la mañana y 4 por la tarde). Confeccionar un programa que permita almacenar los sueldos de los empleados agrupados por turno. Imprimir los gastos en sueldos de cada turno.

– Algoritmos y Estructuras de Datos I –

- 127 -

– ISSD – EDUARDO MANSILLA –

void cargarSueldosM ( )

i = 0; i < sM.length; i++

void cargarSueldosT ( ) Falso

i = 0; i < sT.length; i++

Verdadero

Verdadero

sM [i]

sT [i]

Fin

Fin

float gastos ( float[ ] s )

void imprimirGastos ( )

suma = 0

“Gastos del turno M: “ + gastos (sM)

i = 0; i < s.length; i++

Falso

“Gastos del turno T: “ + gastos (sT)

Verdadero

suma = suma + s[i]

Fin

Retornar suma

Inicio

Fin

cargarSueldosM( ) cargarSueldosT( )

Programa Principal

imprimirGastos( ) Fin

- 128 -

Falso

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – El programa quedaría de la siguiente manera: import hsa.Console; class Ejemplo40 { static Console c; float [] sM; float [] sT; Ejemplo40 () { sM = new float [4]; sT = new float [4]; }

Definición de los Vectores.

Creación de los Vectores

void cargarSueldosM () { c.println ("Cargue los sueldos del Turno Manana: "); for (int i = 0 ; i < sM.length ; i++) { c.print ("Ingrese sueldo[" + (i + 1) + "]: "); sM [i] = c.readFloat (); } } void cargarSueldosT () { c.println ("Cargue los sueldos del Turno Tarde: "); for (int i = 0 ; i < sT.length ; i++) { c.print ("Ingrese sueldo[" + (i + 1) + "]: "); sT [i] = c.readFloat (); } } float gastos (float [] s) { float suma = 0; for (int i = 0 ; i < s.length ; i++) { suma = suma + s [i]; } return suma; Llamado al método gastos con los } vectores sM y sT. void imprimirGastos () { c.println (); c.println ("Gasto del turno Manana: $ " + gastos(sM)); c.println ("Gasto del turno Tarde : $ " + gastos(sT)); }

– Algoritmos y Estructuras de Datos I –

- 129 -

– ISSD – EDUARDO MANSILLA –

}

}

public static void main (String arg []) { c = new Console (); Ejemplo40 e = new Ejemplo40 (); e.cargarSueldosM (); c.println(); e.cargarSueldosT (); c.println(); e.imprimirGastos ();

La ejecución del programa muestra la siguiente salida:

Lo nuevo en este ejemplo, es el método: float gastos (float [] s) { float suma = 0; for (int i = 0 ; i < s.length ; i++) { suma = suma + s [i]; } return suma; } que acepta como parámetro un vector de componentes tipo float y retorna el valor de la suma de los componentes de dicho vector pasado como parámetro. Este método establece una de las ventajas de trabajar con procesos independientes, ya a él se le puede pasar cualquier vector y entregará la suma de sus componentes. En este caso, se le enviarán los vectores del turno mañana y del turno tarde, cosa que se realiza en el método imprimirGastos.

- 130 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Es de suma importancia comprender la reutilización de los métodos, justamente esa es una de las potencialidades de la programación. En el ejercicio anterior, el método gastos, se lo utiliza en dos oportunidades y recibe distintos vectores realizando el cálculo de la suma de cada uno sin ningún problema, lo que ahorra escribir una nueva función para que trabaje con el segundo vector.

Vectores Paralelos El concepto de Vectores Paralelos se dá, cuando hay dos o más vectores relacionados entre sí a través del subíndice. Ejemplo:

Productos Precios

0

1

2

3

4

Televisor

Notebook

Radio

Dvd

Ventilador

4500

3100

340

650

280

Los dos vectores, Productos y Precios, se encuentran relacionados por medio de la posición que ocupa cada elemento, por ejemplo, al producto Televisor que está en la posición cero, le corresponde el precio de 4500, que se encuentra también en la posición cero, y así sucesivamente. Ejemplo Nro. 41: Realizar la carga de los vectores Productos y Precios de 5 artículos. Posteriormente, realizar un listado en dos columnas indicando el valor acumulado de todos los productos. Los diagramas correspondientes, se muestran en la página siguiente.

– Algoritmos y Estructuras de Datos I –

- 131 -

– ISSD – EDUARDO MANSILLA –

void cargarDatos ( )

i = 0; i < productos.length; i++

void imprimirDatos ( ) Falso

suma = 0

Verdadero

i = 0; i < productos.length; i++

productos [i]

Falso

Verdadero

precios [i]

productos[i] , precios[i] suma = suma + precios[i]

Fin

Inicio

“La suma de los precios es: “ + suma

Fin

cargarDatos() imprimirDatos() Inicio

import hsa.Console; class Ejemplo41 { static Console c; String [] productos; float [] precios;

Definición de los vectores

Ejemplo41 () { productos = new String [5]; precios = new float [5]; }

- 132 -

– Algoritmos y Estructuras de Datos I –

Creación de los vectores

– ISSD – EDUARDO MANSILLA – void cargarDatos () { c.println ("Cargue los datos de los articulos: "); c.println (); for (int i = 0 ; i < productos.length ; i++) { c.print ("Ingrese producto[" + (i + 1) + "]: "); productos [i] = c.readLine (); c.print ("Ingrese su precio: "); precios [i] = c.readFloat (); c.println (); } } Se cargan los dos vectores en el mismo ciclo for void imprimirDatos () { float suma = 0; int linea = 5; c.setCursor (3, 10); c.println ("Listado de Productos"); c.setCursor (4, 10); c.println ("--------------------"); for (int i = 0 ; i < productos.length ; i++) { c.setCursor (linea, 10); c.print (productos [i]); c.setCursor (linea, 30); c.print (precios [i],8,2); linea++; suma = suma + precios [i]; } c.println (); c.println (); c.print (" La suma de los precios es: "); c.print (suma,8,2); }

}

public static void main (String arg []) { c = new Console (); Ejemplo41 e = new Ejemplo41 (); e.cargarDatos (); c.clear (); e.imprimirDatos (); }

– Algoritmos y Estructuras de Datos I –

- 133 -

– ISSD – EDUARDO MANSILLA – Lo nuevo en este programa está en el método imprimitDatos(), en donde se utiliza la instrucción c.setCursor para posicionarse en un lugar de la pantalla. Esta instrucción acepta como parámetros, la fila y la columna en donde se quiere posicionar, en el ejemplo figura: c.setCursor (3, 10); c.println ("Listado de Productos"); c.setCursor (4, 10); c.println ("--------------------"); La primera línea establece que se posicione el cursor en la fila 3 y columna 10 y luego imprima la leyenda “Listado de Productos”, posteriormente, se posiciona una línea mas abajo, línea 4, y en la misma columna 10, para subrayar el título. Se continúa con el ciclo for para realizar el listado completo de todos los productos con sus respectivos precios. Se posiciona el cursor donde lo indica el valor de la variable “linea”, que ha sido inicializada en 5 y en la columna 10, allí se imprime el nombre del primer producto, o sea, productos[0], porque la primera vez, la variable “i” vale cero, luego en la misma línea 5, pero en la columna 30, se imprime el valor del precio correspondiente a la posición cero. El valor de 8,2 que figura en la impresión, tiene el siguiente significado: 8 significa el valor del campo en donde se debe imprimir, es decir 8 espacios, y 2 significa la cantidad de decimales con que se deberá imprimir el precio del producto. Es para que todos los precios se muestren alineados a la derecha y con dos decimales. Antes de cerrar el ciclo for, se debe incrementar la variable “linea”, para seguir imprimiendo en las líneas sucesivas los otros pares de datos. Además, también antes de cerrar el for, se debe acumular los precios para poder imprimir fuera de él, la suma de ellos. La salida del programa se verá de la siguiente manera:

- 134 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Ejercicios Propuestos 8.1 - Desarrollar u programa que permita ingresar un vector de 7 elementos y luego informe: a) El valor acumulado de todos los elementos. b) El valor acumulado de todos los elementos mayores a 50 c) Cantidad de valores mayores a 50. 8.2 - Cargar 3 vectores de 5 elementos cada uno. Se deberá imprimir un vector por línea junto con el promedio de cada uno. Por último, determinar cual es el que tiene mayor promedio. 8.3 - En un curso de 8 alumnos se registraron las notas de sus exámenes y se deben procesar de acuerdo a lo siguiente: a) Ingresar Nombre y Nota de cada alumno. b) Realizar un listado en tres columnas de Nombres, Notas y Condición de alumno. En la columna Condición, colocar “Muy Bueno” si la nota es mayor o igual a 8, “Bueno” si la nota está entre 4 y 7.99, y colocar “Insuficiente” si la nota es inferior a 4. c) Imprimir cuantos alumnos tienen la leyenda “Muy Bueno”. Ejemplo:

Listado de notas de alumnos Nombre

Nota

Condición

Javier Marcelo Viviana Raúl Ricardo Roxana Hugo Rita

6 9 7 3 10 5 2 8

Bueno Muy Bueno Bueno Insuficiente Muy Bueno Bueno Insuficiente Muy Bueno

Cantidad de alumnos Muy Buenos: 3

8.4 - Cargar en dos vectores Nombres de productos con sus respectivos Precios. Posteriormente ingresar un valor y mostrar todos los nombres que tienen un precio mayor al valor ingresado.

– Algoritmos y Estructuras de Datos I –

- 135 -

– ISSD – EDUARDO MANSILLA – 8.5 - Desarrollar un método que acepte dos vectores del mismo tamaño como parámetros, y retorne el producto escalar de los mismos. El producto escalar de dos vectores, es un número que se calcula acumulando los productos de las componentes del mismo índice. Ejemplo: V1[i] = [ 2, 8, 5, 3, 8 ] V2[i] = [ 6, 3, 9, 4, 7 ] Producto Escalar = 2 * 6 + 8 * 3 + 5 * 9 + 3 * 4 + 8 * 7 = 149 8.6 - En una empresa de 12 empleados se necesita realizar las siguientes operatorias: a) b) c) d)

Ingresar los nombres de los empleados con sus respectivos sueldos. Indicar cuántos cobran más de $3500. Cuántos cobran menos de $2500. Imprimir en dos columnas, los nombres de los empleados con sus respectivos sueldos. e) Imprimir el importe total que debe tener la empresa para abonar el sueldo a sus empleados. 8.7 - Desarrollar un programa que permita cargar las frecuencias de 7 emisoras de FM con sus respectivos nombres. Luego realizar lo siguiente: a) Impresión en dos columnas de las frecuencias y los nombres de emisoras. b) Ingresar un valor de emisora y mostrar todos los nombres de emisoras que tienen una frecuencia menor a la ingresada.

- 136 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

UNIDAD Nº 4:

Métodos Vectores

TEMAS: Procesos Algorítmicos Mayor y Menor elemento Consultas Ordenamientom de Vectores

Clase

9

Clase Número: 9

Procesos Algorítmicos En esta clase se verán las técnicas y metodologías algorítmicas más comunes a utilizar en la mayoría de los programas y sistemas a realizar, como por ejemplo: Búsqueda del Mayor y Menor, Ordenamiento, etc. En lo que respecta a Ordenamiento de una lista de datos, existen numerosos procesos, y cada uno con una ventaja distinta con respecto al otro, aquí se aprenderá a utilizar los procesos más sencillos y quedará por parte del alumno investigar sobre las demás.

Mayor y Menor elemento de un Vector Dado una lista de elementos almacenadas en un vector, una actividad muy util, es encontrar el mayor y menor elemento de la lista. Es de suma importancia, no solamente encontrar el mayor elemento, sinó, la posición que ocupa dentro del vector. Como generalmente se trabaja con Vectores Paralelos, encontrando la posición del mayor elemento en un vector, se tendrá también a quién le coresponde por medio de esa posición. Ejemplo: Suponer que se tienen dos vectores, uno de Nombres de personas y otro con las edades de las mismas: Nombres de Personas Mario

Alejandra

Laura

Santiago

Luis

27

21

35

28

24

0

1

2

3

4

Edades

Se puede realizar un algoritmo que retorne la posición de la persona de mayor edad, en el ejemplo sería la posición número 2 con 35 años. Como se está trabajando con vectores paralelos, la Posición 2 le corresponde a Laura, por lo – Algoritmos y Estructuras de Datos I – - 137 -

– ISSD – EDUARDO MANSILLA – tanto, se puede decir que, obteniendo la posición del mayor en un vector, se puede conocer todos los datos asociados en todos los otros vectores paralelos, por medio del mismo índice. Ejemplo Nro. 42: Dados tres vectores de nombres, edades y sueldos de personas, imprimir todos los datos de la persona de mayor edad. El algoritmo de la busqueda del mayor con su posición, consiste en lo siguiente: Edades [i]

0

27

1

21

2

35

3

28

4

24

m

p

27

0

Tomar el primer elemento del vector y almacenarlo en una variable auxiliar, por ejemplo “m” y guardar en la variable “p” el valor cero, que corresponde a la primera posición. Este valor guardado en “m” se utilizará para comparar con el resto de los elementos del vector.

Una vez almacenado el primer elemento en “m”, se realiza un ciclo for desde la posición 1 hasta la última y con una estructura if dentro de él, preguntando si alguno de los sucesivos componentes del vector es mas grande al valor almacenado en “m”. En caso de ser verdadero, se le asigna a “m” el nuevo valor y se guarda en “p” la nueva posición, dada por la variable índice del for a cada instante. Una vez recorrido todo el vector, quedará en la variable “m” el mayor de los elementos, y en la variable “p” la posición que ocupa dentro del vector. Con la posición del mayor, obtenida en la variable “p”, se imprimien los datos que sean necesarios, que, en este caso, en el ejemplo 42, se pide imprimir el nombre y el sueldo que le corresponde. Debido a que se está trabajando con Vectores Paralelos, los datos que corresponderán a la persona de mayor edad son los siguiente: nombres[p]

y

sueldos[p]

El diagrama y programa se muestran a continuación:

- 138 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – void cargarDatos ( )

i = 0; i < nombres.length; i++

Falso

Verdadero

nombres [i] edades [i] sueldos [i]

Fin

int mayor (int [] edades ) m = edades[0] p=0 i = 1; i < edades.length; i++

Falso

Verdadero Falso

edades[i] > m

Verdadero

m = edades[i] p=i

Retornar p Fin

– Algoritmos y Estructuras de Datos I –

- 139 -

– ISSD – EDUARDO MANSILLA –

void mostrarDatos() p = mayor (edades)

“El nombre de mayor edad es: “ + nombres[p] “La mayor edad es: “ + edad[p] “Le corresponde un sueldo de: “ + sueldo[p]

Fin

import hsa.Console; class Ejemplo42 { static Console c; String [] nombres; int [] edades; float [] sueldos; Ejemplo42 () { nombres = new String [5]; edades = new int [5]; sueldos = new float [5]; } void cargarDatos () { c.println ("Cargue los datos de las personas: "); c.println (); for (int i = 0 ; i < nombres.length ; i++) { c.print ("Ingrese nombre[" + (i + 1) + "]: "); nombres [i] = c.readLine (); c.print ("Ingrese su edad: "); edades [i] = c.readInt (); c.print ("Ingrese su sueldo: "); sueldos [i] = c.readFloat (); c.println (); } }

- 140 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – int mayor (int [] edades) { int m = edades [0]; int p = 0; for (int i = 1 ; i < edades.length ; i++) { if (edades [i] > m) { m = edades [i]; p = i; } } return p; } void imprimirDatos () { int p; c.setCursor (3, 10); c.println ("Datos de la persona de Mayor edad"); c.setCursor (4, 10); c.println ("---------------------------------");

}

}

c.println (); p = mayor (edades); c.println("El nombre de mayor edad es: " + nombres [p]); c.println("La mayor edad es: " + edades [p]); c.println("Le corresponde un sueldo de: " + sueldos [p]);

public static void main (String arg []) { c = new Console (); Ejemplo42 e = new Ejemplo42 (); e.cargarDatos (); c.clear (); e.imprimirDatos (); }

Para ralizar la búsqueda del Menor, simplemente se debe cambiar el símbolo de mayor por menor

– Algoritmos y Estructuras de Datos I –

- 141 -

– ISSD – EDUARDO MANSILLA –

Funciones básicas para el manejo de cadenas de caracteres int length(): Esta función tiene por objeto determinar la cantidad de caracteres que tiene una palabra o una frase. Ejemplo: String frase = "Hoy es sabado"; int cantidad = frase.length(); En este caso en la variable cantidad queda almacenado la cantidad de caracteres que tiene la frase, o sea, el valor de 13. Tener encuenta que los espacios en blanco también se cuentan. boolean equals(String s): Función que se utiliza para verificar si una cadena de caracteres es igual a otra. Ejemplos: String nombre = "Marcela"; String dato = c.readLine(); if (nombre.equals(dato)) aquí se pregunta si el contenido de la variable nombre, es igual al contenido almacenado en la variable dato. "Viviana".equals("Analia")  False "Viviana".equals("Viviana")  True "Viviana".equals("VIVIANA")  False boolean equalsIgnoreCase(String s): Compara dos string sin discriminar entre mayúsculas y minúsculas. "Viviana".equalsIgnoreCase("Analia")  False "Viviana".eaualsIgnoreCase("Viviana")  True "Viviana".eaualsIgnoreCase("VIVIANA")  True int compareTo(String s): Esta función se utiliza para comparar dos cadenas de caracteres, retornando un valor mayor a cero, menor a cero o igual a cero, de la siguiente manera: cadena1.compareTo(cadena2) Retorna un valor mayor a cero si cadena1 es mayor a cadena2. Retorna un valor menor a cero si cadena1 es menor a cadena2. Retorna el valor cero, si las dos cadenas son iguales. Ejemplos: "Alicia".compareTo("Maria") "Javier".compareTo("Aldo") "Marcos".compareTo("Marcos") - 142 -

  

< 0 > 0 = 0

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Busqueda de un elemento en un vector Consiste en recorrer y comparar cada elemento de un vector con una variable auxiliar. Ejemplo: Buscar los datos de una persona por su nombre, buscar el saldo de un cliente, buscar las notas de un alumno, etc. Ejemplo Nro. 43: Desarrollar un programa que permita cargar los nombres de 5 emisoras de FM y sus respectivas frecuencias. Luego de la carga, realizar una consulta ingresando el nombre de una emisora, y en caso de existir, mostrar la frecuencia que le corresponde. emisoras Shopping

Cadena3

Latina

Libertad

Power

100.5

89.7

105.3

102.3

frecuencias 96.1

Importante: Hay que tener en cuenta que los vectores son estructuras de datos cuya información se pierde cuando finaliza la ejecución del programa.

Para realizar la búsqueda se utiliza una variable auxiliar de tipo String (emisoraAux) para ingresar por teclado el nombre de la emisora a buscar. Otra variable importante es posicion que indica en qué lugar del vector se encuentra el nombre consultado. Esta variable posición se inicializa con el valor -1 como indicando que la emisora buscada hasta el momento no se encuentra en el vector (no se usa el cero, porque el cero es una posición válida dentro del vector). Luego en una estructura repetitiva se controla cada componente del vector emisoras con la variable auxiliar (emisoraAux). En caso que coincida, se guarda en la variable “posicion’, el contenido de la variable del for que representa el número de componente en ese momento.

Observar que en Java, para la comparación de cadenas se utiliza las sentencias: equals(), equalsIgnoreCase o compareTo()

– Algoritmos y Estructuras de Datos I –

- 143 -

– ISSD – EDUARDO MANSILLA –

void cargarDatos ( )

i = 0; i < emisoras.length; i++

Falso

Verdadero

emisoras [i] frecuencias [i]

Fin

void consulta ( ) posicion = -1 emisoraAux

i = 0; i < emisoras.length; i++

Falso

Verdadero Falso

emisoraAux.equals(emisoras[i])

Verdadero

posicion = i

1

- 144 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

1

posicion != -1 “Le corresponde la frecuencia de : “ frecuencias[posicion]

“No existe esa emisora”

Fin

import hsa.Console; class Ejemplo43 { static Console c; String [] emisoras; float [] frecuencias; Ejemplo43 () { emisoras = new String [5]; frecuencias = new float [5]; } void cargarDatos () { c.println ("Cargue las emisoras de FM: "); c.println (); for (int i = 0 ; i < emisoras.length ; i++) { c.print ("Ingrese emisora[" + (i + 1) + "]: "); emisoras [i] = c.readLine (); c.print ("Ingrese su frecuencia: "); frecuencias [i] = c.readFloat (); c.println (); } }

– Algoritmos y Estructuras de Datos I –

- 145 -

– ISSD – EDUARDO MANSILLA – void consultas () { int posicion; String emisoraAux; char op; do { c.clear (); c.println ("Consultas por emisoras"); c.println ("----------------------"); posicion = -1; c.println (); c.print ("Ingrese la emisora a buscar: "); emisoraAux = c.readLine (); for (int i = 0 ; i < emisoras.length ; i++) { if (emisoraAux.equalsIgnoreCase (emisoras [i])) { posicion = i; } } c.println (); if (posicion != -1) { c.print ("Le corresponde la frecuencia de: "); c.println (frecuencias [posicion] + " MHz"); } else { c.println ("No existe esa emisora"); } c.println (); c.println (); c.print ("Desea realizar otra consulta (s/n): "); op = c.readChar (); } while (op == 'S' || op == 's'); }

}

public static void main (String arg []) { c = new Console (); Ejemplo43 e = new Ejemplo43 (); e.cargarDatos (); e.consultas (); System.exit (0); }

- 146 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Explicación del proceso Consultas: Se comienza definiendo las variables que intervienen en el proceso, la variable de posición, la variable auxiliar de búsqueda, “emisoraAux” y la variable de opción “op”. Esta variable “op” será utilizada para poder volver a hacer otra consulta o nó. Se realiza un ciclo do..while para permitir precisamente realizar otra consulta, este ciclo no figuraba en el diagrama, ya que en él, se ha desarrollado únicamente la esencia del algoritmo de búsqueda. Cada vez que se comienza una consulta, se limpia la pantalla con la instrucción c.clear() y se coloca el título. Se inicializa la variable “posicion” en el valor de -1, de esta manera, se asegura que no corresponde a una posición válida del vector. Posteriormente, se pide la emisora a buscar con la línea: emisoraAux = c.readLine (); Luego se ingresa en un ciclo for con una condición dentro para verificar si la emisora auxiliar coincide con alguna de las sucesivas emisoras del vector. En caso de ser verdadera, se guarda el índice de ese instante en la variable “posicion”. Al salir del ciclo for, se verifica el valor de la variable “posicion”, que en caso de tener un valor distinto de -1, es porque se ha encontrado la emisora auxiliar buscada, imprimiendo el valor de la frecuencia que le corresponde. Si la variable “posicion” quedó con el valor de -1, indica que so se encontró a la emisora buscada y por lo tanto, se imprime la leyenda “No existe esa emisora”. Posteriormente se pregunta si se quiere realizar otra consulta, aceptando la letra S o N. Si se responde con la letra S, se retorna al ciclo do y se realiza una nueva consulta, si se responde con letra N, se finaliza el programa.

Ordenamiento de Vectores Ordenamiento es la operación de arreglar los registros de una tabla, vector o algún tipo de estructura, en orden secuencial de acuerdo a un criterio de ordenamiento. El ordenamiento se efectúa con base en el valor de algún campo o dato. El propósito principal de un ordenamiento es el de facilitar las búsquedas de los miembros del conjunto ordenado, o mostrar un listado de datos. El ordenar un grupo de datos significa mover los datos o sus referencias para que queden en una secuencia tal, que represente un orden, el cual puede ser numérico, alfabético o incluso alfanumérico, ascendente o descendente. Entre los métodos más destacados se encuentran: Inserción directa Selección directa Burbuja Shell Quick sort. El método que se verá en este curso se llama Método de la Burbuja – Algoritmos y Estructuras de Datos I –

- 147 -

– ISSD – EDUARDO MANSILLA – (Bubble Sort). Es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición, si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". Ejemplo Nro. 44: Desarrollar un programa para ordenar un vector de valores enteros. v[i] 120

75

82

i = 0;

i < 4;

55

i++

49

Falso

Verdadero Falso

v[i] > v[i+1]

Verdadero

auxi = v[i] v[i] = v[i+1] v[i+1] = auxi

Esta primera aproximación tiene por objetivo analizar los intercambios de elementos dentro del vector. El algoritmo consiste en comparar si la primera componente es mayor a la segunda, en caso que la condición sea verdadera, intercambiamos los contenidos de las componentes.

- 148 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – En este ejemplo: ¿es 120 mayor a 75? La respuesta es verdadera, por lo tanto, se intercambia el contenido de la componente 0 con el de la componente 1. El vector quedaría con el intercambio de la siguiente manera: 75

120

v [0]

v [1]

Luego se compara el contenido de la componente 1 con el de la componente 2: ¿Es 120 mayor a 82? La respuesta es verdadera entonces se intercambian. Es decir que el vector quedaría así: 75

82

120

v[0]

v[1]

v[2]

Si hay 5 componentes, hay que hacer 4 comparaciones, por eso el for va de 0 a 3. Generalizando: si el vector tiene N componentes hay que hacer N-1 comparaciones. v[0]

v[1]

v[2]

v[3]

v[4]

75

120

82

55

49

75

85

120

55

49

75

82

55

120

49

75

82

55

49

120

Podemos ver cómo el valor más grande del vector desciende a la última componente. Se emplea una variable auxiliar (Aux) para el proceso de intercambio: auxi = v[i]; v[i] = v[i+1]; v[i+1] = auxi; Al salir del for en este ejemplo el contenido del vector es el siguiente: 75

82

55

49

120

Analizando el algoritmo podemos comprobar que el elemento mayor del vector se ubica ahora en el último lugar.

– Algoritmos y Estructuras de Datos I –

- 149 -

– ISSD – EDUARDO MANSILLA – Pero todavía este algoritmo no ordena un vector. Solamente en este primer barrido del vector, se tiene la seguridad de que el elemento más grande ha quedado al último. Ahora bien, con los 4 elementos que nos quedan podemos hacer el mismo proceso visto anteriormente, con lo cual quedará ordenado otro elemento del vector (el anteúltimo). Este proceso se repite hasta que quede ordenado por completo el vector. Como debemos repetir el mismo algoritmo, podemos englobar todo el bloque en otra estructura repetitiva.

k = 1;

k < 5;

Falso

k++

Verdadero

i = 0;

i < 4;

Falso

i++

Verdadero Falso

Verdadero

v[i] > v[i+1]

auxi = v[i] v[i] = v[i+1] v[i+1] = auxi

Relicemos una prueba del algoritmo anterior: Cuando k = 1

- 150 -

75

120

82

55

49

75

82

120

55

49

75

82

55

120

49

75

82

55

49

120

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Cuando k = 2 75 75

82 55

55 82

490 49

120

49

120

75

55

49

82

120

75

55

49

82

120

Cuando k = 3 55

75

49

82

120

55

49

75

82

120

55

49

75

82

120

55

49

82

120

75

Cuando k = 4 49

55

75

82

120

49

55

75

82

120

49

55

75

82

120

49

55

75

82

120

¿Por qué se repite 4 veces el for externo? Como se sabe, cada vez que se repite en forma completa el for interno, queda ordenada una componente del vector. Si se observa, cuando quedan dos elementos por ordenar (k=3) al ordenar uno de ellos queda el otro automáticamente ordenado (podemos imaginar que si tenemos un vector con 2 elementos no se requiere el for externo, porque este debería repetirse una única vez). – Algoritmos y Estructuras de Datos I –

- 151 -

– ISSD – EDUARDO MANSILLA – Una última consideración a este ALGORITMO de ordenamiento es que a medida que los elementos se van ordenando, se continúa comparando los elementos aún cuando esto ya no es necesario. Ejemplo: En la primera ejecución del For interno el valor 120 queda ubicado en la posición 5 del vector. En la segunda ejecución se compara si el 82 es mayor a 120, lo cual seguramente será falso: ya que el 120 quedó en su lugar definitivo al terminar la primera vuelta el for interno. Se puede concluir que la primera vez se debe hacer para este ejemplo 4 comparaciones con el ciclo interno, en la segunda ejecución del for interno se deberían hacer 3 comparaciones (porque el último valor ya está ordenado y es una pérdida de tiempo volver a compararlo) y en general se debe ir reduciendo en uno la cantidad de comparaciones. Si bien el algoritmo planteado funciona, un algoritmo más eficiente, que se deriva del anterior es el siguiente:

k = 1;

k<5;

k++

Falso

Verdadero

i = 0;

i<5–k;

i++

Falso

Verdadero Falso

v[i] > v[i+1]

Verdadero

auxi = v[i] v[i] = v[i+1] v[i+1] = auxi

El algoritmo queda planteado con un for interno que va a ir decreciendo en uno cada vez que el contador del for externo se incremente.

- 152 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –  Inicialmente k=1 por lo que el for interno se repite 4 veces (desde i =0 hasta i = 4-k o sea 4 – 1 = 3).  Cuando k=2 el for interno se repite 3 veces (desde 0 hasta 2), y así sucesivamente. Este algoritmo descrito funciona correctamente para un vector de “5” elementos, en caso de tener “N” elementos, la función de ordenamiento de un vector quedaría de la siguiente manera:

void ordenar (v, n)

k = 1;

k
k++

Falso

Verdadero

i = 0;

i
i++

Falso

Verdadero Falso

v[i] > v[i+1]

Verdadero

auxi = v[i] v[i] = v[i+1] v[i+1] = auxi

Fin

– Algoritmos y Estructuras de Datos I –

- 153 -

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 44: Desarrollar un programa para ordenar un vector de n elementos. Se deberá imprimir el vector como se ingresó y luego el vector ordenado. import hsa.Console; class Ejemplo44 { static Console c; int [] v; Ejemplo44 { c.print int n = v = new }

() ("Ingrese la cantidad de elementos del vector: "); c.readInt (); int [n];

void cargarDatos () { c.println ("Cargue los elementos del vector"); c.println (); for (int i = 0 ; i < v.length ; i++) { c.print ("Ingrese elemento[" + (i + 1) + "]: "); v [i] = c.readInt (); } } void ordenar (int [] v, int n) { int auxi; for (int k = 1 ; k < n ; k++) { for (int i = 0 ; i < n - k ; i++) { if (v [i] > v [i + 1]) { auxi = v [i]; v [i] = v [i + 1]; v [i + 1] = auxi; } } } } void imprimir () { for (int i = 0 ; i < v.length ; i++) { c.print (v [i] + " "); } }

- 154 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – void imprimirOrdenado() { int n = v.length; ordenar(v,n); imprimir(); }

}

public static void main (String arg []) { c = new Console (); Ejemplo44 e = new Ejemplo44 (); c.println(); e.cargarDatos (); c.println(); c.println ("Vector ingresado:"); e.imprimir (); c.println (); c.println (); c.println ("Vector ordenado:"); e.imprimirOrdenado (); }

– Algoritmos y Estructuras de Datos I –

- 155 -

– ISSD – EDUARDO MANSILLA –

Ejercicios Propuestos 9.1 - Desarrollar un programa que permita el ingreso de 2 vectores de 10 componentes de tipo float. Implementar dos funciones, una para la carga y otra que muestre por pantalla el mayor elemento de cada uno. 9.2 - Realizar un programa que permita la carga de 20 números enteros. Se deberá mostrar impreso el vector en forma inversa 9.3 - Una empresa que realiza cursos de computación tiene la siguiente información Nombre del curso Operador de PC Reparador de PC Internet Programacion

Enero 223 22 122 121

Febrero 333 22 160 180

Marzo 222 21 190 210

Desarrollar un programa que permita: a) Cargar en vectores los nombres de los cursos y las cantidades de inscriptos en cada curso en los meses de enero, febrero, y marzo. b) Obtener el total de alumnos que se han inscripto en los tres meses para cada curso. c) Qué curso ha tenido mayor cantidad de inscripciones, mostrar el nombre del curso. d) En los meses de enero y febrero cual fue la cantidad de inscripciones en total en la academia (sin discriminar por cursos). e) En el mes de marzo reducir en 5 la cantidad de inscriptos a todos los cursos e imprimir los inscriptos en marzo. 9.4 - Generar un vector de 12 elementos con componentes aleatorias entre los valores de 10 y 90. (Rever la clase número 6 para utilizar la función Math.random). Se deberá imprimir el vector generado y el Rango del mismo. (Se llama Rango de un vector al valor del mínimo y máximo de dicho vector). Ejemplo: Vector generado v[i] = 40 55 13 47 45 67 32 43 66 87 15 72 Rango = [ 13..87 ] 9.5 - Cargar tres vectores que contengan nombre de libro, año de edición y precio. Realizar una consulta por nombre y determinar cual es el libro más antiguo. 9.6 - En el ejercicio anterior, ingresar dos precios y mostrar todos los libros que se encuentran comprendido entre esos precios.

- 156 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – import hsa.Console; class PropuestoNueve3 { static Console c; String [] nombre; int [] enero; int [] febrero; int [] marzo; int [] total;

Solución del ejercicio propuesto 9.3

PropuestoNueve3() { nombre = new String[4]; enero = new int[4]; febrero = new int[4]; marzo = new int[4]; total = new int[4]; } void cargarDatos() //Punto a { int fila = 4; c.setCursor(2,5); c.print("Nombre"); c.setCursor(2,20); c.print("Enero"); c.setCursor(2,35); c.print("Febrero"); c.setCursor(2,50); c.print("Marzo"); for (int i=0; i<nombre.length; i++) { c.setCursor(fila,5); nombre[i]=c.readLine(); c.setCursor(fila,20); enero[i]=c.readInt(); c.setCursor(fila,35); febrero[i]=c.readInt(); c.setCursor(fila,50); marzo[i]=c.readInt(); fila++; } } void totalDeAlumnos() //Punto b { int fila = 4; c.setCursor(2,65); c.print("Total"); for(int i=0; i<enero.length; i++) { total[i] = enero[i] + febrero[i] + marzo[i]; c.setCursor(fila,65); c.print(total[i],4); fila++; } c.readChar(); } void mayor() //Punto c { int m = total[0]; int posicion = 0; for (int i=1; im) { – Algoritmos y Estructuras de Datos I –

- 157 -

– ISSD – EDUARDO MANSILLA – m=total[i]; posicion=i;

}

} c.println(); c.println(); c.print("el curso con mayor cantidad de inscriptos es: "); c.println(nombre[posicion]); c.readChar();

void totalEneroFebrero() //Punto d { int suma = 0; for(int i=0; i<enero.length; i++) { suma = suma + enero[i] + febrero[i]; } c.println(); c.print("El total en los meses de Enero y Febrero es: "); c.println(suma); c.readChar(); } void reducir() //Punto e { int fila = 4; c.println(); c.print("Pulse [Enter] para reducir en 5 los inscriptos en marzo"); c.readChar(); for(int i=0; i<marzo.length; i++) { marzo[i] = marzo[i] - 5; c.setCursor(fila,50); c.print(marzo[i],4); fila++; } }

}

public static void main (String arg []) { c = new Console (); PropuestoNueve3 p = new PropuestoNueve3(); p.cargarDatos(); p.totalDeAlumnos(); p.mayor(); p.totalEneroFebrero(); p.reducir(); p.totalDeAlumnos(); System.exit(0); }

- 158 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

UNIDAD Nº 4:

Métodos Vectores

TEMAS: Ordenamiento con Vectores Paralelos Consultas en vectores paralelos

Clase

10

Clase Número: 10

Ordenamiento con Vectores Paralelos Cuando se tienen vectores paralelos y se ordena uno de ellos hay que tener la precaución de intercambiar los elementos de los otros vectores asociados. Ejemplo Nro. 45: Se tienen dos vectores, en uno se deben cargar los nombres de las provincias argentinas y en el otro las temperaturas medias anuales de cada provincia. Realizar las siguientes operatorias: a) Realizar un listado por pantalla de las provincias en orden alfabético, como se indica a continuación: Nombre de Provincia Buenos Aires Chubut Cordoba Tierra del Fuego

Temperatura 22 8 23 4

b) Realizar un listado ordenado por las temperaturas (desde la temperatura más baja hasta la más alta). Nombre de Provincia Tierra del Fuego Chubut Buenos Aires Cordoba

Temperatura 4 8 22 23

c) Realizar un Menú de opciones, con las siguientes alrenativas: [Carga de Datos] – [Listado Ordenado por Provincia] – [Listado Ordenado por Temperaturas] – [Finalizar]

– Algoritmos y Estructuras de Datos I –

- 159 -

– ISSD – EDUARDO MANSILLA – void cargarDatos ( ) Falso

i = 0; i < provincias.length; i++ Verdadero

provincias [i] temperaturas [i]

Fin

void ordenarPorProvincias (v, n)

k = 1;

k
Falso

k++

Verdadero

i = 0;

i
Falso

i++

Verdadero Falso

provincias[i].compareto(provincias[i+1]) >0

Verdadero

auxiProvincia = provincia[i] provincia[i] = provincia[i+1] provincia[i+1] = auxiprovincia auxiTemperatura = temperatura[i] temperatura[i] = temperatura[i+1] temperatura[i+1] = auxiTemperatura

Fin

- 160 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

void ordenarPorTemperaturas (v, n)

k = 1;

k
Falso

k++

Verdadero

i = 0;

i
Falso

i++

Verdadero Falso

temperaturas[i] > temperaturas[i+1]

Verdadero

auxiProvincia = provincia[i] provincia[i] = provincia[i+1] provincia[i+1] = auxiprovincia auxiTemperatura = temperatura[i] temperatura[i] = temperatura[i+1] temperatura[i+1] = auxiTemperatura

Fin

import hsa.Console; import java.awt.*; class Ejemplo45 { static Console c; String [] provincias; float [] temperaturas; Ejemplo45 () { c.print("Ingrese la cantidad de provincias: "); int n = c.readInt (); provincias = new String [n]; temperaturas = new float [n]; }

– Algoritmos y Estructuras de Datos I –

- 161 -

– ISSD – EDUARDO MANSILLA – void cargarDatos () { c.clear (); c.println ("Cargue los datos"); c.println (); for (int i = 0 ; i < provincias.length ; i++) { c.print ("Ingrese provincias[" + (i + 1) + "]: "); provincias [i] = c.readLine (); c.print ("Ingrese su Temperatura: "); temperaturas [i] = c.readFloat (); c.println (); } } void imprimir () { int fila; c.setCursor(3, 10); c.print ("Provincias"); c.setCursor(4, 10); c.print ("----------"); c.setCursor(3, 30); c.print ("Temperaturas"); c.setCursor(4, 30); c.print ("------------"); fila = 5; for (int i = 0 ; i < provincias.length ; i++) { c.setCursor(fila, 10); c.print(provincias[i]); c.setCursor(fila, 30); c.print(temperaturas[i],4,1); fila++; } c.println(); c.println (); c.setTextColor(Color.red); c.print(" Digite [Enter] para retornar al Menu "); c.readChar (); } void ordenarPorProvincias () { int n=provincias.length; String auxiProvincia; float auxiTemperatura; for (int k = 1 ; k < n ; k++) { for (int i = 0 ; i < n - k ; i++) { if(provincias[i].compareTo(provincias[i+1]) > 0) { auxiProvincia = provincias [i]; provincias [i] = provincias [i + 1]; provincias [i + 1] = auxiProvincia;

}

- 162 -

auxiTemperatura = temperaturas [i]; temperaturas [i] = temperaturas [i + 1]; temperaturas [i + 1] = auxiTemperatura;

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

}

}

}

void ordenarPorTemperaturas () { int n = provincias.length; String auxiProvincia; float auxiTemperatura; for (int k = 1 ; k < n ; k++) { for (int i = 0 ; i < n - k ; i++) { if(temperaturas[i] > temperaturas[i+1]) { auxiProvincia = provincias [i]; provincias [i] = provincias [i + 1]; provincias [i + 1] = auxiProvincia;

}

}

}

}

auxiTemperatura = temperaturas [i]; temperaturas [i] = temperaturas [i + 1]; temperaturas [i + 1] = auxiTemperatura;

public static void main (String arg []) { c = new Console (); Ejemplo45 e = new Ejemplo45 (); int op; c.setTextBackgroundColor (Color.cyan); do { c.clear (); c.setTextColor(Color.blue); c.setCursor (3, 10); c.print ("Menu de Opciones"); c.setCursor (4, 10); c.print ("----------------"); c.setCursor (5, 10); c.print ("1- Cargar Datos"); c.setCursor (6, 10); c.print ("2- Listado ordenado por Provincias"); c.setCursor (7, 10); c.print("3-Listado ordenado por Temperaturas"); c.setCursor (8, 10); c.print ("4- Finalizar el programa"); c.setCursor (12, 10); c.print ("Digite la opcion: "); op = c.readInt ();

– Algoritmos y Estructuras de Datos I –

- 163 -

– ISSD – EDUARDO MANSILLA – switch (op) { case 1: e.cargarDatos (); break; case 2: c.clear (); c.setCursor (1, 10); c.print("Listado Ordenado por Provincias"); e.ordenarPorProvincias (); e.imprimir(); break; case 3: c.clear(); c.setCursor (1, 10); c.print("Listado Ordenado por Temperaturas"); e.ordenarPorTemperaturas (); e.imprimir(); break; } } while (op != 4); System.exit (0); } } Observar que los dos ordenamientos, el de Provincias y el de Temperaturas, son similares, lo único que cambia es la condición del “ if ”. En el ordenamiento por provincia se utiliza el método compareTo( ) de la siguiente manera: if(provincias[i].compareTo(provincias[i+1])>0) Recordando, este método retorna un valor menor a cero si provincias[i] es menor alfabéticamente a provincias[i+1]. Un valor igual a cero, si provincias[i] es igual a provincias[i+1], y un valor mayor a cero, si provincias[i] es mayor a provincias[i+1]. Este último caso es el que se utiliza en la condición, ya que si provincias[i] es mayor a provincias[i+1], se debe realizar el intercambio de datos debido a que las provincias están desordenadas. Para realizar el menú, se utiliza un ciclo do..while en el programa principal, de manera que el programa siempre muestre el menú mientras no se digite la opción 4. La salida del programa para el listado ordenado por provincias sería similar a la siguiente pantalla:

- 164 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Consultas en Vectores Paralelos Cuando se realiza una consulta con vectores paralelos, se debe obtener la posición en el vector del dato por el cual se busca. Una vez localizada la posición, se accede a los otros vectores a través de ella. Ejemplo Nro. 46: Realizar la carga de tres vectores que contengan: Descripción de Producto, Precio Unitario y Procedencia. Desarrollar además, las siguientes operatorias: a) b) c) d) e)

Listado en tres columnas Consultas por Descripción de Producto. Mostrar todos los datos del Producto de menor precio. Consulta por Procedencia Menu de Opciones.

import hsa.Console; import java.awt.*; class Ejemplo46 { static Console c; String [] descripcion; float [] precio; String [] procedencia; Ejemplo46 () { c.print("Ingrese la cantidad de productos: "); int n = c.readInt (); descripcion = new String [n]; precio = new float [n]; procedencia = new String[n]; } void cargarDatos () { c.clear (); c.println ("Cargue los Productos"); c.println (); for (int i = 0 ; i < descripcion.length ; i++) { c.print ("Ingrese descripcion[" +(i + 1)+ "]: "); descripcion [i] = c.readLine (); c.print ("Ingrese su precio unitario: "); precio [i] = c.readFloat (); c.print ("Ingrese su procedencia: "); procedencia [i] = c.readLine (); c.println (); } } – Algoritmos y Estructuras de Datos I –

- 165 -

– ISSD – EDUARDO MANSILLA – void imprimir () { int fila; c.setCursor (3, 10); c.print ("Descripcion"); c.setCursor (4, 10); c.print ("-----------"); c.setCursor (3, 30); c.print ("Precio"); c.setCursor (4, 30); c.print ("------"); c.setCursor (3, 45); c.print ("Procedencia"); c.setCursor (4, 45); c.print ("-----------"); fila = 5; for (int i = 0 ; i < descripcion.length ; i++) { c.setCursor (fila, 10); c.print (descripcion [i]); c.setCursor (fila, 30); c.print (precio [i], 8, 2); c.setCursor (fila, 45); c.print (procedencia [i]); fila++; } c.println (); c.println (); c.setTextColor(Color.red); c.print(" Digite [Enter] para retornar al Menu "); c.readChar (); } void consultasPorDescripcion() { String dx; char op; do { c.clear(); c.setCursor(3,10); c.print("Consultas por Descripcion"); c.setCursor(4,10); c.print("-------------------------"); c.setCursor(6,10); c.print("Ingrese Descripcion de Producto a buscar: "); dx = c.readLine(); int posi=-1;

- 166 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

}

for(int i=0; i<descripcion.length;i++) { if(dx.equalsIgnoreCase(descripcion[i])) { posi = i; } } if(posi !=-1) { c.setCursor(8,10); c.print("Precio Unitario: $ "); c.print(precio[posi],0,2); c.setCursor(9,10); c.print("Procedencia: "); c.print(procedencia[posi]); } else { c.setCursor(9,10); c.print("No existe esa Descripcion"); } c.setCursor(20,10); c.print("Realiza otra consulta: "); op=c.readChar(); }while (op=='s' || op=='S');

void productoDeMenorPrecio() { float menorPrecio=precio[0]; int posi=0; for(int i=1; i<precio.length; i++) { if(precio[i] < menorPrecio) { menorPrecio=precio[i]; posi=i; } } c.clear(); c.setCursor(5,10); c.print("Los datos del producto de menor Precio son: "); c.setCursor(7,10); c.print("Descripcion: "); c.print(descripcion[posi]); c.setCursor(8,10); c.print("Precio Unitario: $ "); c.print(precio[posi],0,2); c.setCursor(9,10); c.print("Procedencia: "); c.print(procedencia[posi]); c.setCursor(20,10); c.setTextColor(Color.red);

– Algoritmos y Estructuras de Datos I –

- 167 -

– ISSD – EDUARDO MANSILLA –

}

c.print (" Digite [Enter] para retornar al Menu "); c.readChar (); void consultasPorProcedencia() { String px; char op; do { c.clear(); c.setCursor(3,10); c.print("Consultas por Procedencia"); c.setCursor(4,10); c.print("-------------------------"); c.setCursor(6,10); c.print("Ingrese Procedencia a buscar: "); px = c.readLine(); int fila=10; for(int i=0; i<descripcion.length;i++) { if(px.equalsIgnoreCase(procedencia[i])) { c.setCursor(8,10); c.print("Descripcion"); c.setCursor(9,10); c.print("-----------"); c.setCursor(8,30); c.print("Precio"); c.setCursor(9,30); c.print("------"); c.setCursor(fila,10); c.print(descripcion[i]); c.setCursor(fila,30); c.print(precio[i],8,2); fila++; } } if(fila == 10) { c.setCursor(9,10); c.print("No existe esa procedencia"); } c.println(); c.println(); c.print("Realiza otra consulta: "); op=c.readChar();

}

} while (op=='s' || op=='S');

- 168 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – void mensaje() { c.clear(); c.setTextColor(Color.red); c.setCursor(10,15); c.print("Faltan cargar los productos"); c.setCursor(14,15); c.print("Digite [Enter para Menu]..."); c.readChar(); } public static void main (String arg []) { c = new Console (); Ejemplo46 e = new Ejemplo46(); int op; c.setTextBackgroundColor (Color.yellow); int bandera=0; do { c.clear (); c.setTextColor(Color.blue); c.setCursor (3, 10); c.print ("Menu de Opciones"); c.setCursor (4, 10); c.print ("----------------"); c.setCursor (5, 10); c.print ("1- Cargar Datos"); c.setCursor (6, 10); c.print ("2- Listado Completo"); c.setCursor (7, 10); c.print ("3- Consultas por descripcion"); c.setCursor (8, 10); c.print("4- Datos del Producto de menor Precio"); c.setCursor (9, 10); c.print ("5- Consultas por Procedencia"); c.setCursor (10, 10); c.print ("6- Finalizar el programa"); c.setCursor (13, 10); c.print ("Digite la opcion: "); op = c.readInt (); switch (op) { case 1: e.cargarDatos(); bandera=1; break; case 2: if(bandera==0) e.mensaje(); else { c.clear (); c.setCursor (1, 10); c.print ("Listado Completo"); e.imprimir (); } break;

– Algoritmos y Estructuras de Datos I –

- 169 -

– ISSD – EDUARDO MANSILLA – case 3: if(bandera==0) e.mensaje(); else e.consultasPorDescripcion(); break; case 4: if(bandera==0) e.mensaje(); else e.productoDeMenorPrecio(); break; case 5: if(bandera==0) e.mensaje(); else e.consultasPorProcedencia(); break; }

}

}

} while (op != 6); System.exit (0);

Explicación: En este ejemplo, se observan dos tipos de consultas que lógicamente tienen conceptos distintos. En primer lugar, se tiene una Consulta por descripción de Producto, en la cual el algoritmo consiste en lo siguiente: Se ingresa la descripción del producto a buscar en la variable “dx” (Simbolizando a la descripción incógnita a buscar), y se coloca a la variable de posición “posi” en el valor de -1, indicando que hasta el momento no se encontró la descripción buscada. Se ingresa en un ciclo for, en donde se pregunta si el dato que tiene almacenado “dx”, coincide con algunos de las descripciones almacenadas en el vector, para ello se ha colocado la instrucción: if(dx.equalsIgnoreCase(descripcion[i])) { posi = i; } El método equalsIgnoreCase se utiliza para preguntar por la igualdad de las descripciones, ignorando mayúsculas de minúsculas. En caso de coincidencia, lo único que se hace es guardar la posición, por lo tanto, una vez recorrido todo el vector, es decir, cuando se finaliza el ciclo for, la variable “posi” puede haber quedado con el valor de -1, (en caso de no haber coincidencias), o con un valor de cero en adelante, si se encontró el producto. Por lo tanto, fuera del ciclo for, se pregunta si la variable “posi” quedó con un valor distinto de -1, y en caso de ser verdadero, significa que se ha encontrado a la descripción buscada, entonces se imprimen los datos de los vectores asociados en la posición indicada por la variable “posi”. Si fuera falsa la condición anterior, indica que no se ha encontrado la descripción buscada, y en ese caso, se imprime la leyenda “No existe esa descripción”. Por último, se pregunta si se desea hacer otra Consulta, almacenando en la variable “op” la opción tipeada y cerrando el ciclo do..while con la condición: while (op=='s' || op=='S');

- 170 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Esta condición establece que mientras la variable “op” sea igual a la letra “s”, ya sea en minúscula o mayúscula, retornará al principio del ciclo do. El otro tipo de Consulta, es la Consulta por Procedencia, en la cual se debe tener en cuenta de que puede haber mas de un producto que pertenezca a la procedencia buscada. El algoritmo comienza ingresando la procedencia a buscar en la variable “px” (procedencia incógnita). En este caso, utilizar la variable “posi” para la coincidencia de procedencia, sería un error conceptual, porque como se mencionó antes, puede haber mas de un producto que cumpla con la condición de igualdad de procedencias, por lo tanto, el proceso sería similar a un listado por condición, es decir que se deben mostrar datos siempre que se verifique una coincidencia entre la procedencia buscada y las almacenadas en el vector de procedencias. Al igual que en todos los Listados, se inicializa una variable para contar las filas que se imprimirán, en este caso, se coloca a la variable “fila” en el valor de 10, ya que líneas anteriores contienen los títulos y el ingreso de la procedencia a buscar. Una vez dentro del ciclo for, se pregunta en forma similar a la pregunta de la descripción, pero con las variables de procedencia: if(px.equalsIgnoreCase(procedencia[i])) { c.setCursor(8,10); c.print("Descripcion"); c.setCursor(9,10); c.print("-----------"); c.setCursor(8,30); c.print("Precio"); c.setCursor(9,30); c.print("------"); c.setCursor(fila,10); c.print(descripcion[i]); c.setCursor(fila,30); c.print(precio[i],8,2); fila++; } En caso de que coincidan las procedencias, se imprimen los títulos en las filas 8 y 9, y los vectores asociados con el índice que le corresponde a la posición indicada por la variable “i” del for a partir de la línea indicada por la variable “fila, o sea, 10. Además, se incrementa a la variable “fila” en una unidad para una próxima coincidencia. Fuera del for, se pregunta si la variable “fila” no ha variado su valor inicial, en este caso se inicializó en 10, y si es verdadero, significa que no se ha impreso ningún dato porque no hubo coincidencia, por lo tanto, se muestra la leyenda “No existe esa procedencia”. Por último, se pregunta al igual que en el método anterior, si se quiere realizar otra consulta.

– Algoritmos y Estructuras de Datos I –

- 171 -

– ISSD – EDUARDO MANSILLA –

Ejercicios Propuestos 10.1 En una empresa que tiene “n” empleados con los siguientes datos: Legajo, Nombre, Profesión y Sueldo, se deben realizar las siguientes operatorias: a) b) c) d) e) f) g)

Carga de los datos de cada empleado. Listado competo ordenado por nombre en cuatro columnas. Consulta por Legajo. Consulta por Nombre. Consulta por Profesión. Datos del la persona de mayor sueldo. Menú de opciones.

10.2 Un video club de la provincia de Córdoba, necesita llevar un sistema donde se carguen los siguientes datos: Cod Pel

Descripción

Genero

Cant de Copias

Copias alquiladas

1

Mision Imposible 3

1

4

3

2

Batman

2

9

5

:

:

:

:

:

Donde género:

1….Accion

2…..Terror

3…Documental

Se pide: a) b) c) d) e)

Ingresar N cantidad de datos, mediante un menú de opciones. Indicar cantidad de películas por género. Indicar la cantidad total de copias alquiladas. Mostrar un Listado de películas ordenadas por descripción. Por cada película indicar la cantidad de películas que quedan en stock, el stock de películas, está dado por la diferencia entre las Cant. de copias y las Copias alquiladas. Generar un vector llamado stock con esta información. f) Ingresar un Código de película mostrar todos sus datos. g) Mostrar que género se alquila mas. (Búsqueda del mayor). h) Mostrar un Listado ordenados por Código de película. i) Mostrar todas las películas que posean en Stock mas de 5 películas. j) Realizar una consulta por descripción. k) Mostrar todas las películas en que el Stock es inferior a 3.

- 172 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

UNIDAD Nº 5:

Arreglos Bidimensionales

TEMAS: Matrices Carga e impresión Procesamiento de Matrices

Clase

11

Clase Número: 11

Arreglos Bidimensionales Un arreglo es Bidimensional, cuando se necesitan dos variables de posición para identificar un elemento determinado, por ejemplo, un tablero de ajedrez es una Matriz Bidimensional, porque para indicar en que lugar se sitúa una determinada pieza, se necesita indicar en que Fila y Columna se encuentra. Las Matrices bidimensionales pueden se cuadradas o rectangulares. Son matrices cuadradas, cuando la cantidad de Filas es igual a la cantidad de Columnas y las matrices rectangulares son aquellas en que la cantidad de Filas es distinta a la cantidad de columnas. En Java existe un tipo más de Matrices en lo que respecta a la disposición y cantidad de elementos de cada columna, llamada matrices Dentadas, las cuales están fuera del alcance de este apunte. Se debe tener en cuenta que tanto las Filas como las columnas de una Matriz, comienzan desde la posición cero y no desde uno. Ejemplo, supongamos que se quiere almacenar 5 notas de alumnos de 4 cursos, la matriz sería como la siguiente: Alumno Nro.

Cursos



0

1

2

3

4

0

7

5

8

9

6

1

8

9

6

7

8

2

9

9

8

7

8

3

7

9

6

8

7

Los 4 cursos estarían identificados desde la posición cero hasta la posición 3 y las 5 notas de los alumnos de cada curso, desde la posición cero hasta la posición 4. Por ejemplo, la nota en el curso 2 del alumno en la posición 3 es 7, es decir: nota[2,3] = 7

– Algoritmos y Estructuras de Datos I –

- 173 -

– ISSD – EDUARDO MANSILLA – De esta manera, se pueden identificar cada una de las notas, a través de la Fila y Columna en la cual se encuentran, por ejemplo: nota[0,0] = 7; nota[0,1] = 5; nota[0,2] = 8 ; nota[0,3] = 9 ; nota[0,4] = 6 nota[1,0] = 8; nota[1,1] = 9; nota[1,2] = 6 ; nota[1,3] = 7 ; nota[1,4] = 8 y así sucesivamente…

Carga e impresión de una Matriz Para realizar la carga de una Matriz en memoria, se deben realizar dos ciclos for, uno dentro del otro, tanto para las Filas como para las Columnas, de manera que cuando el primer for se encuentre en la fila cero, el segundo for varíe entre cero y la cantidad de columnas que tenga la matriz. Ejemplo Nro. 47: Realizar la carga e impresión de una Matriz de componentes enteras, que representan las notas de alumnos de diferentes cursos. cargarMatriz ( )

i = 0;

Falso

i < fila ; i++ Verdadero

j = 0;

j < col ; j++

Falso

Verdadero

nota [i][j]

Fin

La explicación de este método es la siguiente: Se comienza ingresando al primer for, en donde se le asigna a la variable “i” el valor de cero, luego se ingresa en el segundo for, en donde se le asigna a la variable “j” el valor de cero, hasta este momento, tanto “i” como “j” valen cero, por lo tanto, el valor que se pedirá en el símbolo de introducción de datos, será almacenado en la variable nota[0,0].

- 174 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Es decir, que se almacenará en un lugar llamado nota y dentro del él, en la Fila cero y Columna cero. Luego, siguiendo la flecha del diagrama, se accede nuevamente al segundo for, en donde se incrementa el valor de la variable “j” en una unidad, pasando ahora a tener el valor de uno. Si el valor de esta variable “j” es menor al valor de la variable “fila”, se vuelve a pedir otro dato. Este nuevo dato ingresado, será almacenado en la variable nota[0,1], porque “j” vale uno, es decir en el lugar llamado nota en la Fila cero y en la Columna 1. Se continúa sucesivamente ingresando valores almacenándolos en la Fila cero y en las columnas 1, 2, 3, etc., de acuerdo a los valores que vaya tomando la variable “fila”. Cuando se terminó el segundo for, observando el diagrama, se accede al primer ciclo for, incrementándose en este momento la variable “i”, pasando a valer uno, por lo tanto, se estará ahora en la Fila 1. Se ingresa nuevamente en el segundo for, y se debe tener en cuenta, que cada vez que se ingresa a un ciclo for, se le da a la variable en cuestión, el valor inicial, es decir que la variable “j” vuelve a tener el valor de cero. Por lo tanto, se vuelve a repetir el ciclo for para la variable “j”, variando desde cero hasta la cantidad de columnas menos una, y pidiendo datos nuevamente, pero esta vez, almacenándolos en la Fila 1. El proceso se repite hasta que la que la variable “i” del primer for alcance las cantidades de filas a procesar. El método de impresión es similar al de carga, con la diferencia que, en vez de colocar el símbolo de introducción de datos, se coloca el símbolo de impresión.

imprimirMatriz ( )

i = 0;

i < fila ; i++

Falso

Verdadero

j = 0;

j < col ; j++

Falso

Verdadero

nota [i][j]

Fin

El programa se puede observar en la página siguiente.

– Algoritmos y Estructuras de Datos I –

- 175 -

– ISSD – EDUARDO MANSILLA – import hsa.Console; import java.awt.*; class Ejemplo47 { static Console c; int [] [] nota; int fila; int col; Ejemplo47 () { c.print ("Ingrese la cantidad de filas de la Matriz: "); fila = c.readInt (); c.print ("Ingrese la cantidad de columnas de la Matriz: "); col = c.readInt (); nota = new int[fila][col]; } void cargarMatriz () { c.clear (); c.println ("Cargue las Notas"); c.println (); for (int i = 0 ; i < fila ; i++) { for (int j = 0 ; j < col ; j++) { c.print ("Ingrese nota[" + i + "," + j + "]: "); nota [i] [j] = c.readInt (); } c.println (); } c.println (); } void imprimirMatriz () { c.clear (); c.println ("Impresion las Notas"); c.println ("-------------------"); c.println (); for (int i = 0 ; i < fila ; i++) { for (int j = 0 ; j < col ; j++) { c.print ( " " + nota [i][j]); } c.println(); } c.println (); c.readChar(); } public static void main (String arg []) { - 176 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

}

}

c = new Console (); Ejemplo47 e = new Ejemplo47 (); int op; c.setTextBackgroundColor (Color.cyan); c.clear (); e.cargarMatriz(); e.imprimirMatriz(); System.exit(0);

Programa en ejecución cuando se está ingresando los datos de la Matriz

– Algoritmos y Estructuras de Datos I –

- 177 -

– ISSD – EDUARDO MANSILLA –

Programa en ejecución cuando se muestran los datos de la Matriz

Procesamiento de Matrices Ejemplo Nro. 48: Agregar al ejemplo anterior los siguientes métodos: a) Generar e imprimir un vector en el que cada componente sea el promedio de las notas de cada curso. Ejemplo: Vector Generado Alumno Nro.

Cursos



0

1

2

3

4

0

7

5

8

9

6

7

1

8

9

6

7

8

7,60

2

9

9

8

7

8

8,20

3

7

9

6

8

7

7,40

b) Indicar cual es el curso de mayor promedio. Ejemplo: El curso de mayor promedio es el número: 2 c) Promedio general de todos los cursos. Ejemplo: El promedio de todos los cursos es: 7,55

- 178 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

generarVector ( )

i = 0;

i < fila ; i++

Punto a) Falso

Verdadero

suma = 0

j = 0;

j < col ; j++

Falso

Verdadero

suma = suma + nota[i][j]

promedio = suma / col v [i] = promedio

Fin

void imprimirVector ( )

i = 0; i < fila; i++

Falso

Verdadero

v [i]

Fin

– Algoritmos y Estructuras de Datos I –

- 179 -

– ISSD – EDUARDO MANSILLA – void mayor ( )

Punto b)

m = v [0] p=0 Falso

i = 1; i < fila; i++ Verdadero Falso

Verdadero

fila [i] > m

m = fila [i] p=i

“El curso de mayor promedio es el: “+ p

Fin

promedioDeTodosLosCursos ( )

Punto c)

suma = 0

i = 0;

i < fila ; i++

Falso

Verdadero

suma = suma + v [i]

promedio = suma / fila Fin

- 180 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – import hsa.Console; import java.awt.*; class Ejemplo48 { static Console c; int [] [] nota; float [] v; int fila; int col; Ejemplo48 () { c.print ("Ing. la cantidad de filas de la Matriz: "); fila = c.readInt (); c.print ("Ing. la cantidad de columnas de la Matriz: "); col = c.readInt (); nota = new int[fila][col]; v = new float[fila]; } void cargarMatriz () { c.clear (); c.println ("Cargue las Notas"); c.println (); for (int i = 0 ; i < fila ; i++) { for (int j = 0 ; j < col ; j++) { c.print ("Ingrese nota[" + i + "," + j + "]: "); nota [i] [j] = c.readInt (); } c.println (); } c.println (); } void imprimirMatriz () { c.clear (); c.println ("Impresion las Notas"); c.println ("-------------------"); c.println (); for (int i = 0 ; i < fila ; i++) { for (int j = 0 ; j < col ; j++) { c.print ( " " + nota [i][j]); } c.println(); } c.readChar(); }

– Algoritmos y Estructuras de Datos I –

- 181 -

– ISSD – EDUARDO MANSILLA – void generarVector() { for (int i=0; im) { m=v[i]; p=i; } c.println(); c.println("El curso de mayor promedio es el: " + p); c.readChar(); } void promedioDeTodosLosCursos() { float suma=0; for(int i=0; i
- 182 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – public static void main (String arg []) { c = new Console (); Ejemplo48 e = new Ejemplo48 (); int op; c.setTextBackgroundColor (Color.cyan); c.clear (); e.cargarMatriz(); e.imprimirMatriz(); e.generarVector(); e.imprimirVector(); e.mayor(); e.promedioDeTodosLosCursos(); System.exit(0); } } La solución del programa sería una pantalla similar a la siguiente:

Es muy útil en la matemática encontrar la diagonal principal de una matriz cuadrada. Una matriz cuadrada es aquella en que la cantidad de filas es igual a la cantidad de columnas. En el siguiente ejemplo, se realiza el proceso de la diagonal principal.

– Algoritmos y Estructuras de Datos I –

- 183 -

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 49: Cargar una matriz cuadrada y obtener la suma de su diagonal principal. Además, intercambiar la primera fila con la última fila.

sumaDiagonalPrincipal ( ) suma = 0

i = 0;

i < fila ; i++

Falso

Verdadero

suma = suma + m[i][i]

suma

Fin

intercambiarFilas ( )

j = 0;

j < col ; j++

Falso

Verdadero

auxi = m[0][j] m[0][j] = m[fila-1][j] m[fila-1][j] = auxi

Fin

- 184 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – import hsa.Console; import java.awt.*; class Ejemplo49 { static Console c; int [] [] m; int fila; int col; Ejemplo49 () { c.print("Cantidad de filas de la Matriz cuadrada: "); fila = c.readInt (); col = fila; m = new int[fila][col]; } void cargarMatriz () { c.clear (); c.println ("Cargue las Notas"); c.println (); for (int i = 0 ; i < fila ; i++) { for (int j = 0 ; j < col ; j++) { c.print ("Ingrese m[" + i + "," + j + "]: "); m [i] [j] = c.readInt (); } c.println (); } c.println (); } void imprimirMatriz () { c.println ("Impresion la Matriz"); c.println ("-------------------"); c.println (); for (int i = 0 ; i < fila ; i++) { for (int j = 0 ; j < col ; j++) { c.print ( " " + m [i][j]); } c.println(); } c.readChar(); }

– Algoritmos y Estructuras de Datos I –

- 185 -

– ISSD – EDUARDO MANSILLA – void sumaDiagonalPrincipal() { int suma = 0; for (int i=0; i
}

public static void main (String arg []) { c = new Console (); Ejemplo49 e = new Ejemplo49 (); c.setTextBackgroundColor (Color.cyan); c.clear (); e.cargarMatriz(); c.clear(); e.imprimirMatriz(); e.sumaDiagonalPrincipal(); e.intercambiarFilas(); c.println(); c.println("La matriz intercambiadas las filas es: "); e.imprimirMatriz(); System.exit(0); }

Explicación: El método de sumar los elementos de la diagonal principal consiste simplemente en un ciclo for y dentro de él, un acumulador para sumar los elementos que se encuentran en la posición [i][i], es decir en la posición donde coincidan las filas con las columnas, ya que esos son los elementos de la diagonal principal. El método de intercambiar la primera fila con la última tiene en cuenta una variable auxiliar para guardar el valor del elemento de la primera fila. Este método consiste en recorrer las columnas intercambiando elemento por elemento. Observar que la última fila está dada por: [fila-1], ya que, si se tienen por ejemplo 5 filas, como están enumeradas de la cero a la 4, la última será la fila número 4.

- 186 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – Si se ingresa una matriz cuadrada de 3x3, o sea, 3 filas y 3 columnas, la salida sería similar a la siguiente pantalla:

Ejercicios Propuestos 12.3 - Realizar un programa para que reciba, desde teclado, una matriz NxN de números enteros, luego calcule y escriba la suma de todas las filas y todas las columnas. 12.3 - Desarrollar un programa que permita obtener el mayor elemento de una matriz de 4x3 componentes, e informe la posición que ocupa dentro de la matriz (fila y columna del mayor). 12.3 - Cargar una matriz de 5x5 y realizar lo siguiente: a) Imprimir la matriz. b) Intercambiar la primera columna con la última. c) Promedio de los elementos de la última columna.

– Algoritmos y Estructuras de Datos I –

- 187 -

– ISSD – EDUARDO MANSILLA – 12.3 - Simular un tablero de ajedrez, o sea, una matriz de 8x8 casilleros. Se deberá colocar en cada casillero un valor numérico de la siguiente manera: El valor que se deberá colocar en un casillero estará formado por el doble del casillero anterior, comenzando en el casillero 1 con el número 1. Ejemplo: 1

2

4

8

16

32

64

Mostrar la matriz generada. 12.3 - Cargar una matriz de 4x4. Luego ingresar una fila (de cero a 3) y generar un vector con los elementos de esa fila. Mostrar la matriz ingresada y el vector generado. 12.3 - Cargar una matriz de 5x5 y determinar todos los valores pares, imprimiendo el valor y su posición que ocupa dentro de la matriz. 12.3 - Dada una matriz cuadrada de NxN de valores enteros, se deberá ingresar una columna y determinar el promedio de la misma. 12.3 - Desarrollar un programa que permita los siguiente: a) Cargar una matriz de 3x4 elementos. b) Mostrar la matriz cargada. c) Permitir ingresar una fila y que muestre la cantidad de múltiplos de 3 de esa fila. d) Permitir ingresar una columna y que muestre la cantidad de impares de esa columna.

- 188 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

UNIDAD Nº 5:

Clase

TEMAS: Matrices y Vectores paralelos

Arreglos Bidimensionales

12

Clase Número: 12

Matrices y Vectores Paralelos Como ya se vio en clases anteriores, dos o más vectores son paralelos cuando hay una relación entre las componentes de igual subíndice (misma posición) de cada uno de ellos. Generalmente cuando se trabaja con Matrices y vectores paralelos, se establece una relación entre los elementos del vector y las filas o columnas de la matriz. Por ejemplo, supongamos que se desea almacenar en una matriz las producciones de trigo de algunas provincias en determinados años. Se podría establecer a las provincias relacionadas con las filas de la matriz y a los años con las columnas de la matriz de la siguiente manera: 2005

2006

2007

2008

2009

Buenos Aires

150

210

180

130

200

Tucumán

190

220

170

160

180

Córdoba

170

190

160

180

190

Catamarca

180

200

190

140

210

Por lo tanto, se puede conocer perfectamente para cada provincia en un determinado año, el valor de la producción anual. Por ejemplo, para la provincia de Tucumán en el año 2006, la producción fue de 220 toneladas de trigo. En este caso se tienen dos estructuras de datos, un vector de tipo String, en el cual se almacenarán las Provincias, y una matriz de valores enteros, para almacenar las producciones anuales. También se podría haber descripto un vector para almacenar los años.

– Algoritmos y Estructuras de Datos I –

- 189 -

– ISSD – EDUARDO MANSILLA – Ejemplo Nro. 50: Definir las estructuras de datos del ejemplo anterior, para realizar un programa con las siguientes alternativas: a) Carga de datos del vector de Provincias y de la Matriz de Producciones. b) Impresión según el ejemplo. c) Determinar la producción total para cada provincia generando un vector con dicho total. d) ¿Cuál fue la provincia de mayor Producción? e) ¿Cuál fue la provincia de menor Producción? f) Imprimir dos columas, provincia y producción total ordenada por Provincia. import hsa.Console; import java.awt.*; class Ejemplo50 { static Console c; String [] provincias; int [] [] m; int fila; int col; int [] total; Ejemplo50 () { fila = 4; col = 5; provincias = new String [fila]; m = new int [fila] [col]; total = new int [fila]; } void cargarMatriz () { c.clear (); c.setCursor (1, 25); c.print ("Produccion de trigo"); c.setCursor (2, 25); c.print ("-------------------"); c.println (); c.setCursor (3, 3); c.print ("Provincias"); c.setCursor (4, 3); c.print ("----------"); int linea = 3; int columna = 20; int anio = 2005; for (int j = 0 ; j < col ; j++) { c.setCursor (linea, columna); c.print (anio); c.setCursor (linea + 1, columna);

- 190 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – c.print ("----"); columna = columna + 10; anio++;

}

} linea = 5; for (int i = 0 ; i < fila ; i++) { c.setCursor (linea, 3); provincias [i] = c.readLine (); columna = 20; for (int j = 0 ; j < col ; j++) { c.setCursor (linea, columna); m [i] [j] = c.readInt (); columna = columna + 10; } linea++; }

void totalPorProvincia () //Punto c { c.setCursor (3, 72); c.print ("Total"); c.setCursor (4, 72); c.print ("-----"); int linea = 5; int columna = 72; int suma; for (int i = 0 ; i < fila ; i++) { suma = 0; for (int j = 0 ; j < col ; j++) { suma = suma + m [i] [j]; } total [i] = suma; c.setCursor(linea,72); c.print(total[i],5); linea++; } c.readChar (); } void provinciaDeMayorProduccion() { int mayor = total[0]; int posi = 0; for(int i=1; i mayor) { mayor=total[i]; posi = i; } }

// Punto d

– Algoritmos y Estructuras de Datos I –

- 191 -

– ISSD – EDUARDO MANSILLA –

}

c.print("La provincia de mayor produccion es: "); c.println(provincias[posi]); c.println("Con un valor de: "+total[posi]+" toneladas"); c.readChar();

void provinciaDeMenorProduccion() // Punto e { int menor = total[0]; int posi = 0; for(int i=1; i0) { auxiP = provincias[i]; provincias[i] = provincias[i+1]; provincias[i+1] = auxiP; auxiT = total[i]; total[i] = total[i+1]; total[i+1] = auxiT; } } c.clear(); c.setCursor(2,20); c.print("Listado ordenado por Provincias"); c.setCursor(3,20); c.print("-------------------------------"); c.setCursor(4,10); c.print("Provincia"); c.setCursor(5,10); c.print("---------"); c.setCursor(4,30); c.print("Total de Produccion"); c.setCursor(5,30); c.print("-------------------"); int linea=7; for(int i=0; i
– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

}

}

} c.readChar(); public static void main (String arg []) { c = new Console (); Ejemplo50 e = new Ejemplo50 (); c.setTextBackgroundColor (Color.cyan); e.cargarMatriz (); e.totalPorProvincia (); c.println(); e.provinciaDeMayorProduccion(); e.provinciaDeMenorProduccion(); e.listado(); }

La carga de la matriz se diferencia de los métodos realizados anteriormente en el sentido de que, al realizarlo de esta manera, una vez realizada la carga, ya se tiene la matriz impresa, es mucho mas ordenado que las cargas vistas es los ejemplos anteriores. En este proceso, se imprimen los títulos y el cursor va saltando de columna en columna para cargar los datos correspondientes. La primera parte: int linea = 3; int columna = 20; int anio = 2005; for (int j = 0 ; j < col ; j++) { c.setCursor (linea, columna); c.print (anio); c.setCursor (linea + 1, columna); c.print ("----"); columna = columna + 10; anio++; } Tiene por objeto mostrar los años desde el 2005 en adelante, observar que, en el ciclo, el cursor se mantiene siempre en la misma fila, indicada con la línea = 3, lo que varia es la columna de 10 en 10 lugares, por lo tanto, esta fracción de programa, muestra a modo de título subrayado los números del 2005 hasta el 2009.

– Algoritmos y Estructuras de Datos I –

- 193 -

– ISSD – EDUARDO MANSILLA – La segunda parte del método cargarMatriz ( ): linea = 5; for (int i = 0 ; i < fila ; i++) { c.setCursor (linea, 3); provincias [i] = c.readLine (); columna = 20; for (int j = 0 ; j < col ; j++) { c.setCursor (linea, columna); m [i] [j] = c.readInt (); columna = columna + 10; } linea++; } Realiza el ingreso de datos específicamente, de la siguiente manera: El primer for varia las filas y permite cargar el vector de las provincias, ubicándose el cursor en primera instancia, en la línea 5 y columna 3. El for más interno es para la variación de las columnas y poder realiza la carga por fila, de los elementos de la matriz. Los demás procesos ya han sido vistos en forma independientes, queda por parte del alumno, analizarlos y practicarlos. La primera ejecución del programa, arrojaría los siguientes resultados:

- 194 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – La segunda parte de la ejecución del programa, mostraría:

Ejemplo Nro. 51: En un comercio de 4 empleados, se han registrados sus nombres y sus sueldos en los primeros tres meses del año, como se indica a continuación: Enero

Febrero

Marzo

Javier

3540.60

2600.60

5467,60

Marcelo

3843,65

4365,24

4654,66

Alejandro

5376,43

4763,35

6543,55

Ricardo

3521,67

3573,44

4365,77

Nombres

Sueldos

Realizar la siguiente operatoria: a) Carga e impresión de los datos según ejemplo. b) Mostrar los totales por mes que abonó el comercio. c) Realiza una consulta por Nombre de empleado, mostrando los tres sueldos que le corresponden. d) Mostrar el total de sueldo de todos los empleados en los tres meses.

– Algoritmos y Estructuras de Datos I –

- 195 -

– ISSD – EDUARDO MANSILLA – import hsa.Console; import java.awt.*; class Ejemplo51 { static Console c; String [] nombres; float [] [] sueldos; int fila; int col; Ejemplo51 () { fila = 4; col = 3; nombres = new String [fila]; sueldos = new float [fila] [col]; } void cargarMatriz () { c.clear (); c.setCursor (1, 25); c.setCursor (3, 3); c.print ("Nombres"); c.setCursor (4, 3); c.print ("-------"); int linea = 3; int columna = 25; c.setCursor (linea, columna); c.print ("Enero"); c.setCursor (linea + 1, columna); c.print ("-----"); columna = columna + 15; c.setCursor (linea, columna); c.print ("Febrero"); c.setCursor (linea + 1, columna); c.print ("-------"); columna = columna + 15; c.setCursor (linea, columna); c.print ("Marzo"); c.setCursor (linea + 1, columna); c.print ("-----"); linea = 5; for (int i = 0 ; i < fila ; i++) { c.setCursor (linea, 3); nombres [i] = c.readLine (); columna = 25; for (int j = 0 ; j < col ; j++) { c.setCursor (linea, columna); sueldos [i] [j] = c.readFloat (); columna = columna + 15; } linea++; - 196 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

}

}

void totalPorMes () //Punto a { int linea = 11; int columna = 22; float suma; for (int j = 0 ; j < col ; j++) { suma = 0; for (int i = 0 ; i< fila ; i++) { suma = suma + sueldos [i] [j]; } c.setCursor(linea,columna); c.print(suma,8,2); columna = columna + 15; } c.readChar (); } void consultaPorNombre() { c.setCursor(13,10); c.print("Ingrese el nombre a buscar: "); String nx = c.readLine(); int posi = -1; for(int i = 0; i
- 197 -

– ISSD – EDUARDO MANSILLA – {

} c.setCursor(20,10); c.print("El sueldo total de todos los empleados es: $ "); c.println(total,0,2); c.readChar();

}

}

for (int j=0; j
public static void main (String arg []) { c = new Console (); Ejemplo51 e = new Ejemplo51 (); e.cargarMatriz (); e.totalPorMes(); e.consultaPorNombre(); e.sueldoTotal(); }

- 198 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Ejercicios Propuestos 12.1 - Se desea registrar la producción de petróleo de los países que integran el Mercosur en los últimos cinco años. Elegir las estructuras de datos adecuadas: ♦ Para el almacenamiento de las denominaciones de los países. ♦ Para el almacenamiento de las producciones anuales de cada país (en los últimos cinco años). a) Realizar un procedimiento para la carga de datos. (carga de países y las producciones de los mismos en los últimos cinco años) b) Obtener la producción promedio de cada país en los últimos 5 años. c) Listar los países que incrementaron la producción (para ello tener en cuenta únicamente la producción del primero y quinto año, o sea si la producción del quinto año es superior al primero se imprime). d) Listar en orden alfabético los países y la producción media de cada país. Argentina

156

130

180

210

220

Brasil

250

275

280

260

320

Paraguay

110

130

120

140

100

:

:

:

:

:

:

12.2 - En una ferretería se realizó una estadística de las herramientas que comercializó en el segundo semestre del año en curso. Los datos se almacenan según el esquema. Las filas representan al código de una herramienta en particular y las columnas, los meses del semestre. Códigos 0 1 .... .... 999

jul

ago

sept

oct

nov

dic

7 25 14 30 60 95 15 20 18 35 50 40 ............................. ..... .................................. 10 30 15 36 55 75

Se deberán realizar las siguientes operatorias: a) Carga de datos: vector de meses, vector de códigos y matriz de valores. b) Impresión de los datos según esquema. c) Cantidad total de cada una de las herramientas vendidas. d) ¿Cuál es la herramienta que más se vendió en el semestre? e) Ingresar por teclado el código de una herramienta y mostrar cuantas se vendieron en el mes de noviembre. – Algoritmos y Estructuras de Datos I –

- 199 -

– ISSD – EDUARDO MANSILLA – f) Informar los cuatro meses que más venta de herramientas hubo. (ordenados de mayor a menos) 12.3 - Un laboratorio necesita llevar el control de sus visitadores médicos, como asi también la recaudación en pesos de los mismos por zona, para ello se cuentan con los siguientes datos, organizados en las estructuras correspondientes: Cod 001 005 ……

Visitador Juan Perez Julian Juarez ….

Norte 1500 3500 ….

Monto vendido en $ por zona Sur Ctro Oeste 3800 4000 … …. …

Este 1700 500 ..

Se pide: a. Ingresar N Visitadores indicados por teclado, manejar todos los procesos mediante un menú de opciones. b. Monto recaudado por Visitador, el mismo debe ser incorporado en un vector llamado recaudación. c. Indicar el monto recaudado por Zona. d. Ingresar un Visitador mostrar las ventas en cada una de las zonas. e. Ingresa una Zona y muestrar todos los visitadores con sus ventas. f. Realiza un listado acotado por un rango de códigos (desde-hasta), muestra todos los visitadores pertenecientes a él con sus montos vendidos por zona. g. Determinar el Monto promedio de ventas por zona.

- 200 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Anexo Constantes y Métodos Matemáticos Class Math Constantes public final static double E; public final static double PI;

Métodos public static double abs(double a); public static float abs(float a); public static int abs(int a); public static long abs(long a); public static double acos(double a); public static double asin(double a); public static double atan(double a); public static double atan2(double a, double b); public static double ceil(double a); public static double cos(double a); public static double exp(double a); public static double floor(double a); public static double IEEEremainder(double f1, double f2); public static double log(double a); public static double max(double a, double b); public static float max(float a, float b); public static int max(int a, int b); public static long max(long a, long b); public static double min(double a, double b); – Algoritmos y Estructuras de Datos I –

- 201 -

– ISSD – EDUARDO MANSILLA – public static float min(float a, float b); public static int min(int a, int b); public static long min(long a, long b); public static double pow(double a, double b); public static double random(); public static double rint(double a); public static long round(double a); public static int round(float a); public static double sin(double a); public static double sqrt(double a); public static double tan(double a);

- 202 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA –

Modelo de Examen Final EXAMEN FINAL Carrera:

ANALISTA DE SISTEMAS

Materia:

Modalidad:

P-S-D

ALGORITMOS Y ESTRUCTURAS DE DATOS 1

Alumno: PROFESOR:

FECHA:

PUNTAJE OBTENIDO:

NOTA DEFINITIVA:

Realizar la carga de una matriz de 3 x 5, en donde cada componente indica la producción de uvas en toneladas en cada provincia. Cargar además en un vector las provincias intervinientes.

Cordoba Chubut Salta

Lunes

Martes

Miércoles

Jueves

Viernes

120 150 160

200 180 190

180 120 110

150 140 100

100 160 130

Realizar las siguientes operatorias: 1- Mostrar los totales por provincia. 2- Ingresar un día de la semana y mostrar la suma de las producciones para ese día. 3- Indicar el día y la provincia a la cual le corresponde la mayor producción.

Puntajes para Alumnos regulares: Impresión en pantalla y punto 1: 35% ; Punto 2: 30% ; Punto 3: 35%

Alumnos Libres: 4- Ingresar una provincia y un día de la semana y mostrar la producción que le corresponde. Puntajes para Alumnos Libres: Impresión en pantalla y punto 1: 25% Punto 2: 25% Punto 3: 25% Punto 4: 25%

– Algoritmos y Estructuras de Datos I –

- 203 -

– ISSD – EDUARDO MANSILLA – Solución: import hsa.Console; class Examen { static Console c; int [] [] matriz; String [] provincia; String [] dia; Examen () { matriz = new int [3] [5]; provincia = new String [3]; dia = new String [5]; } void cargarMatriz () { int fil, col; for (fil = 0 ; fil < 3 ; fil++) { for (col = 0 ; col < 5 ; col++) { c.print ("Ingrese componente [" + (fil + 1) + "] [" + (col + 1) + "]: "); matriz [fil] [col] = c.readInt (); } } } void cargarProvincias () { c.clear (); int fil; for (fil = 0 ; fil < 3 ; fil++) { c.print ("Ingrese provincia " + (fil + 1) + ": "); provincia [fil] = c.readLine (); } } void cargarDias { dia [0] = dia [1] = dia [2] = dia [3] = dia [4] =

- 204 -

() "Lunes"; "Martes"; "Miercoles"; "Jueves"; "Viernes";

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – }

void imprimirMatriz () { c.clear (); int fil, col, ff, cc; ff = 3; cc = 13; for (col = 0 ; col < 5 ; col++) { c.setCursor (ff, cc); c.print (dia [col]); cc = cc + 10; }

}

ff = 5; for (fil = 0 ; fil < 3 ; fil++) { cc = 15; c.setCursor (ff, 5); c.print (provincia [fil]); for (col = 0 ; col < 5 ; col++) { c.setCursor (ff, cc); c.print (matriz [fil] [col]); cc = cc + 10; } ff = ff + 1; }

void totalesPorProvincia () { int fil, col, total; int ff = 5; c.setCursor (3, 68); c.print ("Totales"); for (fil = 0 ; fil < 3 ; fil++) { total = 0; for (col = 0 ; col < 5 ; col++) { total = total + matriz [fil] [col]; } c.setCursor (ff, 70); c.print (total); ff = ff + 1; } } void sumaDeProducciones () { – Algoritmos y Estructuras de Datos I –

- 205 -

– ISSD – EDUARDO MANSILLA – c.setCursor (11, 15); c.print ("Ingrese dia de la semana para ver su produccion: "); String dx = c.readLine (); int posi = -1; int col; for (col = 0 ; col < 5 ; col++) { if (dx.equalsIgnoreCase (dia [col])) posi = col; } if (posi != -1) { int suma = 0; int fil; for (fil = 0 ; fil < 3 ; fil++) { suma = suma + matriz [fil] [posi]; } c.setCursor (12, 15); c.print ("La produccion para el " + dx + " es de: " + suma); } else { c.setCursor (12, 15); c.print ("Dia incorrecto"); } } void mayorProduccion() { int fil, col, posiF, posiC; posiF = 0; posiC = 0; int m = matriz[0][0]; for (fil=0; fil<3; fil++) { for (col=0; col<5; col++) { if(matriz[fil][col]>m) { m = matriz[fil][col]; posiF=fil; posiC=col; } } } c.setCursor (14, 15); c.print ("La mayor produccion le corresponde a la provincia: " + provincia[posiF]); c.setCursor (15,15); c.print ("En el dia " + dia[posiC]); } // Para los alumnos libres - 206 -

– Algoritmos y Estructuras de Datos I –

– ISSD – EDUARDO MANSILLA – void punto4() { String px, dx; c.setCursor (17,15); c.print ("Ingrese provincia: "); px = c.readLine(); c.setCursor (18,15); c.print ("Ingrese dia: "); dx = c.readLine(); int posiF, posiC; posiF = posiC = -1; if (px.equalsIgnoreCase(provincia[0])) posiF=0; else if (px.equalsIgnoreCase(provincia[1])) posiF=1; else if (px.equalsIgnoreCase(provincia[2])) posiF=2; int col; for (col = 0 ; col < 5 ; col++) { if (dx.equalsIgnoreCase (dia [col])) posiC = col; } if (posiF != -1 && posiC != -1) { c.setCursor (19, 15); c.print ("Le corresponde una produccion de: " + matriz[posiF][posiC]) ; } else { c.setCursor (19, 15); c.print ("Ingreso de datos incorrectos"); } }

}

public static void main (String [] args) { c = new Console (); Examen e = new Examen (); e.cargarMatriz (); e.cargarProvincias (); e.cargarDias (); e.imprimirMatriz (); e.totalesPorProvincia (); e.sumaDeProducciones (); e.mayorProduccion(); e.punto4(); }

– Algoritmos y Estructuras de Datos I –

- 207 -

– ISSD – EDUARDO MANSILLA –

- 208 -

– Algoritmos y Estructuras de Datos I –