Apunte de AED1 PDF

ALGORITMOSYYESTRUCTURAS
ALGORITMOS ESTRUCTURAS DE
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 –

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
CLASE NÚMERO: 3 _____________________________________________ 35

ESTRUCTURA CONDICIONAL ANIDADA ________________________________ 35
ACTIVIDADES ____________________________________________________ 41
INSTRUCCIÓN SWITCH - CASE _______________________________________ 45
Comentarios___________________________________________________ 49
Comentarios de varias líneas ____________________________________ 49
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-

Ingreso de valores hasta que se digite una clave ______________________ 67

CLASE NÚMERO: 5 _____________________________________________ 71

ESTRUCTURA FOR ________________________________________________ 71
ACTIVIDADES ___________________________________________________ 80
Búsqueda del mayor de una serie de números ingresados. ______________ 82
CLASE NÚMERO: 6 _____________________________________________ 87

ESTRUCTURA DO..WHILE __________________________________________ 87
Concepto De Bandera __________________________________________ 93
Posicionamiento del Cursor ______________________________________ 93
Generación de números aleatorios ________________________________ 96
CLASE NÚMERO: 7 ____________________________________________ 101

ARRAY _______________________________________________________ 101
Introducción _________________________________________________ 101
Vectores ____________________________________________________ 102
Carga e Impresión de un Vector _________________________________ 102
EJERCICIOS PROPUESTOS _____________________________________ 116
CLASE NÚMERO: 8 ____________________________________________ 117

MÉTODOS EN JAVA ______________________________________________ 117
Introducción _________________________________________________ 117
CLASES EN JAVA ________________________________________________ 118
ZONAS DE UN PROGRAMA COMPLETO EN JAVA ________________________ 118
MÉTODO QUE DEVUELVEN O RETORNAN UN VALOR _____________________ 122
Vectores utilizando Métodos ____________________________________ 123
VECTORES PARALELOS ___________________________________________ 131
CLASE NÚMERO: 9 ____________________________________________ 137

PROCESOS ALGORÍTMICOS ________________________________________ 137
MAYOR Y MENOR ELEMENTO DE UN VECTOR _________________________ 137
Funciones básicas para el manejo de cadenas de caracteres ___________ 142
Busqueda de un elemento en un vector ____________________________ 143
Ordenamiento de Vectores ______________________________________ 147
CLASE NÚMERO: 10 ___________________________________________ 159

ORDENAMIENTO CON VECTORES PARALELOS _________________________ 159
CONSULTAS EN VECTORES PARALELOS ______________________________ 165

CLASE NÚMERO: 11 ___________________________________________ 173

ARREGLOS BIDIMENSIONALES ______________________________________ 173
CARGA E IMPRESIÓN DE UNA MATRIZ ________________________________ 174
PROCESAMIENTO DE MATRICES _____________________________________ 178
CLASE NÚMERO: 12 ___________________________________________ 189

MATRICES Y VECTORES PARALELOS _________________________________ 189
ANEXO ________________________________________________________ 201
CONSTANTES Y MÉTODOS MATEMÁTICOS ____________________________ 201
Class Math ___________________________________________________ 201
MODELO DE EXAMEN FINAL _______________________________________ 203


TEMAS:
UNIDAD Nº 1: Clase
Conceptos Principales.
1
Introducción a la Diagramación.
lógica y la Programación.
programación Tipos de Variables.
Estructuras Secuenciales.
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

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 Acción que realiza

Muestra la Dirección y
Líneas de Flujo Sentido del flujo del
proceso, conectando cada
uno de los símbolos.
Comienzo o final de En su interior, se coloca

Proceso Inicio o Fin del Diagrama
Se utiliza para ingresar

Introducción de Datos datos. En su interior, se
detalla la variable a
ingresar.
Se utiliza cuando se
Símbolo de Asignación quiere asignar un valor a
una variable.

Símbolo Nombre Acción que realiza

Se utiliza cuando se desea
Símbolo de impresión imprimir una
determinada información.
Se utiliza cuando se debe

Toma de Decisión decidir que camino
corresponde seguir.
En su interior se coloca
Conector 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á.

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 definir la variable sueldo.

Conceptualmente se tendría lo siguiente:
Dato almacenado
5800
Variable (Pertenece al tipo numérico)
sueldo
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 –

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 -

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 Operador

Suma +
Resta -
Multiplicación *
División /
Resto de División %
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.

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
En este caso, se ingresa el valor
de un lado del cuadrado,
lado mediante el símbolo de
Introducción de Datos
(paralelogramo), luego se
superficie = lado * lado calcula la superficie como el
producto de lado por lado, en el
símbolo rectángulo, y por
último se imprime el resultado
superficie de la superficie.
Fin

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:

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 Esta asignación se coloca como está
importe c.println (importe);
Fin }
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.

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

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 lado = c.readFloat();
superficie = lado * lado superficie = lado * lado
superficie c.println(“La superficie es: “ + superficie);
Fin }

Ejemplo Nro. 3 : Ingresar tres nombres con sus respectivas altura y

determinar e imprimir, la altura promedio.
Inicio
En el símbolo de introducción
de datos, se pueden colocar
más de una variable, pero se
n1, a1
debe tener en cuenta que por
cada variable, se debe tener
una instrucción read en el
n2, a2 programa.
En este caso será:

n3, a3
n1 = c.readLine();
a1 = c.readInt();
promedio = (a1 + a2 + a3) / 3
Nota: para pedir in dato de

promedio tipo String, se utilizará la
instrucción c.readLine(), que
significa leer una linea.
Fin

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();
a2 = c.readFloat();
c.print("Ingrese tercer nombre: ");

n3 = c.readLine();
a3 = c.readFloat();
promedio = (a1 + a2 + a3)/3;

c.println();
c.println("La altura promedio es: " + promedio);
}
}

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.

TEMAS: Clase
UNIDAD Nº 1:
2
Estructuras condicionales
Operadores relacionales.
Estructuras Condicional Simple y
condicionales. compuesta.
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:
Se puede observar que

la estructura tiene una
Falso Verdadero entrada y dos salidas,
Condición por el Falso y por el
Verdadero.
Si la condición en su
interior resulta
Sentencia 1; verdadera, el programa
Sentencia 2;
continuará ejecutando
:
Sentencia n; 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

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 En Matemática En Java

Igual = ==
Mayor > >
Menor < <
Mayor o Igual ≥ >=
Menor o Igual ≤ <=
Distinto o No Igual ≠ !=
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%.

Inicio
sueldo
descuento = 0
Falso Verdadero
sueldo > 5000
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);
}
}

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 Verdadero
promedio < 10
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.

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 Verdadero
Actividades a realizar, si la Actividades a realizar, si la

