Ciclos Java - NetsBeans - Algoritmia

ALGORITMIA Y PROGRAMACIÓN

ESTRUCTURAS ITERATIVAS

EISC Universidad del Valle Slide 2

Contenido

Estructuras de Repetición

For

Ciclos anidados

Contadores y acumuladores

While

Do-while

Ejercicios



Ejercicio: Suponga que debe mostrar los números del 1 a 100 en ventanas separadas en una aplicación Java.



Ejercicio: Suponga que debe mostrar los números del 1 a 100 en ventanas separadas en una aplicación Java.

Se podría hacer con el siguiente método:

public static void listarNumeros() { JOptionPane.showMessageDialog (null, “El número es: ” + 1); JOptionPane.showMessageDialog (null, “El número es: ” + 2); JOptionPane.showMessageDialog (null, “El número es: ” + 3); JOptionPane.showMessageDialog (null, “El número es: ” + 4); …… JOptionPane.showMessageDialog( null, “El número es: ” + 100); } Y si nos piden listar del 1 al 5000?



Son un grupo de instrucciones que permite la ejecución

repetitiva de otro grupo de instrucciones. Hay una variable

asociada al ciclo o estructura de repetición que controla

el número de veces que se repetirán las instrucciones.

Existen 3 estructuras de repetición:

for

while

do-while



Problema: Desarrollar una aplicación Java que solicite un número y muestre los números desde el 1 hasta el número solicitado. 1. Análisis del problema Entradas: ?? Salidas: ?? Proceso:??



Problema: Desarrollar una aplicación Java que solicite un número y muestre los números desde el 1 hasta el número solicitado. 1. Análisis del problema Entradas: n Salidas: ?? Proceso:??


Estructuras de Repetición Problema: Desarrollar una aplicación Java que solicite un número y muestre los números desde el 1 hasta el número solicitado. 1. Análisis del problema Entradas: n Salidas: imprimir (número 1) imprimir (número 2) . . imprimir (número n) Proceso:??


Estructuras de Repetición Problema: Desarrollar una aplicación Java que solicite un número y muestre los números desde el 1 hasta el número solicitado. 1. Análisis del problema Entradas: n Salidas: imprimir (número 1) imprimir (número 2) . . imprimir (número n) Proceso: desde 1 hasta n


Estructuras de Repetición Problema: Desarrollar una aplicación Java que solicite un número y muestre los números desde el 1 hasta el número solicitado. 1. Análisis del problema Entradas: n Salidas:

imprimir (número 1) imprimir (número 2) . . imprimir (número n) Proceso: desde 1 hasta n Imprimir 1,2,3,.....n



Problema: Desarrollar una aplicación Java que solicite un número y muestre los números desde el 1 hasta el número solicitado. 2. Diseñar el algoritmo y escribirlo en pseudocódigo

Inicio n: entero leer (n) ???

Fin


Estructuras de Repetición Problema: Desarrollar una aplicación Java que solicite un número y muestre los números desde el 1 hasta el número solicitado. 2. Diseñar el algoritmo y escribirlo en pseudocódigo

Inicio n: entero i: entero (Variable de control) leer (n) Desde i = 1 mientras i <= n incrementando i en 1

Imprimir (i) fin_desde Fin


Estructuras de Repetición Problema: Desarrollar una aplicación Java que solicite un número y muestre los números desde el 1 hasta el número solicitado. 3. Codificar el algoritmo usando algún lenguaje de programación pseudocódigo Java

Desde i = 1; Mientras i <= n; incrementar i en 1 Imprimir (i) Fin_desde


Estructuras de Repetición Problema: Desarrollar una aplicación Java que solicite un número y muestre los números desde el 1 hasta el número solicitado. 3. Codificar el algoritmo usando algún lenguaje de programación pseudocódigo Java

Estructura De Repetición for




Se usa para repetir una instrucción o un conjunto de instrucciones,

Desde un inicio, Mientras una condición se cumpla y con un

incremento o decremento.

Un ciclo for tiene tres partes:

Expresión de inicio,

Expresión de condición y

Expresión de incremento/decremento.




.

for (inicio; prueba; actualización) {

//Instrucciones a Repetir‏ }

Estructura de la instrucción for

Inicializar la variable de

control

Se debe declarar la variable de

control

probar el valor final de la variable de control para continuar el ciclo

Incremento o decremento de la variable de control


Estructura For

Pseudocódigo Java

Desde inicio mientras condición incrementando en incremento Haga instrucción 1 instrucción 2 ……. Fin desde

for ( inicio; condición; incre/decremento) { instrucción 1; instrucción 2; …… }

Expresión de inicio

Expresión de condición (o prueba)

Expresión de incremento/decremento


Estructura for

Pseudocódigo Java


for( inicio; condición; incre/decremento) { instrucción 1; instrucción 2; …… }


Expresión de condición (o prueba)



Estructura for

Pseudocódigo Java


for ( inicio; condición; incre/decremento) { instrucción 1; instrucción 2; …… }


Expresión de condición



Estructura for

Funcionamiento: for ( inicio; condición; incre/decremento){

instrucciones;

}

i, k , j en cada caso será la variable de control del ciclo.

Expresión de Inicio: Es una expresión que permite dar un valor inicial a la variable de control del ciclo.

Variable de control: Es la variable que se utiliza para contar la cantidad

de iteraciones realizadas y es usada en la condición que determina el límite de repeticiones a realizar.

Ejemplos: i=1 k=m j=(y*8)


Expresión de Condición: Es una condición que se evalúa

antes de realizar el bloque de instrucciones en el ciclo. Esta prueba condiciona la cantidad de veces que se va a realizar el ciclo, para determinar cuando se termina su ejecución.

Ejemplos: i<=5 k>total j!=(z%7)

Estructura for


instruciones;

}

