Java - Se desea procesar información respecto de jugadores y su rendimiento

 
Vista:

Se desea procesar información respecto de jugadores y su rendimiento

Publicado por nacho (8 intervenciones) el 23/07/2019 05:39:26
Se desea procesar información respecto de jugadores y su rendimiento en distintos juegos. Para lo anterior se cuenta con un arreglo que almacena el nombre de treinta jugadores y otro con el nombre de 10 juegos. Además, se tiene una matriz de 30x10 que contiene el mejor puntaje obtenido por cada uno de los 30 jugadores en cada uno de los 10 juegos de interés.

Se necesita procesar los datos obtenidos de las competencias que se van desarrollando. Por cada competencia se indica nombre del juego, y para cada jugador que participó en ella, nombre del jugador y puntaje obtenido.

Para la implementación de la solución debe definir una función para cada una de las siguientes tareas:
• Obtener identificador de un jugador. La función deberá retornar identificador del jugador dado su nombre. El identificador de un jugador es la posición que ocupa en el arreglo de nombres de jugadores. Considere que la función necesitará conocer el nombre del jugador a buscar y el arreglo de nombres de jugadores.
• Obtener identificador de un juego. La función deberá retornar identificador del juego dado su nombre. El identificador de un juego es la posición que ocupa en el arreglo de nombres de juegos.
• Determinar si un jugador mejoró su rendimiento en un cierto juego. La función deberá retornar verdadero si el puntaje obtenido en la última competencia es mejor que el registrado y falso en caso contrario. Para esto la función utilizará la matriz de puntajes, el identificador del jugador, el identificador del juego y el puntaje obtenido en la competencia que se está procesando.
• Actualizar mejor puntaje de un jugador en un juego. La función debe actualizar el puntaje en la matriz de puntajes, reemplazando el valor que se tiene registrado por el valor obtenido en la competencia que se está procesando para el juego y el jugador que correspondan.




chicos alguien me puede ayudar en el tema de las funciones por favor
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

Se desea procesar información respecto de jugadores y su rendimiento

Publicado por Kabuto (1381 intervenciones) el 23/07/2019 12:55:49
Hola, este ejercicio es más sencillo de lo que parece. A veces los enunciados nos hacen creer que piden algo complejo pero no es así.

Lo primero es tener clara la estructura básica del programa, es decir, las principales variables y funciones .

Las principales variables serán:
- el arreglo de 30 nombresJugadores;
- el arreglo de 10 nombresJuegos;
- la matriz de 300 puntuaciones (30x10)

Las funciones son las que pide el enunciado.
- devolver posición de un nombre en el arreglo Jugadores (devolverá un int)
- devolver posición de un nombre en el arreglo Juegos (devolverá un int)
- comprobar si una competencia (Puntuación que un Jugador ha obtenido en un Juego) supera la vigente en la matriz (true/false)
- actualizar una competencia en la matriz . En principio no necesita retornar nada, pero puede ser interesante que devuelva true/false para informar de si se ha actualizado o no la competencia.

Vale, con esto en mente, ya podemos crear la estructura básica del programa.
Pego aquí un código que modela todo lo que hemos dicho. Añado también una función extra que lo que va a hacer será inicializar los arreglos con nombres y la matriz con unas puntuaciones al azar.
Así ya estarán listas para poder ser usadas.
Sobre el tipo de juegos y puntuaciones no nos dan instrucciones, por tanto podemos decidir lo que queramos al respecto.
Así que yo he optado por poner nombres de juegos de mesa y las puntuaciones será entre 0 y 100:

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
public class Rendimiento {
 
	private static String[] nombresJugadores;
	private static String[] nombresJuegos;
	private static int[][] puntuaciones;
 
	public static void main(String[] args) {
 
		inicializarArreglos(); //Los arreglos quedan listos para ser usados
 
	}
 
	private static void inicializarArreglos() {
		//30 jugadores
		nombresJugadores = new String[] {
				"Andres", "Adolfo", "Ana", "Begoña", "Bruno",
				"Belinda", "Bertín", "Blanca", "Carina", "Carlos",
				"Casilda", "Cayetano", "Cintia", "Daniel", "Diana",
				"David", "Débora", "Darío", "Eduardo", "Elena",
				"Elías", "Eloy", "Elsa", "Fausto", "Felipe",
				"Fabiola", "Francisco", "Flora", "Fidel", "Gustavo"};
		//10 juegos
		nombresJuegos = new String[] {
				"Parchís", "La Oca", "Damas", "Ajedrez", "Rummy",
				"Monopoly", "Póker", "Black Jack", "Scattergories", "Trivial Pursuit"};
		//300 puntuaciones
		puntuaciones = new int[30][10];
		//Rellenaremos con puntuaciones al azar entre 0 y 100
		for (int f = 0; f < 30; f++)
			for (int c = 0; c < 10; c++)
				puntuaciones[f][c] = (int)(Math.random()*101);
	}
 