condición resultara falsa condición resultara verdadera

La codificación de esta fracción de diagrama en lenguaje Java seria de la

siguiente forma:
if ( Condición )
{
Sentencia1 ; Actividades a realizar si la
Sentencia2 ; condición es Verdadera
}
else
{
SentenciaX ; Actividades a realizar si la
SentenciaZ ; 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 n1 > n2 Verdadero
“El mayor es: “ + n2 “El mayor es: “ + n1
Fin

Desarrollo del programa:
import hsa.Console;
class Ejemplo6
{
static Console c;
{
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 operador “%”,
que devuelve el resto de una división, por ejemplo:
4%2=0 En estos ejemplos se tiene que: El resto de la

7%2=1 división del numero 4 con el número 2 es igual a
16 % 2 = 0 cero, lo mismo se puede observar que el resto de
21 % 2 = 1 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.

Inicio
Falso n % 2 == 0 Verdadero
“El número es impar” “El número es par”
Fin
import hsa.Console;
class Ejemplo7
{
static Console c;
{
int n;
c = new Console ();
c.print ("Ingrese un numero: ");

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

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 Nomenclatura Ejemplos

Y (And) && ( sueldo > 4000 && antiguedad < 10)
O (Or) || ( edad > 21 || dni > 25000000 )
No (Not) ! ( ! 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.

Inicio
dia
mes
Falso dia == 25 Verdadero

&& mes == 12
“No corresponde a Navidad” “Corresponde a Navidad”
Fin
import hsa.Console;
class Ejemplo8
{
static Console c;
{
int dia, mes;
c = new Console ();
c.print ("Ingrese dia: ");

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

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 && Verdadero

edad <=21
“Joven”
Falso edad >21 Verdadero
“Adulto”
Fin

El programa quedaría resuelto de la siguiente forma:
import hsa.Console;
class Ejemplo9
{
static Console c;
{
int edad;
c = new Console ();
c.print ("Ingrese la edad: ");

edad = c.readInt ();
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");
}
}
}

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:

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;
{
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.

TEMAS: Clase
UNIDAD Nº 1:
Estructuras
condicionales.
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 < 0 Verdadero
“Numero Nulo” “Numero Negativo”
Fin

import hsa.Console;
class Ejemplo10
{
static Console c;
{
int numero;
c = new Console ();

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”.

Inicio
nota1, nota2, nota3
prom = (nota1 + nota2 + nota3) / 3
Falso prom >= 7 Verdadero
“Promocionado”
Falso prom >= 4 Verdadero
“Reprobado” “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:

import hsa.Console;
class Ejemplo11
{
static Console c;
{
int nota1, nota2, nota3;
float prom;
c = new Console ();
c.print ("Ingrese Primer nota: ");

nota1 = c.readInt ();
c.print ("Ingrese Segunda nota: ");
c.print ("Ingrese 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

línea:
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.

Ejemplo Nro. 12: Ingresar tres números y determinar el mayor de ellos.
Inicio
n1
n2
n3
Falso n1 > n2 && Verdadero

n1 > n3
“El Mayor es: ” + n1

Falso n2 > n3 Verdadero
“El Mayor es: ” + n3 “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.

import hsa.Console;
class Ejemplo12
{
static Console c;
{
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)
{
}
else
{
}
}
}
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).

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.
y
1º Cuadrante: x > 0 , y>0
2º Cuadrante 1º Cuadrante
2º Cuadrante: x < 0 , y>0
3º Cuadrante: x < 0 , y<0 x
4º Cuadrante: x > 0 , y<0 3º Cuadrante 4º Cuadrante
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: Porcentaje>=90%.

 Nivel medio: Porcentaje>=75% y <90%.
 Nivel regular: Porcentaje>=50% y <75%.
 Fuera de nivel: Porcentaje<50%.
3.4 – Ingresar un valor de frecuencia e indicar a que banda corresponde,

según la siguiente clasificación en telecomunicaciones:
SUBDIVISIÓN DE RANGO DE
BANDA
FRECUENCIA FRECUENCIA
ULF Frecuencia ultra baja 3 a 30 Hz
ELF Frecuencia extremadamente baja 30 a 300 Hz
ILF Frecuencia infra baja 300 Hz a 3 Khz
VLF Frecuencia muy baja 3 a 30 Khz
LF Frecuencia baja 30 a 300 Khz
MF Frecuencia media 300 Khz a 3 Mhz
HF Frecuencia alta 3 a 30 Mhz
VHF Frecuencia muy alta 30 a 300 Mhz
UHF Frecuencia ultra alta 300 Mhz a 3 Ghz
SHF Frecuencia super alta 3 a 30 Ghz
EHF Frecuencia extremadamente alta 30 a 300 Ghz

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
Falso valor1 == valor2 Verdadero

&& valor2 == valor3
suma = valor1 + valor2
multi = suma * valor3

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

Actividad 3.2
Inicio
Falso x > 0 && y > 0 Verdadero
“Primer Cuadrante”
Falso x<0 && y>0 Verdadero
“Segundo Cuadrante”
Falso x > 0 && y > 0 Verdadero
“Cuarto Cuadrante” “Tercer Cuadrante”
Fin

Actividad 3.3
Inicio
Nota: La variable nombre, debe ser

definida de tipo String, y para pedir un nombre
nombre, se lo debe hacer con la
instrucción readLine(), de la siguiente
manera: total
String nombre;
c.print("Ingrese nombre"); correctas
nombre = c.readLine();
por = (correctas / total) * 100
Falso por >= 90 Verdadero
“Nivel Superior”
“Nivel Medio”
“Fuera de Nivel” “Nivel Regular”
Fin

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;
Actividad por defecto
fin

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”
fin Fin del switch
fin Fin del programa

import hsa.Console;
class Ejemplo13
{
static Console c;
{
int mes;
c = new Console ();
c.print ("Ingrese un Numero: ");
mes = c.readInt ();
switch (mes)
{
case 1: c.println ("Corresponde a Enero");
break;
case 2: c.println ("Corresponde a Febrero");
break;
case 3: c.println ("Corresponde a Marzo");
break;
case 4: c.println ("Corresponde a Abril");
break;
case 5: c.println ("Corresponde a Mayo");
break;
case 6: c.println ("Corresponde a Junio");
break;
case 7: c.println ("Corresponde a Julio");
break;
case 8: c.println ("Corresponde a Agosto");
break;
case 9: c.println ("Corresponde a Septiembre");
break;
case 10: c.println ("Corresponde a Octubre");
break;
case 11: c.println ("Corresponde a Noviembre");
break;
case 12: c.println ("Corresponde a Diciembre");
break;
default: c.println ("No Corresponde a un mes valido");
break;
}
}
}
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.

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 Categoría Incremento
1 20%
2 15%
categoria 3 10%
4 5%
categoria
categoria = 1 incremento = sb * 20 / 100
incremento = 0
Fin del switch
sueldo = sb + incremento
sueldo
Fin

import hsa.Console;
class Ejemplo14
{
static Console c;
{
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;
break;
break;
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.
*/

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;
{
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.

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.
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.
Ejemplo: Ingrese número de día: 4
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.

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 Porcentaje
‘A’ 5%
‘B’ 8%
‘C’ 10%
‘D’ 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 Característica Precio por día

1 Sedan 4 puertas $ 800
2 Coupe $ 1000
3 Pick up $ 1200
4 4x4 $ 1500
Ejemplo:
Ingrese Tipo de Vehiculo: 2

Ingrese cantidad de días: 5
Importe a abonar: $ 5000

TEMAS: Clase
UNIDAD Nº 2:
Estructuras
Repetitivas.
Estructuras Repetitivas
Estructura While
Contadores - Acumuladores. 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:
While, significa
Mientras, y en el diagrama
Falso
de la estructura se puede
Condicion observar que, mientras la
condición sea Verdadera, se
procesarán las Sentencias
Verdadero
indicadas, de lo contrario, si
la condición es falsa, sale
Sentencia1; del ciclo repetitivo y
Sentencia2; continúa con la secuencia de
: instrucciones fuera del
SentenciaN; ciclo.
Cabe hacer notar

que, si la condición es falsa
de entrada, no se procesarán
las sentencias indicadas ni
una sola vez.

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
Falso
i <= 100
Verdadero
i+“ “
Incremento
i=i+1
Fin

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;
{
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.

Inicio
i = 100
Falso
i <= 300
Verdadero
i+“ “
i=i+2
Fin
import hsa.Console;
class Ejemplo17
{
static Console c;
{
int i;
c = new Console ();
i = 100;
while (i <= 300)
{
c.print (i + " ");
i = i + 2;
}
}
}

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 Se comienza inicializando el

contador en uno y el
acumulador en cero. El
i=1 contador será el encargado de
a=0 permitir recorrer el ciclo 10
veces, mientras que el
acumulador será en encargado
de sumar los 10 números que
se ingresen.
Falso Se ingresa al ciclo, mientras
i <= 10
el valor de la variable i sea
menor o igual a 10, la primera
Verdadero vez tendrá el valor de uno,
indicando que se deberá
n ingresar el primer valor. Este
primer valor se almacena en
la variable n, indicado en el
símbolo de introducción de
a=a+n datos (paralelogramo), luego
el programa ejecuta la
instrucción a = a + n. Esta
i=i+1 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
a para n, que será acumulado en
la variable a. el proceso
continúa hasta que la variable
Fin i, alcance el valor de 11, con
el cual se imprime el valor
acumulado en a.

El programa, resulta ser el siguiente:
import hsa.Console;
class Ejemplo18
{
static Console c;
{
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.

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
Falso
i <= 12
Verdadero
Falso Verdadero
n % 3 == 0
m3 ++
Falso Verdadero
n % 5 == 0
m5 ++ m3, m5, m35
Fin
Falso n % 3 == 0 && Verdadero
n % 5 ==0
m35 ++
i=i+1

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;
{
int i, m3, m5, m35, n;
c = new Console ();
i = 1;
m3 = 0;
m5 = 0;
m35 = 0;
while (i <= 12)
{
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.

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

import hsa.Console;
class Ejemplo20
{
static Console c;
{
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 …

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
Falso
i <= 100
Verdadero
a=a+i a
i=i+1
Fin
Actividad 4.2
Inicio
i=1
a=0
Falso
i <= 7
Verdadero
2
valor 3

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

Actividad 4.3
Inicio
i=1
par = 0
impar = 0
cero = 0
Falso
i <= 15
Verdadero
Falso Verdadero
n % 2 == 0
impar ++ par ++
Falso Verdadero
n % 10 == 0
cero ++
i=i+1
“Cantidad de Pares: “ + par
“Cantidad de Impares: “ + impar
“Terminados en cero: “ + cero
Fin

Actividad 4.4
Inicio
i=1
a=0
Falso
i <= 10
Verdadero
Falso Verdadero
i>5
a=a+n
i=i+1
Fin

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
Falso
sueldo != 99999
Verdadero
cantidad ++
Falso Verdadero
sueldo >= 5000
menores ++ mayores ++
a = a + sueldo
sueldo

Falso Verdadero
cantidad > 0
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.

import hsa.Console;
class Ejemplo21
{
static Console c;
{
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");
}
}

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.

Clase
UNIDAD Nº 2: TEMAS:
Estructuras
Repetitivas.
Estructura For.
Busqueda del mayor. 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
Falso
Inicialización; condidión a evaluar; modificación
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).

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é Contador que se incrementa

valor comenzará el ciclo repetitivo con cada repetición
Falso
i=1 ; i <= 10 ; 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.

Ejemplo Nro. 22: Realizar un programa que permita imprimir todos los
números del 1 al 100.
Inicio
Falso
i = 1 ; i <= 100 ; i ++
Verdadero
i+“ “
Fin
import hsa.Console;
class Ejemplo22
{
static Console c;
{
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.

Inicio
suma = 0
Falso
i=1 ; i <= 8 ; i ++
Verdadero
altura
suma = suma + altura
promedio = suma / 8
“El promedio es: “ + promedio
Fin
import hsa.Console;
class Ejemplo23
{
static Console c;
{
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);
}
}

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
Falso
i=1 ; i <= 10 ; i ++
Verdadero
nota
Falso Verdadero
nota >7
Falso Verdadero mayores ++

nota >= 4
menores++ entre ++
mayores, entre, menores
Fin

import hsa.Console;
class Ejemplo24
{
static Console c;
{
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 ("Cantidad de mayores a 7: " + mayores);
c.println ("Cantidad entre 4 y 7: " + entre);
c.println ("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.

Inicio
Falso
i = 100 ; i <= 200 ; i ++
Verdadero
Falso Verdadero
i % 6 == 0
i+“ “
Fin
import hsa.Console;
class Ejemplo25
{
static Console c;
{
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.

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
Falso
i=1 ; i <= n ; i ++
Verdadero
numero
Falso Verdadero
numero >1000
mayores ++
suma = suma + numero
mayores, suma
Fin

import hsa.Console;
class Ejemplo26
{
static Console c;
{
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++)

{
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.

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.

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
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

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”.

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
Inicio ingresado, por lo tanto, se
lo guarda en la variable m.
Falso
i = 1; i <= 20; i++
Verdadero
numero
Falso Verdadero
i == 1
m = numero
Falso Verdadero
numero > m
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.

Actividad 5.4 Inicio
i = 1; i <= 20; i++
r=5*i
5+“x“+i+“=“+r
Fin
Actividad 5.5
Inicio
termino = 0
i = 1; i <= 30; i++
termino + “ – “
termino = termino + n
Fin

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”.

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) Cuántos empleados tienen un sueldo inferior $3000.

b) Cuántos tienen un sueldo entre $3000 y $5000.
c) Cuántos tienen un sueldo superior a $5000.
d) 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

TEMAS: Clase
UNIDAD Nº 2: Estructura do..while
6
Concepto de Bandera.
Estructuras Posicionamiento del cursor.
Repetitivas. Generación de números
aleatorios.
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

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
Falso n % 2 == 0 Verdadero
“El Numero ingresado es impar” “El Numero ingresado es par”
Verdadero
n != 0
Falso
Fin while

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;
{
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.

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
Falso n != 9999 Verdadero
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

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;
{
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.");
}
}

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 Verdadero
b == 0
b=1
nx = nombre
px = precio
Falso Verdadero
precio < px
2
nx = nombre
px = precio
“Ingresa otro juego de datos (s/n): “
opcion

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) Se asigna a la bandera el valor de cero (b=0), y se ingresa al ciclo do.

2) Se ingresa el primer juego de datos.
3) Se pregunta si la bandera está en cero.
4) Como b es igual a cero, el diagrama se direcciona por el verdadero.
5) 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<px)”. En caso de ser
verdadero, se reasignan las variables con los nuevos valores.
7) Al finalizar el ingreso de datos, se imprime la variable auxiliar, que
contiene el menor 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);

El programa del diagrama anterior es el siguiente:
import hsa.Console;
class Ejemplo29
{
static Console c;
{
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.print ("--------------");

c.print ("Ingrese Nombre de Producto: ");
nombre = c.readLine ();
c.print ("Ingrese Precio del Producto: ");
if (b == 0)
{
b = 1;
nx = nombre;
px = precio;
}
if (precio < px)

{
nx = nombre;
px = precio;
}

c.print ("Ingresa otro juego de datos (S/N): ");
opcion = c.readChar ();
}
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);
}
}

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.print ("Ingrese Nombre de Producto: ");
nombre = c.readLine ();
Y el precio del mismo, en la fila 9, columna 10 con las instrucciones:

c.print ("Ingrese Precio del Producto: ");
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:
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.

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

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 Verdadero
suma == 7
“Perdió “ “Ganó “
“Realiza otra tirada de dados (s/n): “
opcion
Verdadero Opción == ‘S’
Fin

import hsa.Console;
class Ejemplo30
{
static Console c;
{
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.print ("Dado 1: " + d1);
c.print ("Dado 2: " + d2);
suma = d1 + d2;
if (suma == 7)
c.print ("*** Gano ***");
else
c.print ("Perdio");
c.print ("Realiza otra tirada de dados(s/n): ");
if (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')

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.

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) Cantidad de personas censadas.

b) Cantidad de varones.
c) Cantidad de mujeres.
d) 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.

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.

TEMAS: Clase
UNIDAD Nº 3:
7
Array
Vectores
Arreglos Carga e Impresión de un
Vector
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.
Unidimensionales  Vectores
Bidimensionales
Array
Tridimensionales Matrices
Etc.

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] = 8 Por lo tanto, la variable “i”, deberá

nota[1] = 4 asumir los valores del cero al cuatro. Si
nota[2] = 9 en este vector la variable “i”, tomara el
nota[3] = 5 valor de cinco, daría un error, porque no
nota[4] = 7
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:

Inicio
Falso
i = 0 ; i < 5 ; i++
Verdadero
Carga del Vector edad [i]
Falso
i = 0 ; i < 5 ; i++
Verdadero
Impresión del Vector
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:

import hsa.Console;
class Ejemplo31
{
static Console c;
{
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

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:

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 }
Falso
i = 0 ; i < numerosPares.length ; i++
Verdadero
numerosPares [i]
Fin
import hsa.Console;
class Ejemplo32
{
static Console c;
{
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 ("]");
}
}

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
Falso
i = 0 ; i < alturas.length ; i++
Verdadero
alturas [i]
suma = suma + alturas [i]
promedio = suma / alturas.length
promedio

Falso
i = 0 ; i < numerosPares.length ; i++
Verdadero
Falso Verdadero
altura[i] > promedio
bajas ++ altas ++
“Cantidad de Personas altas: ” + altas

“Cantidad de Personas bajas: “+ bajas
Fin
import hsa.Console;
class Ejemplo33
{
static Console c;
{
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 ();
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.

Inicio Inicialización de
variables
Carga del
Vector 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]

“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;
{
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);
}
}

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
Falso
i = 0 ; i < a.length ; i++
Verdadero
a [i]
suma = suma + a [i]
2 1 3

2 1 3
Falso Verdadero
a [i] >= 7
promocionadoA ++
Falso Verdadero
a [i] < 4
libreA ++
pa = suma / a.length
suma = 0
Falso
i = 0 ; i < b.length ; i++
Verdadero
b [i]
suma = suma + b [i]
Falso Verdadero
b [i] >= 7
promocionadoB ++
Falso Verdadero
b [i] < 4
libreB ++
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 Verdadero
pa > pb
“Curso de mayor promedio: B” “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;
{
c = new Console ();
int [] a;
a = new int [20];

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");
}
}

7.1 - Un comercio tiene almacenados los precios de sus productos en un

vector de 30 elementos. Realizar las siguientes operatorias:
a) Carga del vector de Precios.

b) Impresión del vector.
c) Cuántos productos se tienen un precio menor a $100.
d) Cuantos productos tienen un precio entre $100 y $200.
e) Cuántos productos tienen un precio mayor a $200.
f) 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 ) Tener presente que la

primera componente
Vector de indices pares: ( 5 9 8 5 2 7 ) está en el índice cero
Vector de indices impares: ( 2 4 3 6 5 1 ) que es par.

TEMAS:
UNIDAD Nº 4: Clase
Métodos en Java
8
Clases en Java
Métodos Zonas de un programa
Vectores Métodos que retornan Valores
Vectores Paralelos
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.

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)

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; Variables Miembros

class Ejemplo36
{
static Console c;
int n1, n2, n3;

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

{
c = new Console ();
Ejemplo36 e; Ejemplar de la
e = new Ejemplo36 (); clase
c.println("Promedio de 3 Numeros");
c.println("---------------------");
e.ingresoDeDatos ();
e.calcularPromedio ();
}
}
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
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 ( )
Falso
i = 1; i < 12; i++
n Verdadero
n+“x“+i+“=“+r
Fin
Fin

El diagrama del programa principal sería:
Inicio
ingresoDeDato ( )
tablaDeMultiplicar ( )
Fin
import hsa.Console;
class Ejemplo37
{
static Console c;
int n;
void ingresoDeDato ()
{
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);
}
}

{
c = new Console ();
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

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;
n = c.readInt ();
resultado = cubo (n);
c.print ("Su cubo es: " + resultado);
}


{
c = new Console ();
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) Carga de los sueldos en un Vector.

2) Impresión de todos los sueldos.
3) Cuántos tienen un sueldo superior a $4000.
4) Mostrar todos los sueldos que están por debajo del promedio.
void cargarSueldos ( )
Falso
i = 0; i < s.length; i++
Verdadero
s [i]
Fin
void imprimirSueldos ( )
Falso
Verdadero
s [i]
Fin

