Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » Ayuda con Simulador Go Kart en Java

Java - Ayuda con Simulador Go Kart en Java

Volver
Nuevo Tema
<<>>
 
Vista:
Imágen de perfil de Charly

Ayuda con Simulador Go Kart en Java

Publicado por Charly (4 intervenciones) el 24/07/2021 18:54:35
Hola a tod@s, estoy haciendo un proyecto para la Uni sobre un simulador para Go Kart

Si me orientan por favor sobre como:

1-Crear 5 tipos de competencias (a, b, c, d, e)
2-Cada competencia está formada por un número de vueltas que puede ser diferente en cada una
3-Cada competencia será calculada y generada por un número aleatorio entre 30-50
4-La distancia de cada vuelta será constante para todas las competencias y serán de 8150 pulgadas
5-Ordenar las competencias aleatorias y automáticamente
6- Ordenar el número de vueltas aleatoria automáticamente


Se los agradeceré.

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

Ayuda con Simulador Go Kart en Java

Publicado por Kabuto (1381 intervenciones) el 25/07/2021 00:36:09
El punto 5, y especialmente el 6, no termino de entenderlos.


A ver, hay que crear una clase Competencia

1
2
3
public class Competencia {
 
}

Esta clase, va a tener un valor constante, que es la distancia de vuelta

1
2
3
4
5
public class Competencia {
 
	private final int DISTANCIA = 8150; //pulgadas
 
}

Luego tiene un atributo, que es el número de vueltas:
1
2
3
4
5
6
7
public class Competencia {
 
	private final int DISTANCIA = 8150; //pulgadas
 
	private int vueltas;
 
}

La cantidad de vueltas, es un valor aleatorio entre 30 y 50, así que este valor se puede decidir al construirse el objeto.
Por tanto, lo decidimos en su constructor.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.Random;
 
public class Competencia {
 
	private final int DISTANCIA = 8150; //pulgadas
 
	private int vueltas;
 
	public Competencia() {
		Random azar = new Random();
		vueltas = azar.nextInt(21) + 30; //Valor entre 30 y 50
	}
 
}

Ok, no se pide explícitamente, pero no está de más, poner getter (pero no setter) para el atributo vueltas.
Y de paso, un getter que retorne la distancia total que supone esta Competencia, es decir, el nº de vueltas multiplicado por la DISTANCIA en pulgadas.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Random;
 
public class Competencia {
 
	private final int DISTANCIA = 8150; //pulgadas
 
	private int vueltas;
 
	public Competencia() {
		Random azar = new Random();
		vueltas = azar.nextInt(21) + 30; //Valor entre 30 y 50
	}
 
	public int getVueltas() {
		return vueltas;
	}
 
	public int getDistanciaTotal() {
		return vueltas * DISTANCIA;
	}
 
}

En el programa habrán distintas Competencias: a,b,c,d,e... es decir, tendrán un nombre. Así que añadimos este atributo, que su valor le llegará por constructor y le damos un getter para poder retornarlo cuando sea necesario.

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
import java.util.Random;
 
public class Competencia {
 
	private final int DISTANCIA = 8150; //pulgadas
	private int vueltas;
	private String nombre;
 
	public Competencia(String nombre) {
		Random azar = new Random();
		vueltas = azar.nextInt(21) + 30; //Valor entre 30 y 50
		this.nombre = nombre;
	}
 
	public int getVueltas() {
		return vueltas;
	}
 
	public int getDistanciaTotal() {
		return vueltas * DISTANCIA;
	}
 
	public String getNombre() {
		return nombre;
	}
 
}


Con esto, en una clase con main(), podemos crear las 5 competencias, con su nombre y sus distancias aleatorias:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class GoKart {
 
	private static Competencia[] competencias =  new Competencia[5];
 
	public static void main(String[] args) {
 
		competencias[0] = new Competencia("a");
		competencias[1] = new Competencia("b");
		competencias[2] = new Competencia("c");
		competencias[3] = new Competencia("d");
		competencias[4] = new Competencia("e");
 
 
		for (Competencia comp: competencias) {
			System.out.println("Competencia: " + comp.getNombre());
			System.out.println("Distancia: " + comp.getDistanciaTotal());
			System.out.println("---------");
		}
	}
}

En pantalla podemos ver los datos:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Competencia: a
Distancia: 293400
---------
Competencia: b
Distancia: 277100
---------
Competencia: c
Distancia: 277100
---------
Competencia: d
Distancia: 252650
---------
Competencia: e
Distancia: 350450
---------


