El enunciado esta en el siguiente link enunciado
import java.util.Arrays;
import java.util.Scanner;
/**
* 110202 - Manos de poquer [http://www.programming-chalenges.com]
*
* @author BreakDark
* @version 2.2 beta
*/
// ACEPTADO!!! xD
public class Main {
final static char[] valores = {'2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A'};
// valores de las cartas
final static char[] palos = {'C', 'D', 'H', 'S'}; // palos de las cartas
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
byte[] black = new byte[5]; // cartas jugador negro
byte[] white = new byte[5]; // cartas jugador blanco
byte i; // para los bucles
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
while(Lee.hasNext()){
// jugador negro
for(i = 0; i < 5; i++)
black[i] = getValorNumerico(Lee.next());
// jugador blanco
for(i = 0; i < 5; i++)
white[i] = getValorNumerico(Lee.next());
procesar(black, white);
}
}
/** Procesa las dos barajas y dçmuestra al ganador o si es empate */
private static void procesar(byte[] black, byte[] white) {
if(!hayEscaleraDeColor(black, white))
if(!hayPoquer(black, white))
if(!hayFull(black, white))
if(!hayColor(black, white))
if(!hayEscalera(black, white))
if(!hayTrio(black, white))
if(!hayDoblesParejas(black, white))
if(!hayPareja(black, white))
if(!hayCartaMasAlta(black, white))
System.out.println("Tie.");
}
/**
* Las manos que no se ajusten a ninguna otra categoria se evaluan por la
* carta mas alta. Si se produce un empate en la carta mas alta, se
* considera la siguiente de mayor valor, y asi sucesivamente. Si no hay un
* ganador se devuelve false
*/
private static boolean hayCartaMasAlta(byte[] black, byte[] white) {
byte[] b = new byte[5];
byte[] w = new byte[5];
byte i;
for(i = 0; i < 5; i++){
b[i] = getValor(black[i]);
w[i] = getValor(white[i]);
}
Arrays.sort(b);
Arrays.sort(w);
for(i = 4; i >= 0; i--){
if(b[i] > w[i]){
System.out.println("Black wins.");
return true;
}
else
if(w[i] > b[i]){
System.out.println("White wins.");
return true;
}
}
return false;
}
/**
* Dos de las cinco cartas de la mano tienen el mismo valor. En caso de
* empate en esta categoria, se considerara el valor de las cartas que
* forman la pareja. Si el valor de estas es el mismo, las manos se
* clasificarán en función de las cartas restantes, en orden descendente. Si
* no hay un ganador se devuelve false
*/
private static boolean hayPareja(byte[] black, byte[] white) {
boolean negro = false, blanco = false;
byte[] b = new byte[5];
byte[] w = new byte[5];
byte b_par = 0, w_par = 0;
byte i, j;
for(i = 0; i < 5; i++){
b[i] = getValor(black[i]);
w[i] = getValor(white[i]);
}
Arrays.sort(b);
Arrays.sort(w);
// evaluamos al negro
for(i = 0; i < 4; i++)
if(b[i] == b[i + 1]){
negro = true;
b_par = b[i];
break;
}
// evaluamos al blanco
for(i = 0; i < 4; i++)
if(w[i] == w[i + 1]){
blanco = true;
w_par = w[i];
break;
}
// se pregunta si hay ganador
if(negro && blanco){
// empate
if(b_par > w_par){
System.out.println("Black wins.");
return true;
}
else
if(w_par > b_par){
System.out.println("White wins.");
return true;
}
else{
i = j = 4;
while(i >= 0 && j >= 0){
while(i >= 0 && b[i] == b_par)
i--;
while(j >= 0 && w[j] == w_par)
j--;
if(i >= 0 && j >= 0)
if(b[i] > w[j]){
System.out.println("Black wins.");
return true;
}
else
if(w[i] > b[j]){
System.out.println("White wins.");
return true;
}
else{
i--;
j--;
}
}
}
}
else
if(negro){
System.out.println("Black wins.");
return true;
}
else
if(blanco){
System.out.println("White wins.");
return true;
}
return false;
}
/**
* La mano incluye dos parejas diferentes. Si hay coincidencia, se tendrá en
* cuenta el valor de la pareja más alta. En caso de empate, se considerará
* el valor de la otra pareja y, posteriormente, el valor de la carta
* restante. Si no hay un ganador se devuelve false
*/
private static boolean hayDoblesParejas(byte[] black, byte[] white) {
boolean negro = false, blanco = false;
byte[] b = new byte[5];
byte[] w = new byte[5];
byte i, j;
for(i = 0; i < 5; i++){
b[i] = getValor(black[i]);
w[i] = getValor(white[i]);
}
Arrays.sort(b);
Arrays.sort(w);
// evaluamos al negro
if((b[0] == b[1] && b[2] == b[3]) || (b[0] == b[1] && b[3] == b[4]) || (b[1] == b[2] && b[3] == b[4]))
negro = true;
// evaluamos al blanco
if((w[0] == w[1] && w[2] == w[3]) || (w[0] == w[1] && w[3] == w[4]) || (w[1] == w[2] && w[3] == w[4]))
blanco = true;
// se pregunta si hay ganador
if(negro && blanco){
// empate
if(b[3] > w[3]){
System.out.println("Black wins.");
return true;
}
else
if(w[3] > b[3]){
System.out.println("White wins.");
return true;
}
else
if(b[1] > w[1]){
System.out.println("Black wins.");
return true;
}
else
if(w[1] > b[1]){
System.out.println("White wins.");
return true;
}
else{
i = j = 4;
while(i >= 0 && j >= 0){
while(i >= 0 && (b[i] == b[3] || b[i] == b[1]))
i--;
while(j >= 0 && (w[j] == w[3] || w[j] == w[1]))
j--;
if(i >= 0 && j >= 0)
if(b[i] > w[j]){
System.out.println("Black wins.");
return true;
}
else
if(w[j] > b[i]){
System.out.println("White wins.");
return true;
}
else{
i--;
j--;
}
}
}
}
else
if(negro){
System.out.println("Black wins.");
return true;
}
else
if(blanco){
System.out.println("White wins.");
return true;
}
return false;
}
/**
* Tres de las cartas de la mano tienen el mismo valor. En caso de empate,
* se tendrá en cuenta el valor de las cartas que forman el trio. Si no hay
* un ganador se devuelve false
*/
private static boolean hayTrio(byte[] black, byte[] white) {
boolean negro = false, blanco = false;
byte[] b = new byte[5];
byte[] w = new byte[5];
byte i, j;
for(i = 0; i < 5; i++){
b[i] = getValor(black[i]);
w[i] = getValor(white[i]);
}
Arrays.sort(b);
Arrays.sort(w);
// se evalua al negro
for(i = 0; i < 3; i++)
if(b[i] == b[i + 1] && b[i] == b[i + 2]){
negro = true;
break;
}
// se evalua al blanco
for(i = 0; i < 3; i++)
if(w[i] == w[i + 1] && w[i] == w[i + 2]){
blanco = true;
break;
}
// se pregunta si hay ganador
if(negro && blanco){
// empate
if(b[2] > w[2]){
System.out.println("Black wins.");
return true;
}
else
if(w[2] > b[2]){
System.out.println("White wins.");
return true;
}
else{
i = 4;
j = 4;
while(i >= 0 && j >= 0){
while(i >= 0 && b[i] == b[2])
i--;
while(j >= 0 && w[j] == w[2])
j--;
if(i >= 0 && j >= 0)
if(b[i] > w[j]){
System.out.println("Black wins.");
return true;
}
else
if(w[j] > black[i]){
System.out.println("White wins.");
return true;
}
else{
i--;
j--;
}
}
}
}
else
if(negro){
System.out.println("Black wins.");
return true;
}
else
if(blanco){
System.out.println("White wins.");
return true;
}
return false;
}
/**
* La mano contiene cinco cartas de valores consecutivos. En caso de empate,
* se considera la carta más alta. Si no hay un ganador se devuelve false
*/
private static boolean hayEscalera(byte[] black, byte[] white) {
boolean negro = true, blanco = true;
byte[] b = new byte[5];
byte[] w = new byte[5];
byte i;
for(i = 0; i < 5; i++){
b[i] = getValor(black[i]);
w[i] = getValor(white[i]);
}
Arrays.sort(b);
Arrays.sort(w);
// se evalua al negro y al blanco
for(i = 0; i < 4; i++){
if(b[i] != b[i + 1] - 1)
negro = false;
if(w[i] != w[i + 1] - 1)
blanco = false;
}
// se pregunta si hay ganador
if(negro && blanco){
// empate
if(b[4] > w[4]){
System.out.println("Black wins.");
return true;
}
else
if(w[4] > b[4]){
System.out.println("White wins.");
return true;
}
}
else
if(negro){
System.out.println("Black wins.");
return true;
}
else
if(blanco){
System.out.println("White wins.");
return true;
}
return false;
}
/**
* Las cinco cartas son del mismo palo. En caso de empate, se aplican las
* reglas de la carta más alta. Si no hay un ganador se devuelve false
*/
private static boolean hayColor(byte[] black, byte[] white) {
boolean negro = true, blanco = true;
byte paloB, paloW;
byte[] b = new byte[5];
byte[] w = new byte[5];
byte i;
// se evalua al negro y al blanco
paloB = getPalo(black[0]);
paloW = getPalo(white[0]);
for(i = 1; i < 5; i++){
if(paloB != getPalo(black[i]))
negro = false;
if(paloW != getPalo(white[i]))
blanco = false;
}
if(negro && blanco){
// empate
for(i = 0; i < 5; i++){
b[i] = getValor(black[i]);
w[i] = getValor(white[i]);
}
Arrays.sort(b);
Arrays.sort(w);
for(i = 4; i >= 0; i--)
if(b[i] > w[i]){
System.out.println("Black wins.");
return true;
}
else
if(w[i] > b[i]){
System.out.println("White wins.");
return true;
}
}
else
if(negro){
System.out.println("Black wins.");
return true;
}
else
if(blanco){
System.out.println("White wins.");
return true;
}
return false;
}
/**
* Es una combinación de un trio y una pareja con respecto a sus valores. Se
* desempata en función del valor de las cartas que forman el trio. Si no
* hay un ganador se devuelve false
*/
private static boolean hayFull(byte[] black, byte[] white) {
boolean negro = false, blanco = false;
byte[] b = new byte[5];
byte[] w = new byte[5];
byte i;
for(i = 0; i < 5; i++){
b[i] = getValor(black[i]);
w[i] = getValor(white[i]);
}
Arrays.sort(b);
Arrays.sort(w);
// se evalua al negro
if(b[0] == b[2] && b[3] == b[4])
negro = true;
else
if(b[0] == b[1] && b[2] == b[4])
negro = true;
// se evalua al blanco
if(w[0] == w[2] && w[3] == w[4])
blanco = true;
else
if(w[0] == w[1] && w[2] == w[4])
blanco = true;
// se pregunta si hay ganador
if(negro && blanco){
// empate
if(b[2] > w[2]){
System.out.println("Black wins.");
return true;
}
else
if(w[2] > b[2]){
System.out.println("White wins.");
return true;
}
else
if(b[0] != b[2])
if(w[0] != w[2]){
if(b[0] > w[0]){
System.out.println("Black wins.");
return true;
}
else
if(w[0] > b[0]){
System.out.println("White wins.");
return true;
}
}
else{
if(b[0] > w[4]){
System.out.println("Black wins.");
return true;
}
else
if(w[4] > b[0]){
System.out.println("White wins.");
return true;
}
}
else
if(w[0] != w[2]){
if(b[4] > w[0]){
System.out.println("Black wins.");
return true;
}
else
if(w[0] > b[4]){
System.out.println("White wins.");
return true;
}
}
else{
if(b[4] > w[4]){
System.out.println("Black wins.");
return true;
}
else
if(w[4] > b[4]){
System.out.println("White wins.");
return true;
}
}
}
else
if(negro){
System.out.println("Black wins.");
return true;
}
else
if(blanco){
System.out.println("White wins.");
return true;
}
return false;
}
/**
* Cuatro cartas del mismo valor. De cara al desempate, se considera el
* valor de las mismas. Si no hay un ganador se devuelve false
*/
private static boolean hayPoquer(byte[] black, byte[] white) {
boolean negro = false, blanco = false;
byte[] b = new byte[5];
byte[] w = new byte[5];
byte i;
for(i = 0; i < 5; i++){
b[i] = getValor(black[i]);
w[i] = getValor(white[i]);
}
Arrays.sort(b);
Arrays.sort(w);
// se evalua al negro
if(b[0] == b[3] || b[1] == b[4])
negro = true;
// se evalua al blanco
if(w[0] == w[3] || w[1] == w[4])
blanco = true;
// se pregunta si hay ganador
if(negro && blanco){
// empate
if(b[2] > w[2]){
System.out.println("Black wins.");
return true;
}
else
if(w[2] > b[2]){
System.out.println("White wins.");
return true;
}
else
if(b[0] != b[2])
if(w[0] != w[2]){
if(b[0] > w[0]){
System.out.println("Black wins.");
return true;
}
else
if(w[0] > b[0]){
System.out.println("White wins.");
return true;
}
}
else{
if(b[0] > w[4]){
System.out.println("Black wins.");
return true;
}
else
if(w[4] > b[0]){
System.out.println("White wins.");
return true;
}
}
else
if(w[0] != w[2]){
if(b[4] > w[0]){
System.out.println("Black wins.");
return true;
}
else
if(w[0] > b[4]){
System.out.println("White wins.");
return true;
}
}
else{
if(b[4] > w[4]){
System.out.println("Black wins.");
return true;
}
else
if(w[4] > b[4]){
System.out.println("White wins.");
return true;
}
}
}
else
if(negro){
System.out.println("Black wins.");
return true;
}
else
if(blanco){
System.out.println("White wins.");
return true;
}
return false;
}
/**
* Cinco cartas del mismo palo con valores consecutivos. Para desempatar, se
* considera la carta más alta. Si no hay un ganador se devuelve false
*
* @version 2.0
*/
private static boolean hayEscaleraDeColor(byte[] black, byte[] white) {
boolean negro = true, blanco = true;
byte[] b = new byte[5];
byte[] w = new byte[5];
byte i;
byte paloB, paloW;
// se evalua al negro y al blanco
paloB = getPalo(black[0]);
paloW = getPalo(white[0]);
for(i = 1; i < 5; i++){
if(paloB != getPalo(black[i]))
negro = false;
if(paloW != getPalo(white[i]))
blanco = false;
}
if(negro || blanco){
for(i = 0; i < 5; i++){
b[i] = getValor(black[i]);
w[i] = getValor(white[i]);
}
Arrays.sort(b);
Arrays.sort(w);
for(i = 0; i < 4; i++){
if(b[i] != b[i + 1] - 1)
negro = false;
if(w[i] != w[i + 1] - 1)
blanco = false;
}
}
// se pregunta si hay ganador
if(negro && blanco){
// empate
if(b[4] > w[4]){
System.out.println("Black wins.");
return true;
}
else
if(w[4] > b[4]){
System.out.println("White wins.");
return true;
}
}
else
if(negro){
System.out.println("Black wins.");
return true;
}
else
if(blanco){
System.out.println("White wins.");
return true;
}
return false;
}
/** retorna el valor del naipe */
private static byte getValor(byte naipe) {
return (byte) (naipe / 4);
}
/** retorna el palo de el naipe */
private static byte getPalo(byte naipe) {
return (byte) (naipe % 4);
}
/** Obtiene el valor numerico de la carta */
private static byte getValorNumerico(String naipe) {
for(byte i = 0; i < 4; i++)
if(naipe.charAt(1) == palos[i])
for(byte j = 0; j < 13; j++)
if(naipe.charAt(0) == valores[j])
return (byte) (j * 4 + i);
return 0;
}
}
|
No comments:
Post a Comment