void punto3 ( ) float promedio ( )
superior = 0 suma = 0
Falso Falso
i = 0; i < s.length; i++ i = 0; i < s.length; i++
Verdadero Verdadero
s[i] > 4000 suma = suma + s[i]
superior++
prom = suma / s.length
superior Retornar prom
Fin Fin
Programa Principal
Inicio
void punto4 ( )
cargarSueldos ( )
Falso
imprimirSueldos ( )
Verdadero
s[i] < promedio()

punto3 ( )
s[i]
punto4 ( )
Fin Fin

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: ");
{
c.println (" $ " + s [i]);
}
}
void punto3 ()
{
int superior = 0;
{
if (s [i] > 4000)
superior++;
}
c.println ();
c.println ("Los sueldos superiores a $4000 son: " +
superior);
}
float promedio ()
{
float suma = 0;
float prom;
{
suma = suma + s [i];
}
prom = suma / s.length;
return prom;
}

void punto4 ()
{
c.println();
c.println("El promedio de sueldos es: $ " + promedio());
c.println();
c.println("Los sueldos inferiores al promedio son: ");
{
if (s[i] < promedio() )
c.print(s[i] + " ");
}
}

{
c = new Console ();
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:
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.

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.

void cargarSueldosM ( ) void cargarSueldosT ( )
Falso Falso
i = 0; i < sM.length; i = 0; i < sT.length; i++
i++
Verdadero Verdadero
sM [i] sT [i]
Fin Fin
float gastos ( float[ ] s ) void imprimirGastos ( )
suma = 0 “Gastos del turno M: “ + gastos (sM)
Falso
“Gastos del turno T: “ + gastos (sT)
Verdadero
suma = suma + s[i]

Fin
Retornar suma Inicio
Fin cargarSueldosM( )
cargarSueldosT( )
Programa Principal
imprimirGastos( )
Fin

El programa quedaría de la siguiente manera:
import hsa.Console;
class Ejemplo40
{
static Console c;
float [] sM; Definición de los Vectores.
float [] sT;
Ejemplo40 ()
{
sM = new float [4]; Creación de los Vectores
sT = new float [4];
}
void cargarSueldosM ()
{
c.println ("Cargue los sueldos del Turno Manana: ");
for (int i = 0 ; i < sM.length ; i++)
{
sM [i] = c.readFloat ();
}
}
void cargarSueldosT ()
{
c.println ("Cargue los sueldos del Turno Tarde: ");
for (int i = 0 ; i < sT.length ; i++)
{
sT [i] = c.readFloat ();
}
}
float gastos (float [] s)

{
float suma = 0;
{
}
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));
}


