Foro de elhacker.net

Programación => Ejercicios => Mensaje iniciado por: kasidy en 24 Noviembre 2013, 23:17 pm


Título: AYUDA CON CODIGO DE JUEGO DE CARTAS
Publicado por: kasidy en 24 Noviembre 2013, 23:17 pm
Bueno pues tengo las clases Carta y PruebaPaqueteDeCartas ademas del PaqueteDeCartas y el me arroja las cinco cartas de poker al azar.. el problema es q me pide que identifique si la 5 cartas son:
a) un par
b) dos pares
c) tercia
d) cuatro aces
e) cinco cartas del mismo palo
f) full= un par y una tercia

tengo estas clases
public class PruebaPaqueteDeCartas
{     // Abre clase PruebaDeCartas
    public static void main(String args[])
    {     // Abre main
        PaqueteDeCartas miPaqueteDeCartas = new PaqueteDeCartas();
        miPaqueteDeCartas.barajar();
 
       System.out.println("\n");
       for ( int i = 0; i < 1; i++)
       { // Abre for
           System.out.printf("%-20s%-20s%-20s%-20s%-20s\n",
           miPaqueteDeCartas.repartirCarta(), miPaqueteDeCartas.repartirCarta(),
           miPaqueteDeCartas.repartirCarta(), miPaqueteDeCartas.repartirCarta(), miPaqueteDeCartas.repartirCarta());
       }  // Cierra for
    }
}




°
public class Carta
{
// Abre clase Carta
    private String cara;
    private String palo;
    public Carta( String caraCarta, String paloCarta)
    {   // Abre constructor
        cara = caraCarta;
        palo = paloCarta;
    }   // Cierra constructor
   
    public String toString()
    {   // Abre metodo toString
        return  cara + " de " + palo;
    }   // Cierra metodo toString
 }



° Y AHORA SE SUPONE QUE DEBO MODIFICAR LA CLASE PaqueteDeCartas PARA DETERMINE LO QUE CONTIENE LA MANOS PERO NO TENGO IDEA DE COMO QUEDARIA.......  :huh: :huh: :huh:

import java.util.Random;

public class PaqueteDeCartas
{  // Abre clase PaqueteDeCartas
    private Carta paquete[];
    private int cartaActual;
    private final int NUMERO_DE_CARTAS = 52;
    private Random numerosAleatorios;
   
    public PaqueteDeCartas()
    {   // Abre constructor PaqueteDeCartas
        String caras[] = { "AS", "DOS", "TRES", "CUATRO", "CINCO", "SEIS", "SIETE",
            "OCHO", "NUEVE", "DIEZ", "JOTA", "QUINA", "REY"};
        String palos[] = { "CORAZONES", "DIAMANTES", "TREBOLES", "ESPADAS"};
       
        paquete = new Carta[ NUMERO_DE_CARTAS ];
        cartaActual = 0;
        numerosAleatorios = new Random();
       
        for ( int cuenta = 0; cuenta < paquete.length; cuenta++ )
        paquete[ cuenta ] = new Carta( caras[cuenta % 13], palos[cuenta/13]);
    }   // Cierra constructor PaqueteDeCartas
   
    public void barajar()
    {   // Abre metodo barajar
        cartaActual = 0;
 
        for ( int primera = 0; primera < paquete.length; primera++ )
        { // Abre for
            int segunda = numerosAleatorios.nextInt(NUMERO_DE_CARTAS);
 
            Carta temp = paquete[primera];

            paquete[primera] = paquete[segunda];
            paquete[segunda] = temp;
        }  // Cierra for
    }   // Cierra metodo barajar
   
    public Carta repartirCarta()
   {  // Abre metodo repartirCarta
       if (cartaActual < paquete.length )   
       return paquete[cartaActual++];
       else return null;       
   }
}// Cierra clase PaqueteDeCartas


ESPERO Y ME PUEDAN AYUDAR  ;-) ;-)

Título: Re: AYUDA CON CODIGO DE JUEGO DE CARTAS
Publicado por: Mitsu en 25 Noviembre 2013, 15:07 pm
Primero, es conveniente colocar en la clase Carta unos getters para obtener la carta y el palo. La razón es sencilla, como en el arreglo se guardan las cartas con el formato carta + palo si comparamos las cartas así nomás, nunca habrá coincidencias, porque solo va a existir una carta del palo.

