Java - AYUDA-Java Netbeans

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

AYUDA-Java Netbeans

Publicado por Ulises Tomás (5 intervenciones) el 02/06/2021 00:12:29
Elabore un programa que almacene al azar un premio de $100.00, un premio de $1,000.00 y un premio de $10,000.00, los 3 en efectivo, en 3 posiciones numeradas, y que solicite al usuario un número de posición del 1 al 3. En cuanto el usuario seleccione la posición deseada, deberá indicar lo que ganó y los premios que había en las posiciones restantes. Deberá dividir el código en funciones y utilizar arreglos
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-Java Netbeans

Publicado por Kabuto (978 intervenciones) el 02/06/2021 00:51:32
Comienza tú un código y te ayudamos a completarlo.

Haz primero una versión simplificada y luego haz evolucionar el código hasta alcanzar lo que se pide.

Por ejemplo, puede que lo de asignar esos premios al azar en posiciones de un array te resulte complicado hacerlo. Bien, pues no lo hagas de momento.
Haz un método que reciba un array de tres posiciones y coloca esos premios. No al azar, simplemente ponlos como tu prefieras.

Y continua con el resto del programa, pide un valor al usuario entre 1 y 3, y dile que premio le ha tocado.

Cuando esto te funcione, miramos como hacer lo de asignar premios al azar.

Pero es importante que comiences tú un código, aunque no logres hacer gran cosa.
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
sin imagen de perfil
Val: 9
Ha aumentado su posición en 371 puestos en Java (en relación al último mes)
Gráfica de Java

AYUDA-Java Netbeans

Publicado por Ulises Tomás (5 intervenciones) el 02/06/2021 01:03:12
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
public class regalo {
    static Scanner entrada = new Scanner(System.in);
 
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int premio,regalo,a1,a2,a3;
        boolean encontro=false;
 
        while (!encontro){
 
            premio = 1+(int) (Math.random() * (3) );
 
            System.out.println("Ingresa numero del 1 al 3:");
            a1= entrada.nextInt();
            a2= entrada.nextInt();
            a3= entrada.nextInt();
 
            if (premio == a1){
 
               System.out.println("Felicidades obtuviste 100 pesos");
               encontro = true;
               System.out.println("En los lugares restantes habían 10,000 y 1,000 pesos ");
            }
          if (premio == a2){
 
               System.out.println("Felicidades obtuviste 10,000 pesos");
               encontro = true;
               System.out.println("En los lugares restantes habían 1,000 y 100 pesos ");
 
           }
          if (premio == a3){
 
               System.out.println("Felicidades obtuviste 1,000 pesos");
               encontro = true;
               System.out.println("En los lugares restantes habían 10,000 y 100 pesos ");
 
           }
        }
 
 
    }
}



ésto es lo que pude hacer pero creo que estoy mal
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

AYUDA-Java Netbeans

Publicado por Kabuto (978 intervenciones) el 02/06/2021 11:56:51
Necesitas utilizar un array de tres posiciones.
Cada posición contendrá un premio. La posición asignada a cada premio ha de realizarse al azar.

Luego se pide un (y solo uno) número al usuario, entre 1 y 3.
Este número que da el usuario determina el premio recibido.
Hay que tener en cuenta que las posiciones del array van de 0 a 2, y el usuario nos da un valor de 1 a 3.
Por tanto, al valor que nos de habrá que restarle -1.

Si el usuario nos da un 3, le tocará el premio de la posición 2 -> (3 - 1 = 2)

En pantalla tendremos que indicarle qué ha ganado, y cuáles son los otros premios disponibles.

Bien, esa es la mecánica a seguir.
El programa principal podría quedar así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
 
		int[] arrayPremios = new int[3];
		int eleccion = 0;
 
		asignarPremios(arrayPremios);
 
		//Repetimos hasta que nos de un valor aceptable
		while(eleccion < 1 || eleccion > 3) {
			System.out.print("Elija numero entre 1 y 3: ");
			eleccion = teclado.nextInt();
		}
 
		mostrarPremios(arrayPremios, eleccion - 1); //Restamos -1 porque posiciones array van de 0 a 2
 
		teclado.close();
	}