{
c = new Console ();
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;
{
}
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.

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:
0 1 2 3 4
Productos Televisor Notebook Radio Dvd Ventilador
Precios 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.

void cargarDatos ( ) void imprimirDatos ( )
Falso suma = 0
i = 0; i < productos.length; i++
Verdadero
Falso
productos [i] i = 0; i < productos.length; i++
Verdadero
precios [i] productos[i] , precios[i]
suma = suma + precios[i]
Fin
“La suma de los precios es: “ + suma

Inicio
Fin
cargarDatos()
imprimirDatos()
Inicio
import hsa.Console;
class Ejemplo41
{
static Console c;
String [] productos; Definición de los vectores

float [] precios;
Ejemplo41 ()
{
productos = new String [5]; Creación de los vectores
precios = new float [5];
}

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.println ("Listado de Productos");
c.println ("--------------------");
for (int i = 0 ; i < productos.length ; i++)
{
c.setCursor (linea, 10);
c.print (productos [i]);
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);
}

{
c = new Console ();
e.cargarDatos ();
c.clear ();
e.imprimirDatos ();
}
}

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.println ("Listado de Productos");
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:

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 6 Bueno
Marcelo 9 Muy Bueno
Viviana 7 Bueno
Raúl 3 Insuficiente
Ricardo 10 Muy Bueno
Roxana 5 Bueno
Hugo 2 Insuficiente
Rita 8 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.

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) Ingresar los nombres de los empleados con sus respectivos sueldos.