Código
  1. /* Getters en clase Carta para obtener el palo y la carta */
  2. public String getCarta(){
  3. 	return this.carta;
  4. }
  5.  
  6. public String getPalo() {
  7. 	return this.palo;
  8. }
  9.  

Código
  1. public class CardsPack {
  2.  
  3.     // Abre clase PaqueteDeCartas
  4.     private Card mazo[];
  5.     private int cartaActual;
  6.     private final int NUMERODECARTAS = 52;
  7.     private Random numerosAleatorios;
  8.  
  9. public CardsPack()
  10. {   // Abre constructor PaqueteDeCartas
  11.     String caras[] = { "AS", "DOS", "TRES", "CUATRO", "CINCO", "SEIS", "SIETE",
  12.             "OCHO", "NUEVE", "DIEZ", "JOTO", "QUINA", "REY"};
  13.     String palos[] = { "CORAZONES", "DIAMANTES", "TREBOLES", "ESPADAS"};
  14.  
  15.     mazo = new Card[ NUMERODECARTAS ];
  16.     cartaActual = 0;
  17.     numerosAleatorios = new Random();
  18.  
  19.     for ( int cuenta = 0; cuenta < mazo.length; cuenta++ )
  20.     mazo[ cuenta ] = new Card( caras[cuenta % 13], palos[cuenta/13]); 
  21.  }   // Cierra constructor PaqueteDeCartas
  22.  
  23. /* BARAJA LAS CARTAS */
  24. public void barajar()
  25. {   
  26.     cartaActual = 0;
  27.  
  28.     for ( int primera = 0; primera < mazo.length; primera++ )
  29.     { 
  30.       int segunda = numerosAleatorios.nextInt(NUMERODECARTAS);
  31.  
  32.       Card temp = mazo[primera];
  33.       mazo[primera] = mazo[segunda];
  34.       mazo[segunda] = temp;
  35.     }
  36. }
  37.  
  38. /* METODO DE AYUDA - REPARTE UNA CARTAC */
  39. private Card repartirCarta()
  40. {  
  41.     if (cartaActual < mazo.length )    
  42.            return mazo[cartaActual++];
  43.     else 
  44.            return null;       
  45. }
  46.  
  47. /* REPARTE UNA MANO DE 5 CARTAS */
  48. public Card[] repartirMano() {
  49.         Card[] mano = new Card[5];
  50.          System.out.println("*** Tu mano es: ***\n\n");
  51.             for (byte carta = 0; carta < 5; carta++) {
  52.                 mano[carta] = this.repartirCarta();
  53.                 System.out.println(mano[carta].toString());
  54.             }
  55.          return mano;
  56.     }
  57.  
  58.  
  59. /* RESULTADOS DE LA MANO */
  60. public void analizarMano(Card[] mano) {
  61.     String[][] manoHecha = new String[5][2];
  62.     manoHecha[0][0] = "&#191;Hay par?";
  63.     manoHecha[1][0] = "&#191;Hay doble par?";
  64.     manoHecha[2][0] = "&#191;Hay tercia?";
  65.     manoHecha[3][0] = "&#191;Hay poker de ases?";
  66.     manoHecha[4][0] = "&#191;Hay color?";
  67.  
  68.  
  69.     System.out.println("\n\n*** Resultados de la mano: ***\n\n");
  70.     for (byte indice = 0; indice < manoHecha.length; indice++) {
  71.         byte col = 1;
  72.         switch(indice) {
  73.                 case 0:  manoHecha[indice][col] = String.valueOf(this.hayPar(mano)); break;
  74.                 case 1:  manoHecha[indice][col] = String.valueOf(this.hay2pares(mano)); break;
  75.                 case 2: manoHecha[indice][col] = String.valueOf(this.hayTercia(mano)); break;
  76.                 case 3:  manoHecha[indice][col] = String.valueOf(this.hayPokerAses(mano)); break;
  77.                 case 4: manoHecha[indice][col] = String.valueOf(this.hayColor(mano)); break;
  78.             }
  79.     }
  80.  
  81.      for (byte fila = 0; fila < manoHecha.length; fila++) {
  82.         for (byte col = 0; col < manoHecha[fila].length; col++) {
  83.             if (col == 0) {
  84.             System.out.print(manoHecha[fila][col] + " - ");
  85.             }
  86.             else {
  87.                 System.out.print(manoHecha[fila][col]);
  88.                 System.out.println();
  89.             }
  90.         }
  91.     }
  92.     }
  93.  
  94. /* DETERMINA SI HAY UN PAR EN LA MANO */
  95. private boolean hayPar(Card[] mano) {
  96.  
  97.     boolean isPar = false;
  98.     for (byte fila=0; fila<mano.length; fila++) {
  99.         for(byte elemento=0; elemento<mano.length; elemento++) {
  100.             if (fila != elemento) {
  101.                 if (mano[fila].getCara().equals(mano[elemento].getCara())) {
  102.                     isPar = true;
  103.                     break;
  104. 		}
  105.             }
  106. 	}
  107.     }
  108.         return isPar;
  109.  }
  110.  
  111. /* DETERMINA SI HAY 2 PARES */
  112. private boolean hay2pares(Card[] mano) {
  113.  
  114. 	boolean is2par = false;
  115. 	byte pares = 0;
  116. 	for(byte fila = 0; fila < mano.length; fila++) {
  117. 		for( byte elemento = 0; elemento < mano.length; elemento++) {
  118. 			if (fila != elemento) {
  119. 				if(mano[fila].getCara().equals(mano[elemento].getCara())) {
  120. 					pares++;
  121. 				}
  122. 			}
  123. 		}
  124. 	}
  125. 	if(pares == 2) {
  126. 		is2par = true;
  127. 	}
  128.         return is2par;
  129. }
  130.  
  131. /* COMPRUEBA SI HAY TERCIA */
  132. private boolean hayTercia(Card[] mano) {
  133. 	boolean hayTrio = false;
  134. 	byte tercia = 0;
  135.  
  136. 	for(byte fila = 0; fila < mano.length; fila++) {
  137. 		for( byte elemento = 0; elemento < mano.length; elemento++) {
  138. 			if (fila != elemento) {
  139. 				if(mano[fila].getCara().equals(mano[elemento].getCara())) {
  140. 					tercia++;
  141. 				}
  142. 			}
  143. 		}
  144. 	}
  145.  
  146. 	if(tercia == 3) {
  147. 		hayTrio = true;
  148. 	}
  149.  
  150. 	return hayTrio;
  151. }
  152.  
  153. /* DETERMINA SI HAY 4 ASES */
  154. private boolean hayPokerAses(Card[] mano) {
  155. 	boolean haypoker = false;
  156. 	byte asescount = 0;
  157. 	final String as = "AS";
  158.  
  159. 	for(byte fila = 0; fila < mano.length; fila++) {
  160. 		for( byte elemento = 0; elemento < mano.length; elemento++) {
  161. 			if (fila != elemento) {
  162. 				if(mano[elemento].getCara().equals(as)) {
  163. 					asescount++;
  164. 				}
  165. 			}
  166. 		}
  167. 	}
  168.  
  169. 	if (asescount == 4) {
  170. 		haypoker = true;
  171. 	}
  172.  
  173. 	return haypoker;
  174. }
  175.  
  176. /* DETERMINA SI HAY CINCO CARTAS DEL MISMO PALO */
  177. private boolean hayColor(Card[] mano) {
  178. 	boolean haycolor = false;
  179. 	byte colorcount = 0;
  180.  
  181. 	for(byte fila = 0; fila < mano.length; fila++) {
  182. 		for( byte elemento = 0; elemento < mano.length; elemento++) {
  183. 			if (fila != elemento) {
  184. 				if(mano[fila].getPalo().equals(mano[elemento].getPalo())) {
  185. 					colorcount++;
  186. 				}
  187. 			}
  188. 		}
  189. 	}
  190.  
  191. 	if(colorcount == 5) {
  192. 		haycolor = true;
  193. 	}
  194.  
  195. 	return haycolor;
  196. }
  197.  
  198. public static void main(String... args) {
  199.     CardsPack pack = new CardsPack();
  200.     pack.barajar();
  201.     Card[] mano = pack.repartirMano();
  202.     pack.analizarMano(mano);
  203.  
  204.   }
  205. }
  206.  

Lo del full ya hazlo tú :P

Título: Re: AYUDA CON CODIGO DE JUEGO DE CARTAS
Publicado por: kasidy en 26 Noviembre 2013, 16:00 pm
Una duda porque pones cartas.length? no deberia ser paquete.length?
y dos al poner el paquete.length me marca error en el get.Carta



Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines