Saturday, November 26, 2011

Solución al problema 458 The Decoder [http://uva.onlinejudge.org]

Solución al problema 458 The Decoder [http://uva.onlinejudge.org]
El enunciado esta en el siguiente link enunciado

/**
 * 458 The Decoder [http://uva.onlinejudge.org]
 *
 * @author BreakDark
 * @version 1.3 beta version C++
 */
 // ACEPTADO!!! xD
#include <iostream>
#include <stdio.h>
 
using namespace std;

int main()
{
    char cadena[100000];
    int i;  // para los bucles
    while(gets(cadena)){
        for(i=0;cadena[i];i++)
            cadena[i]-=7;
        printf("%s\n",cadena);
    }
    return 0;
}
Publicado por en No comments:

Solución al problema 272 TEX Quotes [http://uva.onlinejudge.org]

Solución al problema 272 TEX Quotes [http://uva.onlinejudge.org] con Java
El enunciado esta en el siguiente link enunciado

import java.util.Scanner;

/**
 * 272 TEX Quotes [http://uva.onlinejudge.org]
 * 
 * @author BreakDark
 * @version 1.0 beta
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datos de entrada
  char[] linea; // para guardar una linea
  boolean abrir_comillas; // para abrir o cerrar comillas dobles
  int i; // para bucles

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  abrir_comillas = true;
  while (Lee.hasNextLine()) {
   linea = Lee.nextLine().toCharArray();
   for (i = 0; i < linea.length; i++)
    if (linea[i] == '"') {
     if (abrir_comillas)
      System.out.print("``");
     else
      System.out.print("''");
     abrir_comillas = !abrir_comillas;
    } else
     System.out.print(linea[i]);
   System.out.println();
  }
 }
}
Publicado por en No comments:

Monday, November 14, 2011

Solución de 110202 Manos de póquer [http://www.programming-challenges.com] con Java

Solución de 110202 Manos de póquer [http://www.programming-challenges.com]
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;
 }
}
Publicado por en No comments:

Sunday, November 13, 2011

Solucion a 110108 Australian Voting [http://wwwprogramming-challenges.com]

Solucion a 110108 Australian Voting [http://wwwprogramming-challenges.com]
El enunciado esta en el siguiente link enunciado

/*
 * 110108 - Votacion australiana [http://www.programming-challenges.com]
 * Main.cpp
 * Created on: 13/11/2011
 *      Author: BreakDark
 * version 7.1,1 C++ beta basado en el algoritmo de Alexandre Martins
 */
// ACEPTADO!!! xD
#include 
#include 
#include "Main.h"

using namespace std;

short numCandidatos;
char candidatos[20][80];
int numVotos;
short votacion[1000][20];
int n; // variable temporal

/**
 * proceso que hace todo el trabajo
 */
void procesar() {
 short indice_de_los_primeros[numVotos]; // para ubicarse en
           // el primer lugar
 int i, min;
 int votos[numCandidatos];
 bool eliminados[numCandidatos]; /* candidatos eliminados */
 bool ultimos_eliminados[numCandidatos];
 double cincuentaPorCiento = (double) numVotos * 0.5; // para obtener el
               // 50%

 for (i = 0; i < numCandidatos; i++) // inicializamos eliminados
  eliminados[i] = false;
 for (i = 0; i < numVotos; i++)
  indice_de_los_primeros[i] = 0;

 while (true) {
  // inicializamos
  for (i = 0; i < numCandidatos; i++) {
   ultimos_eliminados[i] = false;
   votos[i] = 0;
  }
  /* verifica se alguien tiene mas que el 50% de los votos */
  for (i = 0; i < numVotos; i++)
   votos[votacion[i][indice_de_los_primeros[i]] - 1]++;
  for (i = 0; i < numCandidatos; i++)
   if (votos[i] > cincuentaPorCiento) {
    cout << candidatos[i] << endl;
    return;
   }
  /* identificando candidatos empatados con o menor numero de votos */
  min = 99999;
  for (i = 0; i < numCandidatos; i++)
   if (votos[i] < min && !eliminados[i])
    min = votos[i];
  for (i = 0; i < numCandidatos; i++) {
   if (votos[i] == min && !eliminados[i]) {
    eliminados[i] = true;
    ultimos_eliminados[i] = true;
   }
  }

  /* excluyendo candidatos eliminados de las celdas de votacion */
  for (i = 0; i < numVotos; i++)
   while (eliminados[votacion[i][indice_de_los_primeros[i]] - 1]) {
    indice_de_los_primeros[i]++;
    // si se removio a todos los candidatos
    if (indice_de_los_primeros[i] >= numCandidatos) {
     for (short j = 0; j < numCandidatos; j++) {
      if (ultimos_eliminados[j])
       cout << candidatos[j] << endl;
     }
     return;
    }
   }
 }
}
/** Funcion Principal */
int main() {
 long numCasos; // para el numero de casos de prueba
 int i; // para los bubles
 char linea[256], *p; // para poder procesar una linea, y un puntero
 short votos[20];

 // AQUI INICIA EL PROGRAMA
 gets(linea);
 sscanf(linea, "%ld", &numCasos);
 gets(linea); // linea en blanco
 while (numCasos--) {
  gets(linea);
  sscanf(linea, "%d", &numCandidatos);

  // leemos la lista de candidatos
  for (i = 0; i < numCandidatos; i++)
   gets(candidatos[i]);
  // leemos los votos
  numVotos = 0;
  while (gets(linea) && linea[0] != '\0') {
   for (i = 0, p = linea;
     sscanf(p, "%d%n", &votacion[numVotos][i++], &n) > 0; p += n)
    ;
   numVotos++;
  }
  procesar();
  // para separar las respuestas por una linea en blanco
  if (numCasos > 0)
   cout << endl;
 }
 return 0;
}
Publicado por en No comments:
Subscribe to: Posts (Atom)