	private int getIdJugador(String nombreJugador) {
 
	}
 
	private int getIdJuego(String nombreJuego) {
 
	}
 
	private boolean competenciaMejorada(String nombreJugador, String nombreJuego, int puntaje) {
 
	}
 
	private boolean actualizarCompetencia(String nombreJugador, String nombreJuego, int puntaje) {
 
	}
 
}

Vale, ya tenemos la estructura.
Ahora hay que pensar en el código para que cada función cumpla su cometido.

El primer método, el getIdJugador() ha de recibir un nombre de Jugador, buscarlo en el arreglo y retornar la posición que ocupa.
Es tan simple como esto:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
 * Busca la posicion de un Jugador en el arreglo y 
 * devuelve su posición.
 * Si esta función devuelve el valor -1
 * es porque el nombre que se busca no existe 
 * en el arreglo.
 */
private int getIdJugador(String nombreJugador) {
 
    int idJugador = -1;
 
    for (int f = 0; f < nombresJugadores.length; f++)
        if (nombresJugadores[f].equals(nombreJugador)) //Si encontramos el jugador...
            idJugador = f; //...guardamos su posicion
 
    return idJugador;
}

Con los comentarios incluido ya queda explicado lo que hace.
Se declara un int con valor inicial de -1.
Se busca el nombre en el arreglo y cuando se encuentre guardamos la posición en el int que hemos declarado.
Por último se retorna el int con la posición del nombre.

Pero, ¿y si nos han dado un nombre que no existe en el arreglo? Esta posibilidad hay que contemplarla y podemos saber si esto ha ocurrido en el caso de que la función retorne el valor -1, que es el valor con el que se inicializó el int previamente.
Por eso no le he inicializado a valor 0 como es habitual, necesitamos inicializarlo con un valor que no pueda ser confundido con una posición válida del arreglo.

Bueno, si has entendido la lógica de esta función, seguro que ya puedes escribir tú mismo el código de la siguiente función getIdJuego(), pues es lo mismo pero para el arreglo de nombres de Juegos.

Vamos a ver la tercera función, la de comprobar si la competencia actual supera a la competencia guardada en la matriz.
Es decir, el usuario nos dará un nombre de jugador, un nombre de juego y una puntuación (estas tres cosas son una competencia).
Pues con esos datos, esta función ha de indicar si esta nueva puntuación, supera a la puntuación ya guardada.

Usando las dos primeras funciones obtendremos los ID de Jugador y Juego, que en realidad son los índices de la matriz en la que tenemos que consultar el puntaje.
Una vez tengamos unos ID válidos (nombre de Jugador y Juego son correctos) retornamos el resultado de comparar las puntuaciones.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
 * Ha de comprobar si la puntuación recibida es mejor que
 * la puntuación correspondiente a este Jugador en este Juego (competencia)
 */
private boolean competenciaMejorada(String nombreJugador, String nombreJuego, int puntaje) {
 
    //Obtenemos los id que nos indican que posicion de la matriz de puntos hay que consultar
    int idJugador = getIdJugador(nombreJugador);
    int idJuego = getIdJuego(nombreJuego);
 
    //Si Jugador o Juego no existen, informamos y devolvemos falso
    if (idJugador == -1) {
        System.out.println("No existe JUGADOR con nombre: " + nombreJugador);
        return false;
    }
    else if (idJuego == -1) {
        System.out.println("No existe JUEGO con nombre: " + nombreJuego);
        return false;
    }
    else
        //Retornamos el resultado de comparar si el puntaje actual supera el puntaje en la matriz
        return puntaje > puntuaciones[idJugador][idJuego];
}


OK, si esto te ha quedado claro, también sabrás ya hacer la última función. Es parecido a lo que acabamos de hacer, actualizar el puntaje de la matriz, pero solo, si el puntaje recibido supera al puntaje ya guardado en la matriz.


Y con esto ya tendrías todas las funciones listas.

Luego solo habría que pensar en un main() sencillo, un bucle que pida los datos de Competencias y actualice la matriz, si la nueva Competencia supera a la guardada en la matriz.

Si tienes dudas o te atascar o lo que sea, pregúntanos por aquí.

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
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

Se desea procesar información respecto de jugadores y su rendimiento

Publicado por Kabuto (1381 intervenciones) el 23/07/2019 13:17:59
Por cierto, se me olvidó poner que las funciones han de ser declaradas como static
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