i, k , j en cada caso será la variable de control del ciclo.


Expresión de Incre/Decremento: Es una expresión usada para incrementar o decrementar (actualizar) el valor de la variable de control del ciclo. Ejemplos: i++ k= k + 2 J--

Estructura for


instruciones;

}


Estructura for Ejemplo:

public static void listarNumeros(){ for (int i =1 ; i<=5; i++) { JOptionPane.showMessageDialog (null, “ Número: ” + i ); } }




Valor de i Número Iteración Salida

1 1 “Número 1”

2 2 “Número 2”

3 3 “Número 3”

4 4 “Número 4”

5 5 “Número 5”

6 Se interrumpe





1 1 “Número 1”

2 2 “Número 2”

3 3 “Número 3”

4 4 “Número 4”

5 5 “Número 5”

6 Se interrumpe

El número de iteraciones indica la cantidad de veces que se repite la(s) instrucción(es) que estén en el cuerpo del ciclo.

En el ejemplo, la instrucción: JOptionPane.showMessageDialog(…)

se ejecuta 5 veces.


Estructura for

Cuantas veces se ejecutará la instrucción: JOptionPane.showMessageDialog (null, “ Número: ” + k );

public static void listarNumeros(){ for (int k =18 ; k>10; k = k - 2) { JOptionPane.showMessageDialog (null, “ Número: ” + k ); } }

Ejemplo:


Estructura for

public void listarNumeros(){ for(int k =18 ; k>10; k = k - 2) { JOptionPane.showMessageDialog (null, “ Número: ” + k ); } }


18 1 “Número 18”

16 2 “Número 16”

14 3 “Número 14”

12 4 “Número 12”

10 Se interrumpe

La instrucción: JOptionPane.showMessageDialog (…)

se ejecuta 4 veces

Ejemplo:


Estructura for

Cuantas veces se ejecutará la instrucción:

JOptionPane.showMessageDialog(null ,“El valor de i es " + i);

public void muestraAlgo1( ){ int i=0; for ( i=3; i<=30; i++ ) { if ((i % 10) == 3) { JOptionPane.showMessageDialog(null ,“El valor de i es " + i); } } }

Ejemplo:


Estructura for

public void muestraAlgo1( ){ int i=0; for ( i=3; i<=30; i++ ) { if ((i % 10) == 3) { JOptionPane.showMessageDialog(null ,“El valor de I es " + i); } } }

Ejemplo:

Valor de i Nro Iteración Salida

3 1 “El valor de I es” 3

4,5,6,7,8,9,10, 11,12,13

2,3,4,5,6,7,8,9, 10,11

“El valor de I es” 13

14,15,16,17,18,19,20,21,22,23

12,13,14,15,16,17,18,19,20,21

“El valor de I es” 23

24,25,26,27,28,29,30

22,23,24,25,26,27,28

Se interrumpe

La instrucción: JOptionPane.showMessageDialog (…)

se ejecuta 3 veces


Estructura for

Que debo completar en el mensaje “ NO es ...“ ?

JOptionPane.showMessageDialog(null ,+ j+“ NO es ..." );

public void muestraAlgo2( ){ for ( int j=0; j<=100; j++ ) { if ((j % 3) == 0) { JOptionPane.showMessageDialog(null ,“El valor de J es " + j);} else{ JOptionPane.showMessageDialog(null ,+ j+“ NO es ..." );} } }

Ejemplo:


Estructura for

public void muestraAlgo2( ){ for ( int j=0; j<=20; j++ ) { if ((j % 3) == 0) { JOptionPane.showMessageDialog(null ,“El valor de J es " + j);} else{ JOptionPane.showMessageDialog(null ,+ j+“ NO es ..." );} } }

Ejemplo:

…

…


Estructura for

Una vez el ciclo se interrumpe se ejecuta la instrucción ubicada después

de él. Por ejemplo:

int a=0;

for (int k =0 ; k<=4; k = k + 2) { a++; } JOptionPane.showMessageDialog (null, “ El valor de a es: ” + a );


Estructura for

Una vez el ciclo se interrumpe se ejecuta la instrucción ubicada después

de él. Por ejemplo:

int a=0;

for (int k =0 ; k<=4; k = k + 2) { a++; } JOptionPane.showMessageDialog (null, “ El valor de a es: ” + a );

La variable a inicia con el valor de cero (0).

Se ingresa al ciclo y se ejecuta tres (3) veces la instrucción a++ (recuerde que a++ es lo mismo que a=a+1).

Luego se muestra en pantalla el valor de a, es decir, 3.


Estructura for

Desarrollar un programa Java que pregunte al usuario el número de

estudiantes de un curso, luego pregunte el nombre de cada uno de ellos. Finalmente, se debe mostrar un listado con todos los estudiantes.

Ejercicio 1:


Estructuras de Repetición Problema: Desarrollar un programa Java que pregunte al usuario el

número de estudiantes de un curso, luego pregunte el nombre de cada

uno de ellos. Finalmente, se debe mostrar un listado con todos los

estudiantes 1. Análisis del problema Entradas: numeroEstudiantes, nombreEstudiante, Salidas: listadoEstudiantes Proceso:??





estudiantes

numeroEstudiantes

nombreEstudiantes listadoEstudiantes

Desde x=1 mientras x<=numeroEstudiantes incrementando en x = x +1 Haga

leer(nombreEstudiante) listadoEstudiantes = listadoEstudiantes + nombreEstudiante Fin Desde





estudiantes 1. Análisis del problema Entradas: numeroEstudiantes, nombreEstudiante, Salidas: listadoEstudiantes Proceso:

Desde x=1 mientras x<= numeroEstudiantes incrementando en x = x +1 Haga

leer(nombreEstudiante) listadoEstudiantes = listadoEstudiantes + nombreEstudiante Fin Desde


Estructura for Ejercicio 1:

Inicio

numeroEstudiantes: entero

listadoEstudiantes: texto

nombreEstudiante: texto

leer(numeroEstudiantes) Desde x=1 mientras x<= numeroEstudiantes incrementando en x = x +1 Haga

leer(nombreEstudiante) listadoEstudiantes = listadoEstudiantes + nombreEstudiante Fin Desde imprimir(listadoEstudiantes )

Fin


Estructura for

public class Asignatura { public static void main (String arg[]) { int numEstudiantes; String listadoEstudiantes= “”; String nombreEstudiante; numEstudiantes= Integer.parseInt(JOptionPane.showInputDialog("Ingrese el número de Estudiantes:")); for (int x = 1; x <= numEstudiantes; x++){ nombreEstudiante = JOptionPane.showInputDialog(“Nombre No: “+x); listadoEstudiantes = listadoEstudiantes + "\nEstudiante No: "+ x + " : "+ nombreEstudiante; } JOptionPane.showMessageDialog(null, listadoEstudiantes ); } }

Ejercicio 1:


Estructura for – Ciclos Anidados

Suponga que se desea crear un programa en Java que permita imprimir en pantalla el factorial de cada número existente en la serie 1 a n, siendo n un número menor a 20 el cual es digitado por un usuario.

Ejemplo:

NOTA: Usamos la condición n<=20 con fines académicos y evitar resultados con números exageradamente grandes.

Desde i=1 mientras i<=n incrementando en i = i +1 Haga

instrucción 3 instrucción 4 Fin Desde

Desde j=1 mientras j<=i incrementando en j = j +1 Haga

instrucción 1 instrucción 2 … Fin Desde



Un ciclo anidado es un ciclo, de cualquier tipo, que contiene otro ciclo de cualquier tipo.

En el ejercicio propuesto se observa que se debe crear un ciclo para manejar la serie de 1 a n, y un ciclo anidado para calcular el factorial de ni .

Por ejemplo: si el usuario digita el número 5 el sistema debe recorrer la serie 1 a 5, y para cada número devolver su factorial, así:

Factorial de 1 = 1, Factorial de 2 = 2, Factorial de 3 = 6 , Factorial de 4 = 24 y el Factorial de 5 = 120.

Nota:

El factorial de un número n es la multiplicación de todos los números de la serie 1 a n, entonces, el factorial de 5 es 1 x 2 x 3 x 4 x 5 = 120, el factorial de 3 es 1 x 2 x 3 = 6.



Desde i=1 mientras i<=n incrementando en i = i +1

Haga

factorial=1

respuesta = respuesta + “El factorial de ” + j + “es: ” factorial; Fin Desde

Desde j=1 mientras j<=i incrementando en j = j +1

Haga

factorial = factorial*j Fin Desde

Inicio

factorial, n: entero

respuesta: texto

leer(n)

SI n <= 20 Entonces

imprima(respuesta)

SINO

imprima(“Ha digitado un numero superior a 20”)

Fin



Desde i=1 mientras i<=n incrementando en i = i +1

Haga

factorial=1

respuesta = respuesta + “El factorial de ” + j + “es: ” factorial;

Fin Desde

Desde j=1 mientras j<=i incrementando en j = j +1

Haga

factorial = factorial*j Fin Desde

Inicio

factorial,n: entero

respuesta: texto

leer(n)

SI n<= 20

imprima(respuesta)

SINO

imprima(“Ha digitado un numero superior a 20”)

Fin

El ciclo principal, basado en la variable

de control i, contiene un ciclo anidado

basado en la variable de control j.


Estructura for – Ciclos Anidados public class Factorial {

public static void main(String arg[]){ int n, factorial; String respuesta = ""; n = Integer.parseInt(JOptionPane.showInputDialog("Ingrese n:")); if(n<=20){ for (int i = 1; i <= n; i++){ factorial=1; for (int j = 1; j <= i; j++){ factorial=factorial*j; } respuesta = respuesta + "\n El Factorial de " + i + "es: " + factorial; } JOptionPane.showMessageDialog(null,respuesta); }else{ JOptionPane.showMessageDialog(null,"Ha digitado un número superior a 20"); } } }



Desarrollar un programa java que permita generar y visualizar la siguiente figura:

Tenga en cuenta que el usuario ingresa al programa el número de líneas que debe tener la figura (En el ejemplo hay 7 filas).

Ejercicio 2:



crearFigura(numeroFilas : entero) Inicio triangulo = “” : texto

Desde i=1 mientras i<=numeroFilas incrementando en i = i +1 Haga

Desde j=1 mientras j<=i incrementando en j = j +1 Haga

triangulo = triangulo + “*” Fin Desde

triangulo = triangulo + “\n”

Fin Desde imprimir(triangulo) Fin

Ejercicio 2:



Ejercicio 2:


Estructura For – Ciclos Anidados

Ejercicio 2:


Estructura for - Contadores

Los contadores son variables utilizadas para realizar, como su nombre lo indica, conteos de la cantidad de veces que se cumple una situación específica.

Como su objetivo principal es contar, deben ser de tipo entero y normalmente se inicializan en cero.

Los contadores y los acumuladores

pueden ser usados en cualquier tipo

de ciclos.



Ejemplo:

Suponga que se desea crear un programa en Java que permita imprimir en pantalla la cantidad de números múltiplos de 3 que se encuentran en la serie 1 a n, siendo n un número digitado por un usuario.



Ejemplo:


Inicio contador: entero; contador=0; leer(n)


if ((i%3)==0){ contador=contador+1; }

Fin Desde imprimir(contador);

Fin



Ejemplo:


Inicio contador: entero; contador=0; leerN()


if (esMultiploDeTres(i)){ contador=contador+1; }

Fin Desde imprimir(contador)

Fin



Ejemplo:

public class MultiplosDeTres {

static int n;

public static void leerN() {

n = Integer.parseInt(JOptionPane.showInputDialog("Ingrese n:"));

}

public static boolean esMultiploDeTres(int numero) {

if(numero%3==0){

return true;

}else{

return false;

}

}



Ejemplo:

public static void main (String arg[]) {

int contador=0;

leerN ();

for (int i = 1; i <= n; i++){

if (esMultiploDeTres(i)){

contador++;

}

}

JOptionPane.showMessageDialog(null,"En la serie 1 a "+ n+ " hay " + contador + " múltiplos de 3");

System.exit(0);

}



Ejemplo:


int contador=0;

leerN ();

for (int i = 1; i <= n; i++){

if (esMultiploDeTres(i)){

contador++;

}

} JOptionPane.showMessageDialog(null,"En la serie 1 a "+ n+ " hay " + contador + " múltiplos de 3");

System.exit(0);

}

La variable contador se incrementa en 1 cada vez que el método esMultiploDeTres retorna true (cierto) para el número i


Estructura for - Acumuladores

Los acumuladores son variables utilizadas para ir almacenando (acumulando) el resultado de una operación.

Pueden ser de tipo numérico (entero o real) en las cuales acumula el resultado de operaciones matemáticas, o de tipo cadena en las cuales se concatenan frases o palabras.

En el ejemplo del factorial se pueden observar las variables factorial y respuesta las cuales actúan como acumuladores numéricos y de cadena respectivamente.


Estructura For - Acumuladores

… public static void calcularFactorial(int n) { int factorial = 1; String respuesta=""; if (n >= 0) { if (n<=20){ for (int i = 1; i <= n; i++){ factorial=1; for (int j = 1; j <= i; j++){ factorial=factorial*j; } respuesta += "\n El Factorial de " + i + "es: " + factorial; } } } else { respuesta +=“Factorial de un negativo no existe”; } }

….

La variable factorial va acumulando el valor de la multiplicación y la variable respuesta va acumulando las cadenas usadas como respuesta en cada iteración del ciclo principal.


Ejercicios Estructura for

1. Diseñe un algoritmo que permita detectar los números pares existentes en una serie de 1 a n, siendo n un número digitado por un usuario.

2. Diseñe un algoritmo que permita obtener la suma de todos los números enteros existentes en una serie de 1 a n y la cantidad de números pares encontrados, siendo n un número digitado por un usuario. Use un ciclo for en su diseño.

3. Suponga que se desea saber la nota promedio del curso de algoritmia, diseñe un algoritmo que solicite la cantidad de estudiantes del curso y el promedio de cada estudiante.

NOTA: Para cada ejercicio realice su respectiva implementación en Java



4. Suponga que el calculo de la pensión de una persona se realiza de la siguiente manera: por cada año de servicio se paga $80 si el empleado ingresó en o después de 1995 y $100 si ingresó antes, dicho valor (80 o 100) se multiplica por el número de cada año más la edad que tenía en el año (ej. (100*1994+32)+(100*1995+33)+…), el descuento de seguridad social salud es del 12%. El programa debe recibir el año de ingreso y la edad del empleado en el año de ingreso, devolver el sueldo o mesada bruta, la mesada neta y el valor del descuento por salud.

Ejemplo: Para una persona que ingresó en el 2009 y que tenía 44 años en dicho año, su mesada o sueldo bruto para el 2011 es $482.535, el descuento por salud es $57.904 y por lo tanto su sueldo o mesada neta es $424.630.

NOTA: Realice la respectiva implementación en Java.



5. Escribir una aplicación que permita: generar los números enteros impares entre a y b

6. Crear una aplicación que permita:

• Generar los números pares entre p y q

• Generar los primeros z múltiplos de 3

• Generar la suma de m primeros múltiplos de 7 más los n primeros múltiplos de 9



Estructura while

Evalúa una condición dada para determinar si repite un conjunto de instrucciones. Si la condición es verdadera se repiten las instrucciones.

Observe que el primer paso es validar la condición y luego se ejecutan las instrucciones (en caso de que la condición cumpla).

Pseudocódigo Java

Mientras condición Haga instrucción 1 instrucción 2 ……. Fin mientras

while( condicion) { instrucción 1; instrucción 2; …… }


Estructura while

Iniciar condiciones;

while (condiciones)‏{

// Instrucciones a repetir

}

Debe existir una variable de control del ciclo

La variable de control se inicializa antes del ciclo

La variable de control se compara contra el valor final

La variable debe actualizarse dentro de

cada ciclo


Estructura while

Ejemplo:

int a=5, b=7, c=3;

while (a < b){ c = c *2; a = a + 1;

}


Estructura while

Ejemplo:

int a=5, b=7, c=3;

while (a < b){ c = c *2; a = a + 1;

}

Número Iteración

Valor variable a

Valor variable c

0 5 3

1 6 6

2 7 12

Se interrumpe


Estructura while

Ejemplo:

int a=9, b=7, c=3;

while (a < b){ c = c *2; a = a + 1;

}

Número Iteración

Valor variable a

Valor variable c

0 9 3

Se interrumpe

Si la primera vez la condición del ciclo while no se cumple, no se ejecuta ninguna instrucción.


Estructura do-while

Los ciclos do-while funcionan de la misma manera que los ciclos while, sin embargo un ciclo do-while ejecuta primero las instrucciones y luego hace la validación.

Ciclo do-while: Realiza un bloque de instrucciones y después evalúa la condición para determinar si repite el bloque o no.

Pseudocódigo Java

Haga instrucción 1 instrucción 2 …….

Mientras condición

do { instrucción 1;

instrucción 2; ……

} while(condicion);


Estructura do-while

Iniciar condiciones;

do‏ {

//Instrucciones a repetir

} while (condiciones)

Debe existir una variable de control del ciclo

La variable de control se inicializa antes del ciclo

La variable de control se compara contra el

valor final

La variable de control debe actualizarse dentro de cada ciclo


Estructura do-while

Ejemplo:

int a=5, b=7, c=3;

do { c = c *2;

a = a + 1; } while (a<b);


Estructura do-while

Ejemplo:

int a=5, b=7, c=3;

do { c = c *2;

a = a + 1; } while (a<b);

Número Iteración

Valor variable a

Valor variable c

0 5 3

1 6 6

2 7 12

Se interrumpe


Estructura do-while

Observe que la primera vez se ejecutan las instrucciones aunque la condición del ciclo no sea válida. Por ejemplo:

int a=9, b=7, c=3;

do { c = c *2;

a = a + 1; } while (a < b);


Estructura do-while

Observe que la primera vez se ejecutan las instrucciones aunque la condición del ciclo no sea válida. Por ejemplo:

int a=9, b=7, c=3;

do { c = c *2;

a = a + 1; } while (a < b);

Número Iteración

Valor variable a

Valor variable c

0 9 3

1 10 6

Se interrumpe


Ejercicio Estructura while

Ejercicio: El curso de Algoritmia se califica con dos parciales (el primero tiene un peso de 30% y el segundo 35%), una nota de laboratorios (25%) y una nota del trabajo final del curso (10%)

Calcular la nota definitiva para un grupo de n estudiantes



Ejercicio: El curso de Algoritmia se califica con dos parciales (el

primero pesa 30%, el segundo 35%), laboratorios (25%) y trabajo

final (10%) . Hallar la nota definitiva para n estudiantes.

Inicialmente calculamos la nota para un estudiante, conocidas

sus 4 calificaciones:

real calculaDefinitiva (p1, p2, lab, tra : real) {

real def = 0

def = p1*0.3+p2*0.35+ la*0.25+ta*0.1

retornar def

} // Fin del método calculaDefinitiva


Ejercicio Estructura while Ejercicio: El curso de Algoritmia se califica con dos parciales (el

primero pesa 30%, el segundo 35%), laboratorios (25%) y trabajo final (10%) . Hallar la nota definitiva para n estudiantes.

Prueba de escritorio del algoritmo:

real calculaDefinitiva (p1, p2, lab, tra: real) { real def = 0 def = p1*0.3+p2*0.35+ la*0.25+ta*0.1; retornar def } // Fin del método calculaDefinitiva

p1 p2 lab tra

3,2 2,4 4,4 3,0

def = 3,2



Ejercicio: El curso de Algoritmia se califica con dos parciales (el primero pesa 30%, el segundo 35%), laboratorios (25%) y trabajo final (10%) . Hallar la nota definitiva para n estudiantes.

Ahora trabajamos en el algoritmo principal: Inicio nomb: texto par1, par2, lab, tar: real nEst, j = 1: entero

Leer (nEst)

mientras (j <= nEst) haga leer (nomb) leer(par1) leer(par2) leer(lab) leer(tar) Imprimir(par1 + par2 + lab + tar + calculaDefinitiva(par1, par2, lab, tar)) j++ Fin mientras Fin


Ejercicio Estructura while Ejercicio: El curso de Algoritmia se califica con dos parciales (el primero

pesa 30%, el segundo 35%), laboratorios (25%) y trabajo final (10%) . Hallar la nota definitiva para n estudiantes.

Ahora elaboramos el programa principal a partir del algoritmo, en Java :

Inicio nomb: texto par1, par2, lab, tar: real nEst, j = 1: entero

Leer (nEst)

mientras (j <= nEst) haga Leer (nomb) leer(par1) leer(par2) leer(lab) leer(tar); Imprimir(par1 + par2 + lab + tar + calculaDefinitiva(par1, par2, lab, tar) j++ Fin mientras Fin

public static void main (String [ ] arg) ‏{ String nomb; double par1, par2, lab, tar; int nEst, j= 1; nEs=Integer.parseInt(JOptionPane.showInputDialog (“Numero de Estudiantes:")); while (j < = nEst) { nomb= JOptionPane.showInputDialog(“Nombre"); par1= Double.parseDouble (JOptionPane.showInputDialog (“Parcial 1")); par2, lab, tar =D.pD(JOP.sMD (…)); JOptionPane.showMessageDialog(null, "\n"+nomb+”\t”+par1+"\t"+par2+"\t"+lab+"\t"+ tar+"\t"+calculaDefinitiva (par1, par2, lab, tar) ); j++; } }



Ejercicio: Para ingresar al curso de Producción Cinematográfica se realizó un prueba clasificatoria. Se tiene los resultados de dicho examen por aspirante (una nota comprendida entre 0.0 y 5.0) y se desea saber cuántos aspirantes aprobaron el examen, cuántos lo perdieron (nota menor que 3.0) y cuál fue el promedio de todo el grupo de aspirantes. No sabemos cuántos aspirantes son, pero sabemos que cuando se quiera indicar que se finalizó el ingreso de notas se digitará un valor negativo.


Ejercicio Estructura while void determinarEstadisticasSegunNotas() Inicio nota, promedioCalificaiones: real numAprobados, numReprobados : entero leer(nota)

Mientras nota>=0 Haga

Si (nota<=5 ){ Si (nota>=3 ){

numAprobados = numAprobados +1 } sino{ numReprobados = numReprobados + 1 }

promedioCalificaciones = promedioCalificaciones + nota } leer(nota) Fin mientras

promedioCalificaciones = promedioCalificaciones / (numAprobados + numReprobados) imprimir(numAprobados, numReprobados, promedioCalificaciones)

Fin


Ejercicio Estructura while public class NotasAsignatura { static int numAprobados,numReprobados; static double promedioCalificaciones;

public static void determinarEstadisticasSegunNotas() { numAprobados =0; numReprobados =0; promedioCalificaciones=0.0;

double nota= Double.parseDouble(JOptionPane.showInputDialog(“Digite la nota:"));

while (nota>=0.0){ if(nota<=5){ if(nota>=3){ numAprobados = numAprobados +1; } else{ numReprobados = numReprobados +1; } promedioCalificaciones = promedioCalificaciones + nota; } nota= Double.parseDouble(JOptionPane.showInputDialog(“Digite la nota:")); } promedioCalificaciones = promedioCalificaciones / (numAprobados + numReprobados ); JOptionPane.showMessageDialog(null, “Aspirantes aprobados :”+ numAprobados + “\n Aspirantes reprobados :”+ numReprobados + “\n Promedio notas :”+ promedioCalificaciones ); }




determinarEstadisticasSegunNotas();

System.exit(0); } }


Ejercicio Estructura do-while

Ejercicio: Realice el ejercicio anterior (sobre el calculo de estadísticas para el ingreso al curso de Producción Cinematográfica) utilizando el ciclo do-while.



Ejercicio: Algoritmos del programa Curso Cinematografía.

void determinarEstadisticasSegunNotas() Inicio numAprobados, numReprobados : entero nota, promedioCalificaciones : real Haga leer(nota)

Si (nota>=0 && nota <=5){ Si (nota>=3) { numAprobados = numsAprobados +1 } Sino { numReprobados = numReprobados + 1 }

promedioCalificaciones = promedioCalificaciones + nota } Mientras (nota>=0);

promedioCalificaciones = promedioCalificaciones / (numAprobados + numReprobados ) imprimir(numAprobados, numReprobados, promedioCalificaciones)

Fin



public static void determinarEstadisticasSegunNotas() { numAprobados =0; numReprobados =0; promedioCalificaciones=0.0; double nota;

do{ nota= Double.parseDouble(JOptionPane.showInputDialog(“Digite la nota:"));

if(nota>=0.0 && nota <=5){ if(nota>=3.0){

numAprobados = numAprobados +1; } else { numReprobados = numReprobados +1; } promedioCalificaciones = promedioCalificaciones + nota; }

} while (nota>=0.0);

…



Importante:

En cualquiera de las estructuras de repetición implementadas en Java, se puede detener el ciclo usando la instrucción break o detener una iteración utilizando la instrucción continue.

Normalmente se usan las instrucciones break o continue cuando se ha cumplido una condición de anormalidad u otra especificada por el desarrollador dentro del contexto de un problema. En resumen: break detiene el ciclo completamente y continue detiene una iteración pasando a la siguiente.



Importante:

Cualquiera de los ejercicios mostrados en esta presentación pueden ser implementados sin la necesidad de crear métodos (dentro del método main).


Ejercicios Estructuras while y do-while

1. Diseñe un algoritmo que reciba números digitados por el usuario y los imprima en pantalla, el programa debe terminar cuando el usuario digite un número negativo.

2. Diseñe un algoritmo que reciba números digitados por el usuario y al final imprima la suma de los números digitados, el programa debe terminar cuando el usuario digite 0 (cero).

3. Cree un algoritmo que permita digitar palabras y al final imprima la concatenación de las palabras digitadas, el programa debe terminar cuando el usuario digite la palabra “terminar”.

NOTA: Para cada ejercicio realice su respectiva implementación en Java, use la estructura que le parezca más conveniente (while o do-while)


4. Suponga que el cálculo de la pensión de una persona se realiza de la siguiente manera: por cada año de servicio se paga $80 si el empleado ingresó en o después de 1995 y $100 si ingresó antes, dicho valor (80 o 100) se multiplica por el número de cada año más la edad que tenía en el año (ej (100*1994+32)+(100*1995+33)+…), el descuento de seguridad social en salud es del 12%. El programa debe recibir el año de ingreso y la edad del empleado en el año de ingreso, devolver el sueldo o mesada bruta, la mesada neta y el valor del descuento por salud.

Ejemplo: Para una persona que ingresó en el 2009 y que tenía 44 años en dicho año, su mesada o sueldo bruto para el 2011 es $482.535, el descuento por salud es $57.904 y por lo tanto su sueldo o mesada neta es $424.630.




Suponga que el administrador de una tienda desea calcular el

total de ventas del día, para ello debe registrar el nombre del

producto, el valor del producto y la cantidad de unidades

vendidas. Al final el sistema debe mostrar la lista de productos

digitados, el total de ventas por cada producto, el total de ventas

del día y el valor global cobrado por concepto del IVA.

El administrador puede registrar productos hasta que él decida

que ha terminado para lo cual digita un dato negativo.





Ejercicio: El curso de Algoritmia se califica con dos parciales (el primero tiene un peso de 30% y el segundo 35%), una nota de laboratorios (25%) y una nota del trabajo final del curso (10%) .

Se pide calcular la nota definitiva, pero ahora NO se conoce el número de estudiantes



Ejercicio: El curso de Algoritmia se califica con dos parciales (el primero pesa

30%, el segundo 35%), laboratorios (25%) y trabajo final (10%) . Hallar la nota

definitiva sin conocer el número de estudiantes.

Inicialmente calculamos la nota para un estudiante, conocidas sus 4

calificaciones:

real calculaDefinitiva (p1, p2, lab, tra : real) {

real def = 0

def = p1*0.3+p2*0.35+ la*0.25+ta*0.1

retornar def

} // Fin del método calculaDefinitiva


Ejercicio Estructura while Ejercicio: El curso de Algoritmia se califica con dos parciales (el

primero pesa 30%, el segundo 35%), laboratorios (25%) y trabajo final

(10%) . Hallar la nota definitiva sin conocer el número de estudiantes. Prueba de escritorio del algoritmo:

real calculaDefinitiva (p1, p2, lab, tra: real) { real def = 0 def = p1*0.3+p2*0.35+ la*0.25+ta*0.1 retornar def } // Fin del método calculaDefinitiva

p1 p2 lab tra

3,2 2,4 4,4 3,0

def = 3,2



Ejercicio: El curso de Algoritmia se califica con dos parciales (el primero pesa 30%, el segundo 35%), laboratorios (25%) y trabajo final (10%) . Hallar la nota definitiva sin conocer el número de estudiantes.

Ahora trabajamos en el algoritmo principal: Inicio

nomb: texto

par1, par2, lab, tar: real

Leer (nomb) leer(par1) leer(par2) leer(lab) leer(tar)

haga

Imprimir(par1 + par2 + lab + tar + calculaDefinitiva(par1, par2, lab, tar)

leer (nomb) leer(par1) leer(par2) leer(lab) leer(tar)

mientras (nomb != “Final” )

Fin


Ejercicio Estructura while Ejercicio: El curso de Algoritmia se califica con dos parciales (el primero pesa

30%, el segundo 35%), laboratorios (25%) y trabajo final (10%) . Hallar la nota definitiva sin conocer el número de estudiantes.


Inicio

nomb: String;

par1, par2, lab, tar: float;

Leer (nomb) leer(par1) leer(par2)

leer(lab) leer(tar)

haga

Imprimir(par1 + par2 + lab + tar +

calculaDefinitiva(par1, par2, lab, tar);

Leer (nomb) leer(par1) leer(par2)..

mientras (nomb != “Final” ) ;

Fin

public static void main (String [ ] arg) ‏{ String nomb; float par1, par2, lab, tar; DecimalFormat forma = new DecimalFormat ("0.00"); JTextArea miArea = new JTextArea(15,30); JScrollPane miScroll = new JScrollPane(miArea); miArea.append(“\nNomb \tParc1 \t”+ “Parc2\tLab\tTareas\tDefin"); nomb= JOptionPane.showInputDialog(“Nombre"); // Sigue instrucción do-while …





Inicio

nomb: String;

par1, par2, lab, tar: float;

Leer (nomb) leer(par1) leer(par2)

leer(lab) leer(tar)

haga

Imprimir(par1 + par2 + lab + tar +

calculaDefinitiva(par1, par2, lab, tar);

Leer (nomb) leer(par1) leer(par2)..

mientras (nomb != “Final” ) ;

Fin

do { par1= Double.parseDouble (JOptionPane.showInputDialog (“Parcial 1")); par2, lab, tar =D.pD(JOP.sMD (…)); miArea.append ("\n"+nomb+”\t”+forma.format(par1)+ "\t"+forma.format(par2)+"\t"+ forma.format(lab)+"\t"+ forma.format(tar)+"\t"+ forma.format(calculaDefinitiva (par1, par2, lab, tar) ) ); nomb= JOptionPane.showInputDialog(“Nombre"); } while (!nomb.equals("Final")); } // Se realiza la impresión del área de texto JOptionPane.showMessageDialog(null, miScroll, "Calculo de la Nota Final del Curso ", JOptionPane.INFORMATION_MESSAGE); System.exit(0); } // fin del método main




Probemos el programa:

JTextArea Area de Texto

miArea

JScrollPane barra de

desplazamiento miScroll


Uso del JTextArea

JOptionPane.showMessageDialog(null, miScroll);

JOptionPane.showMessageDialog(null, miScroll,"Calculo de Nota

Final del Curso ", JOptionPane.INFORMATION_MESSAGE);

La instrucción JOptionPane.showMessageDialog sirve para mostrar el conjunto formado por el área de texto y el scroll

Scroll donde se insertó el

área de texto

(miArea)

Ventana de dialogo con el título "Calculo de Nota Final del Curso "


Estructura de Iteración (do-while)

Ejercicio: Calcular el valor del cos (X) (coseno del ángulo x), usando la serie infinita: Imprima el valor del cos (Π/2) con 8 dígitos de precisión


Estructura de Iteración (do-while) 1. Entender el Problema

Sea x = π/2

Entonces la serie será:

Si tomamos 10 términos de la serie, tenemos:

Para un valor final de la suma igual a 0.00

00200734620000052944-0,0000000...620423730600,00002520

02748394260,0009192607633530,02086348

79010480,253669500136171,2337005512/cos

++

+

+=)(π


Ejercicios Estructuras de Iteración

a. Generar los números enteros impares entre p y q utilizando un ciclo

for

b. Generar el valor de para los números enteros x entre p y q

utilizando un ciclo do-while

Utilice la metodología de solución de problemas

Muestre los resultados en un JTextArea

Utilice la clase DecimalFormat para mostrar los resultados reales con 8 decimales.

ex


Ejercicios Estructuras de Iteración Construya una aplicación Java para los siguientes problemas: Utilice la metodología de solución de problemas

)!2(

)1(...

!10!8!6!4!21)cos(

2108642

m

xxxxxxx

mm

)!12(

)1(...

!11!9!7!5!3)(

12119753

m

xxxxxxxxsen

mm

)!2(...

!10!8!6!4!21)cosh(

2108642

m

xxxxxxx

m

)!12(...

!11!9!7!5!3)(

12119753

m

xxxxxxxxsenh

m

!

)1(...

!5!4!3!21

5432

n

Xxxxxxe

nnx

...5

)1(

4

)1(

3

)1(

2

)1()1()ln(

5432

xxxx

xx

Ciclos Java - NetsBeans - Algoritmia

Documents

Transcript of Ciclos Java - NetsBeans - Algoritmia