Y entonces llegamos al punto 5. Ordenar las competencias, vale, para esto convendría implementar la interfaz Comparable para decirle a Competencia cómo ha de compararse con otras Competencias para ordenarse... pero..¿ordenarse en base a qué..?

¿Ordenarse por el nombre? Es decir, hacer un orden alfabético...
¿O tal vez ordenarse por la cantidad de vueltas? Es decir, un orden numérico.

¿Y qué significa el punto 6?
Dice: "Ordenar el número de vueltas"
¿Cómo? Las vueltas son un número, ¿Cómo se ordena un único número? ¿Cómo ordeno el 30? ¿O el 45? ¿O el 42?


No entiendo estos puntos, no se si tendrás más datos sobre el enunciado que aclaren esto
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 Charly

Ayuda con Simulador Go Kart en Java

Publicado por Charly (4 intervenciones) el 25/07/2021 04:33:58
Gracias @Kabuto, voy realizar el Frame a ver como se comporta el código .

Por otra parte, en el punto 5 se refiere a que Debo crear una clase Registro de Competidores con ID y edad de los competidores, el competidor está asociado a un equipo y a una categoría, basado en el ID y la edad debo ordenarlos.

Registro de Competidores
ID (identificación): Numero entre 100 y 500.
Edad: Numero entre los 18 a 80 años.

Categorías de competidores:
18 a 25 años: será Juvenil.
26 a 35 años: será Adulto
36 a 45 años: será Adulto Mayor
46 a 55 Años: será Veterano
56 en adelante será Oro

Equipos:
18 a 20 años: Rápidos y Furiosos / Rápidas y Furiosas
21 a 30 años: Velocidad Total
31 a 50 años: Prudencia
50 años en adelante: Prudencia Total

En el punto 6 el enunciado dice textualmente:

El orden de las competencias y la cantidad de vueltas se definirá aleatoria y automáticamente cuando se inicie la aplicación. Cada competencia está formada por un número de vueltas que puede ser diferente en cada una.

- La cantidad de vueltas de cada competencia será calculada y generada por un número aleatorio entre 30 – 50.
- La distancia de cada vuelta será constante para todas las competencias y serán de 8150 pulgadas.
- Se debe calcular la cantidad de kilómetros que equivalen al total de pulgadas que se recorrerán según la cantidad de vueltas de cada competencia. Utilice factores de conversión para pasar de las pulgadas a kilómetros.
- El orden de las competencias y la cantidad de vueltas y los kilómetros respectivos se deberá desplegar en pantalla.
- Se podrán cambiar estos valores con la opción “Reiniciar el simulador” la cual se explica más adelante.

Clasificación “General”
Por competidor: Es la sumatoria de todos los tiempos que ha realizado un competidor en cada competencia, ordenado de menor a mayor. Se debe desplegar Cédula, tiempo total y diferencia. La diferencia se calcula tomando el tiempo del segundo, restándole el tiempo del primero (esa sería la “diferencia”), el tiempo del tercero con el primero y así sucesivamente. Nota: El primero no tiene diferencia. La diferencia inicia a partir del segundo competidor.

Por Categoría: Es la sumatoria de todos los tiempos de todos los competidores en las 5 competencias que pertenecen a la misma categoría. Se debe desplegar: Nombre de la categoría y sumatoria de tiempos y diferencia. La diferencia se calcula tomando el tiempo del segundo restándole el tiempo del primero (esa sería la “diferencia”), el tiempo del tercero con el primero y así sucesivamente. Nota: El primero no tiene diferencia. La diferencia inicia a partir de la segunda categoría.

Por Equipo: Es la sumatoria de todos los tiempos de todos los competidores que pertenecen al mismo equipo. Se debe desplegar: Nombre del equipo y sumatoria de tiempos y diferencia. La diferencia se calcula tomando el tiempo del segundo restándole el tiempo del primero (esa sería la “diferencia”), el tiempo del tercero con el primero y así sucesivamente. Nota: El primero no tiene diferencia. La diferencia inicia a partir del segundo equipo.




Finalmente una clase que muestre a los ganadores(1er, 2do, 3er lugar)

Cuando todas las “competencias” hayan finalizado, se debe desplegar automáticamente los ganadores de la competencia del Go-Kart. Se muestran los ganadores de la general, por categoría y por equipos. Los ganadores son los que tenga la menor suma de tiempo.
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