Java - Adivinar palabras con 3 dificultades

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

Adivinar palabras con 3 dificultades

Publicado por Jesus Alberto (4 intervenciones) el 01/10/2018 03:30:50
hola que tal estoy haciendo un programa que me adivine palabras y que tenga 3 dificultades pero no logro hacer que me lea las letras que escribo porque directamente me manda a la excepcion que puse en el codigo

esto es lo que llevo actualmente

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
package adivinapalabras;
 
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
 
 
public class AdivinarPalabras {
   public static BufferedReader entrada = new BufferedReader (new InputStreamReader(System.in));
   private static Set correctas;
 
   String Facil[]= {"reir","hola","jugo","papa","pala","pasa","para","alma","nada","casa","mama","tele","mira","tela","bala","cera","tira"};
   String Normal[]={"apretado", "avestruz","ceramica","estimulo","amarillo","eleccion","estrecho","invierno","chatarra","estrella"};
   String Dificil[]={"indiscutible","participante","personalismo","perturbacion","contundencia","supervisamos","buscapleitos","vinculandose"};
 
    public String generaPalabra(int Facil)
    {
        int n;
        n= (int)(Math.random()*4);
        if(Facil==0)
            return Normal[n];
 
        else
            return Dificil[n];
 
    }
 
   public boolean checarLetra (char letra,String palabra )
   {
       boolean mensaje=false;
       for(int i=0;i<palabra.length();i++)
       {
           if(letra==palabra.charAt(i))
           {
               mensaje = true;
               break;
           }
        }
       return mensaje;
    }
 
 
    public Set letrasPalabra(String palabra)
    {
        Set letras = new HashSet();
        for (int i=0;i<palabra.length() ;i++)
        {
            if(palabra.charAt(i) != ' ')
            {
              letras.add(palabra.charAt(i));
            }
        }
        return letras;
    }
 
 
    public String actualizaVisible(Set correctas, String palabra, String visible)
    {
        visible =""; boolean bandera = false;
        Iterator it = correctas.iterator();
        for(int i=0; i<palabra.length() ;i++)
        {
            while(it.hasNext())
            {
                char a = it.next().toString().charAt(0);
                System.out.println(" "+a+"  "+palabra.trim().charAt(i) );
                if ( a == palabra.trim().charAt(i) )
                {
                   visible += a; bandera = true;
                    break;
                }
            }
            if (bandera == false)
            {
                    visible += "_";
            }
            bandera=false; it = correctas.iterator();
        }
        return visible;
    }
 
 
 
    public static void main(String[] args) throws Exception {
 
        System.out.println("Establezca el nivel de dificultad: ");
        System.out.println("Facil(f)");
        System.out.println("Normal(n)");
        System.out.println("Dificil(d)");
        String dificultad = entrada.readLine();
 
        switch(dificultad)
        {
            case "f":
                AdivinarPalabras Operacion = new AdivinarPalabras ();
 
                Operacion.generaPalabra(1);
 
                System.out.println("Palabra generada: ****");
                System.out.println("teclea una letra de la palabra");
                String letra = entrada.readLine();
                char l=letra.charAt(0);
                try
                {
                    Operacion.checarLetra(l, letra);
                    Operacion.letrasPalabra(letra);
                    Operacion.actualizaVisible(  correctas,letra,letra);
                }
                catch(Exception ex)
                {
                    System.out.println("No introdujo una letra valida  "+ex.getMessage());
                }
            case "n":
        }
    }
}


Diapositiva1
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
sin imagen de perfil
Val: 5
Ha aumentado su posición en 7 puestos en Java (en relación al último mes)
Gráfica de Java

Adivinar palabras con 3 dificultades

Publicado por Jesus Alberto (4 intervenciones) el 01/10/2018 06:07:33
volvi a hacer el programa porque la verdad si lo habia echo muy raro y esto es lo que llevo, si alguien me puede ayudar estaria muy agradecido

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
public class AdivinarPalabras {
   public static BufferedReader entrada = new BufferedReader (new InputStreamReader(System.in));
 
   String Facil[]= {"reir","hola","jugo","papa","pala","pasa","para","alma","nada","casa","mama","tele","mira","tela","bala","cera","tira"};
   String Intermedio[]={"apretado", "avestruz","ceramica","estimulo","amarillo","eleccion","estrecho","invierno","chatarra","estrella"};
   String Dificil[]={"indiscutible","participante","personalismo","perturbacion","contundencia","supervisamos","buscapleitos","vinculandose"};
 
   public static void main(String[] args) throws Exception {
 
        System.out.println("Establezca el nivel de dificultad: ");
        System.out.println("Facil(f)");
        System.out.println("Intermedio (i)");
        System.out.println("Dificil(d)");
        String dificultad = entrada.readLine();
 
 
        switch(dificultad)
        {
            case "f":
 
                 System.out.println("Palabra generada: ****");
                 System.out.println("teclea una letra de la palabra");
                 String letra = entrada.readLine();
            case "i":
                System.out.println("Palabra generada: ********");
                 System.out.println("teclea una letra de la palabra");
                 String letra2 = entrada.readLine();
            case "d":
                System.out.println("Palabra generada: ************");
                 System.out.println("teclea una letra de la palabra");
                 String letra3 = entrada.readLine();
 
        }
    }
}
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: 2.995
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Adivinar palabras con 3 dificultades

