Java - Programa de lanzamiento de dados

 
Vista:

Programa de lanzamiento de dados

Publicado por Johan Santiago (1 intervención) el 20/04/2019 03:59:23
Un Grupo de N amigos estan Jugando en el lanzamiento de tres dados y cada uno tiene cinco lanzamientos, cualquiera de ellos inicia el juego y si saca en los tres dados el mismo número será el ganador y el juego termina, en caso de que no suceda lo anterior, el ganador será quien acumule mayor puntaje en los cinco lanzamientos. El puntaje total se obtiene de sumar el valor de los dados en cada lanzamiento. El algoritmo debe de imprimir como salida el nombre del ganador y si fue por puntos (el total) o por sacar los tres dados iguales( ciao número). Utilice el método Sansón de la clase Matt para lanzamiento de dados
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

Programa de lanzamiento de dados

Publicado por Kabuto (1379 intervenciones) el 20/04/2019 15:29:19
Hola.
Para empezar, pensemos en que estructuras de datos vamos a necesitar. Está claro que vamos a tener que guardar los nombres de los jugadores y sus puntuaciones.
Para los nombres, nos basta con un array de String.
1
static String[] jugadores;

Sus puntuaciones, cada jugador tirará 5 veces y obtendrá un resultado que hay que guardar.
Si hay N jugadores (el usuario nos dirá cuantos jugadores participarán), tendremos Nx5 puntuaciones a guardar.

Claramente vamos a necesitar una matriz para guardar valores enteros.
1
static int[][] tablaPuntuaciones;

Bien, pensemos ahora en como funciona eso de "tirar los dados".
Cada tirada se hace con tres dados, es decir, tendríamos tres valores int entre 1 y 6
Podemos hacer un método que se encargue de esto, de generar tres números aleatorios entre 1 y 6 y los retorne juntos en un array de tres elementos.
Los números se generarán con Math.Random()... (nada de Matt ni de Sansón...)

1
2
3
4
5
6
7
8
9
10
static int[] lanzamiento() {
 
		int[] resultados = new int[3]; //Se tiran tres dados
 
		resultados[0] = (int)(Math.random()*6 + 1); //Primer dado
		resultados[1] = (int)(Math.random()*6 + 1); //Segundo dado
		resultados[2] = (int)(Math.random()*6 + 1); //Tercer dado
 
		return resultados;
	}

Este array con el valor de los tres dados, luego lo recogeremos en el programa principal y ya haremos con ellos las operaciones que tengamos que hacer.

Pues con esto ya tendríamos los elementos principales para empezar a crear el código.
Primero, deberíamos hacernos un esquema de como sería el flujo del programa:

* Preguntar al usuario cuantos jugadores participan.
* Inicializar array de nombres y la matriz de puntuaciones según el número de jugadores indicados por el usuario.
* Pedir los nombres de los jugadores.

* Comienza el juego, son 5 turnos y en cada turno los jugadores tiran los dados, ergo, necesitaremos dos bucles anidados.
El bucle principal se repetira durante 5 turnos. El bucle interno se repetirá N veces, según cuantos jugadores participan

* Cada iteración del bucle interno representa el lanzamiento de un determinado jugador, así que aquí dentro llamamos a nuestro método que simula tirar los dados y recogemos el array de tres elementos que nos va a retornar.
- Comprobamos si los tres elementos tienen el mismo valor, en cuyo caso este jugador en cuestión habrá ganado directamente y será el fin del juego.
- Si no son iguales, entonces hay que sumarlos y guardar el resultado en la matriz tablaPuntuaciones. Ojo a la hora de elegir los indices para indicar en que sitio de la matriz se ha de guardar.
Recordemos que la matriz es de N x 5, es decir, cada fila representa un jugador y cada columna representa el turno en el que se obtiene la puntuacion guardada.
El bucle externo nos da el índice de turno en que estamos, llamemosle i.
El bucle interno nos da el indice del jugador que está tirando ahora mismo, llamemosle j.

Si queremos guardar el dato correctamente en la matriz, habrá que indicar tablaPuntuaciones[ j ] [ i ], y no habrá que indicar tablaPuntuaciones[ i ] [ j ]

* Cuando los bucles hayan finalizado, si nadie ha ganado por haber conseguido tres números iguales al tirar los dados, habrá que evaluar la tabla de puntuaciones en busca de la puntuacion mayor y determinar así quien ha ganado




Bien ahora que hemos analizado lo que necesitamos, deberías intentar hacerlo tú. No importa si no lo consigues, si te atascas y/o te equivocas MEJOR, es entonces cuando se abre la oportunidad de aprender y comprender mejor las cosas.
Basta con que nos muestres donde te atascas y te ayudaremos a seguir.