- Declaramos las variables que necesitaremos, un array para los premios y un int para que el usuario elija un número.

- Usaremos un método que recibe el array de premios y asignará los tres premios disponibles.

- Luego pedimos un valor entre 1 y 3. Esta petición la hacemos dentro de un bucle que se repetirá hasta que el usuario nos de un valor dentro del rango que le pedimos.

- Por último, a otro método le pasaremos el array de premios y el número escogido por el usuario para que determine y muestre en pantalla que premio se ha ganado y cuáles no.

Vamos a ver los métodos.

El método de asignarPremios() debería situar los premios en posiciones aleatorias, pero como dije al principio, de momento simplemente colocaremos los premios manualmente. Luego ya pensaremos como dar posiciones aleatorias.

1
2
3
4
5
6
private static void asignarPremios(int[] array) {
		//Asignamos premios manualmente
		array[0] = 100;
		array[1] = 1000;
		array[2] = 10_000;
	}

El método de mostrarPremios() ha de informar de lo ganado y no ganado.
Podemos hacerlo construyendo dos String, uno para informar de lo ganado y el segundo para los otros premios que estaban disponibles.

Entonces, con un bucle recorremos el array y el premio cuya posición se corresponda con la elección del usuario, lo concatenamos en el String del mensaje de premio ganado.
Los otros premios, los concatenaremos en el otro String.

Tras terminar el bucle, ya tendremos los dos mensajes construidos:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private static void mostrarPremios(int[] array, int posicion) {
		//Construiremos dos mensajes, el del premio ganado y el de los otros premios
		String ganado = "Premio ganado: ";
		String otros = "Otros premios disponibles: ";
 
		//Recorremos el array de premios para construir los mensajes
		for (int i = 0; i < array.length; i++) {
			if (i == posicion) //Este es el premio ganado
				ganado = ganado + array[i] + "$";
			else //Otros premios
				otros = otros + "\n-" + array[i] + "$";
		}
 
		//Mostramos los mensajes
		System.out.println("\n" + ganado);
		System.out.println(otros);
	}

Ahora que tenemos todo el código, si lo probamos, veremos en pantalla que funciona:
1
2
3
4
5
6
Elija numero entre 1 y 3: 2
 
Premio ganado: 1000$
Otros premios disponibles:
-100$
-10000$

Aquí ya tenemos varios objetivos del enunciado cumplido, solo faltaría lograr que las posiciones de los premios se asignen al azar. Así cada vez que se ejecute el programa, los premios estarán en distintas posiciones.
Porque ahora, los premios siempre están en el mismo sitio.

Esto lo veremos en el próximo mensaje. De momento, comprueba este código y asegúrate de que lo entiendes bien. Pregunta cualquier cosa que no te quede clara.

Pego aquí el código completo:
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
public class Premios {
 
	public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
 
		int[] arrayPremios = new int[3];
		int eleccion = 0;
 
		asignarPremios(arrayPremios);
 
		//Repetimos hasta que nos de un valor aceptable
		while(eleccion < 1 || eleccion > 3) {
			System.out.print("Elija numero entre 1 y 3: ");
			eleccion = teclado.nextInt();
		}
 
		mostrarPremios(arrayPremios, eleccion - 1); //Restamos -1 porque posiciones array van de 0 a 2
 