Publicado por Kabuto (782 intervenciones) el 02/10/2018 01:08:53
Hola.
Para controlar que letras se han encontrado y cuales no. Se puede usar un array de char, con la misma longitud que la palabra que hay que adivinar.
El array puede empezar lleno de asteriscos y conforme el usuario acierta letras, cambiamos los asteriscos por la letra acertada, en la misma posicion donde dicha letra esta situada en la palabra que hay que acertar.

Cuando el array ya no tiene ningún asterisco, significa que el jugador ya ha descubierto todas las letras y el juego termina.

Esto es sencillo y tan solo hace falta unos pocos métodos para gestionar el array: comprobar si la letra intentada existe, comprobar si quedan o no asteriscos en el array...

Sin embargo, por lo que veo en tu primer intento parece que ya estás familiarizado con la creacion de nuevas clases. Así que lo ideal sería crear una clase que reciba un String con la palabra que hay que adivinar. Y dicha clase se encargará de crear un array de char conforme a la longitud de esa palabra y de toda la gestión necesaria.

He creado la siguiente clase, llamada PalabraMisteriosa (no soy muy bueno bautizando clases) que se encarga de todo lo que he dicho.
Incluso además, guarda una coleccion de todas las letras que el usuario va introduciendo en cada intento. Así podremos informarle de que está intentando con una letra ya repetida.
Para guardar esta coleccion he usado la clase Vector. Es similar a un array, pero más avanzado y dinámico ya que no hay que especificarle un tamaño fijo. Va creciendo según le añadimos elementos, objetos Character en este caso... que es como un char pero representado en forma de clase orientada a objetos, y no como un simple tipo primitivo como es el char y que no son aceptados por Vector
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
package adivinaPalabra;
 
import java.util.Vector;
 
public final class PalabraMisteriosa {
 
	String palabra;//Palabra que hay que adivinar
	char[] arrayLetras;//Sencillo array de char donde iremos poniendo las letras que el usuario acierte
	Vector<Character> letrasIntentadas = new Vector<Character>();//Aqui guardaremos las letras que el usuario vaya probando
 
	public PalabraMisteriosa(String palabra) {
		this.palabra = palabra;
		//Damos dimension al array segun la longitud de la palabra recibida
		arrayLetras = new char[palabra.length()];
		//Iniciamos el array de letras con asteriscos
		for (int i = 0; i < arrayLetras.length; i++)
			arrayLetras[i] = '*';
	}
 
	/**
	 * Devuelve la palabra misteriosa que hay que adivinar
	 * @return Palabra misteriosa a adivinar
	 */
	public String getPalabraMisteriosa() {
		return palabra;
	}
 
	/**
	 * Muestra todas las letras del array.
	 * Las muestra en linea, como si fuera una palabra.
	 */
	public void mostrarLetras() {
		for (char c: arrayLetras)
			System.out.print(c);
 
		System.out.println();//Salto linea
	}
 
	/**
	 * Recibe una letra y comprueba si coincide con alguna/s
	 * de las letras de la "palabra misteriosa".
	 * Informará en pantalla si hay o no coincidencias o bien si se está intentando
	 * con una letra que ya se intentó anteriormente.
	 * Si encuentra coincidencias, cambiará los asteriscos correspondientes
	 * en el array en las posiciones donde deber ir la letra coincidente.
	 * @param c Letra que queremos comprobar.
	 */
	public void buscarLetra(char c) {
 
		if (letrasIntentadas.contains(c)) {//Comprobamos si el usuario repite letra
			System.out.println("Ya intentaste con esta letra, prueba con otra.\n");
		}
		else {
			letrasIntentadas.add(c);//Guardamos la letra de este intento
			boolean coincidencia = false;
			for (int i = 0; i < palabra.length(); i++) {//Recorremos letras de la palabra buscando coincidencias
				if (palabra.charAt(i) == c) {
					coincidencia = true;//¡¡Coincidencia!!
					arrayLetras[i] = c;//Cambiamos asteriscos del array por letra en la posicion correspondiente
				}
			}
			//Informamos de si hubo coincidencias o no
			System.out.println(coincidencia?"Tu letra ha coincidido":"No hay coincidencias para tu letra");
		}
	}
 
	/**
	 * Determina si la palabra misteriosa ya ha sido resuelta o no.
	 * @return TRUE si ha sido resuelta. FALSE si no ha sido resuelta.
	 */
	public boolean palabraResuelta() {
		//Buscamos al menos un asterisco. Si lo encontramos, es que la palabra aun NO se ha resuelto
		for (char c: arrayLetras)
			if (c == '*')//Asterisco encontrado, NO se ha resuelto
				return false;
		//Si el bucle for ha llegado a su fin, es que no hay asteriscos. Por tanto, la palabra ha sido resuelta
		return true;
	}
 
}