b) Indicar cuántos cobran más de $3500.
c) Cuántos cobran menos de $2500.
d) 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.

UNIDAD Nº 4: TEMAS: Clase
9
Procesos Algorítmicos
Mayor y Menor elemento
Métodos
Consultas
Vectores Ordenamientom de Vectores
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
Edades
27 21 35 28 24
0 1 2 3 4
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
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]
m p
0 27 27 0
1 21
Tomar el primer elemento del vector y
2 35 almacenarlo en una variable auxiliar, por
ejemplo “m” y guardar en la variable “p” el valor
3 28 cero, que corresponde a la primera posición. Este
valor guardado en “m” se utilizará para comparar
4 24 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:

void cargarDatos ( )
Falso
i = 0; i < nombres.length; i++
Verdadero
nombres [i]
edades [i]
sueldos [i]
Fin
int mayor (int [] edades )
m = edades[0]
p=0
Falso
i = 1; i < edades.length; i++
Verdadero
Falso Verdadero
edades[i] > m
m = edades[i]
p=i
Retornar p
Fin

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 ();
}
}

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.println ("Datos de la persona de Mayor edad");
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]);
}

{
c = new Console ();
e.cargarDatos ();
c.clear ();
e.imprimirDatos ();
}
}
Para ralizar la búsqueda del Menor, simplemente se debe cambiar el

símbolo de mayor por menor

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")  < 0
"Javier".compareTo("Aldo")  > 0
"Marcos".compareTo("Marcos")  = 0

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
frecuencias
96.1 100.5 89.7 105.3 102.3
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()