		teclado.close();
	}
 
	private static void asignarPremios(int[] array) {
		//Asignamos premios manualmente
		array[0] = 100;
		array[1] = 1000;
		array[2] = 10_000;
	}
 
	private static void mostrarPremios(int[] array, int posicion) {
		//Construiremos dos mensajes, el del premio ganado y el de los otros premios
		String ganado = "Premio ganado: ";
		String otros = "Otros premios disponibles: ";
 
		//Recorremos el array de premios para construir los mensajes
		for (int i = 0; i < array.length; i++) {
			if (i == posicion) //Este es el premio ganado
				ganado = ganado + array[i] + "$";
			else //Otros premios
				otros = otros + "\n-" + array[i] + "$";
		}
 
		//Mostramos los mensajes
		System.out.println("\n" + ganado);
		System.out.println(otros);
	}
 
}
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

AYUDA-Java Netbeans

Publicado por Kabuto (978 intervenciones) el 02/06/2021 12:25:39
Veamos como asignar premios al azar.

Usaremos un objeto Random que nos de valores enteros entre 0 y 2, que son las posiciones que tiene el array.
No va a servir pedirle tres veces que nos de un valor al azar, porque puede darnos posiciones repetidas y esto provocaría que no se repartieran bien todos los premios.

Antes de aceptar un valor al azar como bueno, habrá que comprobar si en esa posición ya hay un premio asignado o no.

Empezaremos asignando el premio de 100$.
Al principio, el array no tiene premios asignados, todos sus valores son 0. Así que ahora mismo, cualquier valor obtenido al azar será aceptable, porque no hay riesgo de "machacar" ningún premio asignado anteriormente.

Luego colocaremos el premio de 1000$
Aquí sí hay riesgo de "machacar" el premio anterior de 100$ porque el objeto Random podría darnos el mismo valor que nos dio antes y estaríamos asignando este premio en la misma posición donde asignamos el anterior.
Entonces, la petición de valores al Random la haremos dentro de un bucle que se repetirá hasta que comprobemos que la posición que nos da, no está ocupada por ningún premio.
Cuando esto se haya comprobado, podremos asignar los 1000$ a la posición obtenida.

Falta el premio de 10,000$.
Podríamos repetir el mismo proceso que antes, pedir valores Random hasta encontrar una posición libre.
Pero no es necesario, ya hemos colocado dos premios, así que ahora mismo solo queda una única posición disponible.
Así que ya no necesitamos el Random, basta con recorrer el array de premios, buscar la posición que está libre y asignar este último premio.


Por tanto, el método asignarPremios() quedaría de la siguiente forma. Parece un código largo pero es por las líneas de comentarios explicándolo.
En realidad es apenas una docena de líneas de código.

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
private static void asignarPremios(int[] array) {
 
    Random azar = new Random();
    int posicion;
 
    /*
     * Para asignar el primer premio de 100$
     * sabemos que el array de premios está vacío.
     * Así que cualquier posicion al azar que obtengamos
     * será aceptable
     */
    posicion = azar.nextInt(3); //Esto genera un entero entre 0 y 2
    array[posicion] = 100;
 
    /*
     * Para los siguientes premios, el array ya no estará vacío.
     * El objeto Random podría darnos posiciones donde ya existe
     * un premio asignado, así que habrá que repetir la generación
     * de posiciones hasta que nos de una posición que esté libre.
     * Una posición estará libre cuando el elemento al que apunta
     * tenga valor 0
     */
    //Asignamos los 1000$
    do {
        posicion = azar.nextInt(3);
    }while(array[posicion] != 0); //Repetimos mientras no obtengamos una posición libre
    //Si el bucle ha terminado, es que ya tenemos una posicion libre
    array[posicion] = 1000;
 
    /*
     * Falta asignar los 10,000$
     * No es necesario generar una posición al azar,
     * pues ya solo queda una posición libre.
     * Basta con buscarla y asignar este último premio
     */
    for (int i = 0; i < array.length; i++)
        if (array[i] == 0) //Posicion libre
            array[i] = 10_000; //Asignamos último premio
 
}


Y listo, con esto se cumple todo lo que pide el enunciado,
Insisto en que repase bien el código línea a línea, y lo que no entiendas, pregúntalo.

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