En cualquier caso, yo te dejo aquí un código escrito por mí y la decisión de intentarlo o no es tuya.
Hay multitud de comentarios explicándo lo que se está haciendo por lo que creo que se entiende bastante bién. En cualquier caso, pregunta lo que no entiendas.

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
public class Dados {
 
	//Variables principales
 
	//Array para guardar nombres de n Jugadores
	static String[] jugadores;
 
	//Por cada Jugador, habrán 5 lanzamientos.Dichas puntuaciones las podemos guardar en una matriz de n x 5
	static int[][] tablaPuntuaciones;
 
	//Metodos
 
	/*
	 * Simula el lanzamiento de tres dados y devuelve los
	 * tres resultados en un array de tres elementos. 
	 */
	static int[] lanzamiento() {
 
		int[] resultados = new int[3]; //Se tiran tres dados
 
		resultados[0] = (int)(Math.random()*6 + 1); //Primer dado
		resultados[1] = (int)(Math.random()*6 + 1); //Segundo dado
		resultados[2] = (int)(Math.random()*6 + 1); //Tercer dado
 
		return resultados;
	}
 
 
	public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
		System.out.print("¿Cuantos jugadores serán?: ");
		int n = Integer.parseInt(teclado.nextLine());
 
		//Inicializamos los arrays con el numero de jugadores.
		jugadores = new String[n];
		tablaPuntuaciones = new int[n][5];
 
		//Pedimos nombres...
		System.out.println("\nIntroduzca nombres.");
		for (int i = 0; i < n; i++) {
			System.out.printf("Jugador #%d: ", (i+1));
			jugadores[i] = teclado.nextLine();
		}
 
		/*
		 * Comienza el juego.
		 * Son 5 turnos y cada jugador tirará los datos una vez.
		 * Si saca tres números iguales habrá ganado.
		 * Si no, se suma el valor de los dados, se guarda
		 * en la casilla correspondiente de la tablaPuntuaciones
		 * y lanza el siguiente jugador.
		 * 
		 * Con un booleano podemos detener el flujo del juego
		 * en el caso de que haya ganador por tres números iguales.
		 */
		boolean hayGanador = false;
 
		for (int i = 0; i < 5 && !hayGanador; i++) {
			System.out.print("\n\t\t\tTURNO #" + (i+1));
 
			//Ahora cada Jugador lanzará una vez
			for (int j = 0; j < jugadores.length && !hayGanador; j++) {
 
				System.out.printf("\n\nLanza el jugador %s --> ", jugadores[j]);
				//Pedimos a nuestro metodo que lance dados y recogemos resultado
				int[] dados = lanzamiento();
				System.out.printf("Dado1: %d\tDado2: %d\tDado3: %d", dados[0], dados[1], dados[2]);
				//Si ha sacado tres iguales, habrá ganado y los bucles finalizarán
				if (dados[0] == dados[1] && dados[1] == dados[2]) {
					System.out.println("\nHa ganado el Jugador " + jugadores[j]);
					hayGanador = true; //Esto pone fin al juego
				}
				else { //No ha ganado, sumamos y guardamos resultado
					tablaPuntuaciones[j][i] = dados[0] + dados[1] + dados[2];
				}
				//Ahora lanzará el siguente jugador...
			}
			System.out.println("\n\n\t\tPULSE INTRO PARA CONTINUAR");
			teclado.nextLine();
			//Ya han lanzado todos, comienza el siguiente turno..
		}
 
		/*
		 * Bucle de turnos finalizado.
		 * Si es porque hayGanador no hay que hacer nada, ya se informó en pantalla de quien ganó.
		 * De lo contrario, hay que evaluar la tablaPuntuaciones y ver quien ha ganado.
		 * 
		 * Podemos recorrer la tabla para ir mostrando los resultados y al mismo tiempo controlar
		 * cual ha sido la puntuacion mayor y a que jugador pertenece
		 */
		if (!hayGanador) {
			int mayorPunt = 0;
			String jugadorMayorPunt = new String();
			System.out.println("\n\n\t\tTABLA DE RESULTADOS");
			for (int i = 0; i < jugadores.length; i++) {
				System.out.print("\n" + jugadores[i]);
				for (int j = 0; j < 5; j++) {
					int puntos = tablaPuntuaciones[i][j]; //Recogemos puntuacion
					System.out.print("\t" + puntos); //Mostramos en pantalla
					if (puntos > mayorPunt) { //Controlamos si es la mayor puntuacion hasta ahora
						mayorPunt = puntos;
						jugadorMayorPunt = jugadores[i];
					}
				}
			}
 
			//TAbla mostrada y evaluada. Anunciamos ganador
 
			System.out.printf("\n\n***Ha ganado %s al conseguir un puntaje de %d***", jugadorMayorPunt, mayorPunt);
		}
		teclado.close();
		System.out.println("\n\n\t\t\tFIN DE PROGRAMA");
 
	}
 
}

En pantalla nos da un resultado como este:
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
¿Cuantos jugadores serán?: 3
 
Introduzca nombres.
Jugador #1: Lucas
Jugador #2: Luisa
Jugador #3: David
 
			TURNO #1
 
Lanza el jugador Lucas --> Dado1: 6	Dado2: 6	Dado3: 4
 
Lanza el jugador Luisa --> Dado1: 5	Dado2: 5	Dado3: 2
 
Lanza el jugador David --> Dado1: 1	Dado2: 3	Dado3: 3
 
		PULSE INTRO PARA CONTINUAR
 
 
			TURNO #2
 
Lanza el jugador Lucas --> Dado1: 1	Dado2: 1	Dado3: 4
 
Lanza el jugador Luisa --> Dado1: 1	Dado2: 3	Dado3: 6
 
Lanza el jugador David --> Dado1: 5	Dado2: 5	Dado3: 4
 
		PULSE INTRO PARA CONTINUAR
 
 
			TURNO #3
 
Lanza el jugador Lucas --> Dado1: 6	Dado2: 6	Dado3: 4
 
Lanza el jugador Luisa --> Dado1: 4	Dado2: 3	Dado3: 3
 
Lanza el jugador David --> Dado1: 5	Dado2: 5	Dado3: 3
 
		PULSE INTRO PARA CONTINUAR
 
 
			TURNO #4
 
Lanza el jugador Lucas --> Dado1: 6	Dado2: 4	Dado3: 1
 
Lanza el jugador Luisa --> Dado1: 1	Dado2: 4	Dado3: 4
 
Lanza el jugador David --> Dado1: 4	Dado2: 6	Dado3: 2
 
		PULSE INTRO PARA CONTINUAR
 
 
			TURNO #5
 
Lanza el jugador Lucas --> Dado1: 1	Dado2: 1	Dado3: 4
 
Lanza el jugador Luisa --> Dado1: 3	Dado2: 1	Dado3: 5
 
Lanza el jugador David --> Dado1: 1	Dado2: 2	Dado3: 4
 
		PULSE INTRO PARA CONTINUAR
 
 
 
		TABLA DE RESULTADOS
 
Lucas	16	6	16	11	6
Luisa	12	10	10	9	9
David	7	14	13	12	7
 
***Ha ganado Lucas al conseguir un puntaje de 16***
 
			FIN DE PROGRAMA
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
3
Comentar

Programa de lanzamiento de dados

Publicado por Alfonso Limón Mota (1 intervención) el 14/02/2021 00:41:37
¡FELICITACIONES!
Muchas gracias por compartir este programa en la red, me fue muy útil.
Aunque para correrlo, le tuve que importar java.util.Scanner; para que funcionara.
¿Hice lo correcto?
De antemano 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

Programa de lanzamiento de dados

Publicado por Kabuto (1379 intervenciones) el 14/02/2021 02:56:34
Sí.
Muchas veces al copiar el código aquí en el foro, me olvido de incluir los "import".
Me alegro de que siga siendo útil, veo que hace casi 2 años que publiqué ese mensaje.

Un saludo.
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

Programa de lanzamiento de dados

Publicado por Frida (2 intervenciones) el 25/06/2021 04:17:40
Muchas gracias!! tengo una duda para que funcione un aleatorio que se tuvo que haber importado?
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

Programa de lanzamiento de dados

Publicado por Kabuto (1379 intervenciones) el 25/06/2021 12:30:11
Cuando se invoca de esta manera:
1
resultados[0] = (int)(Math.random()*6 + 1);

Se está llamando directamente a la clase java.lang.Math y no hay que importar nada, porque esta clase ya está cargada en el paquete de librerías que Java importa por defecto.
Todas las clases del package "java.lang" (como la clase String por ejemplo) ya vienen importadas por defecto.

Aunque si queremos, podemos importarla como static y así en el código ya no será necesario llamar a la clase para acceder a sus métodos estáticos, solo tendremos que invocar directamente los métodos:

1
2
3
4
5
6
import static java.lang.Math.*;
 
.......
........
.........
resultados[0] = (int)(random()*6 + 1);



Hay otra forma de trabajar con aleatorios, y es usando la clase java.util.Random.
En este caso, sí que hay que hacer un import

1
2
3
4
5
6
7
import java.util.Random;
......
........
......
......
Random azar = new Random();
resultados[0] = azar.nextInt(7); //Devuelve entero entre 0 y 6
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

Programa de lanzamiento de dados

Publicado por Frida (2 intervenciones) el 25/06/2021 17:26:47
Muchisimas 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