Java - Ejercicio Java

 
Vista:
sin imagen de perfil
Val: 7
Ha aumentado su posición en 5 puestos en Java (en relación al último mes)
Gráfica de Java

Ejercicio Java

Publicado por Jesus (4 intervenciones) el 06/11/2018 17:07:01
Buenas!, soy estudiante d einformática y me he encontrada con este ejercicio el cual me sirve para estudiar lo que es toy cursando ahora mismo, pero por mas que lo intenti se me complica. Hay alguien que me lo pueda hacer porfavor. En teoria se trata de utilizar arrays bidimensionales, cadenas char, while, variables boleanas, if, else etc..
Muchas grácias

Ejercicio:
Hacer un simulador para el crecimiento de semillas en un jardín. Las reglas del simulador son
las siguientes:

1. Un jardín se define como una matriz bidimensional de valores enteros con 5 filas y 10
elementos por fila.

2. Los valores de cada número entero definen el estado de esa área del jardín como:
• 0: suelo vacío
• 1: significa que una semilla está en el suelo y se convertirá en una planta
• 2: significa que es una planta y puede soltar semillas
• 3: significa una planta adulta que no deja semillas y que necesita ser sacada por el
jardinero

3. El simulador tiene pasos de tiempo donde, durante cada paso de tiempo, una planta
puede soltar una semilla en un espacio de tierra vacío (uno de los nueve espacios
vecinos de manera aleatoria), una semilla puede convertirse en una planta, o una
planta puede ser sacada por el jardinero. Después de que una planta ha sido sacada,
esa zona del jardín vuelve a ser un espacio de suelo vacío.

4. Durante cada paso de tiempo (iteración), todos los valores distintos de cero en la
matriz se actualizan a su próximo estado
Se debe hacer un programa que muestre el estado del jardín en cada momento de tiempo. El
jardín se debe imprimir con las siguientes reglas:
• suelo vacío: mostrar espacio en banco
• semilla: mostrar carácter ‘.’
• planta lista para soltar semillas: mostrar carácter ‘o’
• planta que necesita ser sacada por el jardinero: mostrar carácter ‘X’

Se debe preguntar al usuario después de cada paso de tiempo si desea ver el estado del
jardín en el próximo paso de tiempo o si desea terminar el programa. Inicializa el jardín con
un conjunto de semillas, plantas y suelo vacío. Encuentra una combinación de semillas,
plantas y suelo vacío que genere un patrón interesante de crecimiento.
El programa debe validar la entrada de datos del usuario en todo momento.

Ejemplo de ejecución para una configuración hipotética:
Estado actual del jardín en el paso 1
---------------------------------------------------------
| | |.| | | |o| | | |o| | | |.| | | | |
---------------------------------------------------------
|.| |.| | | |.| | | |.| |.| | | |.| | |
---------------------------------------------------------
| | | | | | |.| | | | | |.| |o| |.| |.|
---------------------------------------------------------
| | | | |o| | | |.| | | | | | | | | | |
---------------------------------------------------------
|.| |.| | | | | | | |o| |.| | | | | | |
---------------------------------------------------------
¿ Desea ver el jardín en el próximo paso ? [S/n] s
Estado actual del jardín en el paso 2
---------------------------------------------------------
|.| |o| |.| |X| |.| |X| |.| |o| |.| |.|
---------------------------------------------------------
|o| |o| | | |o| | | |o| |o| | | |o| | |
---------------------------------------------------------
|.| |.| | | |o| | | | | |o| |X| |o| |o|
---------------------------------------------------------
|.| |.| |X| |.| |o| |.| |.| |.| |.| |.|
---------------------------------------------------------
|o| |o| |.| |.| |.| |X| |o| |.| |.| |.|
---------------------------------------------------------
¿ Desea ver el jardín en el próximo paso ? [S/n] s
Estado actual del jardín en el paso 3
---------------------------------------------------------
|o| |X| |o| | | |o| | | |o| |X| |o| |o|
---------------------------------------------------------
|X| |X| |.| |X| |.| |X| |X| |.| |X| |.|
---------------------------------------------------------
|o| |o| |.| |X| |.| |.| |X| | | |X| |X|
---------------------------------------------------------
|o| |o| | | |o| |X| |o| |o| |o| |o| |o|
---------------------------------------------------------
|X| |X| |o| |o| |o| | | |X| |o| |o| |o|
---------------------------------------------------------
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
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

Ejercicio Java

Publicado por Kabuto (1378 intervenciones) el 06/11/2018 22:13:42
Hola Jesus,