Como puedes ver, tiene tan solo unos pocos métodos y son muy sencillos.
Puesto que ahora esta clase se encarga ella de toda la gestión de comprobar letras, informar de si hay aciertos, informar si ya se ha descubierto la palabra misteriosa o no...la clase con el método main() nos va a quedar muy ligero de código, siendo más fácil de entender y desarrollar.

Verás que en lugar de un BufferedReader para pedir al usuario datos, he usado un Scanner, más que nada porque es más sencillo y acorde ya que tan solo tenemos que pedir letras al usuario.

Añado como atributo un objeto de la clase PalabraMisteriosa que hemos creado.

A continuacion tenemos los arrays de palabras que habías creado. Aquí el unico cambio que he hecho ha sido declararlos como constantes añadiendo el atributo final a su declaración. Esto no es necesario, pero puesto que son datos que no van a ser modificados durante la ejecución del programa, es buena costumbre declararlos como final.

En el main(), pedimos al usuario que escoja dificultad.
Según su eleccion, instanciamos nuestro objeto PalabraMisteriosa con una palabra al azar de los arrays predefinidos.

Y ahora comienza el juego.
Iniciamos un bucle while que se va a repetir mientras la palabra NO se haya resuelto (nos valemos de un metodo propio de esta clase para saberlo)
Y en cada repeticion del bucle, mostramos el array de letras acertadas (al principio solo tiene asteriscos), pedimos una letra al usuario y comprobamos si ha acertado o no.
Los asteriscos se van cambiando por letras en cada acierto.

Cuando el usuario ha acertado todas las letras, el bucle while se cierra y ya solo queda informar al usuario de que el juego ha terminado.
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
package adivinaPalabra;
 
import java.util.Scanner;
 
public final class Adivinar {
 
	static Scanner entrada = new Scanner(System.in);
 
	static PalabraMisteriosa pm;//Objeto que gestiona la palabra misteriosa ha adivinar
 
	final static String Facil[]= {"reir","hola","jugo","papa","pala","pasa","para","alma","nada",
			"casa","mama","tele","mira","tela","bala","cera","tira"};
	final static String Intermedio[]={"apretado", "avestruz","ceramica","estimulo","amarillo",
			"eleccion","estrecho","invierno","chatarra","estrella"};
	final static String Dificil[]={"indiscutible","participante","personalismo","perturbacion",
			"contundencia","supervisamos","buscapleitos","vinculandose"};
 
	public static void main(String[] args) {
 
		System.out.println("Establezca el nivel de dificultad: ");
		System.out.println("Facil(f)");
		System.out.println("Intermedio (i)");
		System.out.println("Dificil(d)");
		char dificultad = entrada.nextLine().toLowerCase().charAt(0);//Esto recoge un caracter en minuscula desde teclado
 
		//Segun la dificultad, instanciaremos el objeto PalabraMisteriosa con palabra de distintas longitudes
		switch(dificultad)
		{
		case 'f':
			pm = new PalabraMisteriosa(Facil[(int)(Math.random() * Facil.length)]);
			break;
		case 'i':
			pm = new PalabraMisteriosa(Intermedio[(int)(Math.random() * Intermedio.length)]);
			break;
		case 'd':
			pm = new PalabraMisteriosa(Dificil[(int)(Math.random() * Dificil.length)]);
			break;
 
		}
 
		/*
		 * Comienza el juego.
		 * El siguiente bucle pide letras al usuarios y comprueba si existen en la palabra misteriosa.
		 * SOLO finaliza cuando la palabra ha sido resuelta.
		 */
		while (!pm.palabraResuelta()) {
			System.out.print("\nPalabra generada: "); pm.mostrarLetras();
			System.out.print("Intente letra: ");
			char intento = entrada.nextLine().toLowerCase().charAt(0);
			pm.buscarLetra(intento);
		}
		//Bucle ya finalizo. Eso es que la palabra ha sido resuelta.
		System.out.println("\nPalabra resuelta: " + pm.getPalabraMisteriosa() +"\nFin del juego");
	}
 
}

Pruebalo, echa un vistazo al código (es simple y ya trae varios comentarios) y no dudes en pregutnar cualquier cosa que no entiendas o te parezca extraña.

Se me ocurre incluso un pequeño cambio que puedes intentar añadir tú mismo.
Podemos añadirle a la clase PalabraMisteriosa un contador de intentos. Por cada letra intentada, incrementamos este contador y podemos informar al usuario del número de intentos que lleva realizados cada vez que le pedimos letra.

Incluso podemos poner un limite de intentos y si el usuario alcanza ese límite sin haber acertado la palabra misteriosa, pierde el juego
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