Falso
i = 0; i < emisoras.length; i++
Verdadero
emisoras [i]
frecuencias [i]
Fin
void consulta ( )
posicion = -1
emisoraAux
Falso
i = 0; i < emisoras.length; i++
Verdadero
Falso Verdadero
emisoraAux.equals(emisoras[i])
posicion = i

posicion != -1
“Le corresponde la
“No existe esa frecuencia de : “
emisora” frecuencias[posicion]
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 ();
}
}

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');
}

{
c = new Console ();
e.cargarDatos ();
e.consultas ();
System.exit (0);
}
}

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

(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 55 49
Falso
i = 0; i < 4; i++
Verdadero
Falso Verdadero
v[i] > v[i+1]
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.

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.

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.
Falso
k = 1; k < 5; k++
Verdadero
Falso
i = 0; i < 4; 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
75 120 82 55 49
75 82 120 55 49
75 82 55 120 49
75 82 55 49 120

Cuando k = 2
75 82 55 490
49 120
75 55 82 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 75 82 120
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).

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:
Falso
k = 1; k<5; k++
Verdadero
Falso
i = 0; i<5–k; i++
Verdadero
Falso Verdadero
v[i] > v[i+1]
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.

 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)
Falso
k = 1; k<n; k++
Verdadero
Falso
i = 0; i<n–k; i++
Verdadero
Falso Verdadero
v[i] > v[i+1]
auxi = v[i]
v[i] = v[i+1]
v[i+1] = auxi
Fin

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 ("Ingrese la cantidad de elementos del vector: ");
int n = c.readInt ();
v = new 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] + " ");
}
}

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

{
c = new Console ();
c.println();
e.cargarDatos ();
c.println();
c.println ("Vector ingresado:");
e.imprimir ();
c.println ();
c.println ();
c.println ("Vector ordenado:");
e.imprimirOrdenado ();
}
}

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 Enero Febrero Marzo

Operador de PC 223 333 222
Reparador de PC 22 22 21
Internet 122 160 190
Programacion 121 180 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.

import hsa.Console;
class PropuestoNueve3
{
static Console c; Solución del ejercicio
String [] nombre; propuesto 9.3
int [] enero;
int [] febrero;
int [] marzo;
int [] total;
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; i<total.length; i++)
if(total[i]>m)
{
m=total[i];
posicion=i;
}
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++;
}
}

{
c = new Console ();
PropuestoNueve3 p = new PropuestoNueve3();
p.cargarDatos();
p.totalDeAlumnos();
p.mayor();
p.totalEneroFebrero();
p.reducir();
p.totalDeAlumnos();
System.exit(0);
}
}

UNIDAD Nº 4: TEMAS: Clase
10
Ordenamiento con Vectores
Paralelos
Métodos
Consultas en vectores
Vectores paralelos
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 Temperatura

Buenos Aires 22
Chubut 8
Cordoba 23
Tierra del Fuego 4
b) Realizar un listado ordenado por las temperaturas (desde la

temperatura más baja hasta la más alta).
Nombre de Provincia Temperatura

Tierra del Fuego 4
Chubut 8
Buenos Aires 22
Cordoba 23
c) Realizar un Menú de opciones, con las siguientes alrenativas:

[Carga de Datos] – [Listado Ordenado por Provincia] – [Listado
Ordenado por Temperaturas] – [Finalizar]

Falso
i = 0; i < provincias.length; i++
Verdadero
provincias [i]
temperaturas [i]
Fin
void ordenarPorProvincias (v, n)
Falso
k = 1; k<n; k++
Verdadero
Falso
i = 0; i<n–k; i++
Verdadero
Falso Verdadero
provincias[i].compareto(provincias[i+1])
>0
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

void ordenarPorTemperaturas (v, n)
Falso
k = 1; k<n; k++
Verdadero
Falso
i = 0; i<n–k; i++
Verdadero
Falso Verdadero
temperaturas[i] > temperaturas[i+1]
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: ");
provincias = new String [n];
temperaturas = new float [n];
}

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;
auxiTemperatura = temperaturas [i];

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

}
}
}
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;
}
}
}
}

{
c = new Console ();
int op;
c.setTextBackgroundColor (Color.cyan);
do
{
c.clear ();
c.setTextColor(Color.blue);
c.print ("Menu de Opciones");
c.print ("----------------");
c.print ("1- Cargar Datos");
c.print ("2- Listado ordenado por Provincias");
c.print("3-Listado ordenado por Temperaturas");
c.print ("4- Finalizar el programa");
c.print ("Digite la opcion: ");
op = c.readInt ();

switch (op)
{
case 1: e.cargarDatos (); break;
case 2: c.clear ();
c.print("Listado Ordenado por Provincias");
e.ordenarPorProvincias ();
e.imprimir(); break;
case 3: c.clear();
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:

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) Listado en tres columnas

b) Consultas por Descripción de Producto.
c) Mostrar todos los datos del Producto de menor precio.
d) Consulta por Procedencia
e) 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: ");
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 ();
}
}

void imprimir ()
{
int fila;
c.print ("Descripcion");
c.print ("-----------");
c.print ("Precio");
c.print ("------");
c.print ("Procedencia");
c.print ("-----------");
fila = 5;
for (int i = 0 ; i < descripcion.length ; i++)
{
c.setCursor (fila, 10);
c.print (descripcion [i]);
c.print (precio [i], 8, 2);
c.print (procedencia [i]);
fila++;
}
c.println ();
c.println ();
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;

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.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.print(precio[i],8,2);
fila++;
}
}
if(fila == 10)
{
c.setCursor(9,10);
c.print("No existe esa procedencia");
}
c.print("Realiza otra consulta: ");
op=c.readChar();
}
while (op=='s' || op=='S');
}

void mensaje()
{
c.clear();
c.setCursor(10,15);
c.print("Faltan cargar los productos");
c.setCursor(14,15);
c.print("Digite [Enter para Menu]...");
c.readChar();
}

{
c = new Console ();
Ejemplo46 e = new Ejemplo46();
int op;
c.setTextBackgroundColor (Color.yellow);
int bandera=0;
do
{
c.clear ();
c.setTextColor(Color.blue);
c.print ("Menu de Opciones");
c.print ("----------------");
c.print ("1- Cargar Datos");
c.print ("2- Listado Completo");
c.print ("3- Consultas por descripcion");
c.print("4- Datos del Producto de menor Precio");
c.print ("5- Consultas por Procedencia");
c.print ("6- Finalizar el programa");
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.print ("Listado Completo");
e.imprimir ();
}
break;


else
e.consultasPorDescripcion();
break;
else
e.productoDeMenorPrecio();
break;
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');

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.print(descripcion[i]);
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.

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) Carga de los datos de cada empleado.

