Siguiendo con los ejemplos del ciclo while, en esta ocación realizaremos cálculos matemáticos.

 

1.- Tabla de multiplicar de un número (Del 1 al 10).

2.- Factorial de un número.

3.- Dado un número imprimima una pirámide, ejemplo:

     Digito el número 5: 

**********
****  ****
***    ***
**      **
*        *
**********

Este programa nos pide la tabla de multiplicar de un número, creo una clase llamada CicloWhileTabla con su respectivo método main.

 

En cuanto al código lo primero es pedir el número al usuario:

 

int num=Integer.parseInt(JOptionPane.showInputDialog("Digita un número"));

 

y continuamos declarando una variable que nos servirá de contador y nuestro ciclo while, como queremos que imprima la tabla del 1 al 10, inicio mi contador en 1 y el ciclo finalizará cuando el contador llegue a 11:

 

int i=1;
while(i<=10){
           
}

 

Ahora solo queda las operaciones dentro del ciclo while:

 

System.out.println(num+" * "+i+" = "+num*i);
i++;

 

Como ven realizo las operaciones dentro del mismo mensaje que imprime, se puede hacer declarando otra variable, asignarle el valor de la multiplicación e imprimirla, pero este tema ya se habia visto (Véase Operaciones Aritméticas).

package pqtCiclos;

import javax.swing.JOptionPane;

public class CicloWhileTabla {

    public static void main(String[] args) {
        int num=Integer.parseInt(JOptionPane.showInputDialog("Digita un número"));
        int i=1;
        while(i<=10){
            System.out.println(num+" * "+i+" = "+(num*i));
            i++;
        }
    }
}

Este segundo programa viene a ser un poco más complicado, si aún no sabes lo que es un factorial te recomiendo antes ver el diagrama de flujo del problema.

 

Crearé una nueva clase llamada CicloWhileFactorial, con su main.

 

Se pide digitar un número el cual va a ser el número para conocer su factorial.

 

int num=Integer.parseInt(JOptionPane.showInputDialog("Digita un número"));

 

Tenemos que evaluar que el número digitado sea mayor que 0, en caso de ser 0 imprimirá su resultado directo que es 1.

 

if(num>0){
    if(num==0){
        JOptionPane.showMessageDialog(null, "El factorial de "+num+" es: 1");
    }else{
        //Aqui va la parte del ciclo
    }
}else{
    JOptionPane.showMessageDialog(null, "No se permiten números negativos");
}

 

Ahora declararemos una variable auxiliar llamada aux que se le asignará el valor de num-1, se procede con el ciclo:

 

int aux=

int aux=num-1;
        while(aux>1){
            num=num*aux;
            aux-=1; //Es lo mismo que hacer aux=aux-1;
        }

JOptionPane.showMessageDialog(null, "El factorial es: "+num);

 

Al final del ciclo simplemente imprimimos el resultado, nótese que esta vez vamos decrementando la variable en lugar de ir incrementandola, se puede resolver el problema incrementando la variable aux si se inicia con 0 y la condicio que sea menor a num.

 

package pqtCiclos;

import javax.swing.JOptionPane;

public class CicloWhileFactorial {

    public static void main(String[] args) {
        int num=Integer.parseInt(JOptionPane.showInputDialog("Digita un número"));
        if(num>0){
            if(num==0){
                JOptionPane.showMessageDialog(null, "El factorial de "+num+" es: 1");
            }else{
                int aux=num-1;
                while(aux>1){
                    num=num*aux;
                    aux-=1; //Es lo mismo que hacer aux=aux-1;
                }
                JOptionPane.showMessageDialog(null, "El factorial es: "+num);
            }
        }else{
            JOptionPane.showMessageDialog(null, "No se permiten números negativos");
        }
    }

}

Es cierto que este no es un programa de operaciones, si no de concatenación de cadenas.

 

Primeramente creo una clase llamada CicloWhilePiramide con su método principal main.

 

En la lógica a usar será la siguiente:

 

1.- Una variable digitada por el usuario (num).

2.- A una variable auxiliar (aux) pasamos el valor de num, esta variable ayudará a determinar los renglones.

3.- Se imprime tantos * dependiendo del renglón, si es renglón 1 imprime * iguales al número digitado.

4.- Otra variable para determinar el número de espacios en blanco a imprimir (El resultado de la resta de num-aux).

5.- En seguida se imprime tantos * como en el tercer paso.

6.- Se repite el proceso hasta alcanzar el número de renglones.

7.- Al finalizar el ciclo se imprime otra linea de * dos veces igual al número original digitado.

 

Al igual que los programas anteriores nos pide digitar un número:

 

int num=Integer.parseInt(JOptionPane.showInputDialog("Digita un número"));

 

 

Entonces necesitamos declarar una variable auxiliar para llevar el control de las lineas.

 

int aux=num; //num determina el número de lineas pero es en aux donde llevamos el control.
while(aux>0){
     //mientras aux es mayor a 0 imprimirá una nueva linea
}

 

El ciclo llegará hasta que el resultado de la resta sea igual a 0.

Para concatenar los * y los espacios en blanco utilizaremos tres ciclos más.

   //Este código va dentro del primer ciclo        

            int i=num-aux; //Variable para saber cuantos * se van a imprimir del lado izquierdo.
            while(i<num){
                System.out.print("*");
                i++;
            }
            i=num-aux; //resta para saber cuantos espacios se van a imprimir.
            while(i>0){
                System.out.print("  ");
                i--;
            }
            i=num-aux; //Misma operación para imprimir los * del lado derecho.
            while(i<num){
                System.out.print("*");
                i++;
            }
            System.out.println(); //Se hace un salto de linea
            aux--; //Se decrementa aux, esto indica que un renglon se imprimió.

 

Nótese que la instrucción System.out.print() es diferente a System.out.println(), la primera imprime las lineas sin hacer saltos de linea, la segunda imprime y da salto de linea.

 

Para finalizar tenemos que imprimir otra linea de * dos veces mayor al número digitado:

 

        while(num>0){
            System.out.print("**");
            num--;
        }

Si se quiere se puede cambiar los espacios en blanco por otro carácter.

package pqtCiclos;

import javax.swing.JOptionPane;

public class CicloWhilePiramide {

    public static void main(String[] args) {
        int num=Integer.parseInt(JOptionPane.showInputDialog("Digita un número"));
        int aux=num;
        while(aux>0){
            int i=num-aux;
            while(i<num){
                System.out.print("*");
                i++;
            }
            i=num-aux;
            while(i>0){
                System.out.print("  ");
                i--;
            }
            i=num-aux;
            while(i<num){
                System.out.print("*");
                i++;
            }
            System.out.println();
            aux--;
        }
        while(num>0){
            System.out.print("**");
            num--;
        }
    }
}