Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » ¿Como lleno automáticamente en el siguiente orden mi arreglo?

Java - ¿Como lleno automáticamente en el siguiente orden mi arreglo?

Volver
Nuevo Tema
<<>>
 
Vista:
Imágen de perfil de Samuel Jair
Val: 1
Ha aumentado su posición en 28 puestos en Java (en relación al último mes)
Gráfica de Java

¿Como lleno automáticamente en el siguiente orden mi arreglo?

Publicado por Samuel Jair (2 intervenciones) el 05/03/2019 01:20:57
Hola buen dia gente, quisiera saber si puedo llenar este arreglo automáticamente con ciclos for, y de que manera:


1
2
3
4
5
6
7
8
9
10
int tablero[][] = {  {91, 92, 93, 94, 95, 96, 97, 98, 99 ,100},
                     {90, 89, 88, 87, 86, 85, 84 ,83, 82, 81},
                     {71, 72, 73, 74, 75, 76, 77, 78, 79, 80},
                     {70, 69, 68, 67, 66, 65, 64, 63, 62, 61},
                     {51, 52, 53, 54, 55, 56, 57, 58, 59, 60},
                     {50, 49, 48, 47, 46, 45, 44, 43, 42, 41},
                     {31, 32, 33, 34, 35, 36, 37, 38 ,39 ,40},
                     {30, 29, 28, 27, 26, 25, 24, 23, 22, 21},
                     {11, 12, 13, 14, 15, 16, 17, 18, 19 ,20},
                     {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}};

es un tablero para serpientes y escaleras, solo quiero saber si existe forma de llenarlo en ese orden automáticamente, ya tengo mi programa, quiero saber como optimizar esta parte, Gracias de Antemano!
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
sin imagen de perfil
Val: 166
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

¿Como lleno automáticamente en el siguiente orden mi arreglo?

Publicado por Cesar (52 intervenciones) el 05/03/2019 01:53:16
Hola.

Forma facil, se me ocurre crear 10 arreglos, que vayan de tal a tal valor, y luego los agregas al arreglo tablero.

Otra forma, se me ocurre crear un while (no for, porque no se me ocurre como manejar los incrementos/decrementos de la forma que lo necesitas), y dentro de el validar el incremento/decremento, y asignarlo a la posicion correspondiente.

Ya casi salgo de trabajar. Si puedo, en un rato mas te pongo un ejemplo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

¿Como lleno automáticamente en el siguiente orden mi arreglo?

Publicado por Samuel Jair (2 intervenciones) el 05/03/2019 01:55:00
Vale gracias
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

¿Como lleno automáticamente en el siguiente orden mi arreglo?

Publicado por Kabuto (1381 intervenciones) el 05/03/2019 02:14:17
Otra forma es decidir en que orden recorremos cada "fila" segun si es par o impar.
Si es par, es decir, las filas 0, 2, 4, 6,..... las recorremos de derecha a izquierda, o sea, empezamos desde la última "columna" hasta la primera.

Si es impar, es decir, las filas 1, 3, 5, 7,.... las recorremos de izquierda a derecha, o sea, desde la primera columna hasta la última.

En ambos casos, vamos rellenando las celdas con números empezado desde la "casilla" mayor, valor 100 en tu ejemplo, y cada vez que guardamos un número en la matriz que representa el tablero, lo decrementamos.

Algo así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class Rellena {
 
	static int[][] tablero;
 
	static void rellenarTablero(int casillas) {
 
		for (int fila = 0; fila < tablero.length; fila++) {
			/*

			 * Las filas pares las rellenamos de derecha a izquierda.

			 * Las impares las rellenamos de izquierda a derecha

			 */
			if (fila % 2 == 0) {//Fila PAR

				for (int columna = tablero[0].length - 1; columna >= 0; columna--)
					tablero[fila][columna] = casillas--;
			}
			else { //Fila IMPAR

				for (int columna = 0; columna < tablero[0].length; columna++)
					tablero[fila][columna] = casillas--;
			}
		}
	}
 
	static void mostrarTablero() {
		for (int fila = 0; fila < tablero.length; fila++) {
			for (int columna = 0; columna < tablero[0].length; columna++) {
				System.out.print(tablero[fila][columna] + " ");
			}
			System.out.println();
		}
	}
 
	public static void main(String[] args) {
 
		int casillas = 100;
		tablero = new int[10][10];
		rellenarTablero(casillas);
		mostrarTablero();
	}
 
}