en este ejercicio (por no decir en todos), es muy importante subdividir lo que nos piden en distintos métodos, cada uno encargándose de una tarea muy específica.
Me ha parecido interesante este ejercicio y lo he hecho ahora.
Fíjate como me ha quedado el main:

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) {
 
		inicializarJardin();
		mostrarJardin();
 
		while(preguntarContinuar()) {
			evolucionarJardin();
			mostrarJardin();
		}
 
	}

Fíjate que son apenas 5 líneas y prácticamente se puede leer como si fuera un pseudocódigo.

Es superimportante conseguir esto, dividir el programa en pequeños objetivos y separarlos en métodos.
Esto hace que sea mucho más sencillo conseguir resolverlo, en lugar de ir a por el TODO, es mejor ir resolviendo objetivos menores.

Te propongo que sigas estos pasos.

1- Método que inicializa el jardin
El jardin es una matriz de enteros de 5x10.
Es decir, el jardin tiene 5 "hileras", cada una con 10 espacios para plantas
Tienes que recorrer elemento a elemento (ya sabes, usando 2 bucles anidados) e insertar al azar un valor entre 0 y 3. Algo así
1
jardin[i][j] = (int)(Math.random()*4);
Este método no tiene que hacer absolutamente nada más, simplemente eso

2 - Método que se encargue de mostrar en pantalla el jardin
De nuevo usamos 2 bucles anidados.
La diferencia es que entre hileras tenemos que insertar lineas que las separen tipo --> "--------------------------------"
Luego, tenemos que preguntar que valor tiene cada elemento y mostrar el caracter correspondiente.
Para esto nos vendrá de maravillas usar un switch, algo así:
1
2
3
4
5
6
7
8
9
10
11
switch(jardin[i][j])
				{
				case 0:
					System.out.print("| | ");
					break;
				case 1:
					System.out.print("|.| ");
					break;
				case 2:
                                 ....
                                 ....

Teniendo estos dos métodos, ya puedes comprobar en pantalla si estás consiguiente crear un jardin y mostrarlo en pantalla.
Cuando hayas conseguido esto, y que el jardin se muestre más o menos bonito, como indica el enunciado, pasa a lo siguiente.

3 - Método que haga evolucionar el jardín
El enunciado dice que todo valor distinto de 0, ha de evolucionar al siguiente estado.
Es decir, recorremos toda la matriz:
- Si encontramos un valor 1, lo incrementamos a 2.
- Si es un valor 2, pasa a 3.
- Si es un valor 3, pasa a 0... porque su evolucion es que esta planta es arrancada y queda el espacio libre.

¿Y que pasa si es un valor 0?
En este caso, debemos decidir al azar si va a recibir una semilla (valor 1) o sigue quedando vacio (valor 0)
Es decir, tenemos que asignarle al azar un valor entre 1 y 0. Algo así:
1
jardin[i][j] = (int)(Math.random()*2);

Si quieres complicarlo un poquito más y hacerlo un poco más interesante, puedes hacer que los espacios vacíos SOLO tengan la posibilidad de recibir una semilla si en su hilera existe una planta con valor 2, que en realidad son las que pueden germinar.
Esto no es necesario, pero puedes intentarlo.
Se puede hacer con un otro método al que le pases por argumento la hilera (no el jardin entero, solo la hilera) sobre la que estés trabajando.
Si encuentra alguna planta con valor 2 que devuelva TRUE y entonces le das la posibilidad de obtener semilla.
Si no hay plantas valor 2, que devuelva FALSE, lo cual significa que esa hilera no puede germinar ahora mismo y por lo tanto no hay posibilidad de dar semillas.

4- Metodo que pida al usuario si desea continuar o no.
Esto lo puedes enfocar como quieras. Yo lo he hecho de manera que el usuario ha de introducir "si" o "no".
Si pone algo distinto, le vuelvo a preguntar.
Cuando me da una de las dos opciones válidas, pues en el caso del "si" devuelvo TRUE, de lo contrario devuelvo FALSE.

Así, este método tal cual, me sirve como condicion para bucle while que va repitiendo todo el proceso.

Básicamente, estos son los pasos que has de seguir.
Como consejo último, recomienda declarar la matriz como atributo de la clase, es decir, fuera del main() y señalándola como static.
De este modo, todos los métodos tendrán acceso directo a la matriz para trabajar con ella, no será necesario pasársela como argumento a cada método.
Lo mismo haría con el objeto Scanner (para pedir opcion al usuario por teclado), declararlo como atributo estatico de la clase.


Mira, te dejo aquí mi código completo. Tú decides si quieres intentarlo primero por tu parte o ver la solución.
Un saludo.
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package simulaJardin;
 
import java.util.Scanner;
 
public final class Jardin {
 
	//Atributos de la clase
	static Scanner teclado = new Scanner(System.in);
 
	//Un jardín se define como una matriz bidimensional de valores enteros con 5 filas y 10
	//elementos por fila.
	static int[][] jardin = new int[5][10];
 
	//Metodos del programa
 
	static void inicializarJardin() {
		//Inicializa el jardín con un conjunto de semillas, plantas y suelo vacío.
		for (int i = 0; i < 5; i++)
			for (int j = 0; j < 10; j++)
				jardin[i][j] = (int)(Math.random()*4);
	}
 
	static void mostrarJardin() {
		/*
		 * Los valores de cada número entero definen el estado de esa área del jardín como:
		 * • 0: suelo vacío
		 * • 1: significa que una semilla está en el suelo y se convertirá en una planta
		 * • 2: significa que es una planta y puede soltar semillas
		 * • 3: significa una planta adulta que no deja semillas y que necesita ser sacada por el jardinero
		 *     -------------------------------------------
		 *El jardín se debe imprimir con las siguientes reglas:
		 *• suelo vacío: mostrar espacio en banco
		 *• semilla: mostrar carácter ‘.
		 *• planta lista para soltar semillas: mostrar carácter ‘o’
		 *• planta que necesita ser sacada por el jardinero: mostrar carácter ‘X’ 
		 */
		System.out.println("-----------------------------------------");
		for (int i = 0; i < 5; i++)
		{
			for (int j = 0; j < 10; j++)
			{
				switch(jardin[i][j])
				{
				case 0:
					System.out.print("| | ");
					break;
				case 1:
					System.out.print("|.| ");
					break;
				case 2:
					System.out.print("|o| ");
					break;
				case 3:
					System.out.print("|X| ");
				}
			}
			System.out.println("\n-----------------------------------------");
		}
		System.out.println("\n");
	}
 
	static void evolucionarJardin() {
		// Durante cada paso de tiempo (iteración), todos los valores distintos de cero en 
		// la matriz se actualizan a su próximo estado
		/*
		 * El enunciado dice que SOLO los valores distintos de cero evolucionan
		 * Los que sean igual a 0, es decir, suelo vacío, se decidirá al azar si reciben semilla o no.
		 * 
		 * En teoría, solo podrían recibir semilla si en esa hilera existe alguna planta en estado "2".
		 * Para hacerlo más interesante, podemos tener esto en cuenta y solo repartiremos semillas al azar
		 * si la hilera contiene una planta en estado "2".
		 * Esto puede provocar que durante la evolución, alguna hilera se quede sin germinar definitivamente.
		 */
 
		for (int i = 0; i < 5; i++)
			for (int j = 0; j < 10; j++)
			{
				switch(jardin[i][j])
				{
				case 0://Suelo vacio, solo si la hilera tiene plantas germinables, le pasaremos una semilla al azar
					if (hileraGerminable(jardin[i]))
						jardin[i][j] = (int)(Math.random()*2);
					break;
				case 3://Planta que hay que arrancar, se convierte en suelo vacio
					jardin[i][j] = 0;
					break;
				default://Para el resto de casos, simplemente avanzan al siguiente estado
					jardin[i][j]++;
				}
			}
	}
 
	static boolean hileraGerminable(int[] hilera) {
		for (int i = 0; i < hilera.length; i++)
			if (hilera[i] == 2)//Esta hilera contiene plantas que germinan
				return true;
 
		return false;//Si el bucle no ha retornado true, es que no hay plantas que germinan
	}
 
	static boolean preguntarContinuar() {
		String opcion = "";
		do {
			System.out.print("¿Quiere ver la siguiente evolucion del Jardin? (si/no): ");
			opcion = teclado.nextLine().toLowerCase();
		}while(!opcion.equals("si") && !opcion.equals("no"));
 
		if (opcion.equals("si"))
			return true;
		else
			return false;
 
	}
 
	public static void main(String[] args) {
 
		inicializarJardin();
		mostrarJardin();
 
		while(preguntarContinuar()) {
			evolucionarJardin();
			mostrarJardin();
		}
 
	}
 
}
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
sin imagen de perfil
Val: 7
Ha aumentado su posición en 5 puestos en Java (en relación al último mes)
Gráfica de Java

Ejercicio Java

Publicado por Jesus (4 intervenciones) el 07/11/2018 20:40:04
¡Muchas gracias Kabuto! me ayuda mucho que me lo expliques.
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