b) Listado competo ordenado por nombre en cuatro columnas.
c) Consulta por Legajo.
d) Consulta por Nombre.
e) Consulta por Profesión.
f) Datos del la persona de mayor sueldo.
g) 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) Ingresar N cantidad de datos, mediante un menú de opciones.

b) Indicar cantidad de películas por género.
c) Indicar la cantidad total de copias alquiladas.
d) Mostrar un Listado de películas ordenadas por descripción.
e) 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.

UNIDAD Nº 5: Clase
TEMAS:
11
Matrices
Arreglos Carga e impresión
Bidimensionales Procesamiento de Matrices
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.  0 1 2 3 4
0 7 5 8 9 6
1 8 9 6 7 8
Cursos
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

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 ( )
Falso
i = 0; i < fila ; i++
Verdadero
Falso
j = 0; j < col ; j++
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].

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 ( )
Falso
i = 0; i < fila ; i++
Verdadero
Falso
j = 0; j < col ; j++
Verdadero
nota [i][j]
Fin
El programa se puede observar en la página siguiente.

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 j = 0 ; j < col ; j++)
{
c.print ( " " + nota [i][j]);
}
c.println();
}
c.println ();
c.readChar();
}

{
c = new Console ();

int op;
c.clear ();
e.cargarMatriz();
e.imprimirMatriz();
System.exit(0);
}
}
Programa en ejecución cuando se

está ingresando los datos de la
Matriz

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.  0 1 2 3 4
0 7 5 8 9 6 7
1 8 9 6 7 8 7,60
Cursos
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

generarVector ( ) Punto a)
Falso
i = 0; i < fila ; i++
Verdadero
suma = 0
Falso
j = 0; j < col ; j++
Verdadero
suma = suma + nota[i][j]
promedio = suma / col
v [i] = promedio
Fin
void imprimirVector ( )
Falso
i = 0; i < fila; i++
Verdadero
v [i]
Fin

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
Falso
i = 0; i < fila ; i++
Verdadero
suma = suma + v [i]
promedio = suma / fila
Fin

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: ");
c.print ("Ing. la cantidad de columnas de la Matriz: ");
col = c.readInt ();
nota = new int[fila][col];
v = new float[fila];
}
{
c.clear ();
c.println ();
{
for (int j = 0 ; j < col ; j++)
{
c.print ("Ingrese nota[" + i + "," + j + "]: ");
nota [i] [j] = c.readInt ();
}
c.println ();
}
c.println ();
}
{
c.clear ();
c.println ("Impresion las Notas");
c.println ("-------------------");
c.println ();
{
for (int j = 0 ; j < col ; j++)
{
c.print ( " " + nota [i][j]);
}
c.println();
}
c.readChar();
}

void generarVector()
{
for (int i=0; i<fila; i++)
{
int suma = 0;
for (int j=0; j<col; j++)
{
suma = suma+nota[i][j];
}
float promedio= (float)suma/col;
v[i]=promedio;
}
}
void imprimirVector() //Promedios de cada curso

{
c.println();
c.println("El promedio de cada curso es:");
c.println();
for(int i=0; i<fila; i++)
{
c.println(" " + "Curso ["+ i +"]: " + v[i]);
}
c.readChar();
}
void mayor()
{
float m=v[0];
int p=0;
if (v[i]>m)
{
m=v[i]; p=i;
}
c.println();
c.println("El curso de mayor promedio es el: " + p);
c.readChar();
}
void promedioDeTodosLosCursos()
{
float suma=0;
{
suma = suma + v[i];
}
float p = suma / fila;
c.println();
c.println("El promedio de todos los cursos es: " + p);
c.readChar();
}


{
c = new Console ();
int op;
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.

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
Falso
i = 0; i < fila ; i++
Verdadero
suma = suma + m[i][i]
suma
Fin
intercambiarFilas ( )
Falso
j = 0; j < col ; j++
Verdadero
auxi = m[0][j]
m[0][j] = m[fila-1][j]
m[fila-1][j] = auxi
Fin

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: ");
col = fila;
m = new int[fila][col];
}
{
c.clear ();
c.println ();
{
for (int j = 0 ; j < col ; j++)
{
c.print ("Ingrese m[" + i + "," + j + "]: ");
m [i] [j] = c.readInt ();
}
c.println ();
}
c.println ();
}
{
c.println ("Impresion la Matriz");
c.println ("-------------------");
c.println ();
{
for (int j = 0 ; j < col ; j++)
{
c.print ( " " + m [i][j]);
}
c.println();
}
c.readChar();
}

void sumaDiagonalPrincipal()
{
int suma = 0;
{
suma = suma+ m[i][i];
}
c.println();
c.print("La suma de de la Diagonal Principal es: ");
c.println(suma);
}
void intercambiarFilas()
{
int auxi;
{
auxi = m[0][j];
m[0][j] = m[fila-1][j];
m[fila-1][j] = auxi;
}
}

{
c = new Console ();
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.

Si se ingresa una matriz cuadrada de 3x3, o sea, 3 filas y 3 columnas, la

salida sería similar a la siguiente pantalla:
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.

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.

UNIDAD Nº 5: Clase
TEMAS:
12
Matrices y Vectores
Arreglos paralelos
Bidimensionales
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.

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];
}
{
c.clear ();
c.print ("Produccion de trigo");
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);
c.print ("----");
columna = columna + 10;
anio++;
}
linea = 5;
{
columna = 20;
for (int j = 0 ; j < col ; j++)
{
}
linea++;
}
}
void totalPorProvincia () //Punto c

{
c.print ("Total");
c.print ("-----");
int linea = 5;
int columna = 72;
int suma;
{
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() // Punto d

{
int mayor = total[0];
int posi = 0;
{
if(total[i]> mayor)
{
mayor=total[i];
posi = i;
}
}
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;
{
if(total[i]< menor)
{
menor=total[i];
posi = i;
}
}
c.print("La provincia de menor produccion es: ");
c.println(provincias[posi]);
c.println("Con un valor de: "+total[posi]+" toneladas");
c.readChar();
}
void listado() // Punto f

{
String auxiP;
int auxiT;
for(int k=1; k<fila; k++)
for(int i=0; i<fila-k; i++)
{
if(provincias[i].compareTo(provincias[i+1])>0)
{
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;
{
c.setCursor(linea,10); c.print(provincias[i]);
c.setCursor(linea,35); c.print(total[i]);
linea++;
}
c.readChar();
}

{
c = new Console ();
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.print (anio);
c.print ("----");
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.

La segunda parte del método cargarMatriz ( ):
linea = 5;
{
columna = 20;
for (int j = 0 ; j < col ; j++)
{
}
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:

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:
Nombres Enero Febrero Marzo

Javier 3540.60 2600.60 5467,60
Marcelo 3843,65 4365,24 4654,66

Sueldos
Alejandro 5376,43 4763,35 6543,55
Ricardo 3521,67 3573,44 4365,77
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.

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];
}
{
c.clear ();
c.setCursor (3, 3);
c.print ("Nombres");
c.setCursor (4, 3);
c.print ("-------");
int linea = 3;
int columna = 25;
c.print ("Enero");
c.print ("-----");
c.print ("Febrero");
c.print ("-------");
c.print ("Marzo");
c.print ("-----");
linea = 5;
{
nombres [i] = c.readLine ();
columna = 25;
for (int j = 0 ; j < col ; j++)
{
sueldos [i] [j] = c.readFloat ();
}
linea++;
}
}
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);
}
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<fila; i++)
{
if (nx.equalsIgnoreCase(nombres[i]))
{
posi=i;
}
}
if (posi != -1)
{
c.setCursor(15,10);
c.print("Le corresponden los sueldos:");
c.setCursor(16,10);
c.print("Enero: $ " + sueldos[posi][0]);
c.setCursor(17,10);
c.print("Febrero: $ " + sueldos[posi][1]);
c.setCursor(18,10);
c.print("Marzo: $ " + sueldos[posi][2]);
}
else
{
c.setCursor(16,10);
c.print("No existe ese empleado");
}
}
void sueldoTotal()
{
float total = 0;
{
{
total = total + sueldos[i][j];
}
}
c.setCursor(20,10);
c.print("El sueldo total de todos los empleados es: $ ");
c.println(total,0,2);
c.readChar();
}

{
c = new Console ();
e.cargarMatriz ();
e.totalPorMes();
e.consultaPorNombre();
e.sueldoTotal();
}
}

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 jul ago sept oct nov dic
0 7 25 14 30 60 95
1 15 20 18 35 50 40
.... ............................. .....
.... ..................................
999 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.

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:
Monto vendido en $ por zona

Cod Visitador Norte Sur Ctro Oeste Este
001 Juan Perez 1500 3800 4000 - 1700
005 Julian Juarez 3500 - - - 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.

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);

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);

Modelo de Examen Final

EXAMEN FINAL
Carrera: ANALISTA DE SISTEMAS Modalidad: P-S-D
Materia: 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.
Lunes Martes Miércoles Jueves Viernes
Cordoba 120 200 180 150 100

Chubut 150 180 120 140 160
Salta 160 190 110 100 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%

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];
}
{
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] = "Lunes";
dia [1] = "Martes";
dia [2] = "Miercoles";
dia [3] = "Jueves";
dia [4] = "Viernes";
{
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.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 ()
{

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.print ("La produccion para el " + dx + " es
de: " + suma);
}
else
{
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.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

void punto4()
{
String px, dx;
c.print ("Ingrese provincia: "); px =
c.readLine();
c.print ("Ingrese dia: "); dx = c.readLine();
int posiF, posiC;
posiF = posiC = -1;
if (px.equalsIgnoreCase(provincia[0])) posiF=0;
else
else
int col;
for (col = 0 ; col < 5 ; col++)
{
if (dx.equalsIgnoreCase (dia [col]))
posiC = col;
}
if (posiF != -1 && posiC != -1)
{
c.print ("Le corresponde una produccion de: "
+ matriz[posiF][posiC]) ;
}
else
{
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();
}
}


Apunte de AED1 PDF

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Apunte de AED1 PDF

Diunggah oleh

Hak Cipta:

Format Tersedia

ALGORITMOSYYESTRUCTURAS

-2- – Algoritmos y Estructuras de Datos I –

CLASE NÚMERO: 1 ______________________________________________ 7

CLASE NÚMERO: 2 _____________________________________________ 21

CLASE NÚMERO: 3 _____________________________________________ 35

CLASE NÚMERO: 4 _____________________________________________ 53

– Algoritmos y Estructuras de Datos I – -3-

Ingreso de valores hasta que se digite una clave ______________________ 67

CLASE NÚMERO: 5 _____________________________________________ 71

CLASE NÚMERO: 6 _____________________________________________ 87

CLASE NÚMERO: 7 ____________________________________________ 101

CLASE NÚMERO: 8 ____________________________________________ 117

CLASE NÚMERO: 9 ____________________________________________ 137

CLASE NÚMERO: 10 ___________________________________________ 159

-4- – Algoritmos y Estructuras de Datos I –

CLASE NÚMERO: 11 ___________________________________________ 173

CLASE NÚMERO: 12 ___________________________________________ 189

– Algoritmos y Estructuras de Datos I – -5-

-6- – Algoritmos y Estructuras de Datos I –

Esta materia es de vital importancia para el avance del alumno en el plan

En general, se puede decir que la materia presenta dos ejes temáticos

Aprender a programar, no es un proceso que se adquiere de un momento

Este material de estudios no es una fuente de información completa o

Ing. Eduardo Mansilla

– Algoritmos y Estructuras de Datos I – -7-

Diagrama de Flujo: Se define a un Diagrama de Flujo, como una

La respuesta obtenida con el desarrollo de un diagrama, no es única, sino que es

Símbolos Normalizados en la Diagramación

Símbolo Nombre Acción que realiza

Comienzo o final de En su interior, se coloca

Se utiliza para ingresar

-8- – Algoritmos y Estructuras de Datos I –

Símbolo Nombre Acción que realiza

Se utiliza cuando se debe

Ventajas de un Diagrama de Flujo

Programa: Se define a un programa, como una secuencia de instrucciones,

Algoritmo: Es un conjunto preescrito de instrucciones o reglas bien

Variable: Se define a una variable, como el espacio físico para albergar un

– Algoritmos y Estructuras de Datos I – -9-

Se puede imaginar a una variable como un “casillero” en el cual se

Ejemplo: Suponer que se quiere definir la variable sueldo.

Se debe tener presente, que lo que se almacena en una variable es un

1. El nombre identificador debe comenzar con una letra en

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

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

Ejemplo: diaDeLaSemana, sueldoDelPersonal, precioUnitario, etc.

- 10 - – Algoritmos y Estructuras de Datos I –

Nota: La letra f al final de cada valor, es obligatorio colocarla para indicar a

– Algoritmos y Estructuras de Datos I – - 11 -

Tipo String: (String significa tira o hilera de caracteres). Una variable

Operación Aritmética Operador

Ejemplo Nro. 1 : Calcular el importe que deberá abonar una persona

Para la solución, se deben pensar en las variables a utilizar en el

- 12 - – Algoritmos y Estructuras de Datos I –

La solución sería la siguiente:

Inicio Inicio del Diagrama

importe = precio * cantidad Cálculo del importe a abonar

importe Impresión del importe a abonar