Esto nos da este resultado en pantalla:
1
2
3
4
5
6
7
8
9
10
91 92 93 94 95 96 97 98 99 100
90 89 88 87 86 85 84 83 82 81
71 72 73 74 75 76 77 78 79 80
70 69 68 67 66 65 64 63 62 61
51 52 53 54 55 56 57 58 59 60
50 49 48 47 46 45 44 43 42 41
31 32 33 34 35 36 37 38 39 40
30 29 28 27 26 25 24 23 22 21
11 12 13 14 15 16 17 18 19 20
10 9 8 7 6 5 4 3 2 1
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Billy Joel
Val: 2.665
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

¿Como lleno automáticamente en el siguiente orden mi arreglo?

Publicado por Billy Joel (876 intervenciones) el 06/03/2019 16:06:28
Yo también lo hice pero con otro enfoque...
He recorrido los números de forma descendente y los he ido colocando dentro de la matriz de derecha a izquierda, invirtiendo el orden de asignación cuando se llega a uno de los extremos del arreglo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class LlenarArreglo {
    public static void main(String[] args) {
        int[][] a = new int[10][10];
        boolean der = true;
        int i, j;
        i = 0;
        if (der) {
            j = a[i].length - 1;
        } else {
            j = 0;
        }
        for (int n = 100; n > 0; n--) {
            if (i < a.length && j >= 0 && j < a[i].length) {
                a[i][j] = n;
            } else {
                break;
            }
            if (der) {
                j--;
                if (j == -1) {
                    j = 0;
                    i++;
                    der = false;
                }
            } else {
                j++;
                if (j == a[i].length) {
                    j--;
                    i++;
                    der = true;
                }
            }
        }
        //Mostramos el resultado

        for (int k = 0; k < a.length; k++) {
            for (int l = 0; l < a[k].length; l++) {
                System.out.print(a[k][l] + (l + 1 < a[k].length ? "\t" : "\n"));
            }
        }
    }
}

Para controlar el orden de asignación (de derecha a izquierda o viceversa) utilizo la variable boleana der.
Cuando el valor de j es -1 o 10; quiere decir que se ha llegado al extremo de la matriz. Cuando eso pasa aumento el valor de i en 1 para continuar con la asignación en la siguiente fila, además de cambiar del valor de la variable der redireccionando el orden de asignación.

Como lo que se recorren son los números del 100 al 1 y su asignación en la matriz me enfoqué por ahí.
Si gustas puedes cambiar los valores de n, el tamaño de la matriz o el orden inicial de dirección de asignación (variable der); Y verás algo bonito

Saludos!!
;-)
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Billy Joel
Val: 2.665
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

¿Como lleno automáticamente en el siguiente orden mi arreglo?

Publicado por Billy Joel (876 intervenciones) el 06/03/2019 19:00:53
Me gustado tanto este algoritmo que lo he comprimido de 37 a 23 líneas.
Funciona igual, pero ya no es tan entendible lo que está pasando.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class LlenarArreglo {
    public static void main(String[] args) {
        int[][] a = new int[10][10];
        boolean der = false;
        int i = 0;
        int j = der ? a[i].length - 1 : 0;
        for (int n = 100; n > 0; n--) {
            if (i < a.length && j >= 0 && j < a[i].length) {
                a[i][j] = n;
            } else {
                break;
            }
            j = der ? j - 1 : j + 1;
            if (j == -1 || j == a[i].length) {
                j = j == -1 ? 0 : a[i].length - 1;
                i++;
                der = !der;
            }
        }
        //Mostramos el resultado

        for (int k = 0; k < a.length; k++) {
            for (int l = 0; l < a[k].length; l++) {
                System.out.print(a[k][l] + (l + 1 < a[k].length ? "\t" : "\n"));
            }
        }
    }
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar